chunk-C7IJTZ24.js

js vzome.com collected 2026-09-24 20:35:38 UTC 447,947 bytes, 13,979 lines download raw bytes

1import {
2  Dynamic_default,
3  Paper_default,
4  ZometoolInstructions,
5  alpha,
6  capitalize,
7  capitalize_default,
8  clsx_m_default,
9  composeClasses,
10  createComponentFactory_default,
11  createStyle_default,
12  createStyled_default,
13  createUnarySpacing,
14  darken,
15  deepmerge,
16  deepmerge2,
17  generateUtilityClass,
18  generateUtilityClasses,
19  getThemeValue_default,
20  handleBreakpoints,
21  inspectChildren,
22  instructionsCSS,
23  isComponentObject,
24  lighten,
25  redefine,
26  resolveBreakpointValues,
27  skipProps,
28  skipRootProps,
29  styled_default,
30  systemPropNames,
31  useTheme_default
32} from "./chunk-OZSYDWV2.js";
33import {
34  DesignViewer,
35  ImageCaptureProvider,
36  SceneIndexingProvider,
37  SceneProvider,
38  urlViewerCSS,
39  useImageCapture,
40  useSceneIndexing
41} from "./chunk-PBSMYCQH.js";
42import {
43  getUserRepos
44} from "./chunk-RIUXEPIU.js";
45import {
46  REVISION
47} from "./chunk-YWNSTGG6.js";
48import {
49  CameraProvider,
50  copyOfCamera,
51  createMutable,
52  createStore,
53  saveTextFile,
54  saveTextFileAs,
55  unwrap,
56  useCamera,
57  useViewer,
58  useWorkerClient
59} from "./chunk-737R77QV.js";
60import {
61  $DEVCOMP,
62  Dynamic,
63  For,
64  Match,
65  Portal,
66  SVGElements,
67  Show,
68  Switch,
69  addEventListener,
70  batch,
71  children,
72  className,
73  createComponent,
74  createComputed,
75  createContext,
76  createEffect,
77  createMemo,
78  createRenderEffect,
79  createSignal,
80  createUniqueId,
81  delegateEvents,
82  getNextElement,
83  insert,
84  isServer,
85  mapArray,
86  memo,
87  mergeProps,
88  on,
89  onCleanup,
90  onMount,
91  setAttribute,
92  sharedConfig,
93  splitProps,
94  spread,
95  ssrElement,
96  style,
97  template,
98  untrack,
99  use,
100  useContext,
101  voidFn
102} from "./chunk-47C2ISC4.js";
103import {
104  doControllerAction,
105  endPreviewStrut,
106  fetchDesign,
107  importMeshFile,
108  movePreviewStrut,
109  newDesign,
110  openDesignFile,
111  requestControllerProperty,
112  scalePreviewStrut,
113  setControllerProperty,
114  startPreviewStrut
115} from "./chunk-J3RXXGCJ.js";
116

vendor: 505 bytes, lines 117-145

117// node_modules/@suid/material/Typography/typographyClasses.js
118function getTypographyUtilityClass(slot) {
119  return generateUtilityClass("MuiTypography", slot);
120}
121var typographyClasses = generateUtilityClasses("MuiTypography", [
122  "root",
123  "h1",
124  "h2",
125  "h3",
126  "h4",
127  "h5",
128  "h6",
129  "subtitle1",
130  "subtitle2",
131  "body1",
132  "body2",
133  "inherit",
134  "button",
135  "caption",
136  "overline",
137  "alignLeft",
138  "alignRight",
139  "alignCenter",
140  "alignJustify",
141  "noWrap",
142  "gutterBottom",
143  "paragraph"
144]);
145

vendor: 629 bytes, lines 146-171

146// node_modules/@suid/system/styleFunctionSx/extendSxProp.jsx
147function splitSxProps(props) {
148  const [systemProps2, sxProps, otherProps] = splitProps(props, systemPropNames, ["sx"]);
149  const sx = () => {
150    const sx2 = sxProps.sx;
151    if (sx2) {
152      if (Array.isArray(sx2)) {
153        return [systemProps2, ...sx2];
154      } else {
155        return mergeProps(systemProps2, sx2);
156      }
157    } else {
158      return systemProps2;
159    }
160  };
161  return [sx, otherProps];
162}
163function extendSxProp(props) {
164  const [sx, otherProps] = splitSxProps(props);
165  return mergeProps(otherProps, {
166    get sx() {
167      return sx();
168    }
169  });
170}
171

vendor: 3,585 bytes, lines 172-291

172// node_modules/@suid/material/Typography/Typography.jsx
173var $ = createComponentFactory_default()({
174  name: "MuiTypography",
175  selfPropNames: ["align", "children", "classes", "gutterBottom", "noWrap", "paragraph", "variant", "variantMapping"],
176  utilityClass: getTypographyUtilityClass,
177  slotClasses: (ownerState) => ({
178    root: ["root", ownerState.variant, ownerState.align !== "inherit" && `align${capitalize_default(ownerState.align)}`, ownerState.gutterBottom && "gutterBottom", ownerState.noWrap && "noWrap", ownerState.paragraph && "paragraph"]
179  })
180});
181var TypographyRoot = styled_default("span", {
182  name: "MuiTypography",
183  slot: "Root",
184  overridesResolver: (props, styles3) => {
185    const {
186      ownerState
187    } = props;
188    return [styles3.root, ownerState.variant && styles3[ownerState.variant], ownerState.align !== "inherit" && styles3[`align${capitalize_default(ownerState.align)}`], ownerState.noWrap && styles3.noWrap, ownerState.gutterBottom && styles3.gutterBottom, ownerState.paragraph && styles3.paragraph];
189  }
190})(({
191  theme,
192  ownerState
193}) => ({
194  margin: 0,
195  color: ownerState.color,
196  ...ownerState.variant && theme.typography[ownerState.variant],
197  ...ownerState.align !== "inherit" && {
198    textAlign: ownerState.align
199  },
200  ...ownerState.noWrap && {
201    overflow: "hidden",
202    textOverflow: "ellipsis",
203    whiteSpace: "nowrap"
204  },
205  ...ownerState.gutterBottom && {
206    marginBottom: "0.35em"
207  },
208  ...ownerState.paragraph && {
209    marginBottom: 16
210  }
211}));
212var defaultVariantMapping = {
213  h1: "h1",
214  h2: "h2",
215  h3: "h3",
216  h4: "h4",
217  h5: "h5",
218  h6: "h6",
219  subtitle1: "h6",
220  subtitle2: "h6",
221  body1: "p",
222  body2: "p",
223  inherit: "p"
224};
225var colorTransformations = {
226  primary: "primary.main",
227  textPrimary: "text.primary",
228  secondary: "secondary.main",
229  textSecondary: "text.secondary",
230  error: "error.main"
231};
232var transformDeprecatedColors = (color) => {
233  return colorTransformations[color] || color;
234};
235var Typography = $.defineComponent(function Typography2(inProps) {
236  const theme = useTheme_default();
237  const themeProps = theme.components?.[$.name]?.defaultProps;
238  const color = () => (
239    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
240    transformDeprecatedColors(inProps.color ?? themeProps?.color)
241  );
242  const [sx, props] = splitSxProps(mergeProps({
243    align: "inherit",
244    variant: "body1",
245    variantMapping: defaultVariantMapping
246  }, themeProps, inProps, {
247    get color() {
248      return color();
249    }
250  }));
251  const [, other] = splitProps(props, ["align", "class", "component", "gutterBottom", "noWrap", "paragraph", "variant", "variantMapping"]);
252  const ownerState = {
253    get classes() {
254      return props.classes;
255    },
256    get align() {
257      return props.align;
258    },
259    get color() {
260      return color();
261    },
262    get gutterBottom() {
263      return props.gutterBottom || false;
264    },
265    get noWrap() {
266      return props.noWrap || false;
267    },
268    get paragraph() {
269      return props.paragraph || false;
270    },
271    get variant() {
272      return props.variant;
273    }
274  };
275  const Component = () => props.component || (props.paragraph ? "p" : props.variantMapping[props.variant] || defaultVariantMapping[props.variant]) || "span";
276  const classes = $.useClasses(ownerState);
277  return createComponent(TypographyRoot, mergeProps({
278    get as() {
279      return Component();
280    },
281    get sx() {
282      return sx();
283    },
284    ownerState,
285    get ["class"]() {
286      return clsx_m_default(classes.root, props.class);
287    }
288  }, other));
289});
290var Typography_default = Typography;
291

vendor: 335 bytes, lines 292-305

292// node_modules/@suid/material/Link/linkClasses.js
293function getLinkUtilityClass(slot) {
294  return generateUtilityClass("MuiLink", slot);
295}
296var linkClasses = generateUtilityClasses("MuiLink", [
297  "root",
298  "underlineNone",
299  "underlineHover",
300  "underlineAlways",
301  "button",
302  "focusVisible"
303]);
304var linkClasses_default = linkClasses;
305

vendor: 2,539 bytes, lines 306-406

306// node_modules/@suid/material/node_modules/@suid/utils/useIsFocusVisible.js
307var hadKeyboardEvent = true;
308var hadFocusVisibleRecently = false;
309var hadFocusVisibleRecentlyTimeout;
310var inputTypesWhitelist = {
311  text: true,
312  search: true,
313  url: true,
314  tel: true,
315  email: true,
316  password: true,
317  number: true,
318  date: true,
319  month: true,
320  week: true,
321  time: true,
322  datetime: true,
323  "datetime-local": true
324};
325function focusTriggersKeyboardModality(node) {
326  const { type, tagName } = node;
327  if (tagName === "INPUT" && inputTypesWhitelist[type] && !node.readOnly) {
328    return true;
329  }
330  if (tagName === "TEXTAREA" && !node.readOnly) {
331    return true;
332  }
333  if (node.isContentEditable) {
334    return true;
335  }
336  return false;
337}
338function handleKeyDown(event) {
339  if (event.metaKey || event.altKey || event.ctrlKey) {
340    return;
341  }
342  hadKeyboardEvent = true;
343}
344function handlePointerDown() {
345  hadKeyboardEvent = false;
346}
347function handleVisibilityChange() {
348  if (this.visibilityState === "hidden") {
349    if (hadFocusVisibleRecently) {
350      hadKeyboardEvent = true;
351    }
352  }
353}
354function prepare(doc) {
355  doc.addEventListener("keydown", handleKeyDown, true);
356  doc.addEventListener("mousedown", handlePointerDown, true);
357  doc.addEventListener("pointerdown", handlePointerDown, true);
358  doc.addEventListener("touchstart", handlePointerDown, true);
359  doc.addEventListener("visibilitychange", handleVisibilityChange, true);
360}
361function isFocusVisible(event) {
362  const { target } = event;
363  try {
364    return target.matches(":focus-visible");
365  } catch (error) {
366  }
367  return hadKeyboardEvent || focusTriggersKeyboardModality(target);
368}
369function useIsFocusVisible() {
370  const ref = (node) => {
371    if (node != null) {
372      prepare(node.ownerDocument);
373    }
374  };
375  const [isFocusVisibleRef, setFocusVisibleRef] = createSignal(false);
376  function handleBlurVisible() {
377    if (isFocusVisibleRef()) {
378      hadFocusVisibleRecently = true;
379      window.clearTimeout(hadFocusVisibleRecentlyTimeout);
380      hadFocusVisibleRecentlyTimeout = window.setTimeout(() => {
381        hadFocusVisibleRecently = false;
382      }, 100);
383      setFocusVisibleRef(false);
384      return true;
385    }
386    return false;
387  }
388  function handleFocusVisible(event) {
389    if (isFocusVisible(event)) {
390      setFocusVisibleRef(true);
391      return true;
392    }
393    return false;
394  }
395  return {
396    isFocusVisibleRef: {
397      get current() {
398        return isFocusVisibleRef();
399      }
400    },
401    onFocus: handleFocusVisible,
402    onBlur: handleBlurVisible,
403    ref
404  };
405}
406

vendor: 3,906 bytes, lines 407-547

407// node_modules/@suid/material/Link/Link.jsx
408var $2 = createComponentFactory_default()({
409  name: "MuiLink",
410  autoCallUseClasses: false,
411  selfPropNames: ["TypographyClasses", "children", "classes", "color", "underline", "variant"],
412  propDefaults: ({
413    set
414  }) => set({
415    color: "primary",
416    component: "a",
417    underline: "always",
418    variant: "inherit"
419  }),
420  utilityClass: getLinkUtilityClass,
421  slotClasses: (ownerState) => ({
422    root: ["root", `underline${capitalize_default(ownerState.underline)}`, ownerState.component === "button" && "button", ownerState.focusVisible && "focusVisible"]
423  })
424});
425var colorTransformations2 = {
426  primary: "primary.main",
427  textPrimary: "text.primary",
428  secondary: "secondary.main",
429  textSecondary: "text.secondary",
430  error: "error.main"
431};
432var transformDeprecatedColors2 = (color) => {
433  return colorTransformations2[color] || color;
434};
435var LinkRoot = styled_default(Typography_default, {
436  name: "MuiLink",
437  slot: "Root",
438  overridesResolver: (props, styles3) => {
439    const {
440      ownerState
441    } = props;
442    return [styles3.root, styles3[`underline${capitalize_default(ownerState.underline)}`], ownerState.component === "button" && styles3.button];
443  }
444})(({
445  theme,
446  ownerState
447}) => {
448  const color = getThemeValue_default(theme, "palette", transformDeprecatedColors2(ownerState.color)) || ownerState.color;
449  return {
450    ...ownerState.underline === "none" && {
451      textDecoration: "none"
452    },
453    ...ownerState.underline === "hover" && {
454      textDecoration: "none",
455      "&:hover": {
456        textDecoration: "underline"
457      }
458    },
459    ...ownerState.underline === "always" && {
460      textDecoration: "underline",
461      textDecorationColor: color !== "inherit" ? alpha(color, 0.4) : void 0,
462      "&:hover": {
463        textDecorationColor: "inherit"
464      }
465    },
466    // Same reset as ButtonBase.root
467    ...ownerState.component === "button" && {
468      position: "relative",
469      WebkitTapHighlightColor: "transparent",
470      backgroundColor: "transparent",
471      // We disable the focus ring for mouse, touch and keyboard users.
472      outline: 0,
473      border: 0,
474      margin: 0,
475      borderRadius: 0,
476      padding: 0,
477      cursor: "pointer",
478      userSelect: "none",
479      verticalAlign: "middle",
480      MozAppearance: "none",
481      WebkitAppearance: "none",
482      "&::-moz-focus-inner": {
483        borderStyle: "none"
484        // Remove Firefox dotted outline.
485      },
486      [`&.${linkClasses_default.focusVisible}`]: {
487        outline: "auto"
488      }
489    }
490  };
491});
492var Link = $2.component(function Link2({
493  allProps,
494  otherProps,
495  props
496}) {
497  const visible = useIsFocusVisible();
498  const [focusVisible, setFocusVisible] = createSignal(false);
499  const ownerState = mergeProps(allProps, {
500    get focusVisible() {
501      return focusVisible();
502    }
503  });
504  const classes = $2.useClasses(ownerState);
505  return createComponent(LinkRoot, mergeProps({
506    get ["class"]() {
507      return clsx_m_default(classes.root, otherProps.class);
508    },
509    get classes() {
510      return props.TypographyClasses;
511    },
512    get color() {
513      return props.color;
514    },
515    onBlur: (event) => {
516      visible.onBlur(event);
517      if (visible.isFocusVisibleRef.current === false) {
518        setFocusVisible(false);
519      }
520      if (typeof otherProps.onBlur === "function") {
521        otherProps.onBlur(event);
522      }
523    },
524    onFocus: (event) => {
525      visible.onFocus(event);
526      if (visible.isFocusVisibleRef.current === true) {
527        setFocusVisible(true);
528      }
529      if (typeof otherProps.onFocus === "function") {
530        otherProps.onFocus(event);
531      }
532    },
533    ownerState: allProps,
534    get variant() {
535      return props.variant;
536    }
537  }, otherProps, {
538    get component() {
539      return otherProps.component;
540    },
541    get children() {
542      return props.children;
543    }
544  }));
545});
546var Link_default = Link;
547

vendor: 477 bytes, lines 548-569

548// node_modules/@suid/material/Divider/dividerClasses.js
549function getDividerUtilityClass(slot) {
550  return generateUtilityClass("MuiDivider", slot);
551}
552var dividerClasses = generateUtilityClasses("MuiDivider", [
553  "root",
554  "absolute",
555  "fullWidth",
556  "inset",
557  "middle",
558  "flexItem",
559  "light",
560  "vertical",
561  "withChildren",
562  "withChildrenVertical",
563  "textAlignRight",
564  "textAlignLeft",
565  "wrapper",
566  "wrapperVertical"
567]);
568var dividerClasses_default = dividerClasses;
569

vendor: 5,431 bytes, lines 570-756

570// node_modules/@suid/material/Divider/Divider.jsx
571var $3 = createComponentFactory_default()({
572  name: "MuiDivider",
573  selfPropNames: ["absolute", "children", "classes", "flexItem", "light", "orientation", "textAlign", "variant"],
574  propDefaults: ({
575    set,
576    inProps
577  }) => set({
578    absolute: false,
579    get component() {
580      return inProps.children ? "div" : "hr";
581    },
582    flexItem: false,
583    light: false,
584    orientation: "horizontal",
585    get role() {
586      return inProps.component !== "hr" ? "separator" : void 0;
587    },
588    textAlign: "center",
589    variant: "fullWidth"
590  }),
591  utilityClass: getDividerUtilityClass,
592  slotClasses: (o) => ({
593    root: ["root", o.absolute && "absolute", o.variant, o.light && "light", o.orientation === "vertical" && "vertical", o.flexItem && "flexItem", !!o.children && "withChildren", !!o.children && o.orientation === "vertical" && "withChildrenVertical", o.textAlign === "right" && o.orientation !== "vertical" && "textAlignRight", o.textAlign === "left" && o.orientation !== "vertical" && "textAlignLeft"],
594    wrapper: ["wrapper", o.orientation === "vertical" && "wrapperVertical"]
595  })
596});
597var DividerRoot = styled_default("div", {
598  name: "MuiDivider",
599  slot: "Root",
600  overridesResolver: (props, styles3) => {
601    const {
602      ownerState
603    } = props;
604    return [styles3.root, ownerState.absolute && styles3.absolute, styles3[ownerState.variant], ownerState.light && styles3.light, ownerState.orientation === "vertical" && styles3.vertical, ownerState.flexItem && styles3.flexItem, ownerState.children && styles3.withChildren, ownerState.children && ownerState.orientation === "vertical" && styles3.withChildrenVertical, ownerState.textAlign === "right" && ownerState.orientation !== "vertical" && styles3.textAlignRight, ownerState.textAlign === "left" && ownerState.orientation !== "vertical" && styles3.textAlignLeft];
605  }
606})(({
607  theme,
608  ownerState
609}) => ({
610  margin: 0,
611  flexShrink: 0,
612  borderWidth: 0,
613  borderStyle: "solid",
614  borderColor: theme.palette.divider,
615  borderBottomWidth: "thin",
616  ...ownerState.absolute && {
617    position: "absolute",
618    bottom: 0,
619    left: 0,
620    width: "100%"
621  },
622  ...ownerState.light && {
623    borderColor: alpha(theme.palette.divider, 0.08)
624  },
625  ...ownerState.variant === "inset" && {
626    marginLeft: 72
627  },
628  ...ownerState.variant === "middle" && ownerState.orientation === "horizontal" && {
629    marginLeft: theme.spacing(2),
630    marginRight: theme.spacing(2)
631  },
632  ...ownerState.variant === "middle" && ownerState.orientation === "vertical" && {
633    marginTop: theme.spacing(1),
634    marginBottom: theme.spacing(1)
635  },
636  ...ownerState.orientation === "vertical" && {
637    height: "100%",
638    borderBottomWidth: 0,
639    borderRightWidth: "thin"
640  },
641  ...ownerState.flexItem && {
642    alignSelf: "stretch",
643    height: "auto"
644  }
645}), ({
646  theme,
647  ownerState
648}) => ({
649  ...ownerState.children && {
650    display: "flex",
651    whiteSpace: "nowrap",
652    textAlign: "center",
653    border: 0,
654    "&::before, &::after": {
655      position: "relative",
656      width: "100%",
657      borderTop: `thin solid ${theme.palette.divider}`,
658      top: "50%",
659      content: '""',
660      transform: "translateY(50%)"
661    }
662  }
663}), ({
664  theme,
665  ownerState
666}) => ({
667  ...ownerState.children && ownerState.orientation === "vertical" && {
668    flexDirection: "column",
669    "&::before, &::after": {
670      height: "100%",
671      top: "0%",
672      left: "50%",
673      borderTop: 0,
674      borderLeft: `thin solid ${theme.palette.divider}`,
675      transform: "translateX(0%)"
676    }
677  }
678}), ({
679  ownerState
680}) => ({
681  ...ownerState.textAlign === "right" && ownerState.orientation !== "vertical" && {
682    "&::before": {
683      width: "90%"
684    },
685    "&::after": {
686      width: "10%"
687    }
688  },
689  ...ownerState.textAlign === "left" && ownerState.orientation !== "vertical" && {
690    "&::before": {
691      width: "10%"
692    },
693    "&::after": {
694      width: "90%"
695    }
696  }
697}));
698var DividerWrapper = styled_default("span", {
699  name: "MuiDivider",
700  slot: "Wrapper",
701  overridesResolver: (props, styles3) => {
702    const {
703      ownerState
704    } = props;
705    return [styles3.wrapper, ownerState.orientation === "vertical" && styles3.wrapperVertical];
706  }
707})(({
708  theme,
709  ownerState
710}) => ({
711  display: "inline-block",
712  paddingLeft: `calc(${theme.spacing(1)} * 1.2)`,
713  paddingRight: `calc(${theme.spacing(1)} * 1.2)`,
714  ...ownerState.orientation === "vertical" && {
715    paddingTop: `calc(${theme.spacing(1)} * 1.2)`,
716    paddingBottom: `calc(${theme.spacing(1)} * 1.2)`
717  }
718}));
719var Divider = $3.component(function Divider2({
720  allProps,
721  otherProps,
722  classes
723}) {
724  const $DividerRoot = redefine(DividerRoot, "div", "hr");
725  return createComponent($DividerRoot, mergeProps({
726    get role() {
727      return allProps.role;
728    },
729    get as() {
730      return otherProps.component;
731    }
732  }, otherProps, {
733    ownerState: allProps,
734    get ["class"]() {
735      return clsx_m_default(classes.root, allProps.class);
736    },
737    get children() {
738      return createComponent(Show, {
739        get when() {
740          return allProps.children;
741        },
742        children: (children2) => createComponent(DividerWrapper, {
743          get ["class"]() {
744            return classes.wrapper;
745          },
746          ownerState: allProps,
747          get children() {
748            return children2();
749          }
750        })
751      });
752    }
753  }));
754});
755var Divider_default = Divider;
756

vendor: 515 bytes, lines 757-767

757// node_modules/@suid/material/transitions/utils.js
758var reflow = (node) => node.scrollTop;
759function getTransitionProps(props, options) {
760  const { timeout, easing: easing2, style: style2 = {} } = props;
761  return {
762    duration: style2.transitionDuration ?? (typeof timeout === "number" ? timeout : typeof timeout === "string" ? 0 : timeout[options.mode] || 0),
763    easing: style2.transitionTimingFunction ?? (typeof easing2 === "object" ? easing2[options.mode] : easing2),
764    delay: style2.transitionDelay
765  };
766}
767

vendor: 2,807 bytes, lines 768-878

768// node_modules/@suid/base/Transition/Transition.jsx
769function resolveTransitionTimeout(timeout) {
770  if (typeof timeout === "number") {
771    return {
772      exit: timeout,
773      enter: timeout,
774      appear: timeout
775    };
776  } else {
777    return {
778      exit: timeout?.exit || 0,
779      enter: timeout?.enter || 0,
780      appear: timeout?.appear ?? timeout?.enter ?? 0
781    };
782  }
783}
784function Transition(inProps) {
785  const props = mergeProps({
786    in: false,
787    mountOnEnter: false,
788    unmountOnExit: false,
789    appear: false,
790    enter: true,
791    exit: true
792  }, inProps);
793  const timeouts = createMemo(() => resolveTransitionTimeout(props.timeout));
794  let initialStatus;
795  if (props.in) {
796    if (props.appear) {
797      initialStatus = "exited";
798    } else {
799      initialStatus = "entered";
800    }
801  } else {
802    if (props.unmountOnExit || props.mountOnEnter) {
803      initialStatus = "unmounted";
804    } else {
805      initialStatus = "exited";
806    }
807  }
808  const [status, setStatus] = createSignal(initialStatus);
809  let enteredTimeout;
810  let exitedTimeout;
811  let inTimeout;
812  let firstStatusChange = true;
813  function onTransitionEnd(ms, cb) {
814    const next = () => setTimeout(cb, ms);
815    let timeout;
816    let stopped = false;
817    const stop = () => {
818      stopped = true;
819      timeout && clearTimeout(timeout);
820    };
821    if (props.addEndListener) {
822      props.addEndListener(() => {
823        if (!stopped) timeout = next();
824      });
825    } else {
826      timeout = next();
827    }
828    return stop;
829  }
830  const result = createMemo(on(() => [status()], () => {
831    const v = status();
832    const result2 = v !== "unmounted" ? props.children(v) : void 0;
833    if (firstStatusChange) {
834      firstStatusChange = false;
835      return result2;
836    }
837    if (v === "entering") {
838      props.onEntering?.();
839      if (exitedTimeout) {
840        exitedTimeout();
841        exitedTimeout = void 0;
842      }
843      enteredTimeout = onTransitionEnd(timeouts().enter, () => setStatus("entered"));
844    } else if (v === "entered") {
845      props.onEntered?.();
846    } else if (v === "exiting") {
847      props.onExiting?.();
848      if (enteredTimeout) {
849        enteredTimeout();
850        enteredTimeout = void 0;
851      }
852      exitedTimeout = onTransitionEnd(timeouts().exit, () => setStatus("exited"));
853    } else if (v === "exited") {
854      props.onExited?.();
855    }
856    return result2;
857  }));
858  createEffect((firstTime) => {
859    if (props.in) {
860      untrack(() => props.onEnter?.());
861      setStatus("entering");
862    } else {
863      if (!firstTime) {
864        untrack(() => props.onExit?.());
865        setStatus("exiting");
866      }
867    }
868    return false;
869  }, true);
870  onCleanup(() => {
871    enteredTimeout?.();
872    exitedTimeout?.();
873    inTimeout && clearTimeout(inTimeout);
874  });
875  return result();
876}
877var Transition_default = Transition;
878

vendor: 101 bytes, lines 879-881

879// node_modules/@suid/base/Transition/TransitionContext.js
880var TransitionContext = createContext();
881

vendor: 407 bytes, lines 882-898

882// node_modules/@suid/system/createRef.js
883function createRef(input) {
884  const cb = (e) => {
885    cb.ref = cb.current = e;
886    if (typeof input === "function") {
887      const inputResult = input();
888      if (typeof inputResult === "function") {
889        inputResult(e);
890      }
891    } else if (typeof input?.ref === "function") {
892      input.ref(e);
893    }
894  };
895  return cb;
896}
897var createRef_default = createRef;
898

vendor: 171 bytes, lines 899-904

899// node_modules/@suid/system/createElementRef.js
900function createElementRef(props) {
901  return createRef_default(props);
902}
903var createElementRef_default = createElementRef;
904

vendor: 2,377 bytes, lines 905-993

905// node_modules/@suid/material/Fade/Fade.jsx
906var $4 = createComponentFactory_default()({
907  name: "MuiFader",
908  selfPropNames: ["appear", "children", "easing", "in", "timeout"],
909  propDefaults: ({
910    set
911  }) => {
912    const theme = useTheme_default();
913    return set({
914      appear: true,
915      get timeout() {
916        return {
917          enter: theme.transitions.duration.enteringScreen,
918          exit: theme.transitions.duration.leavingScreen
919        };
920      }
921    });
922  }
923});
924var fadeSelfPropNames = $4.selfPropNames;
925var Fade = $4.component(function Fade2({
926  props,
927  otherProps
928}) {
929  const theme = useTheme_default();
930  const element = createElementRef_default(props);
931  const timeout = createMemo(() => resolveTransitionTimeout(props.timeout));
932  const c = children(() => props.children);
933  const context = useContext(TransitionContext);
934  return createComponent(Transition_default, mergeProps({
935    get ["in"]() {
936      return props.in ?? context?.in;
937    },
938    get appear() {
939      return props.appear;
940    },
941    get timeout() {
942      return props.timeout;
943    }
944  }, otherProps, {
945    ref: element,
946    onEnter: () => {
947      const e = c();
948      reflow(e);
949      const transitionProps = getTransitionProps({
950        style: otherProps.style,
951        timeout: timeout(),
952        easing: props.easing
953      }, {
954        mode: "enter"
955      });
956      e.style.transition = theme.transitions.create("opacity", transitionProps);
957      otherProps.onEnter?.();
958      context?.onEnter?.();
959    },
960    onExit: () => {
961      const e = c();
962      const transitionProps = getTransitionProps({
963        style: otherProps.style,
964        timeout: timeout(),
965        easing: props.easing
966      }, {
967        mode: "enter"
968      });
969      e.style.transition = theme.transitions.create("opacity", transitionProps);
970      otherProps.onExit?.();
971    },
972    onExited: () => {
973      otherProps.onExited?.();
974      context?.onExited?.();
975    },
976    children: (state) => {
977      const element2 = c();
978      if (state === "exited" && !props.in) {
979        element2.style.visibility = "hidden";
980      } else {
981        element2.style.removeProperty("visibility");
982      }
983      if (state === "entering" || state === "entered") {
984        element2.style.opacity = "1";
985      } else {
986        element2.style.opacity = "0";
987      }
988      return element2;
989    }
990  }));
991});
992var Fade_default = Fade;
993

vendor: 176 bytes, lines 994-999

994// node_modules/@suid/base/utils/isHostComponent.js
995function isHostComponent(element) {
996  return typeof element === "string";
997}
998var isHostComponent_default = isHostComponent;
999

vendor: 259 bytes, lines 1000-1005

1000// node_modules/@suid/base/BackdropUnstyled/backdropUnstyledClasses.js
1001function getBackdropUtilityClass(slot) {
1002  return generateUtilityClass("MuiBackdrop", slot);
1003}
1004var backdropUnstyledClasses = generateUtilityClasses("MuiBackdrop", ["root", "invisible"]);
1005

vendor: 1,203 bytes, lines 1006-1048

1006// node_modules/@suid/base/BackdropUnstyled/BackdropUnstyled.jsx
1007var $5 = createComponentFactory_default()({
1008  name: "BackdropUnstyled",
1009  selfPropNames: ["children", "classes", "components", "componentsProps", "invisible"],
1010  propDefaults: ({
1011    set
1012  }) => set({
1013    component: "div",
1014    components: {},
1015    componentsProps: {},
1016    invisible: false
1017  }),
1018  utilityClass: getBackdropUtilityClass,
1019  slotClasses: (ownerState) => ({
1020    root: ["root", ownerState.invisible && "invisible"]
1021  })
1022});
1023var BackdropUnstyled = $5.component(function BackdropUnstyled2({
1024  props,
1025  otherProps,
1026  allProps,
1027  classes
1028}) {
1029  const Root = () => props.components.Root || otherProps.component;
1030  const rootProps = () => props.componentsProps.root || {};
1031  return createComponent(Dynamic_default, mergeProps({
1032    "aria-hidden": true
1033  }, rootProps, otherProps, () => !isHostComponent_default(Root()) && {
1034    ownerState: allProps
1035  }, {
1036    get $component() {
1037      return Root();
1038    },
1039    get ["class"]() {
1040      return clsx_m_default(classes.root, rootProps().class, otherProps.class);
1041    },
1042    get children() {
1043      return props.children;
1044    }
1045  }));
1046});
1047var BackdropUnstyled_default = BackdropUnstyled;
1048

vendor: 2,138 bytes, lines 1049-1134

1049// node_modules/@suid/material/Backdrop/Backdrop.jsx
1050var $6 = createComponentFactory_default()({
1051  name: "MuiBackdrop",
1052  selfPropNames: ["classes", "open", "transitionDuration"],
1053  propDefaults: ({
1054    set
1055  }) => set({
1056    open: false,
1057    component: "div"
1058  })
1059});
1060var BackdropRoot = styled_default("div", {
1061  name: "MuiBackdrop",
1062  slot: "Root",
1063  overridesResolver: (props, styles3) => {
1064    const {
1065      ownerState
1066    } = props;
1067    return [styles3.root, ownerState.invisible && styles3.invisible];
1068  }
1069})(({
1070  ownerState
1071}) => ({
1072  position: "fixed",
1073  display: "flex",
1074  alignItems: "center",
1075  justifyContent: "center",
1076  right: 0,
1077  bottom: 0,
1078  top: 0,
1079  left: 0,
1080  backgroundColor: "rgba(0, 0, 0, 0.5)",
1081  WebkitTapHighlightColor: "transparent",
1082  ...ownerState.invisible && {
1083    backgroundColor: "transparent"
1084  }
1085}));
1086var Backdrop = $6.component(function Backdrop2({
1087  props,
1088  otherProps
1089}) {
1090  const [fadeProps, backdropProps] = splitProps(otherProps, fadeSelfPropNames);
1091  return createComponent(Fade_default, mergeProps({
1092    get ["in"]() {
1093      return props.open;
1094    },
1095    get timeout() {
1096      return props.transitionDuration;
1097    }
1098  }, fadeProps, {
1099    get children() {
1100      return createComponent(BackdropUnstyled_default, mergeProps(backdropProps, {
1101        get ["class"]() {
1102          return otherProps.class;
1103        },
1104        get invisible() {
1105          return otherProps.invisible;
1106        },
1107        get components() {
1108          return {
1109            Root: BackdropRoot,
1110            ...otherProps.components
1111          };
1112        },
1113        get componentsProps() {
1114          return {
1115            root: {
1116              ...otherProps.componentsProps?.root,
1117              ...(!otherProps.components?.Root || !isHostComponent_default(otherProps.components?.Root)) && {
1118                //ownerState: { ...baseProps.componentsProps?.root?.ownerState },
1119              }
1120            }
1121          };
1122        },
1123        get classes() {
1124          return props.classes;
1125        },
1126        get children() {
1127          return otherProps.children;
1128        }
1129      }));
1130    }
1131  }));
1132});
1133var Backdrop_default = Backdrop;
1134

vendor: 526 bytes, lines 1135-1158

1135// node_modules/@suid/base/Portal/Portal.jsx
1136function Portal2(props) {
1137  const container = () => props.container ?? document.body;
1138  return createComponent(Show, {
1139    get when() {
1140      return !props.disablePortal;
1141    },
1142    get fallback() {
1143      return props.children;
1144    },
1145    get children() {
1146      return createComponent(Portal, {
1147        get mount() {
1148          return container();
1149        },
1150        get children() {
1151          return props.children;
1152        }
1153      });
1154    }
1155  });
1156}
1157var Portal_default = Portal2;
1158

vendor: 365 bytes, lines 1159-1174

1159// node_modules/@suid/base/node_modules/@suid/utils/debounce.js
1160function debounce(func, wait = 166) {
1161  let timeout;
1162  function debounced(...args) {
1163    const later = () => {
1164      func.apply(null, args);
1165    };
1166    clearTimeout(timeout);
1167    timeout = setTimeout(later, wait);
1168  }
1169  debounced.clear = () => {
1170    clearTimeout(timeout);
1171  };
1172  return debounced;
1173}
1174

vendor: 219 bytes, lines 1175-1180

1175// node_modules/@suid/base/node_modules/@suid/utils/getScrollbarSize.js
1176function getScrollbarSize(doc) {
1177  const documentWidth = doc.documentElement.clientWidth;
1178  return Math.abs(window.innerWidth - documentWidth);
1179}
1180

vendor: 152 bytes, lines 1181-1185

1181// node_modules/@suid/base/node_modules/@suid/utils/ownerDocument.js
1182function ownerDocument(node) {
1183  return node && node.ownerDocument || document;
1184}
1185

vendor: 170 bytes, lines 1186-1191

1186// node_modules/@suid/base/node_modules/@suid/utils/ownerWindow.js
1187function ownerWindow(node) {
1188  const doc = ownerDocument(node);
1189  return doc.defaultView || window;
1190}
1191

vendor: 5,442 bytes, lines 1192-1353

1192// node_modules/@suid/base/ModalUnstyled/ModalManager.js
1193function isOverflowing(container) {
1194  const doc = ownerDocument(container);
1195  if (doc.body === container) {
1196    return ownerWindow(container).innerWidth > doc.documentElement.clientWidth;
1197  }
1198  return container.scrollHeight > container.clientHeight;
1199}
1200function ariaHidden(element, show) {
1201  if (show) {
1202    element.setAttribute("aria-hidden", "true");
1203  } else {
1204    element.removeAttribute("aria-hidden");
1205  }
1206}
1207function getPaddingRight(element) {
1208  return parseInt(ownerWindow(element).getComputedStyle(element).paddingRight, 10) || 0;
1209}
1210function ariaHiddenSiblings(container, mountElement, elementsToExclude = [], show) {
1211  const blacklist = [mountElement, ...elementsToExclude];
1212  const blacklistTagNames = ["TEMPLATE", "SCRIPT", "STYLE"];
1213  [].forEach.call(container.children, (element) => {
1214    if (blacklist.indexOf(element) === -1 && blacklistTagNames.indexOf(element.tagName) === -1) {
1215      ariaHidden(element, show);
1216    }
1217  });
1218}
1219function findIndexOf(items, callback) {
1220  let idx = -1;
1221  items.some((item, index) => {
1222    if (callback(item)) {
1223      idx = index;
1224      return true;
1225    }
1226    return false;
1227  });
1228  return idx;
1229}
1230function handleContainer(containerInfo, props) {
1231  const restoreStyle = [];
1232  const container = containerInfo.container;
1233  if (!props.disableScrollLock) {
1234    if (isOverflowing(container)) {
1235      const scrollbarSize = getScrollbarSize(ownerDocument(container));
1236      restoreStyle.push({
1237        value: container.style.paddingRight,
1238        property: "padding-right",
1239        el: container
1240      });
1241      container.style.paddingRight = `${getPaddingRight(container) + scrollbarSize}px`;
1242      const fixedElements = ownerDocument(container).querySelectorAll(".mui-fixed");
1243      [].forEach.call(fixedElements, (element) => {
1244        restoreStyle.push({
1245          value: element.style.paddingRight,
1246          property: "padding-right",
1247          el: element
1248        });
1249        element.style.paddingRight = `${getPaddingRight(element) + scrollbarSize}px`;
1250      });
1251    }
1252    const parent = container.parentElement;
1253    const containerWindow = ownerWindow(container);
1254    const scrollContainer = parent?.nodeName === "HTML" && containerWindow.getComputedStyle(parent).overflowY === "scroll" ? parent : container;
1255    restoreStyle.push({
1256      value: scrollContainer.style.overflow,
1257      property: "overflow",
1258      el: scrollContainer
1259    }, {
1260      value: scrollContainer.style.overflowX,
1261      property: "overflow-x",
1262      el: scrollContainer
1263    }, {
1264      value: scrollContainer.style.overflowY,
1265      property: "overflow-y",
1266      el: scrollContainer
1267    });
1268    scrollContainer.style.overflow = "hidden";
1269  }
1270  const restore = () => {
1271    restoreStyle.forEach(({ value, el, property }) => {
1272      if (value) {
1273        el.style.setProperty(property, value);
1274      } else {
1275        el.style.removeProperty(property);
1276      }
1277    });
1278  };
1279  return restore;
1280}
1281function getHiddenSiblings(container) {
1282  const hiddenSiblings = [];
1283  [].forEach.call(container.children, (element) => {
1284    if (element.getAttribute("aria-hidden") === "true") {
1285      hiddenSiblings.push(element);
1286    }
1287  });
1288  return hiddenSiblings;
1289}
1290var ModalManager = class {
1291  containers;
1292  modals;
1293  constructor() {
1294    this.modals = [];
1295    this.containers = [];
1296  }
1297  add(modal, container) {
1298    let modalIndex = this.modals.findIndex((v) => v.ref === modal.ref);
1299    if (modalIndex !== -1) {
1300      return modalIndex;
1301    }
1302    modalIndex = this.modals.length;
1303    this.modals.push(modal);
1304    ariaHidden(modal.ref, false);
1305    const hiddenSiblings = getHiddenSiblings(container);
1306    ariaHiddenSiblings(container, modal.ref, hiddenSiblings, true);
1307    const containerIndex = findIndexOf(this.containers, (item) => item.container === container);
1308    if (containerIndex !== -1) {
1309      this.containers[containerIndex].modals.push(modal);
1310      return modalIndex;
1311    }
1312    this.containers.push({
1313      modals: [modal],
1314      container,
1315      restore: null,
1316      hiddenSiblings
1317    });
1318    return modalIndex;
1319  }
1320  mount(modal, props) {
1321    const containerIndex = findIndexOf(this.containers, (item) => !!item.modals.find((v) => v.ref === modal.ref));
1322    const containerInfo = this.containers[containerIndex];
1323    if (!containerInfo.restore) {
1324      containerInfo.restore = handleContainer(containerInfo, props);
1325    }
1326  }
1327  remove(modal) {
1328    const modalIndex = this.modals.findIndex((v) => v.ref === modal.ref);
1329    if (modalIndex === -1) {
1330      return modalIndex;
1331    }
1332    const containerIndex = findIndexOf(this.containers, (item) => !!item.modals.find((v) => v.ref === modal.ref));
1333    const containerInfo = this.containers[containerIndex];
1334    containerInfo.modals.splice(containerInfo.modals.findIndex((v) => v.ref === modal.ref), 1);
1335    this.modals.splice(modalIndex, 1);
1336    if (containerInfo.modals.length === 0) {
1337      if (containerInfo.restore) {
1338        containerInfo.restore();
1339      }
1340      ariaHidden(modal.ref, true);
1341      ariaHiddenSiblings(containerInfo.container, modal.ref, containerInfo.hiddenSiblings, false);
1342      this.containers.splice(containerIndex, 1);
1343    } else {
1344      const nextTop = containerInfo.modals[containerInfo.modals.length - 1];
1345      ariaHidden(nextTop.ref, false);
1346    }
1347    return modalIndex;
1348  }
1349  isTopModal(modal) {
1350    return this.modals.length > 0 && this.modals[this.modals.length - 1].ref === modal.ref;
1351  }
1352};
1353

vendor: 238 bytes, lines 1354-1359

1354// node_modules/@suid/base/ModalUnstyled/modalUnstyledClasses.js
1355function getModalUtilityClass(slot) {
1356  return generateUtilityClass("MuiModal", slot);
1357}
1358var modalUnstyledClasses = generateUtilityClasses("MuiModal", ["root", "hidden"]);
1359

vendor: 5,408 bytes, lines 1360-1523

1360// node_modules/@suid/base/ModalUnstyled/ModalUnstyled.jsx
1361var $7 = createComponentFactory_default()({
1362  name: "ModalUnstyled",
1363  propDefaults: ({
1364    set
1365  }) => set({
1366    closeAfterTransition: false,
1367    component: "div",
1368    components: {},
1369    componentsProps: {},
1370    disableAutoFocus: false,
1371    disableEnforceFocus: false,
1372    disableEscapeKeyDown: false,
1373    disablePortal: false,
1374    disableRestoreFocus: false,
1375    disableScrollLock: false,
1376    hideBackdrop: false,
1377    keepMounted: false,
1378    open: false
1379  }),
1380  selfPropNames: ["BackdropComponent", "BackdropProps", "children", "classes", "closeAfterTransition", "components", "componentsProps", "container", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "onBackdropClick", "onClose", "open", "transition"],
1381  utilityClass: getModalUtilityClass,
1382  slotClasses: (ownerState) => ({
1383    root: ["root", !ownerState.open && ownerState.exited && "hidden"]
1384  })
1385});
1386function getContainer(container) {
1387  return typeof container === "function" ? container() : container;
1388}
1389var defaultManager = new ModalManager();
1390var ModalUnstyled = $7.component(function ModalUnstyled2({
1391  allProps,
1392  otherProps,
1393  classes,
1394  props
1395}) {
1396  const element = createElementRef_default(otherProps);
1397  const manager = defaultManager;
1398  const getDoc = () => ownerDocument(element.ref);
1399  const [exited, setExited] = createSignal(true);
1400  const handleMounted = () => {
1401    manager.mount(element, {
1402      disableScrollLock: props.disableScrollLock
1403    });
1404    element.ref.scrollTop = 0;
1405  };
1406  const handleOpen = () => {
1407    const resolvedContainer = getContainer(props.container) || getDoc().body;
1408    manager.add(element, resolvedContainer);
1409    if (element.ref) {
1410      handleMounted();
1411    }
1412  };
1413  const isTopModal = () => manager.isTopModal(element);
1414  const handleClose = () => manager.remove(element);
1415  onCleanup(handleClose);
1416  createEffect((firstTime) => {
1417    if (firstTime) {
1418      if (props.open) handleOpen();
1419      if (props.open && isTopModal()) {
1420        handleMounted();
1421      } else {
1422        if (element.ref) ariaHidden(element.ref, true);
1423      }
1424    } else {
1425      if (props.open) {
1426        handleOpen();
1427      } else if (!props.transition || !props.closeAfterTransition) {
1428        handleClose();
1429      }
1430    }
1431    return false;
1432  }, true);
1433  const handleBackdropClick = (event) => {
1434    if (event.target !== event.currentTarget) {
1435      return;
1436    }
1437    props.onBackdropClick?.(event);
1438    props.onClose?.(event, "backdropClick");
1439  };
1440  const handleKeyDown2 = (event) => {
1441    if (typeof otherProps.onKeyDown === "function") otherProps.onKeyDown?.(event);
1442    if (event.key !== "Escape" || !isTopModal()) {
1443      return;
1444    }
1445    if (!props.disableEscapeKeyDown) {
1446      event.stopPropagation();
1447      props.onClose?.(event, "escapeKeyDown");
1448    }
1449  };
1450  const Root = () => props.components.Root || otherProps.component;
1451  const rootProps = () => props.componentsProps.root || {};
1452  const noMount = () => !props.keepMounted && !props.open && (!props.transition || exited());
1453  return createComponent(TransitionContext.Provider, {
1454    value: {
1455      get in() {
1456        return !!props.transition && props.open;
1457      },
1458      onEnter: () => {
1459        props.transition && setExited(false);
1460      },
1461      onExited: () => {
1462        if (props.transition) {
1463          setExited(true);
1464          if (props.closeAfterTransition) handleClose();
1465        }
1466      }
1467    },
1468    get children() {
1469      return createComponent(Show, {
1470        get when() {
1471          return !noMount();
1472        },
1473        get children() {
1474          return createComponent(Portal_default, {
1475            get container() {
1476              return props.container;
1477            },
1478            get disablePortal() {
1479              return props.disablePortal;
1480            },
1481            get children() {
1482              return createComponent(Dynamic, mergeProps(otherProps, {
1483                get component() {
1484                  return Root();
1485                },
1486                role: "presentation"
1487              }, rootProps, () => !isHostComponent_default(Root()) && {
1488                //component: baseProps.component,
1489                ownerState: allProps
1490              }, {
1491                onKeyDown: handleKeyDown2,
1492                get ["class"]() {
1493                  return clsx_m_default(classes.root, rootProps().class, otherProps.class);
1494                },
1495                ref: element,
1496                get children() {
1497                  return [createComponent(Show, {
1498                    get when() {
1499                      return !props.hideBackdrop && !!props.BackdropComponent;
1500                    },
1501                    get children() {
1502                      return createComponent(Dynamic, mergeProps({
1503                        get component() {
1504                          return props.BackdropComponent;
1505                        },
1506                        get open() {
1507                          return props.open;
1508                        },
1509                        onClick: handleBackdropClick
1510                      }, () => props.BackdropProps ?? {}));
1511                    }
1512                  }), memo(() => props.children)];
1513                }
1514              }));
1515            }
1516          });
1517        }
1518      });
1519    }
1520  });
1521});
1522var ModalUnstyled_default = ModalUnstyled;
1523

vendor: 3,300 bytes, lines 1524-1644

1524// node_modules/@suid/material/Modal/Modal.jsx
1525var $8 = createComponentFactory_default()({
1526  name: "MuiModal",
1527  selfPropNames: ["BackdropComponent", "BackdropProps"]
1528});
1529var ModalRoot = styled_default("div", {
1530  name: "MuiModal",
1531  slot: "Root",
1532  overridesResolver: (props, styles3) => {
1533    const {
1534      ownerState
1535    } = props;
1536    return [styles3.root, !ownerState.open && ownerState.exited && styles3.hidden];
1537  }
1538})(({
1539  theme,
1540  ownerState
1541}) => ({
1542  position: "fixed",
1543  zIndex: theme.zIndex.modal,
1544  right: 0,
1545  bottom: 0,
1546  top: 0,
1547  left: 0,
1548  ...!ownerState.open && ownerState.exited && {
1549    visibility: "hidden"
1550  }
1551}));
1552var ModalBackdrop = styled_default(Backdrop_default, {
1553  name: "MuiModal",
1554  slot: "Backdrop",
1555  overridesResolver: (props, styles3) => {
1556    return styles3.backdrop;
1557  }
1558})({
1559  zIndex: -1
1560});
1561var Modal = $8.defineComponent(function Modal2(inProps) {
1562  const props = $8.useThemeProps({
1563    props: inProps
1564  });
1565  const [, other] = splitProps(props, ["BackdropComponent", "closeAfterTransition", "children", "components", "componentsProps", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted"]);
1566  const baseProps = mergeProps({
1567    BackdropComponent: ModalBackdrop,
1568    closeAfterTransition: false,
1569    components: {},
1570    componentsProps: {},
1571    disableAutoFocus: false,
1572    disableEnforceFocus: false,
1573    disableEscapeKeyDown: false,
1574    disablePortal: false,
1575    disableRestoreFocus: false,
1576    disableScrollLock: false,
1577    hideBackdrop: false,
1578    keepMounted: false
1579  }, props);
1580  const [exited] = createSignal(true);
1581  const commonProps = {
1582    get closeAfterTransition() {
1583      return baseProps.closeAfterTransition;
1584    },
1585    get disableAutoFocus() {
1586      return baseProps.disableAutoFocus;
1587    },
1588    get disableEnforceFocus() {
1589      return baseProps.disableEnforceFocus;
1590    },
1591    get disableEscapeKeyDown() {
1592      return baseProps.disableEscapeKeyDown;
1593    },
1594    get disablePortal() {
1595      return baseProps.disablePortal;
1596    },
1597    get disableRestoreFocus() {
1598      return baseProps.disableRestoreFocus;
1599    },
1600    get disableScrollLock() {
1601      return baseProps.disableScrollLock;
1602    },
1603    get hideBackdrop() {
1604      return baseProps.hideBackdrop;
1605    },
1606    get keepMounted() {
1607      return baseProps.keepMounted;
1608    }
1609  };
1610  const ownerState = mergeProps(props, commonProps, {
1611    get exited() {
1612      return exited();
1613    }
1614  });
1615  return createComponent(ModalUnstyled_default, mergeProps({
1616    get components() {
1617      return mergeProps({
1618        Root: ModalRoot
1619      }, () => baseProps.components);
1620    },
1621    componentsProps: {
1622      get root() {
1623        return mergeProps(() => baseProps.componentsProps.root || {}, () => (!baseProps.components.Root || !isHostComponent_default(baseProps.components.Root)) && {
1624          get ownerState() {
1625            return baseProps.componentsProps.root?.ownerState || {};
1626          }
1627        } || {});
1628      }
1629    },
1630    get BackdropComponent() {
1631      return baseProps.BackdropComponent;
1632    }
1633  }, other, {
1634    get classes() {
1635      return ownerState.classes;
1636    }
1637  }, commonProps, {
1638    get children() {
1639      return props.children;
1640    }
1641  }));
1642});
1643var Modal_default = Modal;
1644

vendor: 138 bytes, lines 1645-1648

1645// node_modules/@suid/material/Dialog/DialogContext.js
1646var DialogContext = createContext({});
1647var DialogContext_default = DialogContext;
1648

vendor: 515 bytes, lines 1649-1671

1649// node_modules/@suid/material/Dialog/dialogClasses.js
1650function getDialogUtilityClass(slot) {
1651  return generateUtilityClass("MuiDialog", slot);
1652}
1653var dialogClasses = generateUtilityClasses("MuiDialog", [
1654  "root",
1655  "scrollPaper",
1656  "scrollBody",
1657  "container",
1658  "paper",
1659  "paperScrollPaper",
1660  "paperScrollBody",
1661  "paperWidthFalse",
1662  "paperWidthXs",
1663  "paperWidthSm",
1664  "paperWidthMd",
1665  "paperWidthLg",
1666  "paperWidthXl",
1667  "paperFullWidth",
1668  "paperFullScreen"
1669]);
1670var dialogClasses_default = dialogClasses;
1671

vendor: 188 bytes, lines 1672-1676

1672// node_modules/@suid/material/node_modules/@suid/utils/createUniqueId.js
1673function createUniqueId3(idOverride) {
1674  return createMemo(() => idOverride?.() ?? `mui-${createUniqueId()}`);
1675}
1676

vendor: 370 bytes, lines 1677-1692

1677// node_modules/@suid/material/node_modules/@suid/utils/debounce.js
1678function debounce2(func, wait = 166) {
1679  let timeout;
1680  function debounced(...args) {
1681    const later = () => {
1682      func.apply(null, args);
1683    };
1684    clearTimeout(timeout);
1685    timeout = setTimeout(later, wait);
1686  }
1687  debounced.clear = () => {
1688    clearTimeout(timeout);
1689  };
1690  return debounced;
1691}
1692

vendor: 157 bytes, lines 1693-1697

1693// node_modules/@suid/material/node_modules/@suid/utils/ownerDocument.js
1694function ownerDocument2(node) {
1695  return node && node.ownerDocument || document;
1696}
1697

vendor: 176 bytes, lines 1698-1703

1698// node_modules/@suid/material/node_modules/@suid/utils/ownerWindow.js
1699function ownerWindow2(node) {
1700  const doc = ownerDocument2(node);
1701  return doc.defaultView || window;
1702}
1703

vendor: 168 bytes, lines 1704-1708

1704// node_modules/@suid/material/node_modules/@suid/utils/randomString.js
1705function randomString2() {
1706  return Math.random().toString(36).substring(2, 15).slice(0, 8);
1707}
1708

vendor: 8,165 bytes, lines 1709-1971

1709// node_modules/@suid/material/Dialog/Dialog.jsx
1710var $9 = createComponentFactory_default()({
1711  name: "MuiDialog",
1712  selfPropNames: ["aria-describedby", "aria-labelledby", "children", "classes", "disableEscapeKeyDown", "fullScreen", "fullWidth", "maxWidth", "onBackdropClick", "onClose", "open", "PaperComponent", "PaperProps", "scroll", "TransitionComponent", "transitionDuration", "TransitionProps"],
1713  utilityClass: getDialogUtilityClass,
1714  slotClasses: (ownerState) => ({
1715    root: ["root"],
1716    container: ["container", `scroll${capitalize(ownerState.scroll)}`],
1717    paper: ["paper", `paperScroll${capitalize(ownerState.scroll)}`, `paperWidth${capitalize(String(ownerState.maxWidth))}`, ownerState.fullWidth && "paperFullWidth", ownerState.fullScreen && "paperFullScreen"]
1718  })
1719});
1720var DialogBackdrop = styled_default(Backdrop_default, {
1721  name: "MuiDialog",
1722  slot: "Backdrop"
1723  //overrides: (props, styles) => styles.backdrop,
1724})({
1725  // Improve scrollable dialog support.
1726  zIndex: -1
1727});
1728var DialogRoot = styled_default(Modal_default, {
1729  name: "MuiDialog",
1730  slot: "Root",
1731  overridesResolver: (props, styles3) => styles3.root
1732})({
1733  "@media print": {
1734    // Use !important to override the Modal inline-style.
1735    position: "absolute !important"
1736  }
1737});
1738var DialogContainer = styled_default("div", {
1739  name: "MuiDialog",
1740  slot: "Container",
1741  overridesResolver: (props, styles3) => {
1742    const {
1743      ownerState
1744    } = props;
1745    return [styles3.container, styles3[`scroll${capitalize(ownerState.scroll)}`]];
1746  }
1747})(({
1748  ownerState
1749}) => ({
1750  height: "100%",
1751  "@media print": {
1752    height: "auto"
1753  },
1754  // We disable the focus ring for mouse, touch and keyboard users.
1755  outline: 0,
1756  ...ownerState.scroll === "paper" && {
1757    display: "flex",
1758    justifyContent: "center",
1759    alignItems: "center"
1760  },
1761  ...ownerState.scroll === "body" && {
1762    overflowY: "auto",
1763    overflowX: "hidden",
1764    textAlign: "center",
1765    "&:after": {
1766      content: '""',
1767      display: "inline-block",
1768      verticalAlign: "middle",
1769      height: "100%",
1770      width: "0"
1771    }
1772  }
1773}));
1774var DialogPaper = styled_default(Paper_default, {
1775  name: "MuiDialog",
1776  slot: "Paper",
1777  overridesResolver: (props, styles3) => {
1778    const {
1779      ownerState
1780    } = props;
1781    return [styles3.paper, styles3[`scrollPaper${capitalize(ownerState.scroll)}`], styles3[`paperWidth${capitalize(String(ownerState.maxWidth))}`], ownerState.fullWidth && styles3.paperFullWidth, ownerState.fullScreen && styles3.paperFullScreen];
1782  }
1783})(({
1784  theme,
1785  ownerState
1786}) => ({
1787  margin: 32,
1788  position: "relative",
1789  overflowY: "auto",
1790  "@media print": {
1791    overflowY: "visible",
1792    boxShadow: "none"
1793  },
1794  ...ownerState.scroll === "paper" && {
1795    display: "flex",
1796    flexDirection: "column",
1797    maxHeight: "calc(100% - 64px)"
1798  },
1799  ...ownerState.scroll === "body" && {
1800    display: "inline-block",
1801    verticalAlign: "middle",
1802    textAlign: "left"
1803    // 'initial' doesn't work on IE11
1804  },
1805  ...!ownerState.maxWidth && {
1806    maxWidth: "calc(100% - 64px)"
1807  },
1808  ...ownerState.maxWidth === "xs" && {
1809    maxWidth: theme.breakpoints.unit === "px" ? Math.max(theme.breakpoints.values.xs, 444) : `${theme.breakpoints.values.xs}${theme.breakpoints.unit}`,
1810    [`&.${dialogClasses_default.paperScrollBody}`]: {
1811      [theme.breakpoints.down(Math.max(theme.breakpoints.values.xs, 444) + 32 * 2)]: {
1812        maxWidth: "calc(100% - 64px)"
1813      }
1814    }
1815  },
1816  ...ownerState.maxWidth !== "xs" && {
1817    maxWidth: `${theme.breakpoints.values[ownerState.maxWidth]}${theme.breakpoints.unit}`,
1818    [`&.${dialogClasses_default.paperScrollBody}`]: {
1819      [theme.breakpoints.down(theme.breakpoints.values[ownerState.maxWidth] + 32 * 2)]: {
1820        maxWidth: "calc(100% - 64px)"
1821      }
1822    }
1823  },
1824  ...ownerState.fullWidth && {
1825    width: "calc(100% - 64px)"
1826  },
1827  ...ownerState.fullScreen && {
1828    margin: 0,
1829    width: "100%",
1830    maxWidth: "100%",
1831    height: "100%",
1832    maxHeight: "none",
1833    borderRadius: 0,
1834    [`&.${dialogClasses_default.paperScrollBody}`]: {
1835      margin: 0,
1836      maxWidth: "100%"
1837    }
1838  }
1839}));
1840var Dialog = $9.defineComponent(function Dialog2(inProps) {
1841  const ref = createRef_default(inProps);
1842  const props = $9.useThemeProps({
1843    props: inProps
1844  });
1845  const theme = useTheme_default();
1846  const defaultTransitionDuration = {
1847    get enter() {
1848      return theme.transitions.duration.enteringScreen;
1849    },
1850    get exit() {
1851      return theme.transitions.duration.leavingScreen;
1852    }
1853  };
1854  const [, other] = splitProps(props, ["aria-describedby", "aria-labelledby", "BackdropComponent", "BackdropProps", "children", "class", "disableEscapeKeyDown", "fullScreen", "fullWidth", "maxWidth", "onBackdropClick", "onClose", "open", "PaperComponent", "PaperProps", "scroll", "TransitionComponent", "transitionDuration", "TransitionProps"]);
1855  const baseProps = mergeProps({
1856    disableEscapeKeyDown: false,
1857    fullScreen: false,
1858    fullWidth: false,
1859    maxWidth: "sm",
1860    PaperComponent: Paper_default,
1861    PaperProps: {},
1862    scroll: "paper",
1863    TransitionComponent: Fade_default,
1864    transitionDuration: defaultTransitionDuration
1865  }, props);
1866  const ownerState = baseProps;
1867  const classes = $9.useClasses(ownerState);
1868  let backdropClick = null;
1869  const handleMouseDown = (event) => {
1870    backdropClick = event.target === event.currentTarget;
1871  };
1872  const handleBackdropClick = (event) => {
1873    if (!backdropClick) {
1874      return;
1875    }
1876    backdropClick = null;
1877    if (props.onBackdropClick) {
1878      props.onBackdropClick(event);
1879    }
1880    if (props.onClose) {
1881      props.onClose(event, "backdropClick");
1882    }
1883  };
1884  const ariaLabelledby = createUniqueId3(() => props["aria-labelledby"]);
1885  const dialogContextValue = {
1886    get titleId() {
1887      return ariaLabelledby();
1888    }
1889  };
1890  return createComponent(DialogRoot, mergeProps({
1891    get ["class"]() {
1892      return clsx_m_default(classes.root, props.class);
1893    },
1894    get BackdropProps() {
1895      return mergeProps({
1896        get transitionDuration() {
1897          return baseProps.transitionDuration;
1898        },
1899        get as() {
1900          return props.BackdropComponent;
1901        }
1902      }, () => props.BackdropProps);
1903    },
1904    closeAfterTransition: true,
1905    BackdropComponent: DialogBackdrop,
1906    get disableEscapeKeyDown() {
1907      return baseProps.disableEscapeKeyDown;
1908    },
1909    get onClose() {
1910      return props.onClose;
1911    },
1912    get open() {
1913      return props.open;
1914    },
1915    ref,
1916    onClick: handleBackdropClick,
1917    ownerState
1918  }, other, {
1919    get children() {
1920      return createComponent(baseProps.TransitionComponent, mergeProps({
1921        appear: true,
1922        get ["in"]() {
1923          return props.open;
1924        },
1925        get timeout() {
1926          return baseProps.transitionDuration;
1927        }
1928      }, () => props.TransitionProps, {
1929        get children() {
1930          return createComponent(DialogContainer, {
1931            get ["class"]() {
1932              return clsx_m_default(classes.container);
1933            },
1934            onMouseDown: handleMouseDown,
1935            ownerState,
1936            get children() {
1937              return createComponent(DialogPaper, mergeProps({
1938                get component() {
1939                  return baseProps.PaperComponent;
1940                },
1941                elevation: 24,
1942                role: "dialog",
1943                get ["aria-describedby"]() {
1944                  return props["aria-describedby"];
1945                },
1946                get ["aria-labelledby"]() {
1947                  return ariaLabelledby();
1948                }
1949              }, () => baseProps.PaperProps, {
1950                get ["class"]() {
1951                  return clsx_m_default(classes.paper, baseProps.PaperProps.class);
1952                },
1953                ownerState,
1954                get children() {
1955                  return createComponent(DialogContext_default.Provider, {
1956                    value: dialogContextValue,
1957                    get children() {
1958                      return props.children;
1959                    }
1960                  });
1961                }
1962              }));
1963            }
1964          });
1965        }
1966      }));
1967    }
1968  }));
1969});
1970var Dialog_default = Dialog;
1971

vendor: 267 bytes, lines 1972-1977

1972// node_modules/@suid/material/DialogActions/dialogActionsClasses.js
1973function getDialogActionsUtilityClass(slot) {
1974  return generateUtilityClass("MuiDialogActions", slot);
1975}
1976var dialogActionsClasses = generateUtilityClasses("MuiDialogActions", ["root", "spacing"]);
1977

vendor: 1,416 bytes, lines 1978-2028

1978// node_modules/@suid/material/DialogActions/DialogActions.jsx
1979var $10 = createComponentFactory_default()({
1980  name: "MuiDialogActions",
1981  selfPropNames: ["children", "classes", "disableSpacing"],
1982  utilityClass: getDialogActionsUtilityClass,
1983  slotClasses: (ownerState) => ({
1984    root: ["root", !ownerState.disableSpacing && "spacing"]
1985  })
1986});
1987var DialogActionsRoot = styled_default("div", {
1988  name: "MuiDialogActions",
1989  slot: "Root",
1990  overridesResolver: (props, styles3) => {
1991    const {
1992      ownerState
1993    } = props;
1994    return [styles3.root, !ownerState.disableSpacing && styles3.spacing];
1995  }
1996})(({
1997  ownerState
1998}) => ({
1999  display: "flex",
2000  alignItems: "center",
2001  padding: 8,
2002  justifyContent: "flex-end",
2003  flex: "0 0 auto",
2004  ...!ownerState.disableSpacing && {
2005    "& > :not(:first-of-type)": {
2006      marginLeft: 8
2007    }
2008  }
2009}));
2010var DialogActions = $10.defineComponent(function DialogActions2(inProps) {
2011  const props = $10.useThemeProps({
2012    props: inProps
2013  });
2014  const [, other] = splitProps(props, ["class", "disableSpacing"]);
2015  const baseProps = mergeProps({
2016    disableSpacing: false
2017  }, props);
2018  const ownerState = baseProps;
2019  const classes = $10.useClasses(ownerState);
2020  return createComponent(DialogActionsRoot, mergeProps({
2021    get ["class"]() {
2022      return clsx_m_default(classes.root, props.class);
2023    },
2024    ownerState
2025  }, other));
2026});
2027var DialogActions_default = DialogActions;
2028

vendor: 297 bytes, lines 2029-2035

2029// node_modules/@suid/material/DialogTitle/dialogTitleClasses.js
2030function getDialogTitleUtilityClass(slot) {
2031  return generateUtilityClass("MuiDialogTitle", slot);
2032}
2033var dialogTitleClasses = generateUtilityClasses("MuiDialogTitle", ["root"]);
2034var dialogTitleClasses_default = dialogTitleClasses;
2035

vendor: 268 bytes, lines 2036-2041

2036// node_modules/@suid/material/DialogContent/dialogContentClasses.js
2037function getDialogContentUtilityClass(slot) {
2038  return generateUtilityClass("MuiDialogContent", slot);
2039}
2040var dialogContentClasses = generateUtilityClasses("MuiDialogContent", ["root", "dividers"]);
2041

vendor: 1,800 bytes, lines 2042-2104

2042// node_modules/@suid/material/DialogContent/DialogContent.jsx
2043var $11 = createComponentFactory_default()({
2044  name: "MuiDialogContent",
2045  selfPropNames: ["children", "classes", "dividers"],
2046  utilityClass: getDialogContentUtilityClass,
2047  slotClasses: (ownerState) => ({
2048    root: ["root", ownerState.dividers && "dividers"]
2049  })
2050});
2051var DialogContentRoot = styled_default("div", {
2052  name: "MuiDialogContent",
2053  slot: "Root",
2054  overridesResolver: (props, styles3) => {
2055    const {
2056      ownerState
2057    } = props;
2058    return [styles3.root, ownerState.dividers && styles3.dividers];
2059  }
2060})(({
2061  theme,
2062  ownerState
2063}) => ({
2064  flex: "1 1 auto",
2065  // Add iOS momentum scrolling for iOS < 13.0
2066  WebkitOverflowScrolling: "touch",
2067  overflowY: "auto",
2068  // https://github.com/microsoft/TypeScript/issues/37559
2069  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
2070  // @ts-ignore
2071  padding: "20px 24px",
2072  ...ownerState.dividers ? {
2073    padding: "16px 24px",
2074    borderTop: `1px solid ${theme.palette.divider}`,
2075    borderBottom: `1px solid ${theme.palette.divider}`
2076  } : {
2077    [`.${dialogTitleClasses_default.root} + &`]: {
2078      paddingTop: 0
2079    }
2080  }
2081}));
2082var DialogContent = $11.defineComponent(function DialogContent2(inProps) {
2083  const props = $11.useThemeProps({
2084    props: inProps
2085  });
2086  const [, other] = splitProps(props, ["class", "dividers"]);
2087  const baseProps = mergeProps({
2088    dividers: false
2089  }, props);
2090  const ownerState = mergeProps(props, {
2091    get dividers() {
2092      return baseProps.dividers;
2093    }
2094  });
2095  const classes = $11.useClasses(ownerState);
2096  return createComponent(DialogContentRoot, mergeProps({
2097    get ["class"]() {
2098      return clsx_m_default(classes.root, props.class);
2099    },
2100    ownerState
2101  }, other));
2102});
2103var DialogContent_default = DialogContent;
2104

vendor: 280 bytes, lines 2105-2110

2105// node_modules/@suid/material/DialogContentText/dialogContentTextClasses.js
2106function getDialogContentTextUtilityClass(slot) {
2107  return generateUtilityClass("MuiDialogContentText", slot);
2108}
2109var dialogContentTextClasses = generateUtilityClasses("MuiDialogContentText", ["root"]);
2110

vendor: 1,095 bytes, lines 2111-2146

2111// node_modules/@suid/material/DialogContentText/DialogContentText.jsx
2112var $12 = createComponentFactory_default()({
2113  name: "MuiDialogContentText",
2114  selfPropNames: ["classes"],
2115  utilityClass: getDialogContentTextUtilityClass,
2116  slotClasses: () => ({
2117    root: ["root"]
2118  })
2119});
2120var DialogContentTextRoot = styled_default(Typography_default, {
2121  skipProps: skipRootProps.filter((v) => v !== "classes"),
2122  name: "MuiDialogContentText",
2123  slot: "Root",
2124  overridesResolver: (props, styles3) => styles3.root
2125})({});
2126var DialogContentText = $12.defineComponent(function DialogContentText2(inProps) {
2127  const ref = createRef_default(inProps);
2128  const props = $12.useThemeProps({
2129    props: inProps
2130  });
2131  const [, ownerState] = splitProps(props, ["children"]);
2132  const classes = $12.useClasses(ownerState);
2133  return createComponent(DialogContentTextRoot, mergeProps({
2134    variant: "body1",
2135    color: "text.secondary",
2136    ref,
2137    ownerState
2138  }, props, {
2139    get component() {
2140      return props.component ?? "p";
2141    },
2142    classes
2143  }));
2144});
2145var DialogContentText_default = DialogContentText;
2146

vendor: 1,194 bytes, lines 2147-2189

2147// node_modules/@suid/material/DialogTitle/DialogTitle.jsx
2148var $13 = createComponentFactory_default()({
2149  name: "MuiDialogTitle",
2150  selfPropNames: ["children", "classes"],
2151  utilityClass: getDialogTitleUtilityClass,
2152  slotClasses: () => ({
2153    root: ["root"]
2154  })
2155});
2156var DialogTitleRoot = styled_default(Typography_default, {
2157  name: "MuiDialogTitle",
2158  slot: "Root",
2159  overridesResolver: (props, styles3) => styles3.root
2160})({
2161  padding: "16px 24px",
2162  flex: "0 0 auto"
2163});
2164var DialogTitle = $13.defineComponent(function DialogTitle2(inProps) {
2165  const props = $13.useThemeProps({
2166    props: inProps
2167  });
2168  const [, other] = splitProps(props, ["class", "id"]);
2169  const ownerState = props;
2170  const classes = $13.useClasses(ownerState);
2171  const context = useContext(DialogContext_default);
2172  const titleId = () => context.titleId ?? props.id;
2173  return createComponent(DialogTitleRoot, mergeProps({
2174    get ["class"]() {
2175      return clsx_m_default(classes.root, props.class);
2176    },
2177    ownerState,
2178    variant: "h6",
2179    get id() {
2180      return titleId();
2181    }
2182  }, other, {
2183    get component() {
2184      return props.component ?? "h2";
2185    }
2186  }));
2187});
2188var DialogTitle_default = DialogTitle;
2189

vendor: 142 bytes, lines 2190-2195

2190// node_modules/@suid/system/defineComponent.js
2191function defineComponent(cb) {
2192  return cb;
2193}
2194var defineComponent_default = defineComponent;
2195

vendor: 108 bytes, lines 2196-2199

2196// node_modules/@suid/system/styled.jsx
2197var styled = createStyled_default();
2198var styled_default2 = styled;
2199

vendor: 446 bytes, lines 2200-2216

2200// node_modules/@suid/system/Box/Box.jsx
2201var BoxRoot = styled_default2("div", {
2202  name: "MuiBox",
2203  slot: "Root",
2204  skipProps: [...skipProps, "component"]
2205})();
2206var Box = defineComponent_default(function Box2(inProps) {
2207  inProps = extendSxProp(inProps);
2208  return createComponent(BoxRoot, mergeProps(inProps, {
2209    get as() {
2210      return inProps.as ?? inProps.component;
2211    }
2212  }));
2213});
2214Box.toString = BoxRoot.toString;
2215var Box_default = Box;
2216

vendor: 535 bytes, lines 2217-2240

2217// node_modules/@suid/material/Box/Box.jsx
2218var $14 = createComponentFactory_default()({
2219  name: "MuiBox",
2220  selfPropNames: [],
2221  utilityClass: (slot) => `MuiBox-${slot}`,
2222  slotClasses: () => ({
2223    root: ["root"]
2224  })
2225});
2226var Box3 = $14.component(function Box4({
2227  otherProps,
2228  classes
2229}) {
2230  const theme = useTheme_default();
2231  return createComponent(Box_default, mergeProps({
2232    theme
2233  }, otherProps, {
2234    get ["class"]() {
2235      return clsx_m_default(classes.root, otherProps.class);
2236    }
2237  }));
2238});
2239var Box_default2 = Box3;
2240

vendor: 1,802 bytes, lines 2241-2298

2241// node_modules/@suid/material/ButtonBase/Ripple.jsx
2242var _tmpl$ = /* @__PURE__ */ template(`<span>`);
2243var $15 = createComponentFactory_default()({
2244  name: "MuiRipple",
2245  selfPropNames: ["class", "classes", "pulsate", "rippleX", "rippleY", "rippleSize", "in", "onExited", "timeout"]
2246});
2247var Ripple = $15.component(function Ripple2({
2248  props,
2249  otherProps
2250}) {
2251  const [leaving, setLeaving] = createSignal(false);
2252  const rippleClassName = () => clsx_m_default(props.class, props.classes.ripple, props.classes.rippleVisible, props.classes.ripplePulsate && {
2253    [props.classes.ripplePulsate]: props.pulsate
2254  });
2255  const rippleStyles = () => ({
2256    width: `${props.rippleSize}px`,
2257    height: `${props.rippleSize}px`,
2258    top: `${-(props.rippleSize / 2) + props.rippleY}px`,
2259    left: `${-(props.rippleSize / 2) + props.rippleX}px`
2260  });
2261  const childClassName = () => clsx_m_default(props.classes.child, props.classes.childLeaving && {
2262    [props.classes.childLeaving]: leaving()
2263  }, props.classes.childPulsate && {
2264    [props.classes.childPulsate]: props.pulsate
2265  });
2266  createEffect(() => {
2267    if (!props.in && !leaving()) {
2268      setLeaving(true);
2269    }
2270  });
2271  let timeoutId;
2272  createEffect(() => {
2273    if (!props.in && props.onExited) {
2274      clearTimeout(timeoutId);
2275      timeoutId = window.setTimeout(props.onExited, props.timeout);
2276    }
2277  });
2278  onCleanup(() => clearTimeout(timeoutId));
2279  return createComponent(Box_default2, {
2280    as: "span",
2281    get ["class"]() {
2282      return rippleClassName();
2283    },
2284    get style() {
2285      return rippleStyles();
2286    },
2287    get sx() {
2288      return otherProps.sx;
2289    },
2290    get children() {
2291      const _el$ = _tmpl$();
2292      createRenderEffect(() => className(_el$, childClassName()));
2293      return _el$;
2294    }
2295  });
2296});
2297var Ripple_default = Ripple;
2298

vendor: 296 bytes, lines 2299-2310

2299// node_modules/@suid/material/ButtonBase/touchRippleClasses.js
2300var touchRippleClasses = generateUtilityClasses("MuiTouchRipple", [
2301  "root",
2302  "ripple",
2303  "rippleVisible",
2304  "ripplePulsate",
2305  "child",
2306  "childLeaving",
2307  "childPulsate"
2308]);
2309var touchRippleClasses_default = touchRippleClasses;
2310

vendor: 7,548 bytes, lines 2311-2582

2311// node_modules/@suid/material/ButtonBase/TouchRipple.jsx
2312var $16 = createComponentFactory_default()({
2313  name: "MuiTouchRipple",
2314  selfPropNames: ["center", "classes", "ref"]
2315});
2316var DURATION = 550;
2317var DELAY_RIPPLE = 80;
2318var TouchRippleRoot = styled_default("span", {
2319  name: "MuiTouchRipple",
2320  slot: "Root"
2321})({
2322  overflow: "hidden",
2323  pointerEvents: "none",
2324  position: "absolute",
2325  zIndex: 0,
2326  top: 0,
2327  right: 0,
2328  bottom: 0,
2329  left: 0,
2330  borderRadius: "inherit"
2331});
2332var TouchRippleRipple = styled_default(Ripple_default, {
2333  name: "MuiTouchRipple",
2334  slot: "Ripple"
2335})(({
2336  theme
2337}) => ({
2338  position: "absolute",
2339  "@keyframes animation-enter-$id": {
2340    0: {
2341      transform: "scale(0)",
2342      opacity: 0.1
2343    },
2344    100: {
2345      transform: "scale(1)",
2346      opacity: 0.3
2347    }
2348  },
2349  "@keyframes animation-exit-$id": {
2350    0: {
2351      opacity: 1
2352    },
2353    100: {
2354      opacity: 0
2355    }
2356  },
2357  "@keyframes animation-pulsate-$id": {
2358    0: {
2359      transform: "scale(1)"
2360    },
2361    50: {
2362      transform: "scale(0.92)"
2363    },
2364    100: {
2365      transform: "scale(1)"
2366    }
2367  },
2368  [`&.${touchRippleClasses_default.rippleVisible}`]: {
2369    opacity: "0.3",
2370    transform: "scale(1)",
2371    animationName: `animation-enter-$id`,
2372    animationDuration: `${DURATION}ms`,
2373    animationTimingFunction: theme.transitions.easing.easeInOut
2374  },
2375  [`&.${touchRippleClasses_default.ripplePulsate}`]: {
2376    animationDuration: `${theme.transitions.duration.shorter}ms`
2377  },
2378  [`& .${touchRippleClasses_default.child}`]: {
2379    opacity: 1,
2380    display: "block",
2381    width: "100%",
2382    height: "100%",
2383    borderRadius: "50%",
2384    backgroundColor: "currentColor"
2385  },
2386  [`& .${touchRippleClasses_default.childLeaving}`]: {
2387    opacity: 0,
2388    animationName: `animation-exit-$id`,
2389    animationDuration: `${DURATION}ms`,
2390    animationTimingFunction: `${theme.transitions.easing.easeInOut}`
2391  },
2392  [`& .${touchRippleClasses_default.childPulsate}`]: {
2393    position: "absolute",
2394    left: "0px",
2395    top: 0,
2396    animationName: `animation-pulsate-$id`,
2397    animationDuration: "2500ms",
2398    animationTimingFunction: `${theme.transitions.easing.easeInOut}`,
2399    animationIterationCount: "infinite",
2400    animationDelay: "200ms"
2401  }
2402}));
2403var TouchRipple = $16.defineComponent(function TouchRipple2(inProps) {
2404  const props = mergeProps({
2405    classes: {}
2406  }, inProps);
2407  const [, otherProps] = splitProps(props, ["center", "classes", "ref"]);
2408  let counter = 0;
2409  const [ripples, setRipples] = createSignal([]);
2410  const inState = createMutable({});
2411  let rippleCallback;
2412  let ignoringMouseDown = false;
2413  let startTimer;
2414  let startTimerCommit;
2415  const container = createElementRef_default();
2416  const activeIds = [];
2417  onCleanup(() => {
2418    if (startTimer) clearTimeout(startTimer);
2419  });
2420  createEffect(() => {
2421    ripples();
2422    if (rippleCallback) {
2423      rippleCallback();
2424      rippleCallback = void 0;
2425    }
2426  });
2427  const startCommit = (params) => {
2428    const id = counter++;
2429    activeIds.push(id);
2430    inState[id] = true;
2431    setRipples((oldRipples) => [...oldRipples, {
2432      id,
2433      params
2434    }]);
2435    rippleCallback = params.cb;
2436  };
2437  const start = (event, options = {
2438    pulsate: false,
2439    center: props.center
2440  }, cb) => {
2441    options = mergeProps(options, {
2442      center: options.center || options.pulsate
2443    });
2444    if (event.type === "mousedown" && ignoringMouseDown) {
2445      ignoringMouseDown = false;
2446      return;
2447    }
2448    if (event.type === "touchstart") {
2449      ignoringMouseDown = true;
2450    }
2451    const rect = container.ref ? container.ref.getBoundingClientRect() : {
2452      width: 0,
2453      height: 0,
2454      left: 0,
2455      top: 0
2456    };
2457    let rippleX;
2458    let rippleY;
2459    let rippleSize;
2460    if (options.center || event.clientX === 0 && event.clientY === 0 || !event.clientX && !event.touches) {
2461      rippleX = Math.round(rect.width / 2);
2462      rippleY = Math.round(rect.height / 2);
2463    } else {
2464      const {
2465        clientX,
2466        clientY
2467      } = event.touches ? event.touches[0] : event;
2468      rippleX = Math.round(clientX - rect.left);
2469      rippleY = Math.round(clientY - rect.top);
2470    }
2471    if (options.center) {
2472      rippleSize = Math.sqrt((2 * rect.width ** 2 + rect.height ** 2) / 3);
2473      if (rippleSize % 2 === 0) {
2474        rippleSize += 1;
2475      }
2476    } else {
2477      const sizeX = Math.max(Math.abs((container.ref ? container.ref.clientWidth : 0) - rippleX), rippleX) * 2 + 2;
2478      const sizeY = Math.max(Math.abs((container.ref ? container.ref.clientHeight : 0) - rippleY), rippleY) * 2 + 2;
2479      rippleSize = Math.sqrt(sizeX ** 2 + sizeY ** 2);
2480    }
2481    if (event.touches) {
2482      if (!startTimerCommit) {
2483        startTimerCommit = () => {
2484          startCommit({
2485            pulsate: options.pulsate,
2486            rippleX,
2487            rippleY,
2488            rippleSize,
2489            cb
2490          });
2491        };
2492        startTimer = setTimeout(() => {
2493          if (startTimerCommit) {
2494            startTimerCommit();
2495            startTimerCommit = void 0;
2496          }
2497        }, DELAY_RIPPLE);
2498      }
2499    } else {
2500      startCommit({
2501        pulsate: options.pulsate,
2502        rippleX,
2503        rippleY,
2504        rippleSize,
2505        cb
2506      });
2507    }
2508  };
2509  const pulsate = () => start({}, {
2510    pulsate: true
2511  });
2512  const stop = (event, cb) => {
2513    clearTimeout(startTimer);
2514    if (event.type === "touchend" && startTimerCommit) {
2515      startTimerCommit();
2516      startTimerCommit = void 0;
2517      startTimer = setTimeout(() => {
2518        stop(event, cb);
2519      });
2520      return;
2521    }
2522    for (const id in inState) inState[id] = false;
2523    startTimerCommit = void 0;
2524    rippleCallback = cb;
2525  };
2526  const actions = {
2527    pulsate,
2528    start,
2529    stop
2530  };
2531  if (typeof props.ref === "function") {
2532    props.ref(actions);
2533  }
2534  return createComponent(TouchRippleRoot, mergeProps({
2535    get ["class"]() {
2536      return clsx_m_default(props.classes.root, touchRippleClasses_default.root, otherProps.class);
2537    },
2538    ref: container
2539  }, otherProps, {
2540    get children() {
2541      return createComponent(For, {
2542        get each() {
2543          return ripples();
2544        },
2545        children: (data) => createComponent(TouchRippleRipple, {
2546          get ["in"]() {
2547            return inState[data.id];
2548          },
2549          onExited: () => {
2550            setRipples((oldRipples) => oldRipples.filter((v) => v.id !== data.id));
2551            delete inState[data.id];
2552          },
2553          get classes() {
2554            return {
2555              ripple: clsx_m_default(props.classes.ripple, touchRippleClasses_default.ripple),
2556              rippleVisible: clsx_m_default(props.classes.rippleVisible, touchRippleClasses_default.rippleVisible),
2557              ripplePulsate: clsx_m_default(props.classes.ripplePulsate, touchRippleClasses_default.ripplePulsate),
2558              child: clsx_m_default(props.classes.child, touchRippleClasses_default.child),
2559              childLeaving: clsx_m_default(props.classes.childLeaving, touchRippleClasses_default.childLeaving),
2560              childPulsate: clsx_m_default(props.classes.childPulsate, touchRippleClasses_default.childPulsate)
2561            };
2562          },
2563          timeout: DURATION,
2564          get pulsate() {
2565            return data.params.pulsate;
2566          },
2567          get rippleX() {
2568            return data.params.rippleX;
2569          },
2570          get rippleY() {
2571            return data.params.rippleY;
2572          },
2573          get rippleSize() {
2574            return data.params.rippleSize;
2575          }
2576        })
2577      });
2578    }
2579  }));
2580});
2581var TouchRipple_default = TouchRipple;
2582

vendor: 317 bytes, lines 2583-2589

2583// node_modules/@suid/material/ButtonBase/buttonBaseClasses.js
2584function getButtonBaseUtilityClass(slot) {
2585  return generateUtilityClass("MuiButtonBase", slot);
2586}
2587var buttonBaseClasses = generateUtilityClasses("MuiButtonBase", ["root", "disabled", "focusVisible"]);
2588var buttonBaseClasses_default = buttonBaseClasses;
2589

vendor: 8,494 bytes, lines 2590-2840

2590// node_modules/@suid/material/ButtonBase/ButtonBase.jsx
2591var $17 = createComponentFactory_default()({
2592  name: "MuiButtonBase",
2593  selfPropNames: ["LinkComponent", "TouchRippleProps", "action", "centerRipple", "children", "classes", "disableRipple", "disableRipple", "disableTouchRipple", "disabled", "focusRipple", "focusVisibleClassName", "onFocusVisible", "tabIndex", "touchRippleRef"],
2594  autoCallUseClasses: false,
2595  utilityClass: getButtonBaseUtilityClass,
2596  slotClasses: (ownerState) => ({
2597    root: ["root", ownerState.disabled && "disabled", ownerState.focusVisible && "focusVisible"]
2598  })
2599});
2600var ButtonBaseRoot = styled_default("button", {
2601  name: "MuiButtonBase",
2602  slot: "Root",
2603  overridesResolver: (props, styles3) => styles3.root
2604})({
2605  display: "inline-flex",
2606  alignItems: "center",
2607  justifyContent: "center",
2608  position: "relative",
2609  boxSizing: "border-box",
2610  ["WebkitTapHighlightColor"]: "transparent",
2611  backgroundColor: "transparent",
2612  // We disable the focus ring for mouse, touch and keyboard users.
2613  outline: 0,
2614  border: 0,
2615  margin: 0,
2616  borderRadius: 0,
2617  padding: 0,
2618  cursor: "pointer",
2619  userSelect: "none",
2620  verticalAlign: "middle",
2621  ["MozAppearance"]: "none",
2622  ["WebkitAppearance"]: "none",
2623  textDecoration: "none",
2624  // So we take precedent over the style of a native <a /> element.
2625  color: "inherit",
2626  "&::-moz-focus-inner": {
2627    borderStyle: "none"
2628    // Remove Firefox dotted outline.
2629  },
2630  [`&.${buttonBaseClasses_default.disabled}`]: {
2631    pointerEvents: "none",
2632    cursor: "default"
2633  },
2634  "@media print": {
2635    colorAdjust: "exact"
2636  }
2637});
2638var ButtonBase = $17.defineComponent(function ButtonBase2(inProps) {
2639  const theme = useTheme_default();
2640  const props = mergeProps({
2641    component: "button",
2642    LinkComponent: "a",
2643    tabIndex: 0
2644  }, theme.components?.[$17.name]?.defaultProps, inProps);
2645  const button = createRef_default(inProps);
2646  const ripple = createRef_default(() => props.touchRippleRef);
2647  const focus = useIsFocusVisible();
2648  let keydown = false;
2649  const [focusVisible, setFocusVisible] = createSignal(false);
2650  const [mountedState, setMountedState] = createSignal(false);
2651  const [, otherProps] = splitProps(props, ["LinkComponent", "TouchRippleProps", "action", "centerRipple", "children", "classes", "disableRipple", "disableRipple", "disableTouchRipple", "disabled", "focusRipple", "focusVisibleClassName", "onFocusVisible", "tabIndex", "touchRippleRef"]);
2652  const ownerState = {
2653    get classes() {
2654      return props.classes;
2655    },
2656    get disabled() {
2657      return props.disabled || false;
2658    },
2659    get focusVisible() {
2660      return focusVisible();
2661    }
2662  };
2663  const classes = $17.useClasses(ownerState);
2664  onMount(() => {
2665    setMountedState(true);
2666  });
2667  createEffect(() => {
2668    if (props.disabled && focusVisible()) {
2669      setFocusVisible(false);
2670    }
2671  });
2672  createEffect(() => {
2673    if (focusVisible() && props.focusRipple && !props.disableRipple) {
2674      ripple.ref.pulsate();
2675    }
2676  });
2677  function useRippleHandler(rippleAction, eventCallback, skipRippleAction = props.disableTouchRipple) {
2678    return (event) => {
2679      if (typeof eventCallback === "function") {
2680        eventCallback(event);
2681      }
2682      const ignore = skipRippleAction;
2683      if (!ignore && ripple.ref) {
2684        ripple.ref[rippleAction](event);
2685      }
2686      return true;
2687    };
2688  }
2689  const handleMouseDown = useRippleHandler("start", props.onMouseDown);
2690  const handleContextMenu = useRippleHandler("stop", props.onContextMenu);
2691  const handleDragLeave = useRippleHandler("stop", props.onDragLeave);
2692  const handleMouseUp = useRippleHandler("stop", props.onMouseUp);
2693  const handleMouseLeave = useRippleHandler("stop", (event) => {
2694    if (focusVisible()) {
2695      event.preventDefault();
2696    }
2697    if (typeof props.onMouseLeave === "function") {
2698      props.onMouseLeave(event);
2699    }
2700  });
2701  const handleTouchStart = useRippleHandler("start", props.onTouchStart);
2702  const handleTouchEnd = useRippleHandler("stop", props.onTouchEnd);
2703  const handleTouchMove = useRippleHandler("stop", props.onTouchMove);
2704  const handleBlur = useRippleHandler("stop", (event) => {
2705    focus.onBlur(event);
2706    if (focus.isFocusVisibleRef.current === false) {
2707      setFocusVisible(false);
2708    }
2709    if (typeof props.onFocusOut === "function") {
2710      props.onFocusOut(event);
2711    }
2712  }, false);
2713  const handleFocus = (event) => {
2714    if (!button.ref) {
2715      button.ref = event.currentTarget;
2716    }
2717    focus.onFocus(event);
2718    if (focus.isFocusVisibleRef.current === true) {
2719      setFocusVisible(true);
2720      if (props.onFocusVisible) {
2721        props.onFocusVisible(event);
2722      }
2723    }
2724    if (typeof props.onFocusIn === "function") {
2725      props.onFocusIn(event);
2726    }
2727  };
2728  const isNonNativeButton = () => {
2729    return props.component && props.component !== "button" && !(button.ref.tagName === "A" && button.ref.hasAttribute("href"));
2730  };
2731  const handleKeyDown2 = (event) => {
2732    if (props.focusRipple && !keydown && focusVisible() && ripple.ref && event.key === " ") {
2733      keydown = true;
2734      ripple.ref.stop(event, () => {
2735        ripple.ref.start(event);
2736      });
2737    }
2738    if (event.target === event.currentTarget && isNonNativeButton() && event.key === " ") {
2739      event.preventDefault();
2740    }
2741    if (typeof props.onKeyDown === "function") {
2742      props.onKeyDown(event);
2743    }
2744    if (event.target === event.currentTarget && isNonNativeButton() && event.key === "Enter" && !props.disabled) {
2745      event.preventDefault();
2746      if (typeof props.onClick === "function") {
2747        props.onClick(event);
2748      }
2749    }
2750  };
2751  const handleKeyUp = (event) => {
2752    if (props.focusRipple && event.key === " " && ripple.ref && focusVisible() && !event.defaultPrevented) {
2753      keydown = false;
2754      ripple.ref.stop(event, () => {
2755        ripple.ref.pulsate(event);
2756      });
2757    }
2758    if (typeof props.onKeyUp === "function") {
2759      props.onKeyUp(event);
2760    }
2761    if (typeof props.onClick === "function" && event.target === event.currentTarget && isNonNativeButton() && event.key === " " && !event.defaultPrevented) {
2762      props.onClick(event);
2763    }
2764  };
2765  const ComponentProp = createMemo(() => {
2766    let result = props.component;
2767    if (result === "button" && (props.href || props.to)) {
2768      result = props.LinkComponent;
2769    }
2770    return result;
2771  });
2772  const isButtonComponent = () => ComponentProp() === "button";
2773  const enableTouchRipple = () => mountedState() && !props.disableRipple && !props.disabled;
2774  const touchRipple = props.TouchRippleProps;
2775  return createComponent(ButtonBaseRoot, mergeProps({
2776    get type() {
2777      return isButtonComponent() ? props.type === void 0 ? "button" : props.type : void 0;
2778    },
2779    get disabled() {
2780      return isButtonComponent() ? props.disabled : void 0;
2781    },
2782    get role() {
2783      return !isButtonComponent() && props.href && !props.to ? "button" : void 0;
2784    },
2785    get ["aria-disabled"]() {
2786      return !isButtonComponent() && props.disabled ? true : void 0;
2787    }
2788  }, otherProps, {
2789    get ["class"]() {
2790      return clsx_m_default(classes.root, props.class);
2791    },
2792    ownerState,
2793    onFocusOut: handleBlur,
2794    get onClick() {
2795      return props.onClick;
2796    },
2797    onContextMenu: handleContextMenu,
2798    onFocusIn: handleFocus,
2799    onKeyDown: handleKeyDown2,
2800    onKeyUp: handleKeyUp,
2801    onMouseDown: handleMouseDown,
2802    onMouseLeave: handleMouseLeave,
2803    onMouseUp: handleMouseUp,
2804    onDragLeave: handleDragLeave,
2805    onTouchEnd: handleTouchEnd,
2806    onTouchMove: handleTouchMove,
2807    onTouchStart: handleTouchStart,
2808    ref: button,
2809    get tabIndex() {
2810      return props.disabled ? -1 : props.tabIndex;
2811    },
2812    get as() {
2813      return ComponentProp();
2814    },
2815    get children() {
2816      return [memo(() => props.children), createComponent(Show, {
2817        get when() {
2818          return enableTouchRipple();
2819        },
2820        get children() {
2821          return createComponent(TouchRipple_default, mergeProps({
2822            ref: (ref) => {
2823              ripple(ref);
2824              if (true) {
2825                if (!ref) {
2826                  console.error(["MUI: The `component` prop provided to ButtonBase is invalid.", "Please make sure the children prop is rendered in this custom component."].join("\n"));
2827                }
2828              }
2829            },
2830            get center() {
2831              return props.centerRipple;
2832            }
2833          }, touchRipple));
2834        }
2835      })];
2836    }
2837  }));
2838});
2839var ButtonBase_default = ButtonBase;
2840

vendor: 163 bytes, lines 2841-2844

2841// node_modules/@suid/material/ButtonGroup/ButtonGroupContext.js
2842var ButtonGroupContext = createContext({});
2843var ButtonGroupContext_default = ButtonGroupContext;
2844

vendor: 906 bytes, lines 2845-2887

2845// node_modules/@suid/material/Button/buttonClasses.js
2846function getButtonUtilityClass(slot) {
2847  return generateUtilityClass("MuiButton", slot);
2848}
2849var buttonClasses = generateUtilityClasses("MuiButton", [
2850  "root",
2851  "text",
2852  "textInherit",
2853  "textPrimary",
2854  "textSecondary",
2855  "outlined",
2856  "outlinedInherit",
2857  "outlinedPrimary",
2858  "outlinedSecondary",
2859  "contained",
2860  "containedInherit",
2861  "containedPrimary",
2862  "containedSecondary",
2863  "disableElevation",
2864  "focusVisible",
2865  "disabled",
2866  "colorInherit",
2867  "textSizeSmall",
2868  "textSizeMedium",
2869  "textSizeLarge",
2870  "outlinedSizeSmall",
2871  "outlinedSizeMedium",
2872  "outlinedSizeLarge",
2873  "containedSizeSmall",
2874  "containedSizeMedium",
2875  "containedSizeLarge",
2876  "sizeMedium",
2877  "sizeSmall",
2878  "sizeLarge",
2879  "fullWidth",
2880  "startIcon",
2881  "endIcon",
2882  "iconSizeSmall",
2883  "iconSizeMedium",
2884  "iconSizeLarge"
2885]);
2886var buttonClasses_default = buttonClasses;
2887

vendor: 10,257 bytes, lines 2888-3206

2888// node_modules/@suid/material/Button/Button.jsx
2889var $18 = createComponentFactory_default()({
2890  name: "MuiButton",
2891  selfPropNames: ["children", "classes", "color", "disableElevation", "disableFocusRipple", "disabled", "endIcon", "fullWidth", "href", "size", "startIcon", "variant"],
2892  propDefaults: ({
2893    set
2894  }) => {
2895    const contextProps = useContext(ButtonGroupContext_default);
2896    return set({
2897      get color() {
2898        return contextProps.color ?? "primary";
2899      },
2900      component: "button",
2901      get disabled() {
2902        return contextProps.disabled ?? false;
2903      },
2904      get disableElevation() {
2905        return contextProps.disableElevation ?? false;
2906      },
2907      get disableFocusRipple() {
2908        return contextProps.disableFocusRipple ?? false;
2909      },
2910      get fullWidth() {
2911        return contextProps.fullWidth ?? false;
2912      },
2913      get size() {
2914        return contextProps.size ?? "medium";
2915      },
2916      get variant() {
2917        return contextProps.variant ?? "text";
2918      }
2919    });
2920  },
2921  utilityClass: getButtonUtilityClass,
2922  slotClasses: (ownerState) => ({
2923    root: ["root", ownerState.variant, `${ownerState.variant}${capitalize_default(ownerState.color)}`, `size${capitalize_default(ownerState.size)}`, `${ownerState.variant}Size${capitalize_default(ownerState.size)}`, ownerState.color === "inherit" && "colorInherit", ownerState.disableElevation && "disableElevation", ownerState.fullWidth && "fullWidth"],
2924    label: ["label"],
2925    startIcon: ["startIcon", `iconSize${capitalize_default(ownerState.size)}`],
2926    endIcon: ["endIcon", `iconSize${capitalize_default(ownerState.size)}`]
2927  })
2928});
2929var commonIconStyles = (ownerState) => ({
2930  ...ownerState.size === "small" && {
2931    "& > *:nth-of-type(1)": {
2932      fontSize: 18
2933    }
2934  },
2935  ...ownerState.size === "medium" && {
2936    "& > *:nth-of-type(1)": {
2937      fontSize: 20
2938    }
2939  },
2940  ...ownerState.size === "large" && {
2941    "& > *:nth-of-type(1)": {
2942      fontSize: 22
2943    }
2944  }
2945});
2946var ButtonRoot = styled_default(ButtonBase_default, {
2947  skipProps: skipRootProps.filter((v) => v !== "classes"),
2948  name: "MuiButton",
2949  slot: "Root",
2950  overridesResolver: (props, styles3) => {
2951    const {
2952      ownerState
2953    } = props;
2954    return [styles3.root, styles3[ownerState.variant], styles3[`${ownerState.variant}${capitalize_default(ownerState.color)}`], styles3[`size${capitalize_default(ownerState.size)}`], styles3[`${ownerState.variant}Size${capitalize_default(ownerState.size)}`], ownerState.color === "inherit" && styles3.colorInherit, ownerState.disableElevation && styles3.disableElevation, ownerState.fullWidth && styles3.fullWidth];
2955  }
2956})(({
2957  theme,
2958  ownerState
2959}) => ({
2960  ...theme.typography.button,
2961  minWidth: 64,
2962  padding: "6px 16px",
2963  borderRadius: theme.shape.borderRadius,
2964  transition: theme.transitions.create(["background-color", "box-shadow", "border-color", "color"], {
2965    duration: theme.transitions.duration.short
2966  }),
2967  "&:hover": {
2968    textDecoration: "none",
2969    backgroundColor: alpha(theme.palette.text.primary, theme.palette.action.hoverOpacity),
2970    // Reset on touch devices, it doesn't add specificity
2971    "@media (hover: none)": {
2972      backgroundColor: "transparent"
2973    },
2974    ...ownerState.variant === "text" && ownerState.color !== "inherit" && {
2975      backgroundColor: alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
2976      // Reset on touch devices, it doesn't add specificity
2977      "@media (hover: none)": {
2978        backgroundColor: "transparent"
2979      }
2980    },
2981    ...ownerState.variant === "outlined" && ownerState.color !== "inherit" && {
2982      border: `1px solid ${theme.palette[ownerState.color].main}`,
2983      backgroundColor: alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
2984      // Reset on touch devices, it doesn't add specificity
2985      "@media (hover: none)": {
2986        backgroundColor: "transparent"
2987      }
2988    },
2989    ...ownerState.variant === "contained" && {
2990      backgroundColor: theme.palette.grey.A100,
2991      boxShadow: theme.shadows[4],
2992      // Reset on touch devices, it doesn't add specificity
2993      "@media (hover: none)": {
2994        boxShadow: theme.shadows[2],
2995        backgroundColor: theme.palette.grey[300]
2996      }
2997    },
2998    ...ownerState.variant === "contained" && ownerState.color !== "inherit" && {
2999      backgroundColor: theme.palette[ownerState.color].dark,
3000      // Reset on touch devices, it doesn't add specificity
3001      "@media (hover: none)": {
3002        backgroundColor: theme.palette[ownerState.color].main
3003      }
3004    }
3005  },
3006  "&:active": {
3007    ...ownerState.variant === "contained" && {
3008      boxShadow: theme.shadows[8]
3009    }
3010  },
3011  [`&.${buttonClasses_default.focusVisible}`]: {
3012    ...ownerState.variant === "contained" && {
3013      boxShadow: theme.shadows[6]
3014    }
3015  },
3016  [`&.${buttonClasses_default.disabled}`]: {
3017    color: theme.palette.action.disabled,
3018    ...ownerState.variant === "outlined" && {
3019      border: `1px solid ${theme.palette.action.disabledBackground}`
3020    },
3021    ...ownerState.variant === "outlined" && ownerState.color === "secondary" && {
3022      border: `1px solid ${theme.palette.action.disabled}`
3023    },
3024    ...ownerState.variant === "contained" && {
3025      color: theme.palette.action.disabled,
3026      boxShadow: theme.shadows[0],
3027      backgroundColor: theme.palette.action.disabledBackground
3028    }
3029  },
3030  ...ownerState.variant === "text" && {
3031    padding: "6px 8px"
3032  },
3033  ...ownerState.variant === "text" && ownerState.color !== "inherit" && {
3034    color: theme.palette[ownerState.color].main
3035  },
3036  ...ownerState.variant === "outlined" && {
3037    padding: "5px 15px",
3038    border: `1px solid ${theme.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)"}`
3039  },
3040  ...ownerState.variant === "outlined" && ownerState.color !== "inherit" && {
3041    color: theme.palette[ownerState.color].main,
3042    border: `1px solid ${alpha(theme.palette[ownerState.color].main, 0.5)}`
3043  },
3044  ...ownerState.variant === "contained" && {
3045    color: theme.palette.getContrastText(theme.palette.grey[300]),
3046    backgroundColor: theme.palette.grey[300],
3047    boxShadow: theme.shadows[2]
3048  },
3049  ...ownerState.variant === "contained" && ownerState.color !== "inherit" && {
3050    color: theme.palette[ownerState.color].contrastText,
3051    backgroundColor: theme.palette[ownerState.color].main
3052  },
3053  ...ownerState.color === "inherit" && {
3054    color: "inherit",
3055    borderColor: "currentColor"
3056  },
3057  ...ownerState.size === "small" && ownerState.variant === "text" && {
3058    padding: "4px 5px",
3059    fontSize: theme.typography.pxToRem(13)
3060  },
3061  ...ownerState.size === "large" && ownerState.variant === "text" && {
3062    padding: "8px 11px",
3063    fontSize: theme.typography.pxToRem(15)
3064  },
3065  ...ownerState.size === "small" && ownerState.variant === "outlined" && {
3066    padding: "3px 9px",
3067    fontSize: theme.typography.pxToRem(13)
3068  },
3069  ...ownerState.size === "large" && ownerState.variant === "outlined" && {
3070    padding: "7px 21px",
3071    fontSize: theme.typography.pxToRem(15)
3072  },
3073  ...ownerState.size === "small" && ownerState.variant === "contained" && {
3074    padding: "4px 10px",
3075    fontSize: theme.typography.pxToRem(13)
3076  },
3077  ...ownerState.size === "large" && ownerState.variant === "contained" && {
3078    padding: "8px 22px",
3079    fontSize: theme.typography.pxToRem(15)
3080  },
3081  ...ownerState.fullWidth && {
3082    width: "100%"
3083  }
3084}), ({
3085  ownerState
3086}) => ({
3087  ...ownerState.disableElevation && {
3088    boxShadow: "none",
3089    "&:hover": {
3090      boxShadow: "none"
3091    },
3092    [`&.${buttonClasses_default.focusVisible}`]: {
3093      boxShadow: "none"
3094    },
3095    "&:active": {
3096      boxShadow: "none"
3097    },
3098    [`&.${buttonClasses_default.disabled}`]: {
3099      boxShadow: "none"
3100    }
3101  }
3102}));
3103var ButtonStartIcon = styled_default("span", {
3104  name: "MuiButton",
3105  slot: "StartIcon",
3106  overridesResolver: (props, styles3) => {
3107    const {
3108      ownerState
3109    } = props;
3110    return [styles3.startIcon, styles3[`iconSize${capitalize_default(ownerState.size)}`]];
3111  }
3112})(({
3113  ownerState
3114}) => ({
3115  display: "inherit",
3116  marginRight: 8,
3117  marginLeft: -4,
3118  ...ownerState.size === "small" && {
3119    marginLeft: -2
3120  },
3121  ...commonIconStyles(ownerState)
3122}));
3123var ButtonEndIcon = styled_default("span", {
3124  name: "MuiButton",
3125  slot: "EndIcon",
3126  overridesResolver: (props, styles3) => {
3127    const {
3128      ownerState
3129    } = props;
3130    return [styles3.endIcon, styles3[`iconSize${capitalize_default(ownerState.size)}`]];
3131  }
3132})(({
3133  ownerState
3134}) => ({
3135  display: "inherit",
3136  marginRight: -4,
3137  marginLeft: 8,
3138  ...ownerState.size === "small" && {
3139    marginRight: -2
3140  },
3141  ...commonIconStyles(ownerState)
3142}));
3143var Button = $18.component(function Button2({
3144  allProps,
3145  otherProps,
3146  props,
3147  classes
3148}) {
3149  const contextProps = useContext(ButtonGroupContext_default);
3150  return createComponent(ButtonRoot, mergeProps({
3151    ownerState: allProps,
3152    get ["class"]() {
3153      return clsx_m_default(classes.root, otherProps.class, contextProps.class);
3154    },
3155    get disabled() {
3156      return props.disabled;
3157    },
3158    get focusRipple() {
3159      return !props.disableFocusRipple;
3160    },
3161    get focusVisibleClassName() {
3162      return clsx_m_default(props.classes?.focusVisible, otherProps.focusVisibleClassName);
3163    },
3164    get type() {
3165      return otherProps.type;
3166    },
3167    get href() {
3168      return props.href;
3169    }
3170  }, otherProps, {
3171    get classes() {
3172      return props.classes;
3173    },
3174    get children() {
3175      return [createComponent(Show, {
3176        get when() {
3177          return props.startIcon;
3178        },
3179        children: (startIcon) => createComponent(ButtonStartIcon, {
3180          get ["class"]() {
3181            return classes.startIcon;
3182          },
3183          ownerState: allProps,
3184          get children() {
3185            return startIcon();
3186          }
3187        })
3188      }), memo(() => props.children), createComponent(Show, {
3189        get when() {
3190          return props.endIcon;
3191        },
3192        children: (endIcon) => createComponent(ButtonEndIcon, {
3193          get ["class"]() {
3194            return classes.endIcon;
3195          },
3196          ownerState: allProps,
3197          get children() {
3198            return endIcon();
3199          }
3200        })
3201      })];
3202    }
3203  }));
3204});
3205var Button_default = Button;
3206

3207// src/app/framework/guardrail.jsx
3208var Guardrail = (props) => {
3209  const handleCancel = () => {
3210    props.close(false);
3211  };
3212  const handleContinue = () => {
3213    props.close(true);
3214  };
3215  return createComponent(Dialog_default, {
3216    get open() {
3217      return props.show;
3218    },
3219    onClose: handleCancel,
3220    "aria-labelledby": "form-dialog-title",
3221    get children() {
3222      return [createComponent(DialogTitle_default, {
3223        id: "form-dialog-title",
3224        children: "Unsaved Changes"
3225      }), createComponent(DialogContent_default, {
3226        get children() {
3227          return createComponent(DialogContentText_default, {
3228            children: "You have unsaved changes, and you will lose that work if you continue."
3229          });
3230        }
3231      }), createComponent(DialogActions_default, {
3232        get children() {
3233          return [createComponent(Button_default, {
3234            onClick: handleContinue,
3235            color: "secondary",
3236            children: "Continue"
3237          }), createComponent(Button_default, {
3238            onClick: handleCancel,
3239            color: "primary",
3240            children: "Cancel"
3241          })];
3242        }
3243      })];
3244    }
3245  });
3246};
3247

3248// src/app/framework/context/editor.jsx
3249var defaultSharingStyle = (scenes) => {
3250  let indexed = true;
3251  scenes.slice(1).map((scene) => {
3252    if (scene.title) indexed = false;
3253  });
3254  const style2 = scenes.length < 2 ? "none" : indexed ? "indexed" : "titled";
3255  return style2;
3256};
3257var initialState = () => {
3258  const {
3259    scenes
3260  } = useViewer();
3261  const {
3262    state: {
3263      camera
3264    }
3265  } = useCamera();
3266  return {
3267    sharing: {
3268      title: "untitled",
3269      description: "A 3D design created in vZome.  Use your mouse or touch to interact.",
3270      style: defaultSharingStyle(scenes)
3271    },
3272    copiedCamera: copyOfCamera(camera),
3273    // The color last CHOSEN in the "Set Color" picker, so it reopens where the user left
3274    //  off.  Desktop vZome keeps the equivalent as DocumentController.lastObjectColor,
3275    //  including this initial value, but it is purely a UI convenience -- the worker never
3276    //  needs it -- so online keeps it client-side.  Note it is NOT the color of the current
3277    //  selection.
3278    lastObjectColor: "#ffffff"
3279  };
3280};
3281var EditorContext = createContext({});
3282var useEditor = () => {
3283  return useContext(EditorContext);
3284};
3285var EditorProvider = (props) => {
3286  const workerClient = useWorkerClient();
3287  const {
3288    resetCamera,
3289    state: cameraState
3290  } = useCamera();
3291  const {
3292    scenes,
3293    resetScenes,
3294    setReload,
3295    setSource
3296  } = useViewer();
3297  const [state, setState] = createStore({
3298    ...initialState()
3299  });
3300  const [partsList, setPartsList] = createSignal({
3301    balls: 0,
3302    panels: 0,
3303    struts: 0,
3304    orbitColors: []
3305  });
3306  workerClient.subscribeFor("SCENE_RENDERED", ({
3307    scene: {
3308      parts
3309    }
3310  }) => setPartsList(parts));
3311  const [sceneIndex, setSceneIndex] = createSignal(0);
3312  const [clientStateEdited, setEdited] = createSignal(false);
3313  const workerStateEdited = () => controllerProperty(rootController(), "edited") === "true";
3314  const edited = () => workerStateEdited() || clientStateEdited();
3315  const [showGuardrail, setShowGuardrail] = createSignal(false);
3316  let continuation;
3317  const guard = (guardedAction) => {
3318    if (edited()) {
3319      continuation = guardedAction;
3320      setShowGuardrail(true);
3321    } else guardedAction();
3322  };
3323  const closeGuardrail = (continued) => {
3324    setShowGuardrail(false);
3325    if (continued) continuation();
3326    continuation = void 0;
3327  };
3328  const exportPromises = {};
3329  const onWorkerMessage = (data) => {
3330    switch (data.type) {
3331      case "SHARE_SUCCESS": {
3332        exportPromises["shareToGitHub"].resolve(data.payload);
3333        break;
3334      }
3335      case "SHARE_FAILURE": {
3336        exportPromises["shareToGitHub"].reject(data.payload);
3337        break;
3338      }
3339      case "TEXT_FETCHED": {
3340        setSource("url", void 0);
3341        let {
3342          name: name2
3343        } = data.payload;
3344        if (name2 && name2.toLowerCase().endsWith(".vzome")) {
3345          if (!state.ignoreDesignName) {
3346            name2 = name2.substring(0, name2.length - 6);
3347            setState("designName", name2);
3348            setState("sharing", {
3349              title: name2.replaceAll("-", " ")
3350            });
3351          }
3352          setState("ignoreDesignName", false);
3353        }
3354        break;
3355      }
3356      case "SNAPSHOT_CAPTURED": {
3357        const snapshot = data.payload;
3358        exportPromises["captureSnapshot"].resolve(snapshot);
3359        break;
3360      }
3361      case "SCENE_RENDERED": {
3362        const {
3363          edit
3364        } = data.payload;
3365        setState("edit", edit);
3366        break;
3367      }
3368      case "CONTROLLER_CREATED":
3369        setState({
3370          workerReady: true,
3371          controller: {
3372            __store: store,
3373            __path: []
3374          }
3375        });
3376        break;
3377      case "CONTROLLER_PROPERTY_CHANGED":
3378        const {
3379          controllerPath,
3380          name,
3381          value
3382        } = data.payload;
3383        const names = controllerPath ? controllerPath.split(":") : [];
3384        for (let index = 0; index < names.length; index++) {
3385          const prefix = names.slice(0, index);
3386          const controllerName = names[index];
3387          const __path = names.slice(0, index + 1);
3388          setState.apply(null, ["controller", ...prefix, controllerName, {
3389            __path
3390          }]);
3391        }
3392        setState.apply(null, ["controller", ...names, name, value]);
3393        break;
3394      case "SCENES_DISCOVERED":
3395        setState("sharing", "style", defaultSharingStyle(data.payload.scenes));
3396        if (sceneIndex() === 0 && data.payload.length > 1) setSceneIndex(1);
3397        setReload(true);
3398        break;
3399      case "BOM_CHANGED":
3400      case "SYMMETRY_CHANGED":
3401      case "DESIGN_XML_PARSED":
3402      case "LAST_BALL_CREATED":
3403      case "INSTANCE_ADDED":
3404      case "INSTANCE_REMOVED":
3405      case "FETCH_STARTED":
3406      case "CAMERA_SNAPPED":
3407      case "SHAPE_DEFINED":
3408        break;
3409      default:
3410        console.log("UNRECOGNIZED message from worker for EditorProvider:", data.type);
3411        break;
3412    }
3413  };
3414  const onWorkerError = (error) => {
3415    console.log(error);
3416  };
3417  workerClient.subscribe({
3418    onWorkerMessage,
3419    onWorkerError
3420  });
3421  const expectResponse = (controllerPath, action, parameters) => {
3422    return new Promise((resolve2, reject) => {
3423      exportPromises[action] = {
3424        resolve: resolve2,
3425        reject
3426      };
3427      workerClient.postMessage(doControllerAction(controllerPath, action, parameters));
3428    });
3429  };
3430  const store = {
3431    state,
3432    setState,
3433    expectResponse
3434  };
3435  const rootController = () => {
3436    if (!state.controller) {
3437      setState("controller", {
3438        __store: store,
3439        __path: []
3440      });
3441    }
3442    return state.controller;
3443  };
3444  const controllerAction = (controller, action, parameters) => {
3445    if (!workerClient.isWorkerReady()) {
3446      console.log("Worker not ready:", action);
3447      return;
3448    }
3449    const controllerPath = controller.__path.join(":");
3450    if (action === "setProperty") {
3451      const {
3452        name,
3453        value
3454      } = parameters;
3455      workerClient.postMessage(setControllerProperty(controllerPath, name, value));
3456    } else workerClient.postMessage(doControllerAction(controllerPath, action, parameters));
3457  };
3458  const createDesign = (field) => {
3459    resetCamera();
3460    resetScenes();
3461    setSceneIndex(0);
3462    setSource("url", void 0);
3463    workerClient.postMessage(newDesign(field));
3464  };
3465  const shareToGitHub = (target, blog, publish, image) => {
3466    const name = state?.designName || "untitled";
3467    const config = {
3468      ...unwrap(state.sharing),
3469      blog,
3470      publish,
3471      originalDate: state.originalDate
3472    };
3473    return new Promise((resolve2, reject) => {
3474      const camera = unwrap(cameraState.camera);
3475      const lighting = unwrap(cameraState.lighting);
3476      const scenes2 = unwrap(scenes);
3477      expectResponse("", "shareToGitHub", {
3478        target,
3479        config,
3480        data: {
3481          name,
3482          image,
3483          camera,
3484          lighting,
3485          scenes: scenes2
3486        }
3487      }).then((url) => resolve2(url)).catch((error) => reject(error));
3488    });
3489  };
3490  const openDesignFile2 = (file, debug) => {
3491    resetCamera();
3492    resetScenes();
3493    setSceneIndex(0);
3494    setState("source", {
3495      type: "file",
3496      data: file
3497    });
3498    setState("originalDate", null);
3499    workerClient.postMessage(openDesignFile(file, debug));
3500  };
3501  const fetchDesignUrl = (url, config) => {
3502    resetCamera();
3503    resetScenes();
3504    setSceneIndex(0);
3505    setState("source", {
3506      type: "url",
3507      data: url
3508    });
3509    setState("originalDate", null);
3510    workerClient.postMessage(fetchDesign(url, config));
3511  };
3512  const providerValue = {
3513    ...store,
3514    guard,
3515    edited,
3516    setEdited,
3517    lastObjectColor: () => state.lastObjectColor,

3518    setLastObjectColor: (hex) => setState("lastObjectColor", hex),
3519    rootController,
3520    controllerAction,
3521    shareToGitHub,
3522    createDesign,
3523    openDesignFile: openDesignFile2,
3524    fetchDesignUrl,
3525    partsList,
3526    sceneIndex,
3527    setSceneIndex,
3528    importMeshFile: (file, format) => workerClient.postMessage(importMeshFile(file, format)),
3529    startPreviewStrut: (id, dir) => workerClient.postMessage(startPreviewStrut(id, dir)),
3530    movePreviewStrut: (direction) => workerClient.postMessage(movePreviewStrut(direction)),
3531    scalePreviewStrut: (increment) => workerClient.postMessage(scalePreviewStrut(increment)),
3532    endPreviewStrut: () => workerClient.postMessage(endPreviewStrut())
3533  };
3534  return createComponent(EditorContext.Provider, {
3535    value: providerValue,
3536    get children() {
3537      return [createComponent(Guardrail, {
3538        get show() {
3539          return showGuardrail();
3540        },
3541        close: closeGuardrail
3542      }), memo(() => props.children)];
3543    }
3544  });
3545};
3546var subController = (parent, key) => {
3547  if (!parent[key]) {
3548    const __path = [...parent.__path, key];
3549    parent.__store.setState.apply(null, ["controller", ...__path, {
3550      __path,
3551      __store: parent.__store
3552    }]);
3553  }
3554  return parent[key];
3555};
3556var controllerProperty = (controller, propName, changeName = propName, isList = false) => {
3557  if (typeof controller[propName] === "undefined") {
3558    const controllerPath = controller.__path.join(":");
3559    const workerClient = useWorkerClient();
3560    createEffect(() => {
3561      if (workerClient.isWorkerReady && workerClient.isWorkerReady()) {
3562        workerClient.postMessage(requestControllerProperty(controllerPath, propName, changeName, isList));
3563      }
3564    });
3565  }
3566  if (isList) return controller[propName] || [];
3567  return controller[propName];
3568};
3569

vendor: 417 bytes, lines 3570-3587

3570// node_modules/@suid/material/AppBar/appBarClasses.js
3571function getAppBarUtilityClass(slot) {
3572  return generateUtilityClass("MuiAppBar", slot);
3573}
3574var appBarClasses = generateUtilityClasses("MuiAppBar", [
3575  "root",
3576  "positionFixed",
3577  "positionAbsolute",
3578  "positionSticky",
3579  "positionStatic",
3580  "positionRelative",
3581  "colorDefault",
3582  "colorPrimary",
3583  "colorSecondary",
3584  "colorInherit",
3585  "colorTransparent"
3586]);
3587

vendor: 3,214 bytes, lines 3588-3697

3588// node_modules/@suid/material/AppBar/AppBar.jsx
3589var $19 = createComponentFactory_default()({
3590  name: "MuiAppBar",
3591  selfPropNames: ["classes", "color", "enableColorOnDark", "position"],
3592  utilityClass: getAppBarUtilityClass,
3593  propDefaults: ({
3594    set
3595  }) => set({
3596    component: "header",
3597    color: "primary",
3598    enableColorOnDark: false,
3599    position: "fixed"
3600  }),
3601  slotClasses: (ownerState) => ({
3602    root: ["root", `color${capitalize_default(ownerState.color)}`, `position${capitalize_default(ownerState.position)}`]
3603  })
3604});
3605var AppBarRoot = styled_default(Paper_default, {
3606  name: "MuiAppBar",
3607  slot: "Root",
3608  overridesResolver: (props, styles3) => {
3609    return [styles3.root, styles3[`position${capitalize_default(props.ownerState.position)}`], styles3[`color${capitalize_default(props.ownerState.color)}`]];
3610  }
3611})(({
3612  theme,
3613  ownerState
3614}) => {
3615  const backgroundColorDefault = theme.palette.mode === "light" ? theme.palette.grey[100] : theme.palette.grey[900];
3616  return {
3617    display: "flex",
3618    flexDirection: "column",
3619    width: "100%",
3620    boxSizing: "border-box",
3621    flexShrink: 0,
3622    ...ownerState.position === "fixed" && {
3623      position: "fixed",
3624      zIndex: theme.zIndex.appBar,
3625      top: 0,
3626      left: "auto",
3627      right: 0,
3628      "@media print": {
3629        // Prevent the app bar to be visible on each printed page.
3630        position: "absolute"
3631      }
3632    },
3633    ...ownerState.position === "absolute" && {
3634      position: "absolute",
3635      zIndex: theme.zIndex.appBar,
3636      top: 0,
3637      left: "auto",
3638      right: 0
3639    },
3640    ...ownerState.position === "sticky" && {
3641      // â ï¸ sticky is not supported by IE11.
3642      position: "sticky",
3643      zIndex: theme.zIndex.appBar,
3644      top: 0,
3645      left: "auto",
3646      right: 0
3647    },
3648    ...ownerState.position === "static" && {
3649      position: "static"
3650    },
3651    ...ownerState.position === "relative" && {
3652      position: "relative"
3653    },
3654    ...ownerState.color === "default" && {
3655      backgroundColor: backgroundColorDefault,
3656      color: theme.palette.getContrastText(backgroundColorDefault)
3657    },
3658    ...ownerState.color && ownerState.color !== "default" && ownerState.color !== "inherit" && ownerState.color !== "transparent" && {
3659      backgroundColor: theme.palette[ownerState.color].main,
3660      color: theme.palette[ownerState.color].contrastText
3661    },
3662    ...ownerState.color === "inherit" && {
3663      color: "inherit"
3664    },
3665    ...theme.palette.mode === "dark" && !ownerState.enableColorOnDark && {
3666      backgroundColor: void 0,
3667      color: void 0
3668    },
3669    ...ownerState.color === "transparent" && {
3670      backgroundColor: "transparent",
3671      color: "inherit",
3672      ...theme.palette.mode === "dark" && {
3673        backgroundImage: "none"
3674      }
3675    }
3676  };
3677});
3678var AppBar = $19.component(function AppBar2({
3679  allProps,
3680  classes,
3681  props,
3682  otherProps
3683}) {
3684  return createComponent(AppBarRoot, mergeProps({
3685    square: true,
3686    ownerState: allProps,
3687    elevation: 4,
3688    get ["class"]() {
3689      return clsx_m_default(classes.root, {
3690        "mui-fixed": props.position === "fixed"
3691        // Useful for the Dialog
3692      }, otherProps.class);
3693    }
3694  }, otherProps));
3695});
3696var AppBar_default = AppBar;
3697

vendor: 261 bytes, lines 3698-3708

3698// node_modules/@suid/material/Toolbar/toolbarClasses.js
3699function getToolbarUtilityClass(slot) {
3700  return generateUtilityClass("MuiToolbar", slot);
3701}
3702var toolbarClasses = generateUtilityClasses("MuiToolbar", [
3703  "root",
3704  "gutters",
3705  "regular",
3706  "dense"
3707]);
3708

vendor: 1,668 bytes, lines 3709-3776

3709// node_modules/@suid/material/Toolbar/Toolbar.jsx
3710var $20 = createComponentFactory_default()({
3711  name: "MuiToolbar",
3712  selfPropNames: ["children", "classes", "disableGutters", "variant"],
3713  propDefaults: ({
3714    set
3715  }) => set({
3716    component: "div",
3717    disableGutters: false,
3718    variant: "regular"
3719  }),
3720  utilityClass: getToolbarUtilityClass,
3721  slotClasses: (ownerState) => ({
3722    root: ["root", !ownerState.disableGutters && "gutters", ownerState.variant]
3723  })
3724});
3725var ToolbarRoot = styled_default("div", {
3726  name: "MuiToolbar",
3727  slot: "Root",
3728  overridesResolver: (props, styles3) => {
3729    const {
3730      ownerState
3731    } = props;
3732    return [styles3.root, !ownerState.disableGutters && styles3.gutters, styles3[ownerState.variant]];
3733  }
3734})(({
3735  theme,
3736  ownerState
3737}) => ({
3738  position: "relative",
3739  display: "flex",
3740  alignItems: "center",
3741  ...!ownerState.disableGutters && {
3742    paddingLeft: theme.spacing(2),
3743    paddingRight: theme.spacing(2),
3744    [theme.breakpoints.up("sm")]: {
3745      paddingLeft: theme.spacing(3),
3746      paddingRight: theme.spacing(3)
3747    }
3748  },
3749  ...ownerState.variant === "dense" && {
3750    minHeight: 48
3751  }
3752}), ({
3753  theme,
3754  ownerState
3755}) => ownerState.variant === "regular" && theme.mixins.toolbar);
3756var Toolbar = $20.component(function Toolbar2({
3757  allProps,
3758  props,
3759  classes,
3760  otherProps
3761}) {
3762  return createComponent(ToolbarRoot, mergeProps(otherProps, {
3763    get as() {
3764      return otherProps.component;
3765    },
3766    get ["class"]() {
3767      return clsx_m_default(classes.root, otherProps.class);
3768    },
3769    ownerState: allProps,
3770    get children() {
3771      return props.children;
3772    }
3773  }));
3774});
3775var Toolbar_default = Toolbar;
3776

vendor: 437 bytes, lines 3777-3794

3777// node_modules/@suid/material/IconButton/iconButtonClasses.js
3778function getIconButtonUtilityClass(slot) {
3779  return generateUtilityClass("MuiIconButton", slot);
3780}
3781var iconButtonClasses = generateUtilityClasses("MuiIconButton", [
3782  "root",
3783  "disabled",
3784  "colorInherit",
3785  "colorPrimary",
3786  "colorSecondary",
3787  "edgeStart",
3788  "edgeEnd",
3789  "sizeSmall",
3790  "sizeMedium",
3791  "sizeLarge"
3792]);
3793var iconButtonClasses_default = iconButtonClasses;
3794

vendor: 3,429 bytes, lines 3795-3908

3795// node_modules/@suid/material/IconButton/IconButton.jsx
3796var $21 = createComponentFactory_default()({
3797  name: "MuiIconButton",
3798  selfPropNames: ["children", "classes", "color", "disableFocusRipple", "disabled", "edge", "size"],
3799  propDefaults: ({
3800    set
3801  }) => set({
3802    edge: false,
3803    color: "default",
3804    disabled: false,
3805    disableFocusRipple: false,
3806    size: "medium"
3807  }),
3808  utilityClass: getIconButtonUtilityClass,
3809  slotClasses: (ownerState) => ({
3810    root: ["root", ownerState.disabled && "disabled", ownerState.color !== "default" && `color${capitalize_default(ownerState.color)}`, ownerState.edge && `edge${capitalize_default(ownerState.edge)}`, `size${capitalize_default(ownerState.size)}`]
3811  })
3812});
3813var IconButtonRoot = styled_default(ButtonBase_default, {
3814  name: "MuiIconButton",
3815  slot: "Root",
3816  overridesResolver: (props, styles3) => {
3817    const {
3818      ownerState
3819    } = props;
3820    return [styles3.root, ownerState.color !== "default" && styles3[`color${capitalize_default(ownerState.color)}`], ownerState.edge && styles3[`edge${capitalize_default(ownerState.edge)}`], styles3[`size${capitalize_default(ownerState.size)}`]];
3821  }
3822})(({
3823  theme,
3824  ownerState
3825}) => ({
3826  textAlign: "center",
3827  flex: "0 0 auto",
3828  fontSize: theme.typography.pxToRem(24),
3829  padding: 8,
3830  borderRadius: "50%",
3831  overflow: "visible",
3832  color: theme.palette.action.active,
3833  transition: theme.transitions.create("background-color", {
3834    duration: theme.transitions.duration.shortest
3835  }),
3836  ...!ownerState.disableRipple && {
3837    "&:hover": {
3838      backgroundColor: alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),
3839      // Reset on touch devices, it doesn't add specificity
3840      "@media (hover: none)": {
3841        backgroundColor: "transparent"
3842      }
3843    }
3844  },
3845  ...ownerState.edge === "start" && {
3846    marginLeft: ownerState.size === "small" ? -3 : -12
3847  },
3848  ...ownerState.edge === "end" && {
3849    marginRight: ownerState.size === "small" ? -3 : -12
3850  }
3851}), ({
3852  theme,
3853  ownerState
3854}) => ({
3855  ...ownerState.color === "inherit" && {
3856    color: "inherit"
3857  },
3858  ...ownerState.color !== "inherit" && ownerState.color !== "default" && {
3859    color: theme.palette[ownerState.color].main,
3860    ...!ownerState.disableRipple && {
3861      "&:hover": {
3862        backgroundColor: alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
3863        // Reset on touch devices, it doesn't add specificity
3864        "@media (hover: none)": {
3865          backgroundColor: "transparent"
3866        }
3867      }
3868    }
3869  },
3870  ...ownerState.size === "small" && {
3871    padding: 5,
3872    fontSize: theme.typography.pxToRem(18)
3873  },
3874  ...ownerState.size === "large" && {
3875    padding: 12,
3876    fontSize: theme.typography.pxToRem(28)
3877  },
3878  [`&.${iconButtonClasses_default.disabled}`]: {
3879    backgroundColor: "transparent",
3880    color: theme.palette.action.disabled
3881  }
3882}));
3883var IconButton = $21.component(function IconButton2({
3884  allProps,
3885  classes,
3886  otherProps,
3887  props
3888}) {
3889  return createComponent(IconButtonRoot, mergeProps({
3890    get ["class"]() {
3891      return clsx_m_default(classes.root, otherProps.class);
3892    },
3893    centerRipple: true,
3894    get focusRipple() {
3895      return !props.disableFocusRipple;
3896    },
3897    get disabled() {
3898      return props.disabled;
3899    },
3900    ownerState: allProps
3901  }, otherProps, {
3902    get children() {
3903      return props.children;
3904    }
3905  }));
3906});
3907var IconButton_default = IconButton;
3908

vendor: 4,788 bytes, lines 3909-4041

3909// node_modules/@suid/icons-material/node_modules/@suid/system/colorManipulator.js
3910function clamp(value, min = 0, max = 1) {
3911  if (true) {
3912    if (value < min || value > max) {
3913      console.error(`MUI: The value provided ${value} is out of range [${min}, ${max}].`);
3914    }
3915  }
3916  return Math.min(Math.max(min, value), max);
3917}
3918function hexToRgb(color) {
3919  color = color.substr(1);
3920  const re = new RegExp(`.{1,${color.length >= 6 ? 2 : 1}}`, "g");
3921  let colors = color.match(re);
3922  if (colors && colors[0].length === 1) {
3923    colors = colors.map((n) => n + n);
3924  }
3925  return colors ? `rgb${colors.length === 4 ? "a" : ""}(${colors.map((n, index) => {
3926    return index < 3 ? parseInt(n, 16) : Math.round(parseInt(n, 16) / 255 * 1e3) / 1e3;
3927  }).join(", ")})` : "";
3928}
3929function decomposeColor(color) {
3930  if (typeof color !== "string") {
3931    return color;
3932  }
3933  if (color.charAt(0) === "#") {
3934    return decomposeColor(hexToRgb(color));
3935  }
3936  const marker = color.indexOf("(");
3937  const type = color.substring(0, marker);
3938  if (["rgb", "rgba", "hsl", "hsla", "color"].indexOf(type) === -1) {
3939    throw new Error("MUI: Unsupported `%s` color.\nThe following formats are supported: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color(). " + color);
3940  }
3941  const valuesInput = color.substring(marker + 1, color.length - 1);
3942  let values2;
3943  let colorSpace;
3944  if (type === "color") {
3945    values2 = valuesInput.split(" ");
3946    colorSpace = values2.shift();
3947    if (values2.length === 4 && values2[3].charAt(0) === "/") {
3948      values2[3] = values2[3].substr(1);
3949    }
3950    if (["srgb", "display-p3", "a98-rgb", "prophoto-rgb", "rec-2020"].indexOf(
3951      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
3952      colorSpace
3953    ) === -1) {
3954      throw new Error("MUI: unsupported `%s` color space.\nThe following color spaces are supported: srgb, display-p3, a98-rgb, prophoto-rgb, rec-2020. " + colorSpace);
3955    }
3956  } else {
3957    values2 = valuesInput.split(",");
3958  }
3959  return { type, values: values2.map((value) => parseFloat(value)), colorSpace };
3960}
3961function recomposeColor(color) {
3962  const { type, colorSpace } = color;
3963  const { values: values2 } = color;
3964  let newValues;
3965  if (type.indexOf("rgb") !== -1) {
3966    newValues = values2.map((n, i) => i < 3 ? parseInt(n.toString(), 10) : n).join(",");
3967  } else if (type.indexOf("hsl") !== -1) {
3968    newValues = values2.map((n, i) => i === 1 || i === 2 ? `${n}%` : n).join(",");
3969  }
3970  if (type.indexOf("color") !== -1) {
3971    newValues = `${colorSpace} ${values2.join(" ")}`;
3972  } else {
3973    newValues = `${values2.join(", ")}`;
3974  }
3975  return `${type}(${newValues})`;
3976}
3977function hslToRgb(color) {
3978  const c = decomposeColor(color);
3979  const { values: values2 } = c;
3980  const h = values2[0];
3981  const s = values2[1] / 100;
3982  const l = values2[2] / 100;
3983  const a = s * Math.min(l, 1 - l);
3984  const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
3985  let type = "rgb";
3986  const rgb = [
3987    Math.round(f(0) * 255),
3988    Math.round(f(8) * 255),
3989    Math.round(f(4) * 255)
3990  ];
3991  if (c.type === "hsla") {
3992    type += "a";
3993    rgb.push(values2[3]);
3994  }
3995  return recomposeColor({ type, values: rgb });
3996}
3997function getLuminance(color) {
3998  const { type, values: values2 } = decomposeColor(color);
3999  let rgb = type === "hsl" ? decomposeColor(hslToRgb(color)).values : values2;
4000  rgb = rgb.map((val) => {
4001    if (type !== "color") {
4002      val /= 255;
4003    }
4004    return val <= 0.03928 ? val / 12.92 : ((val + 0.055) / 1.055) ** 2.4;
4005  });
4006  return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3));
4007}
4008function getContrastRatio(foreground, background) {
4009  const lumA = getLuminance(foreground);
4010  const lumB = getLuminance(background);
4011  return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05);
4012}
4013function darken2(inputColor, coefficient) {
4014  const color = decomposeColor(inputColor);
4015  coefficient = clamp(coefficient);
4016  if (color.type.indexOf("hsl") !== -1) {
4017    color.values[2] *= 1 - coefficient;
4018  } else if (color.type.indexOf("rgb") !== -1 || color.type.indexOf("color") !== -1) {
4019    for (let i = 0; i < 3; i += 1) {
4020      color.values[i] *= 1 - coefficient;
4021    }
4022  }
4023  return recomposeColor(color);
4024}
4025function lighten2(inputColor, coefficient) {
4026  const color = decomposeColor(inputColor);
4027  coefficient = clamp(coefficient);
4028  if (color.type.indexOf("hsl") !== -1) {
4029    color.values[2] += (100 - color.values[2]) * coefficient;
4030  } else if (color.type.indexOf("rgb") !== -1) {
4031    for (let i = 0; i < 3; i += 1) {
4032      color.values[i] += (255 - color.values[i]) * coefficient;
4033    }
4034  } else if (color.type.indexOf("color") !== -1) {
4035    for (let i = 0; i < 3; i += 1) {
4036      color.values[i] += (1 - color.values[i]) * coefficient;
4037    }
4038  }
4039  return recomposeColor(color);
4040}
4041

vendor: 1,185 bytes, lines 4042-4082

4042// node_modules/@suid/icons-material/node_modules/@suid/system/breakpoints.js
4043var values = {
4044  xs: 0,
4045  sm: 600,
4046  md: 900,
4047  lg: 1200,
4048  xl: 1536
4049  // large screens
4050};
4051function handleBreakpoints2(props, propValue, styleFromPropValue) {
4052  const theme = props.theme || {};
4053  if (Array.isArray(propValue)) {
4054    const themeBreakpoints = theme.breakpoints;
4055    return propValue.reduce((acc, item, index) => {
4056      acc = {
4057        ...acc,
4058        ...themeBreakpoints.up(themeBreakpoints.keys[index], styleFromPropValue(propValue[index]))
4059      };
4060      return acc;
4061    }, {});
4062  }
4063  if (typeof propValue === "object") {
4064    const themeBreakpoints = theme.breakpoints;
4065    const keys = Object.keys(propValue);
4066    return keys.reduce((acc, breakpoint) => {
4067      if (Object.keys(themeBreakpoints.values || values).indexOf(breakpoint) !== -1) {
4068        acc = {
4069          ...acc,
4070          ...themeBreakpoints.up(breakpoint, styleFromPropValue(propValue[breakpoint], breakpoint))
4071        };
4072      } else {
4073        const cssKey = breakpoint;
4074        acc[cssKey] = propValue[cssKey];
4075      }
4076      return acc;
4077    }, {});
4078  }
4079  const output = styleFromPropValue(propValue);
4080  return output;
4081}
4082

vendor: 216 bytes, lines 4083-4086

4083// node_modules/@suid/icons-material/node_modules/@suid/styled-engine/StyledEngineProvider/StyledEngineContext.jsx
4084var StyledEngineContext = createContext({});
4085var StyledEngineContext_default = StyledEngineContext;
4086

vendor: 905 bytes, lines 4087-4116

4087// node_modules/@suid/utils/deepmerge.js
4088function isPlainObject3(item) {
4089  return item !== null && typeof item === "object" && item.constructor === Object;
4090}
4091function sortKeys(object, keys) {
4092  for (const key of keys) {
4093    const value = object[key];
4094    delete object[key];
4095    object[key] = value;
4096  }
4097}
4098function deepmerge4(target, source, options = { clone: true }) {
4099  const output = options.clone ? { ...target } : target;
4100  if (isPlainObject3(target) && isPlainObject3(source)) {
4101    Object.keys(source).forEach((key) => {
4102      if (key === "__proto__") {
4103        return;
4104      }
4105      if (isPlainObject3(source[key]) && key in target && isPlainObject3(target[key])) {
4106        output[key] = deepmerge4(target[key], source[key], options);
4107      } else {
4108        output[key] = source[key];
4109      }
4110    });
4111    if (options.sortKeys)
4112      sortKeys(output, Object.keys(source));
4113  }
4114  return output;
4115}
4116

vendor: 490 bytes, lines 4117-4138

4117// node_modules/@suid/utils/cloneObject.js
4118function cloneObject3(target) {
4119  if (Array.isArray(target)) {
4120    const output = [];
4121    for (const value of target) {
4122      output.push(cloneObject3(value));
4123    }
4124    return output;
4125  } else if (isPlainObject3(target)) {
4126    const output = {};
4127    for (const key in target) {
4128      if (key === "__proto__") {
4129        continue;
4130      }
4131      output[key] = cloneObject3(target[key]);
4132    }
4133    return output;
4134  } else {
4135    return target;
4136  }
4137}
4138

vendor: 201 bytes, lines 4139-4147

4139// node_modules/@suid/utils/merge.js
4140function merge3(target, ...sources) {
4141  for (const source of sources)
4142    deepmerge4(target, cloneObject3(source), {
4143      clone: false
4144    });
4145  return target;
4146}
4147

vendor: 337 bytes, lines 4148-4159

4148// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createComponents.jsx
4149var componentsDefault = createComponentsOptions({});
4150function createComponentsOptions(options) {
4151  return options;
4152}
4153function createComponents(data) {
4154  const result = {
4155    ...merge3({}, componentsDefault, data ?? {})
4156  };
4157  return result;
4158}
4159

vendor: 391 bytes, lines 4160-4175

4160// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createMixins.js
4161function createMixins(breakpoints, spacing = void 0, mixins = {}) {
4162  return {
4163    toolbar: {
4164      minHeight: 56,
4165      [`${breakpoints.up("xs")} and (orientation: landscape)`]: {
4166        minHeight: 48
4167      },
4168      [breakpoints.up("sm")]: {
4169        minHeight: 64
4170      }
4171    },
4172    ...mixins
4173  };
4174}
4175

vendor: 163 bytes, lines 4176-4182

4176// node_modules/@suid/icons-material/node_modules/@suid/material/colors/common.js
4177var common = {
4178  black: "#000",
4179  white: "#fff"
4180};
4181var common_default = common;
4182

vendor: 372 bytes, lines 4183-4201

4183// node_modules/@suid/icons-material/node_modules/@suid/material/colors/red.js
4184var red = {
4185  50: "#ffebee",
4186  100: "#ffcdd2",
4187  200: "#ef9a9a",
4188  300: "#e57373",
4189  400: "#ef5350",
4190  500: "#f44336",
4191  600: "#e53935",
4192  700: "#d32f2f",
4193  800: "#c62828",
4194  900: "#b71c1c",
4195  A100: "#ff8a80",
4196  A200: "#ff5252",
4197  A400: "#ff1744",
4198  A700: "#d50000"
4199};
4200var red_default = red;
4201

vendor: 384 bytes, lines 4202-4220

4202// node_modules/@suid/icons-material/node_modules/@suid/material/colors/purple.js
4203var purple = {
4204  50: "#f3e5f5",
4205  100: "#e1bee7",
4206  200: "#ce93d8",
4207  300: "#ba68c8",
4208  400: "#ab47bc",
4209  500: "#9c27b0",
4210  600: "#8e24aa",
4211  700: "#7b1fa2",
4212  800: "#6a1b9a",
4213  900: "#4a148c",
4214  A100: "#ea80fc",
4215  A200: "#e040fb",
4216  A400: "#d500f9",
4217  A700: "#aa00ff"
4218};
4219var purple_default = purple;
4220

vendor: 376 bytes, lines 4221-4239

4221// node_modules/@suid/icons-material/node_modules/@suid/material/colors/blue.js
4222var blue = {
4223  50: "#e3f2fd",
4224  100: "#bbdefb",
4225  200: "#90caf9",
4226  300: "#64b5f6",
4227  400: "#42a5f5",
4228  500: "#2196f3",
4229  600: "#1e88e5",
4230  700: "#1976d2",
4231  800: "#1565c0",
4232  900: "#0d47a1",
4233  A100: "#82b1ff",
4234  A200: "#448aff",
4235  A400: "#2979ff",
4236  A700: "#2962ff"
4237};
4238var blue_default = blue;
4239

vendor: 396 bytes, lines 4240-4258

4240// node_modules/@suid/icons-material/node_modules/@suid/material/colors/lightBlue.js
4241var lightBlue = {
4242  50: "#e1f5fe",
4243  100: "#b3e5fc",
4244  200: "#81d4fa",
4245  300: "#4fc3f7",
4246  400: "#29b6f6",
4247  500: "#03a9f4",
4248  600: "#039be5",
4249  700: "#0288d1",
4250  800: "#0277bd",
4251  900: "#01579b",
4252  A100: "#80d8ff",
4253  A200: "#40c4ff",
4254  A400: "#00b0ff",
4255  A700: "#0091ea"
4256};
4257var lightBlue_default = lightBlue;
4258

vendor: 380 bytes, lines 4259-4277

4259// node_modules/@suid/icons-material/node_modules/@suid/material/colors/green.js
4260var green = {
4261  50: "#e8f5e9",
4262  100: "#c8e6c9",
4263  200: "#a5d6a7",
4264  300: "#81c784",
4265  400: "#66bb6a",
4266  500: "#4caf50",
4267  600: "#43a047",
4268  700: "#388e3c",
4269  800: "#2e7d32",
4270  900: "#1b5e20",
4271  A100: "#b9f6ca",
4272  A200: "#69f0ae",
4273  A400: "#00e676",
4274  A700: "#00c853"
4275};
4276var green_default = green;
4277

vendor: 384 bytes, lines 4278-4296

4278// node_modules/@suid/icons-material/node_modules/@suid/material/colors/orange.js
4279var orange = {
4280  50: "#fff3e0",
4281  100: "#ffe0b2",
4282  200: "#ffcc80",
4283  300: "#ffb74d",
4284  400: "#ffa726",
4285  500: "#ff9800",
4286  600: "#fb8c00",
4287  700: "#f57c00",
4288  800: "#ef6c00",
4289  900: "#e65100",
4290  A100: "#ffd180",
4291  A200: "#ffab40",
4292  A400: "#ff9100",
4293  A700: "#ff6d00"
4294};
4295var orange_default = orange;
4296

vendor: 376 bytes, lines 4297-4315

4297// node_modules/@suid/icons-material/node_modules/@suid/material/colors/grey.js
4298var grey = {
4299  50: "#fafafa",
4300  100: "#f5f5f5",
4301  200: "#eeeeee",
4302  300: "#e0e0e0",
4303  400: "#bdbdbd",
4304  500: "#9e9e9e",
4305  600: "#757575",
4306  700: "#616161",
4307  800: "#424242",
4308  900: "#212121",
4309  A100: "#f5f5f5",
4310  A200: "#eeeeee",
4311  A400: "#bdbdbd",
4312  A700: "#616161"
4313};
4314var grey_default = grey;
4315

vendor: 5,891 bytes, lines 4316-4521

4316// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createPalette.jsx
4317var useLightOptions = () => ({
4318  text: {
4319    primary: "rgba(0, 0, 0, 0.87)",
4320    secondary: "rgba(0, 0, 0, 0.6)",
4321    disabled: "rgba(0, 0, 0, 0.38)"
4322  },
4323  divider: "rgba(0, 0, 0, 0.12)",
4324  background: {
4325    paper: common_default.white,
4326    default: common_default.white
4327  },
4328  action: {
4329    active: "rgba(0, 0, 0, 0.54)",
4330    hover: "rgba(0, 0, 0, 0.04)",
4331    hoverOpacity: 0.04,
4332    selected: "rgba(0, 0, 0, 0.08)",
4333    selectedOpacity: 0.08,
4334    disabled: "rgba(0, 0, 0, 0.26)",
4335    disabledBackground: "rgba(0, 0, 0, 0.12)",
4336    disabledOpacity: 0.38,
4337    focus: "rgba(0, 0, 0, 0.12)",
4338    focusOpacity: 0.12,
4339    activatedOpacity: 0.12
4340  }
4341});
4342var lightColors = {
4343  primary: {
4344    main: blue_default[700],
4345    light: blue_default[400],
4346    dark: blue_default[800]
4347  },
4348  secondary: {
4349    main: purple_default[500],
4350    light: purple_default[300],
4351    dark: purple_default[700]
4352  },
4353  error: {
4354    main: red_default[700],
4355    light: red_default[400],
4356    dark: red_default[800]
4357  },
4358  info: {
4359    main: lightBlue_default[700],
4360    light: lightBlue_default[800],
4361    dark: lightBlue_default[900]
4362  },
4363  success: {
4364    main: green_default[800],
4365    light: green_default[500],
4366    dark: green_default[900]
4367  },
4368  warning: {
4369    main: "#ED6C02",
4370    light: orange_default[500],
4371    dark: orange_default[900]
4372  }
4373};
4374var useDarkOptions = () => ({
4375  text: {
4376    primary: common_default.white,
4377    secondary: "rgba(255, 255, 255, 0.7)",
4378    disabled: "rgba(255, 255, 255, 0.5)"
4379  },
4380  divider: "rgba(255, 255, 255, 0.12)",
4381  background: {
4382    paper: "#121212",
4383    default: "#121212"
4384  },
4385  action: {
4386    active: common_default.white,
4387    hover: "rgba(255, 255, 255, 0.08)",
4388    hoverOpacity: 0.08,
4389    selected: "rgba(255, 255, 255, 0.16)",
4390    selectedOpacity: 0.16,
4391    disabled: "rgba(255, 255, 255, 0.3)",
4392    disabledBackground: "rgba(255, 255, 255, 0.12)",
4393    disabledOpacity: 0.38,
4394    focus: "rgba(255, 255, 255, 0.12)",
4395    focusOpacity: 0.12,
4396    activatedOpacity: 0.24
4397  }
4398});
4399var darkColors = {
4400  primary: {
4401    main: blue_default[200],
4402    light: blue_default[50],
4403    dark: blue_default[400]
4404  },
4405  secondary: {
4406    main: purple_default[200],
4407    light: purple_default[50],
4408    dark: purple_default[400]
4409  },
4410  error: {
4411    main: red_default[500],
4412    light: red_default[300],
4413    dark: red_default[700]
4414  },
4415  info: {
4416    main: lightBlue_default[400],
4417    light: lightBlue_default[300],
4418    dark: lightBlue_default[700]
4419  },
4420  success: {
4421    main: green_default[400],
4422    light: green_default[300],
4423    dark: green_default[700]
4424  },
4425  warning: {
4426    main: orange_default[400],
4427    light: orange_default[300],
4428    dark: orange_default[700]
4429  }
4430};
4431var modes = {
4432  light: useLightOptions,
4433  dark: useDarkOptions
4434};
4435function getContrastText(background, contrastThreshold) {
4436  return getContrastRatio(background, common_default.white) >= contrastThreshold ? common_default.white : "rgba(0, 0, 0, 0.87)";
4437}
4438function addLightOrDark(intent, direction, shade, tonalOffset) {
4439  const tonalOffsetLight = typeof tonalOffset === "number" ? tonalOffset : tonalOffset.light;
4440  const tonalOffsetDark = typeof tonalOffset === "number" ? tonalOffset * 1.5 : tonalOffset.dark;
4441  if (!intent[direction]) {
4442    if (intent.hasOwnProperty(shade)) {
4443      intent[direction] = intent[shade];
4444    } else if (direction === "light") {
4445      intent.light = lighten2(intent.main, tonalOffsetLight);
4446    } else if (direction === "dark") {
4447      intent.dark = darken2(intent.main, tonalOffsetDark);
4448    }
4449  }
4450}
4451function augmentColor(data) {
4452  const color = {
4453    ...data.color
4454  };
4455  const mainShade = data.mainShade ?? 500;
4456  if (!data.color.main && data.color[mainShade]) color.main = data.color[mainShade];
4457  addLightOrDark(color, "light", data.lightShade ?? 300, data.tonalOffset);
4458  addLightOrDark(color, "dark", data.darkShade ?? 700, data.tonalOffset);
4459  if (!color.contrastText) color.contrastText = getContrastText(color.main, data.contrastThreshold);
4460  return color;
4461}
4462var usePalleteDefaults = () => createPaletteOptions({
4463  mode: "light",
4464  tonalOffset: 0.2,
4465  contrastThreshold: 3,
4466  grey: grey_default,
4467  common: common_default
4468});
4469function createPaletteOptions(data) {
4470  return data;
4471}
4472function createPalette(options) {
4473  const colorNames = ["error", "info", "primary", "secondary", "success", "warning"];
4474  const palleteDefaults = usePalleteDefaults();
4475  const result = {
4476    ...merge3({}, palleteDefaults, modes[options?.mode ?? palleteDefaults.mode](), options),
4477    isColorName(name) {
4478      return colorNames.includes(name);
4479    },
4480    getColorObject(color) {
4481      return result[color];
4482    },
4483    getColor(color) {
4484      return result.mode === "light" ? result[color].light : result[color].dark;
4485    },
4486    augmentColor(data) {
4487      return augmentColor({
4488        ...data,
4489        tonalOffset: result.tonalOffset,
4490        contrastThreshold: result.contrastThreshold
4491      });
4492    },
4493    getContrastText(background) {
4494      return getContrastText(background, result.contrastThreshold);
4495    }
4496  };
4497  const getDefaultColor = (color) => result.mode === "light" ? lightColors[color] : darkColors[color];
4498  result.primary = result.augmentColor({
4499    color: result.primary || getDefaultColor("primary")
4500  });
4501  result.secondary = result.augmentColor({
4502    color: result.secondary || getDefaultColor("secondary"),
4503    mainShade: "A400",
4504    lightShade: "A200",
4505    darkShade: "A700"
4506  });
4507  result.error = result.augmentColor({
4508    color: result.error || getDefaultColor("error")
4509  });
4510  result.warning = result.augmentColor({
4511    color: result.warning || getDefaultColor("warning")
4512  });
4513  result.info = result.augmentColor({
4514    color: result.info || getDefaultColor("info")
4515  });
4516  result.success = result.augmentColor({
4517    color: result.success || getDefaultColor("success")
4518  });
4519  return result;
4520}
4521

vendor: 2,314 bytes, lines 4522-4540

4522// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createShadows.jsx
4523var cache = {};
4524var shadowKeyUmbraOpacity = 0.2;
4525var shadowKeyPenumbraOpacity = 0.14;
4526var shadowAmbientShadowOpacity = 0.12;
4527function createCssShadow(...px) {
4528  return [`${px[0]}px ${px[1]}px ${px[2]}px ${px[3]}px rgba(0,0,0,${shadowKeyUmbraOpacity})`, `${px[4]}px ${px[5]}px ${px[6]}px ${px[7]}px rgba(0,0,0,${shadowKeyPenumbraOpacity})`, `${px[8]}px ${px[9]}px ${px[10]}px ${px[11]}px rgba(0,0,0,${shadowAmbientShadowOpacity})`].join(",");
4529}
4530var shadows = [() => "none", () => createCssShadow(0, 2, 1, -1, 0, 1, 1, 0, 0, 1, 3, 0), () => createCssShadow(0, 3, 1, -2, 0, 2, 2, 0, 0, 1, 5, 0), () => createCssShadow(0, 3, 3, -2, 0, 3, 4, 0, 0, 1, 8, 0), () => createCssShadow(0, 2, 4, -1, 0, 4, 5, 0, 0, 1, 10, 0), () => createCssShadow(0, 3, 5, -1, 0, 5, 8, 0, 0, 1, 14, 0), () => createCssShadow(0, 3, 5, -1, 0, 6, 10, 0, 0, 1, 18, 0), () => createCssShadow(0, 4, 5, -2, 0, 7, 10, 1, 0, 2, 16, 1), () => createCssShadow(0, 5, 5, -3, 0, 8, 10, 1, 0, 3, 14, 2), () => createCssShadow(0, 5, 6, -3, 0, 9, 12, 1, 0, 3, 16, 2), () => createCssShadow(0, 6, 6, -3, 0, 10, 14, 1, 0, 4, 18, 3), () => createCssShadow(0, 6, 7, -4, 0, 11, 15, 1, 0, 4, 20, 3), () => createCssShadow(0, 7, 8, -4, 0, 12, 17, 2, 0, 5, 22, 4), () => createCssShadow(0, 7, 8, -4, 0, 13, 19, 2, 0, 5, 24, 4), () => createCssShadow(0, 7, 9, -4, 0, 14, 21, 2, 0, 5, 26, 4), () => createCssShadow(0, 8, 9, -5, 0, 15, 22, 2, 0, 6, 28, 5), () => createCssShadow(0, 8, 10, -5, 0, 16, 24, 2, 0, 6, 30, 5), () => createCssShadow(0, 8, 11, -5, 0, 17, 26, 2, 0, 6, 32, 5), () => createCssShadow(0, 9, 11, -5, 0, 18, 28, 2, 0, 7, 34, 6), () => createCssShadow(0, 9, 12, -6, 0, 19, 29, 2, 0, 7, 36, 6), () => createCssShadow(0, 10, 13, -6, 0, 20, 31, 3, 0, 8, 38, 7), () => createCssShadow(0, 10, 13, -6, 0, 21, 33, 3, 0, 8, 40, 7), () => createCssShadow(0, 10, 14, -6, 0, 22, 35, 3, 0, 8, 42, 7), () => createCssShadow(0, 11, 14, -7, 0, 23, 36, 3, 0, 9, 44, 8), () => createCssShadow(0, 11, 15, -7, 0, 24, 38, 3, 0, 9, 46, 8)];
4531function createShadows() {
4532  return new Proxy([], {
4533    get: (target, p) => {
4534      if (typeof p !== "string" || isNaN(Number(p))) return target[p];
4535      if (p in cache) return cache[p];
4536      return cache[p] = shadows[p]();
4537    }
4538  });
4539}
4540

vendor: 2,382 bytes, lines 4541-4612

4541// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createTransitions.jsx
4542var easing = {
4543  easeInOut: "cubic-bezier(0.4, 0, 0.2, 1)",
4544  easeOut: "cubic-bezier(0.0, 0, 0.2, 1)",
4545  easeIn: "cubic-bezier(0.4, 0, 1, 1)",
4546  sharp: "cubic-bezier(0.4, 0, 0.6, 1)"
4547};
4548var duration = {
4549  shortest: 150,
4550  shorter: 200,
4551  short: 250,
4552  standard: 300,
4553  complex: 375,
4554  enteringScreen: 225,
4555  leavingScreen: 195
4556};
4557function formatMs(milliseconds) {
4558  return `${Math.round(milliseconds)}ms`;
4559}
4560function getAutoHeightDuration(height) {
4561  if (!height) {
4562    return 0;
4563  }
4564  const constant = height / 36;
4565  return Math.round((4 + 15 * constant ** 0.25 + constant / 5) * 10);
4566}
4567function createTransitions(inputTransitions) {
4568  const mergedEasing = {
4569    ...easing,
4570    ...inputTransitions.easing
4571  };
4572  const mergedDuration = {
4573    ...duration,
4574    ...inputTransitions.duration
4575  };
4576  const create2 = (props = ["all"], options = {}) => {
4577    const {
4578      duration: durationOption = mergedDuration.standard,
4579      easing: easingOption = mergedEasing.easeInOut,
4580      delay = 0,
4581      ...other
4582    } = options;
4583    if (true) {
4584      const isString = (value) => typeof value === "string";
4585      const isNumber = (value) => !isNaN(parseFloat(value));
4586      if (!isString(props) && !Array.isArray(props)) {
4587        console.error('MUI: Argument "props" must be a string or Array.');
4588      }
4589      if (!isNumber(durationOption) && !isString(durationOption)) {
4590        console.error(`MUI: Argument "duration" must be a number or a string but found ${durationOption}.`);
4591      }
4592      if (!isString(easingOption)) {
4593        console.error('MUI: Argument "easing" must be a string.');
4594      }
4595      if (!isNumber(delay) && !isString(delay)) {
4596        console.error('MUI: Argument "delay" must be a number or a string.');
4597      }
4598      if (Object.keys(other).length !== 0) {
4599        console.error(`MUI: Unrecognized argument(s) [${Object.keys(other).join(",")}].`);
4600      }
4601    }
4602    return (Array.isArray(props) ? props : [props]).map((animatedProp) => `${animatedProp} ${typeof durationOption === "string" ? durationOption : formatMs(durationOption)} ${easingOption} ${typeof delay === "string" ? delay : formatMs(delay)}`).join(",");
4603  };
4604  return {
4605    getAutoHeightDuration,
4606    create: create2,
4607    ...inputTransitions,
4608    easing: mergedEasing,
4609    duration: mergedDuration
4610  };
4611}
4612

vendor: 2,367 bytes, lines 4613-4686

4613// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createTypography.jsx
4614var fontWeight = {
4615  light: 300,
4616  regular: 400,
4617  medium: 500,
4618  bold: 700
4619};
4620var typographyDefaults = createTypographyOptions({
4621  fontFamily: '"Roboto", "Helvetica", "Arial", sans-serif',
4622  fontSize: 14,
4623  htmlFontSize: 16,
4624  h1: {},
4625  h2: {},
4626  h3: {},
4627  h4: {},
4628  h5: {},
4629  h6: {},
4630  subtitle1: {},
4631  subtitle2: {},
4632  body1: {},
4633  body2: {},
4634  button: {},
4635  caption: {},
4636  overline: {},
4637  fontWeightLight: 300,
4638  fontWeightRegular: 400,
4639  fontWeightMedium: 500,
4640  fontWeightBold: 700
4641});
4642function createTypographyOptions(options) {
4643  return options;
4644}
4645function round(value) {
4646  return Math.round(value * 1e5) / 1e5;
4647}
4648function makeVariant(base, fontWeight2, size, lineHeight, letterSpacing, casing) {
4649  return {
4650    fontFamily: base.fontFamily,
4651    fontWeight: fontWeight2,
4652    fontSize: base.pxToRem(size),
4653    lineHeight: `${lineHeight}`,
4654    letterSpacing: `${round(letterSpacing / size)}em`,
4655    ...casing ? {
4656      textTransform: "uppercase"
4657    } : {}
4658  };
4659}
4660function createTypography(options = {}) {
4661  const base = {
4662    fontFamily: options.fontFamily ?? typographyDefaults.fontFamily,
4663    fontSize: options.fontSize ?? typographyDefaults.fontSize,
4664    htmlFontSize: options?.htmlFontSize ?? typographyDefaults.htmlFontSize,
4665    pxToRem: (size) => {
4666      const coef = base.fontSize / 14;
4667      return `${size / base.htmlFontSize * coef}rem`;
4668    }
4669  };
4670  return merge3(base, {
4671    h1: makeVariant(base, fontWeight.light, 96, 1.167, -1.5),
4672    h2: makeVariant(base, fontWeight.light, 60, 1.2, -0.5),
4673    h3: makeVariant(base, fontWeight.regular, 48, 1.167, 0),
4674    h4: makeVariant(base, fontWeight.regular, 34, 1.235, 0.25),
4675    h5: makeVariant(base, fontWeight.regular, 24, 1.334, 0),
4676    h6: makeVariant(base, fontWeight.medium, 20, 1.6, 0.15),
4677    subtitle1: makeVariant(base, fontWeight.regular, 16, 1.75, 0.15),
4678    subtitle2: makeVariant(base, fontWeight.medium, 14, 1.57, 0.1),
4679    body1: makeVariant(base, fontWeight.regular, 16, 1.5, 0.15),
4680    body2: makeVariant(base, fontWeight.regular, 14, 1.43, 0.15),
4681    button: makeVariant(base, fontWeight.medium, 14, 1.75, 0.4, true),
4682    caption: makeVariant(base, fontWeight.regular, 12, 1.66, 0.4),
4683    overline: makeVariant(base, fontWeight.regular, 12, 2.66, 1, true)
4684  }, typographyDefaults, options);
4685}
4686

vendor: 426 bytes, lines 4687-4706

4687// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createZIndex.jsx
4688var zIndexDefaults = createZIndexOptions({
4689  mobileStepper: 1e3,
4690  speedDial: 1050,
4691  appBar: 1100,
4692  drawer: 1200,
4693  modal: 1300,
4694  snackbar: 1400,
4695  tooltip: 1500
4696});
4697function createZIndexOptions(data) {
4698  return data;
4699}
4700function createZIndex(data) {
4701  const result = {
4702    ...merge3({}, zIndexDefaults, data)
4703  };
4704  return result;
4705}
4706

vendor: 591 bytes, lines 4707-4723

4707// node_modules/@suid/css/renderMediaQuery.js
4708function renderMediaQuery(comparator, width, units = "px") {
4709  let selector;
4710  if (comparator === "up") {
4711    selector = `(min-width:${width}${units})`;
4712  } else if (comparator === "down") {
4713    selector = `(max-width:${width}${units})`;
4714  } else if (comparator === "between") {
4715    const [maxW, minW] = width;
4716    selector = `(max-width:${maxW}${units}) and (min-width:${minW}${units})`;
4717  } else {
4718    throw new Error(`Invalid comparator: ${comparator}`);
4719  }
4720  return `@media ${selector}`;
4721}
4722var renderMediaQuery_default = renderMediaQuery;
4723

vendor: 1,139 bytes, lines 4724-4764

4724// node_modules/@suid/icons-material/node_modules/@suid/system/createTheme/createBreakpoints.js
4725var breakpointsDefault = createBreakpointsOptions({
4726  columns: 12,
4727  keys: ["xs", "sm", "md", "lg", "xl"],
4728  values: {
4729    xs: 0,
4730    sm: 600,
4731    md: 900,
4732    lg: 1200,
4733    xl: 1536
4734  },
4735  unit: "px"
4736});
4737function createBreakpointsOptions(options) {
4738  return options;
4739}
4740function createBreakpoints(options) {
4741  const result = {
4742    ...breakpointsDefault,
4743    ...options ?? {},
4744    up: (value, css) => {
4745      const key = renderMediaQuery_default("up", result.resolve(value));
4746      return css ? { [key]: css } : key;
4747    },
4748    down: (value, css) => {
4749      const key = renderMediaQuery_default("down", result.resolve(value));
4750      return css ? { [key]: css } : key;
4751    },
4752    between: (value, css) => {
4753      const key = renderMediaQuery_default("between", [
4754        result.resolve(value[0]),
4755        result.resolve(value[1])
4756      ]);
4757      return css ? { [key]: css } : key;
4758    },
4759    resolve: (value) => typeof value === "number" ? value : result.values[value]
4760  };
4761  return result;
4762}
4763var createBreakpoints_default = createBreakpoints;
4764

vendor: 386 bytes, lines 4765-4775

4765// node_modules/@suid/icons-material/node_modules/@suid/system/createTheme/createSpacing.js
4766function createSpacing(options) {
4767  if (typeof options === "function")
4768    return options;
4769  const resolved = (...values2) => {
4770    return values2.map((v) => typeof v === "number" ? `${v * (options ?? 8)}px` : v).join(" ");
4771  };
4772  return resolved;
4773}
4774var createSpacing_default = createSpacing;
4775

vendor: 351 bytes, lines 4776-4790

4776// node_modules/@suid/icons-material/node_modules/@suid/system/createTheme/shape.js
4777var shapeDefaults = createShapeOptions({
4778  borderRadius: 4
4779});
4780function createShapeOptions(data) {
4781  return data;
4782}
4783function createShape(options) {
4784  const result = {
4785    ...merge3({}, shapeDefaults, options)
4786  };
4787  return result;
4788}
4789var shape_default = createShape;
4790

vendor: 1,177 bytes, lines 4791-4824

4791// node_modules/@suid/icons-material/node_modules/@suid/material/styles/createTheme.jsx
4792function createTheme(input = {}) {
4793  const theme = {
4794    direction: "ltr",
4795    ...input
4796  };
4797  function def(key, defaults) {
4798    const inputValue = input[key];
4799    Object.defineProperty(theme, key, {
4800      configurable: true,
4801      enumerable: true,
4802      ...typeof inputValue === "function" ? {
4803        get: inputValue
4804      } : {
4805        value: defaults({
4806          [key]: inputValue
4807        })
4808      }
4809    });
4810  }
4811  def("breakpoints", (input2) => createBreakpoints_default(input2.breakpoints));
4812  def("components", (input2) => createComponents(input2.components));
4813  def("palette", (input2) => createPalette(input2.palette));
4814  def("shape", (input2) => shape_default(input2.shape));
4815  def("spacing", (input2) => createSpacing_default(input2.spacing));
4816  def("typography", (input2) => createTypography(input2.typography));
4817  def("shadows", () => createShadows());
4818  def("transitions", () => createTransitions({}));
4819  def("zIndex", (input2) => createZIndex(input2.zIndex));
4820  def("mixins", () => createMixins(theme.breakpoints));
4821  return theme;
4822}
4823var createTheme_default = createTheme;
4824

vendor: 345 bytes, lines 4825-4836

4825// node_modules/@suid/icons-material/node_modules/@suid/system/makeGetDefaultTheme.js
4826function makeGetDefaultTheme(createTheme3) {
4827  let defaultTheme;
4828  return function getDefaultTheme() {
4829    if (!defaultTheme) {
4830      defaultTheme = createTheme3();
4831    }
4832    return defaultTheme;
4833  };
4834}
4835var makeGetDefaultTheme_default = makeGetDefaultTheme;
4836

vendor: 172 bytes, lines 4837-4839

4837// node_modules/@suid/icons-material/node_modules/@suid/material/styles/getDefaultTheme.js
4838var getDefaultTheme_default = makeGetDefaultTheme_default(createTheme_default);
4839

vendor: 386 bytes, lines 4840-4850

4840// node_modules/@suid/icons-material/node_modules/@suid/system/ThemeContext/ThemeContext.jsx
4841var ThemeContext;
4842if (true) {
4843  const global = globalThis;
4844  const suid = global.__suid || (global.__suid = {});
4845  ThemeContext = suid.systemThemeContext || (suid.systemThemeContext = createContext({}));
4846} else {
4847  ThemeContext = createContext({});
4848}
4849var ThemeContext_default = ThemeContext;
4850

vendor: 530 bytes, lines 4851-4870

4851// node_modules/@suid/icons-material/node_modules/@suid/system/createTheme/createTheme.jsx
4852function createTheme2(data) {
4853  const result = {
4854    direction: "ltr",
4855    shadows: void 0,
4856    transitions: void 0,
4857    components: void 0,
4858    palette: void 0,
4859    typography: void 0,
4860    zIndex: void 0,
4861    mixins: void 0,
4862    ...data,
4863    breakpoints: createBreakpoints(data?.breakpoints),
4864    shape: createShape(data?.shape),
4865    spacing: createSpacing(data?.spacing)
4866  };
4867  return result;
4868}
4869var createTheme_default2 = createTheme2;
4870

vendor: 165 bytes, lines 4871-4873

4871// node_modules/@suid/icons-material/node_modules/@suid/system/getDefaultTheme.js
4872var getDefaultTheme_default2 = makeGetDefaultTheme_default(createTheme_default2);
4873

vendor: 144 bytes, lines 4874-4880

4874// node_modules/@suid/utils/isEmptyObject.js
4875function isEmptyObject3(object) {
4876  for (const _key in object)
4877    return false;
4878  return true;
4879}
4880

vendor: 466 bytes, lines 4881-4894

4881// node_modules/@suid/icons-material/node_modules/@suid/system/useTheme.js
4882function useTheme(defaultTheme = getDefaultTheme_default2, Context = ThemeContext_default) {
4883  const theme = useContext(Context);
4884  if (isEmptyObject3(theme) && defaultTheme) {
4885    if (typeof defaultTheme === "function")
4886      return defaultTheme();
4887    return defaultTheme;
4888  }
4889  if (!theme)
4890    throw new Error("Theme is not defined");
4891  return theme;
4892}
4893var useTheme_default2 = useTheme;
4894

vendor: 247 bytes, lines 4895-4900

4895// node_modules/@suid/icons-material/node_modules/@suid/material/styles/useTheme.js
4896function useTheme2(defaultTheme = getDefaultTheme_default) {
4897  return useTheme_default2(defaultTheme, ThemeContext_default);
4898}
4899var useTheme_default3 = useTheme2;
4900

vendor: 210 bytes, lines 4901-4906

4901// node_modules/@suid/icons-material/node_modules/@suid/base/useTheme.js
4902function useTheme3(defaultTheme) {
4903  return useTheme_default2(defaultTheme, ThemeContext_default);
4904}
4905var useTheme_default4 = useTheme3;
4906

vendor: 488 bytes, lines 4907-4921

4907// node_modules/@suid/icons-material/node_modules/@suid/base/useThemeProps.js
4908function useThemeProps(options) {
4909  const theme = useTheme_default4();
4910  const set = (v) => v;
4911  const propDefaults = typeof options.propDefaults === "function" ? options.propDefaults({
4912    set,
4913    inProps: options.props
4914  }) : options.propDefaults;
4915  return mergeProps(...[
4916    ...propDefaults ? [propDefaults] : [],
4917    () => theme.components?.[options.name]?.defaultProps || {},
4918    options.props
4919  ]);
4920}
4921

vendor: 1,271 bytes, lines 4922-4959

4922// node_modules/@suid/icons-material/node_modules/@suid/system/Dynamic/Dynamic.jsx
4923function createElement(tagName, isSVG = false) {
4924  return isSVG ? document.createElementNS("http://www.w3.org/2000/svg", tagName) : document.createElement(tagName);
4925}
4926function ServerDynamic(props) {
4927  const [p, others] = splitProps(props, ["$component"]);
4928  const comp = p.$component, t = typeof comp;
4929  if (comp) {
4930    if (t === "function") return comp(others);
4931    else if (t === "string") {
4932      return ssrElement(comp, others, void 0, true);
4933    }
4934  }
4935}
4936function Dynamic2(props) {
4937  if (isServer) return ServerDynamic(props);
4938  const [p, others] = splitProps(props, ["$component"]);
4939  const cached = createMemo(() => p.$component);
4940  return createMemo(() => {
4941    const component = cached();
4942    switch (typeof component) {
4943      case "function":
4944        if ("_DX_DEV_") Object.assign(component, {
4945          [$DEVCOMP]: true
4946        });
4947        return untrack(() => component(others));
4948      case "string":
4949        const isSvg = SVGElements.has(component);
4950        const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg);
4951        spread(el, others, isSvg);
4952        return el;
4953      default:
4954        break;
4955    }
4956  });
4957}
4958var Dynamic_default2 = Dynamic2;
4959

vendor: 445 bytes, lines 4960-4975

4960// node_modules/@suid/icons-material/node_modules/@suid/styled-engine/mergeStyleProps.js
4961function mergeStyleProps(values2) {
4962  const result = values2.reduce((result2, value) => {
4963    if ("name" in value)
4964      result2[`--${value.name}`] = "0";
4965    deepmerge4(result2, value, {
4966      clone: false,
4967      sortKeys: true
4968    });
4969    return result2;
4970  }, {});
4971  delete result.name;
4972  return result;
4973}
4974var mergeStyleProps_default = mergeStyleProps;
4975

vendor: 461 bytes, lines 4976-4995

4976// node_modules/@suid/css/assert.js
4977function isVar(value) {
4978  return value.startsWith("--");
4979}
4980function isPrivateVar(value) {
4981  return value.startsWith("__");
4982}
4983function isSelector(value) {
4984  return /[^a-z-]/i.test(value) && !isVar(value);
4985}
4986function isGlobalSelector(value) {
4987  return value.startsWith("@global");
4988}
4989function isMediaQuery(value) {
4990  return value.startsWith("@media");
4991}
4992function isKeyframes(value) {
4993  return value.startsWith("@keyframes");
4994}
4995

vendor: 148 bytes, lines 4996-5000

4996// node_modules/@suid/css/utils/string.js
4997function snakeCase3(value) {
4998  return value.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
4999}
5000

vendor: 2,770 bytes, lines 5001-5082

5001// node_modules/@suid/css/render.js
5002function renderSelector(propKey, propValue, selectors = [], options = {}) {
5003  const subselectors = propKey.split(",").map((v) => {
5004    v = v.trim();
5005    return v.includes("&") ? v : `& ${v}`;
5006  });
5007  return render(propValue, (selectors.length ? selectors : [""]).flatMap((selector) => subselectors.map((v) => v.replace(/&/g, selector).trim())), {
5008    ...options
5009  });
5010}
5011function render(css, selectors = [], options = {}) {
5012  const props = [];
5013  const rules = [];
5014  for (let propKey in css) {
5015    const propValue = css[propKey];
5016    if (isPrivateVar(propKey)) {
5017      continue;
5018    } else if (isGlobalSelector(propKey)) {
5019      for (const selector in propValue) {
5020        rules.push(...renderSelector(selector, propValue[selector], [], options));
5021      }
5022    } else if (isMediaQuery(propKey)) {
5023      rules.push(...render(propValue, selectors, {
5024        ...options,
5025        sublevel: true
5026      }).map((v) => `${propKey} {
5027${v}
5028}`));
5029    } else if (isVar(propKey)) {
5030      if (propValue !== void 0 && propValue !== null)
5031        props.push(`${propKey}: ${propValue};`);
5032    } else if (isKeyframes(propKey)) {
5033      const keyframes = [];
5034      for (const k in propValue) {
5035        keyframes.push(...render(propValue[k], [/^\d+$/.test(k) ? `${k}%` : k], {
5036          ...options,
5037          sublevel: true
5038        }));
5039      }
5040      rules.push(`${propKey} {
5041${keyframes.join("\n")}
5042}`);
5043    } else if (isSelector(propKey)) {
5044      rules.push(...renderSelector(propKey, propValue, selectors, options));
5045    } else if (options.extraProperties && propKey in options.extraProperties) {
5046      const extraProps = options.extraProperties[propKey](propValue);
5047      for (const extraPropKey in extraProps) {
5048        const inValue = extraProps[extraPropKey];
5049        const value = options.onPropertyValue ? options.onPropertyValue(extraPropKey, inValue) : inValue;
5050        if (value !== void 0 && value !== null)
5051          props.push(`${snakeCase3(extraPropKey)}: ${value};`);
5052      }
5053    } else {
5054      propKey = snakeCase3(propKey);
5055      const value = options.onPropertyValue ? options.onPropertyValue(propKey, propValue) : propValue;
5056      if (value !== void 0 && value !== null)
5057        props.push(`${propKey}: ${value};`);
5058    }
5059  }
5060  const renderProps = (level) => {
5061    const pad = "	".repeat(level);
5062    return `${pad}${props.join(`
5063${pad}`)}`;
5064  };
5065  if (selectors.length) {
5066    const pad = options.sublevel ? `	` : ``;
5067    const selectorStr = pad + selectors.join(`,
5068${pad}`);
5069    return [
5070      ...props.length ? [
5071        `${selectorStr} {
5072${renderProps(options.sublevel ? 2 : 1)}
5073${pad}}`
5074      ] : [],
5075      ...rules
5076    ];
5077  } else {
5078    return [...props.length ? [renderProps(0)] : [], ...rules];
5079  }
5080}
5081var render_default = render;
5082

vendor: 133 bytes, lines 5083-5087

5083// node_modules/@suid/css/utils/array.js
5084function toArray3(value) {
5085  return value ? Array.isArray(value) ? value : [value] : [];
5086}
5087

vendor: 154 bytes, lines 5088-5094

5088// node_modules/@suid/css/utils/function.js
5089function resolveFunction3(value) {
5090  if (typeof value === "function")
5091    value = value();
5092  return value;
5093}
5094

vendor: 1,455 bytes, lines 5095-5140

5095// node_modules/@suid/css/createStyleObject.js
5096var StyleCache = class {
5097  ids = /* @__PURE__ */ new Map();
5098  rules = /* @__PURE__ */ new Map();
5099  create(name, rules, componentId) {
5100    let styleObject = this.rules.get(rules);
5101    if (styleObject)
5102      return styleObject;
5103    let componentIndex = this.ids.get(componentId);
5104    if (typeof componentIndex === "number") {
5105      this.ids.set(componentId, ++componentIndex);
5106      componentId += `_${componentIndex}`;
5107    }
5108    styleObject = create(name, rules, componentId);
5109    this.save(styleObject, rules);
5110    return styleObject;
5111  }
5112  save(style2, rules) {
5113    this.ids.set(style2.id, 0);
5114    this.rules.set(rules, style2);
5115  }
5116  delete(style2) {
5117    this.ids.delete(style2.id);
5118    this.rules.delete(style2.rules);
5119  }
5120};
5121function create(name, rules, id) {
5122  return {
5123    id,
5124    name,
5125    className: `${name}-${id}`,
5126    rules: rules.replaceAll(`$id`, `${id}`)
5127  };
5128}
5129function createStyleObject(options) {
5130  const className2 = `${options.name}-$id`;
5131  const propsValues = toArray3(resolveFunction3(options.props));
5132  const rules = propsValues.map((v) => typeof v === "string" ? `.${className2} {
5133${v}
5134}` : render_default(v, [`.${className2}`], {
5135    extraProperties: options.extraProperties
5136  }).join("\n")).join("\n");
5137  return options.cache?.create(options.name, rules, options.componentId) || create(options.name, rules, options.componentId);
5138}
5139var createStyleObject_default = createStyleObject;
5140

vendor: 331 bytes, lines 5141-5151

5141// node_modules/@suid/css/dom/setStyleElementText.js
5142function setStyleElementText(element, text) {
5143  if ("styleSheet" in element) {
5144    element["styleSheet"].cssText = text;
5145  } else {
5146    element.innerText = "";
5147    element.appendChild(document.createTextNode(text));
5148  }
5149}
5150var setStyleElementText_default = setStyleElementText;
5151

vendor: 646 bytes, lines 5152-5174

5152// node_modules/@suid/css/dom/createStyleElement.js
5153function setAttributes(element, attributes) {
5154  for (const name in attributes) {
5155    const value = attributes[name];
5156    if (value !== void 0) {
5157      if (value === null) {
5158        element.removeAttribute(name);
5159      } else {
5160        element.setAttribute(name, value);
5161      }
5162    }
5163  }
5164}
5165function createStyleElement(css, attributes) {
5166  const element = document.createElement("style");
5167  element.type = "text/css";
5168  if (attributes)
5169    setAttributes(element, attributes);
5170  setStyleElementText_default(element, css);
5171  return element;
5172}
5173var createStyleElement_default = createStyleElement;
5174

vendor: 292 bytes, lines 5175-5182

5175// node_modules/@suid/css/dom/registerStyleElementUsage.js
5176function registerStyleElementUsage(style2) {
5177  let uses = Number(style2.getAttribute("data-uses"));
5178  uses++;
5179  style2.setAttribute("data-uses", uses.toString());
5180}
5181var registerStyleElementUsage_default = registerStyleElementUsage;
5182

vendor: 1,220 bytes, lines 5183-5215

5183// node_modules/@suid/css/dom/appendStyleElement.js
5184var placeholderId = "suid-injectFirst";
5185function appendStyleElement(css, attributes, injectFirst) {
5186  if (Array.isArray(css))
5187    css = css.join("\n");
5188  const id = attributes?.["id"];
5189  const head = document.head || document.getElementsByTagName("head")[0];
5190  const prevElement = id && document.getElementById(id);
5191  if (prevElement && prevElement instanceof HTMLStyleElement) {
5192    setStyleElementText_default(prevElement, css);
5193    registerStyleElementUsage_default(prevElement);
5194    return prevElement;
5195  } else {
5196    if (prevElement)
5197      prevElement.remove();
5198    const element = createStyleElement_default(css, attributes);
5199    registerStyleElementUsage_default(element);
5200    if (injectFirst) {
5201      let placeholderElement = head.querySelector(`#${placeholderId}`);
5202      if (!placeholderElement) {
5203        placeholderElement = document.createElement("style");
5204        placeholderElement.setAttribute("id", placeholderId);
5205        head.prepend(placeholderElement);
5206      }
5207      head.insertBefore(element, placeholderElement);
5208    } else {
5209      head.appendChild(element);
5210    }
5211    return element;
5212  }
5213}
5214var appendStyleElement_default = appendStyleElement;
5215

vendor: 415 bytes, lines 5216-5225

5216// node_modules/@suid/css/dom/findStyleElement.js
5217function findStyleElement(input, classPrefix = "css-") {
5218  if (typeof input === "string")
5219    return document.getElementById(input);
5220  const className2 = [...input.classList].find((name) => name.startsWith(classPrefix));
5221  if (className2)
5222    return document.getElementById(className2.slice(classPrefix.length));
5223}
5224var findStyleElement_default = findStyleElement;
5225

vendor: 357 bytes, lines 5226-5237

5226// node_modules/@suid/css/dom/unregisterStyleElementUsage.js
5227function unregisterStyleElementUsage(style2) {
5228  let uses = Number(style2.getAttribute("data-uses"));
5229  uses--;
5230  if (uses <= 0) {
5231    style2.remove();
5232  } else {
5233    style2.setAttribute("data-uses", uses.toString());
5234  }
5235}
5236var unregisterStyleElementUsage_default = unregisterStyleElementUsage;
5237

vendor: 252 bytes, lines 5238-5245

5238// node_modules/@suid/utils/capitalize.js
5239function capitalize3(string) {
5240  if (typeof string !== "string") {
5241    throw new Error("MUI: `capitalize(string)` expects a string argument.");
5242  }
5243  return string.charAt(0).toUpperCase() + string.slice(1);
5244}
5245

vendor: 140 bytes, lines 5246-5250

5246// node_modules/@suid/utils/randomString.js
5247function randomString3() {
5248  return Math.random().toString(36).substring(2, 15).slice(0, 8);
5249}
5250

vendor: 2,922 bytes, lines 5251-5336

5251// node_modules/@suid/icons-material/node_modules/@suid/styled-engine/createStyle.jsx
5252var _tmpl$2 = /* @__PURE__ */ template(`<style>`);
5253var styleCache = isServer ? void 0 : new StyleCache();
5254function normalizeStyleProps(props) {
5255  if (!props) return [];
5256  return (Array.isArray(props) ? props : [props]).flat(Infinity).filter((v) => !!v);
5257}
5258function createStyleId() {
5259  if (!sharedConfig.context) return randomString3();
5260  const id = createUniqueId().replaceAll("-", "");
5261  const chunkSize = 9;
5262  const chunks = Math.ceil(id.length / chunkSize);
5263  const ids = [];
5264  for (let chunk = 1; chunk <= chunks; ++chunk) {
5265    const index = (chunk - 1) * chunkSize;
5266    const number = Number(id.slice(index, index + chunkSize));
5267    ids.push(number.toString(32));
5268  }
5269  return ids.join("-");
5270}
5271function createStyle(value) {
5272  const context = useContext(StyledEngineContext_default);
5273  const [name, setName] = createSignal("");
5274  const componentId = createStyleId();
5275  let styleElement;
5276  createRenderEffect((prevResult) => {
5277    const propsValue = value();
5278    let styleObject;
5279    if (propsValue) {
5280      styleObject = createStyleObject_default({
5281        name: "css",
5282        props: mergeStyleProps_default(normalizeStyleProps(propsValue)),
5283        cache: styleCache,
5284        componentId
5285      });
5286      if (isServer) {
5287        if (true) {
5288          if (context.injectFirst) console.warn(`SUID: 'injectFirst' is not supported in SSR mode.`);
5289        }
5290        voidFn(() => (() => {
5291          const _el$ = _tmpl$2();
5292          createRenderEffect((_p$) => {
5293            const _v$ = styleObject.id, _v$2 = styleObject.rules, _v$3 = context.cache?.nonce;
5294            _v$ !== _p$._v$ && setAttribute(_el$, "id", _p$._v$ = _v$);
5295            _v$2 !== _p$._v$2 && (_el$.innerHTML = _p$._v$2 = _v$2);
5296            _v$3 !== _p$._v$3 && setAttribute(_el$, "nonce", _p$._v$3 = _v$3);
5297            return _p$;
5298          }, {
5299            _v$: void 0,
5300            _v$2: void 0,
5301            _v$3: void 0
5302          });
5303          return _el$;
5304        })());
5305      } else {
5306        styleElement = findStyleElement_default(styleObject.id);
5307        if (styleElement) {
5308          registerStyleElementUsage_default(styleElement);
5309        } else {
5310          styleElement = appendStyleElement_default(styleObject.rules, {
5311            id: styleObject.id,
5312            nonce: context.cache?.nonce
5313          }, context.injectFirst);
5314        }
5315        if (prevResult?.styleElement) {
5316          unregisterStyleElementUsage_default(prevResult.styleElement);
5317        }
5318      }
5319    }
5320    if (typeof styleObject?.className === "string") {
5321      setName(styleObject.className);
5322    } else {
5323      setName("");
5324    }
5325    return {
5326      className: styleObject?.className,
5327      styleElement
5328    };
5329  }, void 0);
5330  onCleanup(() => {
5331    if (styleElement) unregisterStyleElementUsage_default(styleElement);
5332  });
5333  return name;
5334}
5335var createStyle_default2 = createStyle;
5336

vendor: 892 bytes, lines 5337-5366

5337// node_modules/@suid/css/resolve.js
5338function resolve(css, onProp, cssTarget = {}) {
5339  for (const name in css) {
5340    const value = css[name];
5341    if (isGlobalSelector(name)) {
5342      cssTarget[name] = resolve(value, onProp);
5343    } else if (isMediaQuery(name)) {
5344      cssTarget[name] = resolve(value, onProp);
5345    } else if (isKeyframes(name)) {
5346      cssTarget[name] = {};
5347      for (const v in value) {
5348        cssTarget[name][v] = resolve(value[v], onProp);
5349      }
5350    } else if (isSelector(name)) {
5351      cssTarget[name] = resolve(value, onProp);
5352    } else {
5353      const result = onProp(name, value);
5354      if (result) {
5355        for (const key in result) {
5356          cssTarget[key] = isMediaQuery(key) ? { ...cssTarget[key], ...result[key] } : result[key];
5357        }
5358      } else {
5359        cssTarget[name] = value;
5360      }
5361    }
5362  }
5363  return cssTarget;
5364}
5365var resolve_default = resolve;
5366

vendor: 1,211 bytes, lines 5367-5424

5367// node_modules/@suid/icons-material/node_modules/@suid/system/resolveStyledProps.js
5368var unitLess = /* @__PURE__ */ new Set([
5369  "animationIterationCount",
5370  "borderImageOutset",
5371  "borderImageSlice",
5372  "borderImageWidth",
5373  "boxFlex",
5374  "boxFlexGroup",
5375  "boxOrdinalGroup",
5376  "columnCount",
5377  "columns",
5378  "flex",
5379  "flexGrow",
5380  "flexPositive",
5381  "flexShrink",
5382  "flexNegative",
5383  "flexOrder",
5384  "gridRow",
5385  "gridRowEnd",
5386  "gridRowSpan",
5387  "gridRowStart",
5388  "gridColumn",
5389  "gridColumnEnd",
5390  "gridColumnSpan",
5391  "gridColumnStart",
5392  "msGridRow",
5393  "msGridRowSpan",
5394  "msGridColumn",
5395  "msGridColumnSpan",
5396  "fontWeight",
5397  "lineHeight",
5398  "opacity",
5399  "order",
5400  "orphans",
5401  "tabSize",
5402  "widows",
5403  "zIndex",
5404  "zoom",
5405  "WebkitLineClamp",
5406  "fillOpacity",
5407  "floodOpacity",
5408  "stopOpacity",
5409  "strokeDasharray",
5410  "strokeDashoffset",
5411  "strokeMiterlimit",
5412  "strokeOpacity",
5413  "strokeWidth"
5414]);
5415function resolveStyledPropsValue(name, value) {
5416  if (typeof value === "number") {
5417    return { [name]: unitLess.has(name) ? value.toString() : `${value}px` };
5418  }
5419}
5420function resolveStyledProps(v) {
5421  return resolve_default(v, resolveStyledPropsValue);
5422}
5423var resolveStyledProps_default = resolveStyledProps;
5424

vendor: 404 bytes, lines 5425-5439

5425// node_modules/@suid/icons-material/node_modules/@suid/system/getThemeValue.js
5426function getThemeValue(theme, key, value) {
5427  if (typeof value !== "string")
5428    return value;
5429  const names = value.split(".");
5430  let ref = theme[key];
5431  for (let i = 0; i < names.length; i++) {
5432    ref = ref?.[names[i]];
5433    if (!ref)
5434      break;
5435  }
5436  return ref ?? value;
5437}
5438var getThemeValue_default2 = getThemeValue;
5439

vendor: 1,860 bytes, lines 5440-5494

5440// node_modules/@suid/icons-material/node_modules/@suid/system/spacing.js
5441function getPath(obj, path) {
5442  if (!path || typeof path !== "string") {
5443    return null;
5444  }
5445  return path.split(".").reduce((acc, item) => acc && acc[item] ? acc[item] : null, obj);
5446}
5447function createUnaryUnit(theme, themeKey, defaultValue, propName) {
5448  const themeSpacing = getPath(theme, themeKey) || defaultValue;
5449  if (typeof themeSpacing === "number") {
5450    return (abs) => {
5451      if (typeof abs === "string") {
5452        return abs;
5453      }
5454      if (true) {
5455        if (typeof abs !== "number") {
5456          console.error(`MUI: Expected ${propName} argument to be a number or a string, got ${abs}.`);
5457        }
5458      }
5459      return themeSpacing * abs;
5460    };
5461  }
5462  if (Array.isArray(themeSpacing)) {
5463    return (abs) => {
5464      if (typeof abs === "string") {
5465        return abs;
5466      }
5467      if (true) {
5468        if (!Number.isInteger(abs)) {
5469          console.error([
5470            `MUI: The \`theme.${themeKey}\` array type cannot be combined with non integer values.You should either use an integer value that can be used as index, or define the \`theme.${themeKey}\` as a number.`
5471          ].join("\n"));
5472        } else if (abs > themeSpacing.length - 1) {
5473          console.error([
5474            `MUI: The value provided (${abs}) overflows.`,
5475            `The supported values are: ${JSON.stringify(themeSpacing)}.`,
5476            `${abs} > ${themeSpacing.length - 1}, you need to add the missing values.`
5477          ].join("\n"));
5478        }
5479      }
5480      return themeSpacing[abs];
5481    };
5482  }
5483  if (typeof themeSpacing === "function") {
5484    return themeSpacing;
5485  }
5486  if (true) {
5487    console.error([
5488      `MUI: The \`theme.${themeKey}\` value (${themeSpacing}) is invalid.`,
5489      "It should be a number, an array or a function."
5490    ].join("\n"));
5491  }
5492  return () => void 0;
5493}
5494

vendor: 7,636 bytes, lines 5495-5702

5495// node_modules/@suid/icons-material/node_modules/@suid/system/createSystemProps.js
5496var dirMap = {
5497  x: ["Left", "Right"],
5498  y: ["Top", "Bottom"]
5499};
5500function asPx(value) {
5501  return typeof value === "number" ? `${value}px` : value;
5502}
5503function customProp(name, onValue) {
5504  return (value, theme) => onValue(name, value, theme);
5505}
5506function prop(name, onValue) {
5507  return onValue ? (value, theme) => ({
5508    [name]: onValue(name, value, theme)
5509  }) : (value) => ({ [name]: value });
5510}
5511function pxProp(name) {
5512  return prop(name, (name2, value) => asPx(value));
5513}
5514function mProp(name, suffix, onValue) {
5515  const names = suffix.map((v) => `${name}${v}`);
5516  return onValue ? (value, theme) => names.reduce((result, name2) => {
5517    result[name2] = onValue(name2, value, theme);
5518    return result;
5519  }, {}) : (value) => names.reduce((result, name2) => {
5520    result[name2] = value;
5521    return result;
5522  }, {});
5523}
5524function createSystemProps() {
5525  return {
5526    ...createSystemDisplayProps(),
5527    ...createSystemFlexboxProps(),
5528    ...createSystemGridProps(),
5529    ...createSystemPositionProps(),
5530    ...createSystemPaletteProps(),
5531    ...createSystemSizingProps(),
5532    ...createSystemBorderProps(),
5533    ...createSystemSpacingProps(),
5534    ...createSystemTypographyProps()
5535  };
5536}
5537function createSystemDisplayProps() {
5538  return {
5539    displayPrint: customProp("displayPrint", (name, display) => ({
5540      "@media print": {
5541        display
5542      }
5543    })),
5544    displayRaw: prop("display"),
5545    overflow: prop("overflow"),
5546    textOverflow: prop("textOverflow"),
5547    visibility: prop("visibility"),
5548    whiteSpace: prop("whiteSpace")
5549  };
5550}
5551function createSystemFlexboxProps() {
5552  return {
5553    flexBasis: prop("flexBasis"),
5554    flexDirection: prop("flexDirection"),
5555    flexWrap: prop("flexWrap"),
5556    justifyContent: prop("justifyContent"),
5557    alignItems: prop("alignItems"),
5558    alignContent: prop("alignContent"),
5559    order: prop("order"),
5560    flex: prop("flex"),
5561    flexGrow: prop("flexGrow"),
5562    flexShrink: prop("flexShrink"),
5563    alignSelf: prop("alignSelf"),
5564    justifyItems: prop("justifyItems"),
5565    justifySelf: prop("justifySelf")
5566  };
5567}
5568function createSystemGridProps() {
5569  const spacing = (name, value, theme) => createUnaryUnit(theme, "spacing", 8, name)(value);
5570  return {
5571    gap: prop("gap", spacing),
5572    columnGap: prop("columnGap", spacing),
5573    rowGap: prop("rowGap", spacing),
5574    gridColumn: prop("gridColumn"),
5575    gridRow: prop("gridRow"),
5576    gridAutoFlow: prop("gridAutoFlow"),
5577    gridAutoColumns: prop("gridAutoColumns"),
5578    gridAutoRows: prop("gridAutoRows"),
5579    gridTemplateColumns: prop("gridTemplateColumns"),
5580    gridTemplateRows: prop("gridTemplateRows"),
5581    gridTemplateAreas: prop("gridTemplateAreas"),
5582    gridArea: prop("gridArea")
5583  };
5584}
5585function createSystemPositionProps() {
5586  return {
5587    position: prop("position"),
5588    zIndex: prop("zIndex", (name, value, theme) => theme.zIndex?.[name] ?? value),
5589    top: pxProp("top"),
5590    right: pxProp("right"),
5591    bottom: pxProp("bottom"),
5592    left: pxProp("left")
5593  };
5594}
5595function createSystemPaletteProps() {
5596  const paletteValue = (name, value, theme) => getThemeValue_default2(theme, "palette", value);
5597  return {
5598    color: prop("color", paletteValue),
5599    bgcolor: prop("backgroundColor", paletteValue),
5600    backgroundColor: prop("backgroundColor", paletteValue)
5601  };
5602}
5603function createSystemSizingProps() {
5604  const onValue = (name, value, theme) => {
5605    if (name === "maxWidth") {
5606      value = theme.breakpoints.values[name] ?? value;
5607    }
5608    if (typeof value === "number") {
5609      value = value > 0 && value <= 1 ? `${value * 100}%` : `${value}px`;
5610    }
5611    return value;
5612  };
5613  return {
5614    width: prop("width", onValue),
5615    maxWidth: prop("maxWidth", onValue),
5616    minWidth: prop("minWidth", onValue),
5617    height: prop("height", onValue),
5618    maxHeight: prop("maxHeight", onValue),
5619    minHeight: prop("minHeight", onValue),
5620    boxSizing: prop("boxSizing", onValue)
5621  };
5622}
5623function createSystemBorderProps() {
5624  const borderValue = (name, value) => typeof value === "number" ? `${value}px solid` : value;
5625  const paletteValue = (name, value, theme) => getThemeValue_default2(theme, "palette", value);
5626  return {
5627    border: prop("border", borderValue),
5628    borderTop: prop("borderTop", borderValue),
5629    borderRight: prop("borderRight", borderValue),
5630    borderBottom: prop("borderBottom", borderValue),
5631    borderLeft: prop("borderLeft", borderValue),
5632    borderColor: prop("borderColor", paletteValue),
5633    borderTopColor: prop("borderTopColor", paletteValue),
5634    borderRightColor: prop("borderRightColor", paletteValue),
5635    borderBottomColor: prop("borderBottomColor", paletteValue),
5636    borderLeftColor: prop("borderLeftColor", paletteValue),
5637    borderRadius: prop("borderRadius", (name, value, theme) => typeof value === "number" ? `${theme.shape.borderRadius * value}px` : value)
5638  };
5639}
5640function createSystemTypographyProps() {
5641  const typographyValue = (name, value, theme) => getThemeValue_default2(theme, "typography", value);
5642  return {
5643    typography: customProp("typography", (name, value, theme) => getThemeValue_default2(theme, "typography", value)),
5644    fontFamily: prop("fontFamily", typographyValue),
5645    fontSize: prop("fontSize", (name, value, theme) => asPx(typographyValue(name, value, theme))),
5646    fontStyle: prop("fontStyle", typographyValue),
5647    fontWeight: prop("fontWeight", typographyValue),
5648    letterSpacing: pxProp("letterSpacing"),
5649    lineHeight: prop("lineHeight"),
5650    textAlign: prop("textAlign"),
5651    textTransform: prop("textTransform")
5652  };
5653}
5654function createSystemSpacingProps() {
5655  const spacing = (name, value, theme) => theme.spacing(value);
5656  const m = "margin";
5657  const p = "padding";
5658  return {
5659    m: prop(m, spacing),
5660    mt: prop("marginTop", spacing),
5661    mr: prop("marginRight", spacing),
5662    mb: prop("marginBottom", spacing),
5663    ml: prop("marginLeft", spacing),
5664    mx: mProp(m, dirMap["x"], spacing),
5665    my: mProp(m, dirMap["y"], spacing),
5666    margin: prop(m, spacing),
5667    marginTop: prop("marginTop", spacing),
5668    marginRight: prop("marginRight", spacing),
5669    marginBottom: prop("marginBottom", spacing),
5670    marginLeft: prop("marginLeft", spacing),
5671    marginX: mProp(m, dirMap["x"], spacing),
5672    marginY: mProp(m, dirMap["y"], spacing),
5673    marginInline: mProp(m, ["Inline", "InlineStart"], spacing),
5674    marginInlineStart: prop("marginInlineStart", spacing),
5675    marginInlineEnd: prop("marginInlineEnd", spacing),
5676    marginBlock: mProp(m, ["BlockStart", "BlockEnd"], spacing),
5677    marginBlockStart: prop("marginBlockStart", spacing),
5678    marginBlockEnd: prop("marginBlockEnd", spacing),
5679    p: prop(p, spacing),
5680    pt: prop("paddingTop", spacing),
5681    pr: prop("paddingRight", spacing),
5682    pb: prop("paddingBottom", spacing),
5683    pl: prop("paddingLeft", spacing),
5684    px: mProp(p, dirMap["x"], spacing),
5685    py: mProp(p, dirMap["y"], spacing),
5686    padding: prop(p, spacing),
5687    paddingTop: prop("paddingTop", spacing),
5688    paddingRight: prop("paddingRight", spacing),
5689    paddingBottom: prop("paddingBottom", spacing),
5690    paddingLeft: prop("paddingLeft", spacing),
5691    paddingX: mProp(p, dirMap["x"], spacing),
5692    paddingY: mProp(p, dirMap["y"], spacing),
5693    paddingInline: mProp(p, ["Inline", "InlineStart"], spacing),
5694    paddingInlineStart: prop("paddingInlineStart", spacing),
5695    paddingInlineEnd: prop("paddingInlineEnd", spacing),
5696    paddingBlock: mProp(p, ["BlockStart", "BlockEnd"], spacing),
5697    paddingBlockStart: prop("paddingBlockStart", spacing),
5698    paddingBlockEnd: prop("paddingBlockEnd", spacing)
5699  };
5700}
5701var createSystemProps_default = createSystemProps;
5702

vendor: 214 bytes, lines 5703-5707

5703// node_modules/@suid/icons-material/node_modules/@suid/system/systemProps.js
5704var systemProps = createSystemProps_default();
5705var systemPropNames2 = Object.keys(systemProps);
5706var systemProps_default = systemProps;
5707

vendor: 1,042 bytes, lines 5708-5734

5708// node_modules/@suid/icons-material/node_modules/@suid/system/resolveSxProps.js
5709function resolveSystemPropsValue(name, value, theme) {
5710  return systemProps_default[name](value, theme);
5711}
5712function resolveSxPropsValue(name, value, theme) {
5713  return name in systemProps_default ? resolveSystemPropsValue(name, value, theme) : resolveStyledPropsValue(name, value);
5714}
5715function resolveSxProps(object, theme) {
5716  return resolve_default(object, (name, value) => {
5717    if (typeof value === "function") {
5718      value = value(theme);
5719    }
5720    if (value === null || value === void 0) {
5721      return value;
5722    } else if (typeof value === "object") {
5723      const sortedCss = {};
5724      for (const key of theme.breakpoints.keys) {
5725        sortedCss[theme.breakpoints.up(key)] = {};
5726      }
5727      return Object.assign(sortedCss, handleBreakpoints2({ theme }, value, (v) => resolveSxPropsValue(name, v, theme) ?? { [name]: v }));
5728    } else {
5729      return resolveSxPropsValue(name, value, theme);
5730    }
5731  });
5732}
5733var resolveSxProps_default = resolveSxProps;
5734

vendor: 3,501 bytes, lines 5735-5827

5735// node_modules/@suid/icons-material/node_modules/@suid/system/createStyled.jsx
5736var skipProps2 = ["ownerState", "theme", "sx", "as"];
5737function resolveStyles(useTheme4, className2, styles3, inProps) {
5738  return createMemo(() => {
5739    const theme = useTheme4();
5740    return styles3.reduce((result, style2) => {
5741      let styledProps;
5742      if (typeof style2 === "function") {
5743        styledProps = style2({
5744          ownerState: inProps.ownerState,
5745          theme,
5746          sx: inProps.sx,
5747          as: inProps.as,
5748          props: inProps
5749        });
5750      } else if (style2) {
5751        styledProps = style2;
5752      }
5753      if (styledProps) result.push({
5754        ["name"]: className2,
5755        ...resolveStyledProps_default(styledProps)
5756      });
5757      return result;
5758    }, []);
5759  });
5760}
5761function isStyledComponent(input) {
5762  return typeof input === "function" && "__styled" in input && !!input.__styled;
5763}
5764function createStyled(config) {
5765  return function styled2(Component, options = {}) {
5766    let className2;
5767    if (options.name) {
5768      const slot = options.slot || "Root";
5769      className2 = `${options.name}-${slot.slice(0, 1).toLowerCase() + slot.slice(1)}`;
5770    } else {
5771      className2 = `styled-${randomString3()}`;
5772    }
5773    return function(...styles3) {
5774      function StyledComponent(inProps) {
5775        const $useTheme = () => inProps.theme ?? (config?.onUseTheme ? config.onUseTheme() : useTheme_default2());
5776        const [, otherProps] = splitProps(inProps, options.skipProps ?? skipProps2);
5777        const inStyles = resolveStyles(
5778          $useTheme,
5779          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
5780          options.name ? className2 : "css",
5781          styles3,
5782          inProps
5783        );
5784        const inSx = createMemo(() => !options.skipSx && inProps.sx ? Array.isArray(inProps.sx) ? inProps.sx : [inProps.sx] : []);
5785        const sx = () => {
5786          const theme = $useTheme();
5787          return [...inStyles().map((v) => ({
5788            ...v,
5789            __resolved: true
5790          })), ...inSx().map((sx2) => sx2.__resolved ? sx2 : resolveSxProps_default(sx2, theme))];
5791        };
5792        const styledComponent = createMemo(() => isStyledComponent(Component));
5793        const $component = () => inProps.as && !styledComponent() ? inProps.as : Component;
5794        const styled$Component = createMemo(() => isStyledComponent($component()));
5795        const as = () => inProps.as && styledComponent() ? inProps.as : void 0;
5796        const styledProps = () => styled$Component() && {
5797          ownerState: inProps.ownerState,
5798          get sx() {
5799            return sx();
5800          }
5801        };
5802        const styleClassName = createStyle_default2(() => styled$Component() ? void 0 : sx());
5803        const component = () => styled$Component() ? otherProps.component : null;
5804        return createComponent(Dynamic_default2, mergeProps(otherProps, {
5805          get $component() {
5806            return $component();
5807          },
5808          get component() {
5809            return component();
5810          },
5811          get as() {
5812            return as();
5813          }
5814        }, styledProps, {
5815          get ["class"]() {
5816            return clsx_m_default([.../* @__PURE__ */ new Set([inProps.class, className2, styleClassName()])]);
5817          }
5818        }));
5819      }
5820      StyledComponent["__styled"] = true;
5821      if (className2) StyledComponent.toString = () => `.${className2}`;
5822      return StyledComponent;
5823    };
5824  };
5825}
5826var createStyled_default2 = createStyled;
5827

vendor: 223 bytes, lines 5828-5833

5828// node_modules/@suid/icons-material/node_modules/@suid/material/styles/styled.jsx
5829var skipRootProps2 = [...skipProps2, "classes"];
5830var styled_default3 = createStyled_default2({
5831  onUseTheme: () => useTheme_default3()
5832});
5833

vendor: 176 bytes, lines 5834-5837

5834// node_modules/@suid/icons-material/node_modules/@suid/material/SvgIcon/SvgIconContext.jsx
5835var SvgIconContext = createContext();
5836var SvgIconContext_default = SvgIconContext;
5837

vendor: 995 bytes, lines 5838-5871

5838// node_modules/@suid/icons-material/node_modules/@suid/base/generateUtilityClass.js
5839var defaultGenerator = (componentName) => componentName;
5840var createClassNameGenerator = () => {
5841  let generate = defaultGenerator;
5842  return {
5843    configure(generator) {
5844      generate = generator;
5845    },
5846    generate(componentName) {
5847      return generate(componentName);
5848    },
5849    reset() {
5850      generate = defaultGenerator;
5851    }
5852  };
5853};
5854var ClassNameGenerator = createClassNameGenerator();
5855var globalStateClassesMapping = {
5856  active: "Mui-active",
5857  checked: "Mui-checked",
5858  completed: "Mui-completed",
5859  disabled: "Mui-disabled",
5860  error: "Mui-error",
5861  expanded: "Mui-expanded",
5862  focused: "Mui-focused",
5863  focusVisible: "Mui-focusVisible",
5864  required: "Mui-required",
5865  selected: "Mui-selected"
5866};
5867function generateUtilityClass2(componentName, slot) {
5868  const globalStateClass = globalStateClassesMapping[slot];
5869  return globalStateClass || `${ClassNameGenerator.generate(componentName)}-${slot}`;
5870}
5871

vendor: 282 bytes, lines 5872-5880

5872// node_modules/@suid/icons-material/node_modules/@suid/base/generateUtilityClasses.js
5873function generateUtilityClasses2(componentName, slots) {
5874  const result = {};
5875  slots.forEach((slot) => {
5876    result[slot] = generateUtilityClass2(componentName, slot);
5877  });
5878  return result;
5879}
5880

vendor: 681 bytes, lines 5881-5901

5881// node_modules/@suid/icons-material/node_modules/@suid/base/composeClasses.js
5882function composeClasses2(slots, getUtilityClass, classes) {
5883  const output = {};
5884  Object.keys(slots).forEach(
5885    // `Objet.keys(slots)` can't be wider than `T` because we infer `T` from `slots`.
5886    // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208
5887    (slot) => {
5888      output[slot] = slots[slot].reduce((acc, key) => {
5889        if (key) {
5890          if (classes && classes[key]) {
5891            acc.push(classes[key]);
5892          }
5893          acc.push(getUtilityClass(key));
5894        }
5895        return acc;
5896      }, []).join(" ");
5897    }
5898  );
5899  return output;
5900}
5901

vendor: 429 bytes, lines 5902-5918

5902// node_modules/@suid/icons-material/node_modules/@suid/material/SvgIcon/svgIconClasses.js
5903function getSvgIconUtilityClass(slot) {
5904  return generateUtilityClass2("MuiSvgIcon", slot);
5905}
5906var svgIconClasses = generateUtilityClasses2("MuiSvgIcon", [
5907  "root",
5908  "colorPrimary",
5909  "colorSecondary",
5910  "colorAction",
5911  "colorError",
5912  "colorDisabled",
5913  "fontSizeInherit",
5914  "fontSizeSmall",
5915  "fontSizeMedium",
5916  "fontSizeLarge"
5917]);
5918

vendor: 461 bytes, lines 5919-5938

5919// node_modules/@suid/icons-material/node_modules/@suid/system/inspect.js
5920var $INSPECT = Symbol("solid-inspect");
5921var inspectionEnabled = false;
5922function componentTrap(fn) {
5923  function Component(props) {
5924    if (inspectionEnabled)
5925      return {
5926        Component,
5927        props,
5928        $INSPECT
5929      };
5930    return fn(props);
5931  }
5932  Object.defineProperty(Component, "name", {
5933    value: fn.name
5934  });
5935  Component.toString = fn.toString;
5936  return Component;
5937}
5938

vendor: 2,348 bytes, lines 5939-6011

5939// node_modules/@suid/icons-material/node_modules/@suid/base/createComponentFactory.js
5940function createComponentFactory() {
5941  return function(options) {
5942    function useClasses(ownerState) {
5943      const haveSlotClasses = !!options.slotClasses;
5944      const compose = () => {
5945        if (!options.slotClasses)
5946          throw new Error(`'slotClasses' option is not defined`);
5947        if (!options.utilityClass)
5948          throw new Error(`'utilityClass' option is not defined`);
5949        return composeClasses2(options.slotClasses(ownerState), options.utilityClass, ownerState["classes"] ?? "");
5950      };
5951      const classes = createMutable({});
5952      if (haveSlotClasses)
5953        createComputed(() => {
5954          const result = compose();
5955          batch(() => {
5956            for (const slot in result)
5957              classes[slot] = result[slot];
5958          });
5959        });
5960      return classes;
5961    }
5962    function splitInProps(allProps) {
5963      const [props, otherProps] = splitProps(allProps, options.selfPropNames);
5964      return { allProps, props, otherProps };
5965    }
5966    function useThemeProps3(input) {
5967      return useThemeProps({
5968        propDefaults: options.propDefaults,
5969        ...input,
5970        name: options.name
5971      });
5972    }
5973    function useProps(props) {
5974      const themeProps = useThemeProps3({ props });
5975      return splitInProps(themeProps);
5976    }
5977    function defineComponent2(cb, styled2 = true) {
5978      cb = componentTrap(cb);
5979      cb.toString = () => `.${options.name}-root`;
5980      if (styled2)
5981        cb.__styled = true;
5982      return cb;
5983    }
5984    function component(cb) {
5985      const Component = defineComponent2(function Component2(inProps) {
5986        const { allProps, otherProps, props } = useProps(inProps);
5987        const classes = options.autoCallUseClasses ?? true ? useClasses(allProps) : {};
5988        return cb({
5989          allProps,
5990          otherProps,
5991          props,
5992          classes
5993        });
5994      });
5995      Object.defineProperty(Component, "name", { value: cb.name });
5996      return Component;
5997    }
5998    return {
5999      name: options.name,
6000      selfPropNames: options.selfPropNames,
6001      component,
6002      defineComponent: defineComponent2,
6003      useClasses,
6004      useThemeProps: useThemeProps3,
6005      useProps,
6006      splitInProps
6007    };
6008  };
6009}
6010var createComponentFactory_default2 = createComponentFactory;
6011

vendor: 2,888 bytes, lines 6012-6113

6012// node_modules/@suid/icons-material/node_modules/@suid/material/SvgIcon/SvgIcon.jsx
6013var _tmpl$3 = /* @__PURE__ */ template(`<title>`);
6014var $22 = createComponentFactory_default2()({
6015  name: "MuiSvgIcon",
6016  selfPropNames: ["children", "classes", "color", "fontSize", "htmlColor", "inheritViewBox", "shapeRendering", "titleAccess", "viewBox"],
6017  propDefaults: ({
6018    set
6019  }) => {
6020    const context = useContext(SvgIconContext_default);
6021    return set({
6022      component: "svg",
6023      color: "inherit",
6024      get fontSize() {
6025        return context?.fontSize ?? "medium";
6026      },
6027      inheritViewBox: false,
6028      viewBox: "0 0 24 24"
6029    });
6030  },
6031  utilityClass: getSvgIconUtilityClass,
6032  slotClasses: (o) => ({
6033    root: ["root", o.color !== "inherit" && `color${capitalize3(o.color)}`, `fontSize${capitalize3(o.fontSize)}`]
6034  })
6035});
6036var SvgIconRoot = styled_default3("svg", {
6037  name: "MuiSvgIcon",
6038  slot: "Root",
6039  overridesResolver: (props, styles3) => {
6040    const {
6041      ownerState
6042    } = props;
6043    return [styles3.root, ownerState.color !== "inherit" && styles3[`color${capitalize3(ownerState.color)}`], styles3[`fontSize${capitalize3(ownerState.fontSize)}`]];
6044  }
6045})(({
6046  theme,
6047  ownerState
6048}) => ({
6049  userSelect: "none",
6050  width: "1em",
6051  height: "1em",
6052  display: "inline-block",
6053  fill: "currentColor",
6054  flexShrink: 0,
6055  transition: theme.transitions?.create?.("fill", {
6056    duration: theme.transitions?.duration?.shorter
6057  }),
6058  fontSize: {
6059    inherit: "inherit",
6060    small: theme.typography?.pxToRem?.(20) || "1.25rem",
6061    medium: theme.typography?.pxToRem?.(24) || "1.5rem",
6062    large: theme.typography?.pxToRem?.(35) || "2.1875"
6063  }[ownerState.fontSize],
6064  // TODO v5 deprecate, v6 remove for sx
6065  color: theme.palette?.[ownerState.color]?.main ?? {
6066    action: theme.palette?.action?.active,
6067    disabled: theme.palette?.action?.disabled,
6068    inherit: void 0
6069  }[ownerState.color]
6070}));
6071var SvgIcon = $22.component(function SvgIcon2({
6072  allProps,
6073  props,
6074  otherProps,
6075  classes
6076}) {
6077  return createComponent(SvgIconRoot, mergeProps({
6078    get ["aria-hidden"]() {
6079      return props.titleAccess ? void 0 : true;
6080    },
6081    get role() {
6082      return props.titleAccess ? "img" : void 0;
6083    },
6084    get viewBox() {
6085      return !props.inheritViewBox ? props.viewBox : void 0;
6086    }
6087  }, {
6088    ["focusable"]: "false"
6089  }, {
6090    get color() {
6091      return props.htmlColor;
6092    }
6093  }, otherProps, {
6094    get ["class"]() {
6095      return clsx_m_default(classes.root, otherProps.class);
6096    },
6097    ownerState: allProps,
6098    get children() {
6099      return [memo(() => props.children), createComponent(Show, {
6100        get when() {
6101          return !!props.titleAccess;
6102        },
6103        get children() {
6104          const _el$ = _tmpl$3();
6105          insert(_el$, () => props.titleAccess);
6106          return _el$;
6107        }
6108      })];
6109    }
6110  }));
6111});
6112var SvgIcon_default = SvgIcon;
6113

vendor: 313 bytes, lines 6114-6123

6114// node_modules/@suid/icons-material/node_modules/@suid/material/utils/createSvgIcon.jsx
6115function createSvgIcon(path, displayName) {
6116  const Component = (props) => createComponent(SvgIcon_default, mergeProps({
6117    "data-testid": `${displayName}Icon`
6118  }, props, {
6119    children: path
6120  }));
6121  return Component;
6122}
6123

vendor: 425 bytes, lines 6124-6127

6124// node_modules/@suid/icons-material/FolderOpenRounded.jsx
6125var _tmpl$4 = /* @__PURE__ */ template(`<svg><path d="M20 6h-8l-1.41-1.41C10.21 4.21 9.7 4 9.17 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm-1 12H5c-.55 0-1-.45-1-1V9c0-.55.45-1 1-1h14c.55 0 1 .45 1 1v8c0 .55-.45 1-1 1z"></svg>`, false, true);
6126var FolderOpenRounded_default = createSvgIcon(() => _tmpl$4(), "FolderOpenRounded");
6127

vendor: 208 bytes, lines 6128-6136

6128// node_modules/@suid/material/List/ListContext.js
6129var ListContext = createContext({
6130  dense: false
6131});
6132function useListContext() {
6133  return useContext(ListContext);
6134}
6135var ListContext_default = ListContext;
6136

vendor: 245 bytes, lines 6137-6147

6137// node_modules/@suid/material/List/listClasses.js
6138function getListUtilityClass(slot) {
6139  return generateUtilityClass("MuiList", slot);
6140}
6141var listClasses = generateUtilityClasses("MuiList", [
6142  "root",
6143  "padding",
6144  "dense",
6145  "subheader"
6146]);
6147

vendor: 1,673 bytes, lines 6148-6214

6148// node_modules/@suid/material/List/List.jsx
6149var $23 = createComponentFactory_default()({
6150  name: "MuiList",
6151  selfPropNames: ["children", "classes", "dense", "disablePadding", "subheader"],
6152  propDefaults: ({
6153    set
6154  }) => set({
6155    component: "ul",
6156    dense: false,
6157    disablePadding: false
6158  }),
6159  utilityClass: getListUtilityClass,
6160  slotClasses: (ownerState) => ({
6161    root: ["root", !ownerState.disablePadding && "padding", ownerState.dense && "dense", !!ownerState.subheader && "subheader"]
6162  })
6163});
6164var ListRoot = styled_default("ul", {
6165  name: "MuiList",
6166  slot: "Root",
6167  overridesResolver: (props, styles3) => {
6168    const {
6169      ownerState
6170    } = props;
6171    return [styles3.root, !ownerState.disablePadding && styles3.padding, ownerState.dense && styles3.dense, ownerState.subheader && styles3.subheader];
6172  }
6173})(({
6174  ownerState
6175}) => ({
6176  listStyle: "none",
6177  margin: 0,
6178  padding: 0,
6179  position: "relative",
6180  ...!ownerState.disablePadding && {
6181    paddingTop: 8,
6182    paddingBottom: 8
6183  },
6184  ...ownerState.subheader && {
6185    paddingTop: 0
6186  }
6187}));
6188var List = $23.component(function List2({
6189  allProps,
6190  classes,
6191  otherProps,
6192  props
6193}) {
6194  return createComponent(ListContext_default.Provider, {
6195    value: {
6196      get dense() {
6197        return props.dense;
6198      }
6199    },
6200    get children() {
6201      return createComponent(ListRoot, mergeProps(otherProps, {
6202        get ["class"]() {
6203          return clsx_m_default(classes.root, otherProps.class);
6204        },
6205        ownerState: allProps,
6206        get children() {
6207          return [memo(() => props.subheader), memo(() => props.children)];
6208        }
6209      }));
6210    }
6211  });
6212});
6213var List_default = List;
6214

vendor: 5,867 bytes, lines 6215-6386

6215// node_modules/@suid/material/MenuList/MenuList.jsx
6216var $24 = createComponentFactory_default()({
6217  name: "MuiMenuList",
6218  selfPropNames: ["autoFocus", "autoFocusItem", "children", "disabledItemsFocusable", "disableListWrap", "variant"]
6219});
6220function nextItem(list, item, disableListWrap) {
6221  if (list === item) {
6222    return list.firstChild;
6223  }
6224  if (item && item.nextElementSibling) {
6225    return item.nextElementSibling;
6226  }
6227  return disableListWrap ? void 0 : list.firstChild;
6228}
6229function previousItem(list, item, disableListWrap) {
6230  if (list === item) {
6231    return disableListWrap ? list.firstChild : list.lastChild;
6232  }
6233  if (item && item.previousElementSibling) {
6234    return item.previousElementSibling;
6235  }
6236  return disableListWrap ? void 0 : list.lastChild;
6237}
6238function textCriteriaMatches(nextFocus, textCriteria) {
6239  if (textCriteria === void 0) {
6240    return true;
6241  }
6242  let text = nextFocus.innerText;
6243  if (text === void 0) {
6244    text = nextFocus.textContent ?? "";
6245  }
6246  text = text.trim().toLowerCase();
6247  if (text.length === 0) {
6248    return false;
6249  }
6250  if (textCriteria.repeating) {
6251    return text[0] === textCriteria.keys[0];
6252  }
6253  return text.indexOf(textCriteria.keys.join("")) === 0;
6254}
6255function moveFocus(list, currentFocus, disableListWrap, disabledItemsFocusable, traversalFunction, textCriteria) {
6256  let wrappedOnce = false;
6257  let nextFocus = traversalFunction(list, currentFocus, currentFocus ? disableListWrap : false);
6258  while (nextFocus) {
6259    if (nextFocus === list.firstChild) {
6260      if (wrappedOnce) {
6261        return false;
6262      }
6263      wrappedOnce = true;
6264    }
6265    const nextFocusDisabled = disabledItemsFocusable ? false : nextFocus["disabled"] || nextFocus.getAttribute("aria-disabled") === "true";
6266    if (!nextFocus.hasAttribute("tabindex") || !textCriteriaMatches(nextFocus, textCriteria) || nextFocusDisabled) {
6267      nextFocus = traversalFunction(list, nextFocus, disableListWrap);
6268    } else {
6269      nextFocus.focus();
6270      return true;
6271    }
6272  }
6273  return false;
6274}
6275var MenuList = $24.defineComponent(function MenuList2(props) {
6276  const listRef = createRef_default(props);
6277  const [, other] = splitProps(props, ["autoFocus", "autoFocusItem", "children", "class", "disabledItemsFocusable", "disableListWrap", "onKeyDown", "variant"]);
6278  const baseProps = mergeProps({
6279    autoFocus: false,
6280    autoFocusItem: false,
6281    disabledItemsFocusable: false,
6282    disableListWrap: false,
6283    variant: "selectedMenu"
6284  }, props);
6285  const criteria = {
6286    keys: [],
6287    repeating: true,
6288    previousKeyMatched: true,
6289    lastTime: 0
6290  };
6291  createEffect(() => {
6292    if (baseProps.autoFocus) {
6293      listRef.current.focus();
6294    }
6295  }, [baseProps.autoFocus]);
6296  const handleKeyDown2 = (event) => {
6297    const list = listRef.current;
6298    const key = event.key;
6299    const currentFocus = ownerDocument2(list).activeElement;
6300    if (key === "ArrowDown") {
6301      event.preventDefault();
6302      moveFocus(list, currentFocus, baseProps.disableListWrap, baseProps.disabledItemsFocusable, nextItem);
6303    } else if (key === "ArrowUp") {
6304      event.preventDefault();
6305      moveFocus(list, currentFocus, baseProps.disableListWrap, baseProps.disabledItemsFocusable, previousItem);
6306    } else if (key === "Home") {
6307      event.preventDefault();
6308      moveFocus(list, void 0, baseProps.disableListWrap, baseProps.disabledItemsFocusable, nextItem);
6309    } else if (key === "End") {
6310      event.preventDefault();
6311      moveFocus(list, void 0, baseProps.disableListWrap, baseProps.disabledItemsFocusable, previousItem);
6312    } else if (key.length === 1) {
6313      const lowerKey = key.toLowerCase();
6314      const currTime = performance.now();
6315      if (criteria.keys.length > 0) {
6316        if (currTime - criteria.lastTime > 500) {
6317          criteria.keys = [];
6318          criteria.repeating = true;
6319          criteria.previousKeyMatched = true;
6320        } else if (criteria.repeating && lowerKey !== criteria.keys[0]) {
6321          criteria.repeating = false;
6322        }
6323      }
6324      criteria.lastTime = currTime;
6325      criteria.keys.push(lowerKey);
6326      const keepFocusOnCurrent = currentFocus && !criteria.repeating && textCriteriaMatches(currentFocus, criteria);
6327      if (criteria.previousKeyMatched && (keepFocusOnCurrent || moveFocus(list, currentFocus, false, baseProps.disabledItemsFocusable, nextItem, criteria))) {
6328        event.preventDefault();
6329      } else {
6330        criteria.previousKeyMatched = false;
6331      }
6332    }
6333    if (typeof props.onKeyDown === "function") {
6334      props.onKeyDown(event);
6335    }
6336  };
6337  const children2 = inspectChildren(() => props.children);
6338  const activeItemIndex = createMemo(() => {
6339    let result = -1;
6340    let index = 0;
6341    for (const child of children2()) {
6342      if (isComponentObject(child)) {
6343        if (!child.props.disabled) {
6344          if (baseProps.variant === "selectedMenu" && child.props.selected) {
6345            result = index;
6346          } else if (result === -1) {
6347            result = index;
6348          }
6349        }
6350      }
6351      index++;
6352    }
6353    return result;
6354  });
6355  const items = mapArray(children2, (child, index) => {
6356    if (isComponentObject(child)) {
6357      return createComponent(child.Component, mergeProps(child.props, {
6358        get autoFocus() {
6359          if (index() === activeItemIndex() && baseProps.autoFocusItem) return true;
6360        },
6361        get tabIndex() {
6362          if (child.props.tabIndex === void 0 && index() === activeItemIndex() && baseProps.variant) return 0;
6363        }
6364      }));
6365    } else {
6366      return child;
6367    }
6368  });
6369  return createComponent(List_default, mergeProps({
6370    role: "menu",
6371    ref: listRef,
6372    get ["class"]() {
6373      return props.class;
6374    },
6375    onKeyDown: handleKeyDown2,
6376    get tabIndex() {
6377      return baseProps.autoFocus ? 0 : -1;
6378    }
6379  }, other, {
6380    get children() {
6381      return items();
6382    }
6383  }));
6384});
6385var MenuList_default = MenuList;
6386

vendor: 3,851 bytes, lines 6387-6529

6387// node_modules/@suid/material/Grow/Grow.jsx
6388var $25 = createComponentFactory_default()({
6389  name: "MuiGrow",
6390  propDefaults: ({
6391    set
6392  }) => set({
6393    appear: true,
6394    timeout: "auto"
6395  }),
6396  selfPropNames: ["appear", "children", "easing", "in", "ref", "timeout"]
6397});
6398function getScale(value) {
6399  return `scale(${value}, ${value ** 2})`;
6400}
6401var styles = {
6402  entering: {
6403    opacity: 1,
6404    transform: getScale(1)
6405  },
6406  entered: {
6407    opacity: 1,
6408    transform: "none"
6409  }
6410};
6411var Grow = $25.component(function Grow2({
6412  props,
6413  otherProps
6414}) {
6415  const autoTimeout = {
6416    current: void 0
6417  };
6418  const theme = useTheme_default();
6419  const resolved = children(() => props.children);
6420  let timer;
6421  onCleanup(() => timer && clearTimeout(timer));
6422  return createComponent(Transition_default, mergeProps(otherProps, {
6423    get appear() {
6424      return props.appear;
6425    },
6426    get ["in"]() {
6427      return props.in;
6428    },
6429    onEnter: () => {
6430      const node = resolved();
6431      reflow(node);
6432      const {
6433        duration: transitionDuration,
6434        delay,
6435        easing: transitionTimingFunction
6436      } = getTransitionProps({
6437        style: otherProps.style,
6438        timeout: props.timeout,
6439        easing: props.easing
6440      }, {
6441        mode: "enter"
6442      });
6443      let duration2;
6444      if (props.timeout === "auto") {
6445        duration2 = theme.transitions.getAutoHeightDuration(node.clientHeight);
6446        autoTimeout.current = duration2;
6447      } else {
6448        duration2 = transitionDuration;
6449      }
6450      node.style.transition = [theme.transitions.create("opacity", {
6451        duration: duration2,
6452        delay
6453      }), theme.transitions.create("transform", {
6454        duration: Number(duration2) * 0.666,
6455        delay,
6456        easing: transitionTimingFunction
6457      })].join(",");
6458      otherProps.onEnter?.();
6459    },
6460    onExit: () => {
6461      const node = resolved();
6462      const {
6463        duration: transitionDuration,
6464        delay,
6465        easing: transitionTimingFunction
6466      } = getTransitionProps({
6467        style: otherProps.style,
6468        timeout: props.timeout,
6469        easing: props.easing
6470      }, {
6471        mode: "exit"
6472      });
6473      let duration2;
6474      if (props.timeout === "auto") {
6475        duration2 = theme.transitions.getAutoHeightDuration(node.clientHeight);
6476        autoTimeout.current = duration2;
6477      } else {
6478        duration2 = transitionDuration;
6479      }
6480      node.style.transition = [theme.transitions.create("opacity", {
6481        duration: duration2,
6482        delay
6483      }), theme.transitions.create("transform", {
6484        duration: Number(duration2) * 0.666,
6485        delay: delay || Number(duration2) * 0.333,
6486        easing: transitionTimingFunction
6487      })].join(",");
6488      node.style.opacity = "0";
6489      node.style.transform = getScale(0.75);
6490      otherProps.onExit?.();
6491    },
6492    addEndListener: (next) => {
6493      if (props.timeout === "auto") {
6494        timer = setTimeout(next, autoTimeout.current || 0);
6495      }
6496      if (otherProps.addEndListener) {
6497        otherProps.addEndListener(next);
6498      }
6499    },
6500    get timeout() {
6501      return props.timeout === "auto" ? void 0 : props.timeout;
6502    },
6503    children: (state) => {
6504      const element = resolved();
6505      element.style.opacity = "0";
6506      element.style.transform = getScale(0.75);
6507      if (state === "exited" && !props.in) {
6508        element.style.visibility = "hidden";
6509      } else {
6510        element.style.removeProperty("visibility");
6511      }
6512      const style2 = {
6513        ...styles[state] || {},
6514        ...otherProps.style || {}
6515      };
6516      for (const name in style2) {
6517        const value = style2[name];
6518        if (value === void 0) {
6519          element.style.removeProperty(name);
6520        } else {
6521          element.style[name] = value;
6522        }
6523      }
6524      return element;
6525    }
6526  }));
6527});
6528var Grow_default = Grow;
6529

vendor: 235 bytes, lines 6530-6538

6530// node_modules/@suid/material/Popover/popoverClasses.js
6531function getPopoverUtilityClass(slot) {
6532  return generateUtilityClass("MuiPopover", slot);
6533}
6534var popoverClasses = generateUtilityClasses("MuiPopover", [
6535  "root",
6536  "paper"
6537]);
6538

vendor: 10,007 bytes, lines 6539-6829

6539// node_modules/@suid/material/Popover/Popover.jsx
6540var $26 = createComponentFactory_default()({
6541  name: "MuiPopover",
6542  selfPropNames: ["action", "anchorEl", "anchorOrigin", "anchorPosition", "anchorReference", "children", "classes", "container", "elevation", "marginThreshold", "onClose", "open", "PaperProps", "transformOrigin", "TransitionComponent", "transitionDuration", "TransitionProps"],
6543  utilityClass: getPopoverUtilityClass,
6544  slotClasses: () => ({
6545    root: ["root"],
6546    paper: ["paper"]
6547  })
6548});
6549function getOffsetTop(rect, vertical) {
6550  let offset = 0;
6551  if (typeof vertical === "number") {
6552    offset = vertical;
6553  } else if (vertical === "center") {
6554    offset = rect.height / 2;
6555  } else if (vertical === "bottom") {
6556    offset = rect.height;
6557  }
6558  return offset;
6559}
6560function getOffsetLeft(rect, horizontal) {
6561  let offset = 0;
6562  if (typeof horizontal === "number") {
6563    offset = horizontal;
6564  } else if (horizontal === "center") {
6565    offset = rect.width / 2;
6566  } else if (horizontal === "right") {
6567    offset = rect.width;
6568  }
6569  return offset;
6570}
6571function getTransformOriginValue(transformOrigin) {
6572  return [transformOrigin.horizontal, transformOrigin.vertical].map((n) => typeof n === "number" ? `${n}px` : n).join(" ");
6573}
6574function resolveAnchorEl(anchorEl) {
6575  return typeof anchorEl === "function" ? anchorEl() : anchorEl;
6576}
6577var PopoverRoot = styled_default(Modal_default, {
6578  name: "MuiPopover",
6579  slot: "Root",
6580  overridesResolver: (props, styles3) => styles3.root
6581})({});
6582var PopoverPaper = styled_default(Paper_default, {
6583  name: "MuiPopover",
6584  slot: "Paper",
6585  overridesResolver: (props, styles3) => styles3.paper
6586})({
6587  position: "absolute",
6588  overflowY: "auto",
6589  overflowX: "hidden",
6590  // So we see the popover when it's empty.
6591  // It's most likely on issue on userland.
6592  minWidth: 16,
6593  minHeight: 16,
6594  maxWidth: "calc(100% - 32px)",
6595  maxHeight: "calc(100% - 32px)",
6596  // We disable the focus ring for mouse, touch and keyboard users.
6597  outline: 0
6598});
6599var Popover = $26.defineComponent(function Popover2(inProps) {
6600  const props = $26.useThemeProps({
6601    props: inProps
6602  });
6603  const [, other] = splitProps(props, ["action", "anchorEl", "anchorOrigin", "anchorPosition", "anchorReference", "children", "class", "container", "elevation", "marginThreshold", "open", "PaperProps", "transformOrigin", "TransitionComponent", "transitionDuration", "TransitionProps"]);
6604  const baseProps = mergeProps({
6605    anchorOrigin: {
6606      vertical: "top",
6607      horizontal: "left"
6608    },
6609    anchorReference: "anchorEl",
6610    elevation: 8,
6611    marginThreshold: 16,
6612    PaperProps: {},
6613    transformOrigin: {
6614      vertical: "top",
6615      horizontal: "left"
6616    },
6617    TransitionComponent: Grow_default,
6618    transitionDuration: "auto"
6619  }, props);
6620  const [, TransitionProps] = splitProps(mergeProps(() => props.TransitionProps || {}), ["onEntering"]);
6621  const paperRef = createRef_default(() => baseProps.PaperProps.ref);
6622  const ownerState = mergeProps(props, {
6623    get anchorOrigin() {
6624      return baseProps.anchorOrigin;
6625    },
6626    get anchorReference() {
6627      return baseProps.anchorReference;
6628    },
6629    get elevation() {
6630      return baseProps.elevation;
6631    },
6632    get marginThreshold() {
6633      return baseProps.marginThreshold;
6634    },
6635    get PaperProps() {
6636      return baseProps.PaperProps;
6637    },
6638    get transformOrigin() {
6639      return baseProps.transformOrigin;
6640    },
6641    get TransitionComponent() {
6642      return baseProps.TransitionComponent;
6643    },
6644    get transitionDuration() {
6645      return baseProps.transitionDuration;
6646    },
6647    TransitionProps
6648  });
6649  const classes = $26.useClasses(ownerState);
6650  const getAnchorOffset = () => {
6651    if (baseProps.anchorReference === "anchorPosition") {
6652      if (true) {
6653        if (!props.anchorPosition) {
6654          console.error('MUI: You need to provide a `anchorPosition` prop when using <Popover anchorReference="anchorPosition" />.');
6655        }
6656      }
6657      return props.anchorPosition;
6658    }
6659    const resolvedAnchorEl = resolveAnchorEl(props.anchorEl);
6660    const anchorElement = resolvedAnchorEl && resolvedAnchorEl.nodeType === 1 ? resolvedAnchorEl : ownerDocument2(paperRef.current).body;
6661    const anchorRect = anchorElement.getBoundingClientRect();
6662    if (true) {
6663      const box = anchorElement.getBoundingClientRect();
6664      if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
6665        console.warn(["MUI: The `anchorEl` 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("\n"));
6666      }
6667    }
6668    return {
6669      top: anchorRect.top + getOffsetTop(anchorRect, baseProps.anchorOrigin.vertical),
6670      left: anchorRect.left + getOffsetLeft(anchorRect, baseProps.anchorOrigin.horizontal)
6671    };
6672  };
6673  const getTransformOrigin = (elemRect) => {
6674    return {
6675      vertical: getOffsetTop(elemRect, baseProps.transformOrigin.vertical),
6676      horizontal: getOffsetLeft(elemRect, baseProps.transformOrigin.horizontal)
6677    };
6678  };
6679  const getPositioningStyle = (element) => {
6680    const elemRect = {
6681      width: element.offsetWidth,
6682      height: element.offsetHeight
6683    };
6684    const elemTransformOrigin = getTransformOrigin(elemRect);
6685    if (baseProps.anchorReference === "none") {
6686      return {
6687        top: null,
6688        left: null,
6689        transformOrigin: getTransformOriginValue(elemTransformOrigin)
6690      };
6691    }
6692    const anchorOffset = getAnchorOffset();
6693    let top = anchorOffset.top - elemTransformOrigin.vertical;
6694    let left = anchorOffset.left - elemTransformOrigin.horizontal;
6695    const bottom = top + elemRect.height;
6696    const right = left + elemRect.width;
6697    const containerWindow = ownerWindow2(resolveAnchorEl(props.anchorEl));
6698    const heightThreshold = containerWindow.innerHeight - baseProps.marginThreshold;
6699    const widthThreshold = containerWindow.innerWidth - baseProps.marginThreshold;
6700    if (top < baseProps.marginThreshold) {
6701      const diff = top - baseProps.marginThreshold;
6702      top -= diff;
6703      elemTransformOrigin.vertical += diff;
6704    } else if (bottom > heightThreshold) {
6705      const diff = bottom - heightThreshold;
6706      top -= diff;
6707      elemTransformOrigin.vertical += diff;
6708    }
6709    if (true) {
6710      if (elemRect.height > heightThreshold && elemRect.height && heightThreshold) {
6711        console.error(["MUI: The popover component is too tall.", `Some part of it can not be seen on the screen (${elemRect.height - heightThreshold}px).`, "Please consider adding a `max-height` to improve the user-experience."].join("\n"));
6712      }
6713    }
6714    if (left < baseProps.marginThreshold) {
6715      const diff = left - baseProps.marginThreshold;
6716      left -= diff;
6717      elemTransformOrigin.horizontal += diff;
6718    } else if (right > widthThreshold) {
6719      const diff = right - widthThreshold;
6720      left -= diff;
6721      elemTransformOrigin.horizontal += diff;
6722    }
6723    return {
6724      top: `${Math.round(top)}px`,
6725      left: `${Math.round(left)}px`,
6726      transformOrigin: getTransformOriginValue(elemTransformOrigin)
6727    };
6728  };
6729  const setPositioningStyles = () => {
6730    const element = paperRef.current;
6731    if (!element) {
6732      return;
6733    }
6734    const positioning = getPositioningStyle(element);
6735    if (positioning.top !== null) {
6736      element.style.top = positioning.top;
6737    }
6738    if (positioning.left !== null) {
6739      element.style.left = positioning.left;
6740    }
6741    element.style.transformOrigin = positioning.transformOrigin;
6742  };
6743  const handleEntering = () => {
6744    if (props.TransitionProps?.onEntering) {
6745      props.TransitionProps?.onEntering();
6746    }
6747    setPositioningStyles();
6748  };
6749  createEffect(() => {
6750    if (props.open) {
6751      setPositioningStyles();
6752    }
6753  });
6754  if (typeof props.action === "function") {
6755    props.action({
6756      updatePosition: () => {
6757        if (props.open) setPositioningStyles();
6758      }
6759    });
6760  }
6761  createEffect(on(() => [props.anchorEl, props.open, setPositioningStyles], () => {
6762    if (!props.open) {
6763      return void 0;
6764    }
6765    const handleResize = debounce2(() => {
6766      setPositioningStyles();
6767    });
6768    const containerWindow = ownerWindow2(resolveAnchorEl(props.anchorEl));
6769    containerWindow.addEventListener("resize", handleResize);
6770    return () => {
6771      handleResize.clear();
6772      containerWindow.removeEventListener("resize", handleResize);
6773    };
6774  }));
6775  const transitionDuration = () => {
6776    let transitionDuration2 = baseProps.transitionDuration;
6777    if (baseProps.transitionDuration === "auto" && !baseProps.TransitionComponent.muiSupportAuto) {
6778      transitionDuration2 = void 0;
6779    }
6780    return transitionDuration2;
6781  };
6782  const container = () => props.container || (props.anchorEl ? ownerDocument2(resolveAnchorEl(props.anchorEl)).body : void 0);
6783  return createComponent(PopoverRoot, mergeProps({
6784    BackdropProps: {
6785      invisible: true
6786    },
6787    get ["class"]() {
6788      return clsx_m_default(classes.root, props.class);
6789    },
6790    get container() {
6791      return container();
6792    },
6793    get open() {
6794      return props.open;
6795    },
6796    ownerState
6797  }, other, {
6798    get children() {
6799      return createComponent(baseProps.TransitionComponent, mergeProps({
6800        appear: true,
6801        get ["in"]() {
6802          return props.open;
6803        },
6804        onEntering: handleEntering,
6805        get timeout() {
6806          return transitionDuration();
6807        }
6808      }, TransitionProps, {
6809        get children() {
6810          return createComponent(PopoverPaper, mergeProps({
6811            get elevation() {
6812              return baseProps.elevation;
6813            }
6814          }, () => baseProps.PaperProps, {
6815            ref: paperRef,
6816            get ["class"]() {
6817              return clsx_m_default(classes.paper, baseProps.PaperProps.class);
6818            },
6819            get children() {
6820              return props.children;
6821            }
6822          }));
6823        }
6824      }));
6825    }
6826  }));
6827});
6828var Popover_default = Popover;
6829

vendor: 227 bytes, lines 6830-6839

6830// node_modules/@suid/material/Menu/menuClasses.js
6831function getMenuUtilityClass(slot) {
6832  return generateUtilityClass("MuiMenu", slot);
6833}
6834var menuClasses = generateUtilityClasses("MuiMenu", [
6835  "root",
6836  "paper",
6837  "list"
6838]);
6839

vendor: 4,926 bytes, lines 6840-7004

6840// node_modules/@suid/material/Menu/Menu.jsx
6841var $27 = createComponentFactory_default()({
6842  name: "MuiMenu",
6843  selfPropNames: ["anchorEl", "autoFocus", "children", "classes", "disableAutoFocusItem", "MenuListProps", "onClose", "open", "PopoverClasses", "transitionDuration", "TransitionProps", "variant"],
6844  utilityClass: getMenuUtilityClass,
6845  slotClasses: () => ({
6846    root: ["root"],
6847    paper: ["paper"],
6848    list: ["list"]
6849  })
6850});
6851var RTL_ORIGIN = {
6852  vertical: "top",
6853  horizontal: "right"
6854};
6855var LTR_ORIGIN = {
6856  vertical: "top",
6857  horizontal: "left"
6858};
6859var MenuRoot = styled_default(Popover_default, {
6860  skipProps: skipRootProps.filter((v) => v !== "classes"),
6861  name: "MuiMenu",
6862  slot: "Root",
6863  overridesResolver: (props, styles3) => styles3.root
6864})({});
6865var MenuPaper = styled_default(Paper_default, {
6866  name: "MuiMenu",
6867  slot: "Paper",
6868  overridesResolver: (props, styles3) => styles3.paper
6869})({
6870  // specZ: The maximum height of a simple menu should be one or more rows less than the view
6871  // height. This ensures a tapable area outside of the simple menu with which to dismiss
6872  // the menu.
6873  maxHeight: "calc(100% - 96px)",
6874  // Add iOS momentum scrolling for iOS < 13.0
6875  WebkitOverflowScrolling: "touch"
6876});
6877var MenuMenuList = styled_default(MenuList_default, {
6878  name: "MuiMenu",
6879  slot: "List",
6880  overridesResolver: (props, styles3) => styles3.list
6881})({
6882  // We disable the focus ring for mouse, touch and keyboard users.
6883  outline: 0
6884});
6885var Menu = $27.defineComponent(function Menu2(inProps) {
6886  const ref = createRef_default(inProps);
6887  const props = $27.useThemeProps({
6888    props: inProps
6889  });
6890  const [, other] = splitProps(props, ["autoFocus", "children", "disableAutoFocusItem", "MenuListProps", "onClose", "open", "PaperProps", "PopoverClasses", "transitionDuration", "TransitionProps", "variant"]);
6891  const baseProps = mergeProps({
6892    autoFocus: true,
6893    disableAutoFocusItem: false,
6894    MenuListProps: {},
6895    PaperProps: {},
6896    transitionDuration: "auto",
6897    variant: "selectedMenu"
6898  }, props);
6899  const [, TransitionProps] = splitProps(mergeProps(() => props.TransitionProps || {}), ["onEntering"]);
6900  const theme = useTheme_default();
6901  const isRtl = () => theme.direction === "rtl";
6902  const ownerState = mergeProps(baseProps, {
6903    TransitionProps
6904  });
6905  const classes = $27.useClasses(ownerState);
6906  const autoFocusItem = () => baseProps.autoFocus && !baseProps.disableAutoFocusItem && props.open;
6907  const handleEntering = () => {
6908    if (props.TransitionProps?.onEntering) {
6909      props.TransitionProps?.onEntering();
6910    }
6911  };
6912  const handleListKeyDown = (event) => {
6913    if (event.key === "Tab") {
6914      event.preventDefault();
6915      if (props.onClose) {
6916        props.onClose(event, "tabKeyDown");
6917      }
6918    }
6919  };
6920  const children2 = inspectChildren(() => props.children);
6921  const activeItemIndex = () => {
6922    let result = -1;
6923    let index = 0;
6924    for (const child of children2()) {
6925      if (isComponentObject(child)) {
6926        if (!child.props.disabled) {
6927          if (baseProps.variant === "selectedMenu" && child.props.selected) {
6928            result = index;
6929          } else if (result === -1) {
6930            result = index;
6931          }
6932        }
6933      }
6934      index++;
6935    }
6936    return result;
6937  };
6938  const PaperProps = mergeProps({
6939    component: MenuPaper
6940  }, () => baseProps.PaperProps, {
6941    classes: mergeProps(() => baseProps.PaperProps.classes, {
6942      get root() {
6943        return classes.paper;
6944      }
6945    })
6946  });
6947  const transitionProps = mergeProps({
6948    onEntering: handleEntering
6949  }, TransitionProps);
6950  return createComponent(MenuRoot, mergeProps({
6951    get classes() {
6952      return props.PopoverClasses;
6953    },
6954    get onClose() {
6955      return props.onClose;
6956    },
6957    anchorOrigin: {
6958      vertical: "bottom",
6959      get horizontal() {
6960        return isRtl() ? "right" : "left";
6961      }
6962    },
6963    get transformOrigin() {
6964      return isRtl() ? RTL_ORIGIN : LTR_ORIGIN;
6965    },
6966    PaperProps,
6967    get ["class"]() {
6968      return classes.root;
6969    },
6970    get open() {
6971      return props.open;
6972    },
6973    ref,
6974    get transitionDuration() {
6975      return baseProps.transitionDuration;
6976    },
6977    TransitionProps: transitionProps,
6978    ownerState
6979  }, other, {
6980    get children() {
6981      return createComponent(MenuMenuList, mergeProps({
6982        onKeyDown: handleListKeyDown,
6983        get autoFocus() {
6984          return memo(() => !!baseProps.autoFocus)() && (activeItemIndex() === -1 || baseProps.disableAutoFocusItem);
6985        },
6986        get autoFocusItem() {
6987          return autoFocusItem();
6988        },
6989        get variant() {
6990          return baseProps.variant;
6991        }
6992      }, () => baseProps.MenuListProps, {
6993        get ["class"]() {
6994          return clsx_m_default(classes.list, baseProps.MenuListProps.class);
6995        },
6996        get children() {
6997          return children2();
6998        }
6999      }));
7000    }
7001  }));
7002});
7003var Menu_default = Menu;
7004

vendor: 328 bytes, lines 7005-7011

7005// node_modules/@suid/material/ListItemIcon/listItemIconClasses.js
7006function getListItemIconUtilityClass(slot) {
7007  return generateUtilityClass("MuiListItemIcon", slot);
7008}
7009var listItemIconClasses = generateUtilityClasses("MuiListItemIcon", ["root", "alignItemsFlexStart"]);
7010var listItemIconClasses_default = listItemIconClasses;
7011

vendor: 1,415 bytes, lines 7012-7069

7012// node_modules/@suid/material/ListItemIcon/ListItemIcon.jsx
7013var $28 = createComponentFactory_default()({
7014  name: "MuiListItemIcon",
7015  selfPropNames: ["alignItems", "children", "classes"],
7016  propDefaults: ({
7017    set
7018  }) => set({
7019    component: "div"
7020  }),
7021  utilityClass: getListItemIconUtilityClass,
7022  slotClasses: (ownerState) => ({
7023    root: ["root", ownerState.alignItems === "flex-start" && "alignItemsFlexStart"]
7024  })
7025});
7026var ListItemIconRoot = styled_default("div", {
7027  name: "MuiListItemIcon",
7028  slot: "Root",
7029  overridesResolver: (props, styles3) => {
7030    const {
7031      ownerState
7032    } = props;
7033    return [styles3.root, ownerState.alignItems === "flex-start" && styles3.alignItemsFlexStart];
7034  }
7035})(({
7036  theme,
7037  ownerState
7038}) => ({
7039  minWidth: 56,
7040  color: theme.palette.action.active,
7041  flexShrink: 0,
7042  display: "inline-flex",
7043  ...ownerState.alignItems === "flex-start" && {
7044    marginTop: 8
7045  }
7046}));
7047var ListItemIcon = $28.component(function ListItemIcon2({
7048  allProps,
7049  classes,
7050  otherProps,
7051  props
7052}) {
7053  const context = useListContext();
7054  const ownerState = mergeProps({
7055    get alignItems() {
7056      return context.alignItems;
7057    }
7058  }, allProps);
7059  return createComponent(ListItemIconRoot, mergeProps(otherProps, {
7060    get ["class"]() {
7061      return clsx_m_default(classes.root, otherProps.class);
7062    },
7063    ownerState,
7064    get children() {
7065      return props.children;
7066    }
7067  }));
7068});
7069

vendor: 360 bytes, lines 7070-7076

7070// node_modules/@suid/material/ListItemText/listItemTextClasses.js
7071function getListItemTextUtilityClass(slot) {
7072  return generateUtilityClass("MuiListItemText", slot);
7073}
7074var listItemTextClasses = generateUtilityClasses("MuiListItemText", ["root", "multiline", "dense", "inset", "primary", "secondary"]);
7075var listItemTextClasses_default = listItemTextClasses;
7076

vendor: 4,358 bytes, lines 7077-7212

7077// node_modules/@suid/material/ListItemText/ListItemText.jsx
7078var $29 = createComponentFactory_default()({
7079  name: "MuiListItemText",
7080  selfPropNames: ["children", "classes", "disableTypography", "inset", "primary", "primaryTypographyProps", "secondary", "secondaryTypographyProps"],
7081  utilityClass: getListItemTextUtilityClass,
7082  slotClasses: (ownerState) => ({
7083    root: ["root", ownerState.inset && "inset", ownerState.dense && "dense", !!ownerState.primary && !!ownerState.secondary && "multiline"],
7084    primary: ["primary"],
7085    secondary: ["secondary"]
7086  })
7087});
7088var ListItemTextRoot = styled_default("div", {
7089  name: "MuiListItemText",
7090  slot: "Root",
7091  overridesResolver: (props, styles3) => {
7092    const {
7093      ownerState
7094    } = props;
7095    return [{
7096      [`& .${listItemTextClasses_default.primary}`]: styles3.primary
7097    }, {
7098      [`& .${listItemTextClasses_default.secondary}`]: styles3.secondary
7099    }, styles3.root, ownerState.inset && styles3.inset, ownerState.primary && ownerState.secondary && styles3.multiline, ownerState.dense && styles3.dense];
7100  }
7101})(({
7102  ownerState
7103}) => ({
7104  flex: "1 1 auto",
7105  minWidth: 0,
7106  marginTop: 4,
7107  marginBottom: 4,
7108  ...ownerState.primary && ownerState.secondary && {
7109    marginTop: 6,
7110    marginBottom: 6
7111  },
7112  ...ownerState.inset && {
7113    paddingLeft: 56
7114  }
7115}));
7116var ListItemText = $29.defineComponent(function ListItemText2(inProps) {
7117  const theme = useTheme_default();
7118  const context = useListContext();
7119  const props = mergeProps(theme.components?.[$29.name]?.defaultProps, inProps);
7120  const primary = createMemo(() => props.primary);
7121  const secondary = createMemo(() => props.secondary);
7122  const ownerState = {
7123    get classes() {
7124      return props.classes;
7125    },
7126    get inset() {
7127      return props.inset || false;
7128    },
7129    get primary() {
7130      return !!primary();
7131    },
7132    get secondary() {
7133      return !!secondary();
7134    },
7135    get dense() {
7136      return context.dense;
7137    }
7138  };
7139  const classes = $29.useClasses(ownerState);
7140  const [, otherProps] = splitProps(props, ["children", "classes", "disableTypography", "inset", "primary", "primaryTypographyProps", "secondary", "secondaryTypographyProps"]);
7141  const isDefined = (v) => v !== void 0 && v !== null;
7142  const isTypography = (v) => v instanceof HTMLElement && v.classList.contains(Typography_default.toString());
7143  const Primary = () => {
7144    const $primary = children(() => primary() ?? props.children);
7145    const primaryTypographyProps = props.primaryTypographyProps;
7146    return createComponent(Show, {
7147      get when() {
7148        return isDefined($primary()) && !isTypography($primary()) && !props.disableTypography;
7149      },
7150      get fallback() {
7151        return $primary();
7152      },
7153      get children() {
7154        return createComponent(Typography_default, mergeProps({
7155          get variant() {
7156            return context.dense ? "body2" : "body1";
7157          },
7158          get ["class"]() {
7159            return classes.primary;
7160          },
7161          component: "span",
7162          display: "block"
7163        }, primaryTypographyProps, {
7164          get children() {
7165            return $primary();
7166          }
7167        }));
7168      }
7169    });
7170  };
7171  const Secondary = () => {
7172    const secondaryTypographyProps = props.secondaryTypographyProps;
7173    return createComponent(Show, {
7174      get when() {
7175        return isDefined(secondary()) && !isTypography(secondary()) && !props.disableTypography;
7176      },
7177      get fallback() {
7178        return secondary();
7179      },
7180      get children() {
7181        return createComponent(Typography_default, mergeProps({
7182          variant: "body2",
7183          get ["class"]() {
7184            return classes.secondary;
7185          },
7186          sx: {
7187            display: "block",
7188            color: "text.secondary"
7189          }
7190        }, secondaryTypographyProps, {
7191          get component() {
7192            return secondaryTypographyProps?.component ?? "p";
7193          },
7194          get children() {
7195            return secondary();
7196          }
7197        }));
7198      }
7199    });
7200  };
7201  return createComponent(ListItemTextRoot, mergeProps(otherProps, {
7202    get ["class"]() {
7203      return clsx_m_default(classes.root, otherProps.class);
7204    },
7205    ownerState,
7206    get children() {
7207      return [createComponent(Primary, {}), createComponent(Secondary, {})];
7208    }
7209  }));
7210});
7211var ListItemText_default = ListItemText;
7212

vendor: 360 bytes, lines 7213-7227

7213// node_modules/@suid/material/MenuItem/menuItemClasses.js
7214function getMenuItemUtilityClass(slot) {
7215  return generateUtilityClass("MuiMenuItem", slot);
7216}
7217var menuItemClasses = generateUtilityClasses("MuiMenuItem", [
7218  "root",
7219  "focusVisible",
7220  "dense",
7221  "disabled",
7222  "divider",
7223  "gutters",
7224  "selected"
7225]);
7226var menuItemClasses_default = menuItemClasses;
7227

vendor: 5,357 bytes, lines 7228-7403

7228// node_modules/@suid/material/MenuItem/MenuItem.jsx
7229var $30 = createComponentFactory_default()({
7230  name: "MuiMenuItem",
7231  selfPropNames: ["autoFocus", "classes", "dense", "disabled", "disableGutters", "divider", "selected"],
7232  utilityClass: getMenuItemUtilityClass,
7233  slotClasses: (ownerState) => ({
7234    root: ["root", ownerState.dense && "dense", ownerState.disabled && "disabled", !ownerState.disableGutters && "gutters", ownerState.divider && "divider", ownerState.selected && "selected"]
7235  })
7236});
7237var MenuItemRoot = styled_default(ButtonBase_default, {
7238  skipProps: skipRootProps.filter((v) => v !== "classes"),
7239  name: "MuiMenuItem",
7240  slot: "Root",
7241  overridesResolver: (props, styles3) => {
7242    const {
7243      ownerState
7244    } = props;
7245    return [styles3.root, ownerState.dense && styles3.dense, ownerState.divider && styles3.divider, !ownerState.disableGutters && styles3.gutters];
7246  }
7247})(({
7248  theme,
7249  ownerState
7250}) => ({
7251  ...theme.typography.body1,
7252  display: "flex",
7253  justifyContent: "flex-start",
7254  alignItems: "center",
7255  position: "relative",
7256  textDecoration: "none",
7257  minHeight: 48,
7258  paddingTop: 6,
7259  paddingBottom: 6,
7260  boxSizing: "border-box",
7261  whiteSpace: "nowrap",
7262  ...!ownerState.disableGutters && {
7263    paddingLeft: 16,
7264    paddingRight: 16
7265  },
7266  ...ownerState.divider && {
7267    borderBottom: `1px solid ${theme.palette.divider}`,
7268    backgroundClip: "padding-box"
7269  },
7270  "&:hover": {
7271    textDecoration: "none",
7272    backgroundColor: theme.palette.action.hover,
7273    // Reset on touch devices, it doesn't add specificity
7274    "@media (hover: none)": {
7275      backgroundColor: "transparent"
7276    }
7277  },
7278  [`&.${menuItemClasses_default.selected}`]: {
7279    backgroundColor: alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity),
7280    [`&.${menuItemClasses_default.focusVisible}`]: {
7281      backgroundColor: alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
7282    }
7283  },
7284  [`&.${menuItemClasses_default.selected}:hover`]: {
7285    backgroundColor: alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
7286    // Reset on touch devices, it doesn't add specificity
7287    "@media (hover: none)": {
7288      backgroundColor: alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
7289    }
7290  },
7291  [`&.${menuItemClasses_default.focusVisible}`]: {
7292    backgroundColor: theme.palette.action.focus
7293  },
7294  [`&.${menuItemClasses_default.disabled}`]: {
7295    opacity: theme.palette.action.disabledOpacity
7296  },
7297  [`& + .${dividerClasses_default.root}`]: {
7298    marginTop: theme.spacing(1),
7299    marginBottom: theme.spacing(1)
7300  },
7301  [`& + .${dividerClasses_default.inset}`]: {
7302    marginLeft: 52
7303  },
7304  [`& .${listItemTextClasses_default.root}`]: {
7305    marginTop: 0,
7306    marginBottom: 0
7307  },
7308  [`& .${listItemTextClasses_default.inset}`]: {
7309    paddingLeft: 36
7310  },
7311  [`& .${listItemIconClasses_default.root}`]: {
7312    minWidth: 36
7313  },
7314  ...!ownerState.dense && {
7315    [theme.breakpoints.up("sm")]: {
7316      minHeight: "auto"
7317    }
7318  },
7319  ...ownerState.dense && {
7320    minHeight: 32,
7321    paddingTop: 4,
7322    paddingBottom: 4,
7323    ...theme.typography.body2,
7324    [`& .${listItemIconClasses_default.root} svg`]: {
7325      fontSize: "1.25rem"
7326    }
7327  }
7328}));
7329var MenuItem = $30.defineComponent(function MenuItem2(inProps) {
7330  const menuItemRef = createRef_default(inProps);
7331  const props = $30.useThemeProps({
7332    props: inProps
7333  });
7334  const [, other] = splitProps(props, ["autoFocus", "component", "dense", "divider", "disableGutters", "focusVisibleClassName", "role", "tabIndex"]);
7335  const baseProps = mergeProps({
7336    autoFocus: false,
7337    component: "li",
7338    dense: false,
7339    divider: false,
7340    disableGutters: false,
7341    role: "menuitem"
7342  }, props);
7343  const context = useContext(ListContext_default);
7344  const childContext = {
7345    get dense() {
7346      return baseProps.dense || context.dense || false;
7347    },
7348    get disableGutters() {
7349      return baseProps.disableGutters;
7350    }
7351  };
7352  createEffect(() => {
7353    if (baseProps.autoFocus) {
7354      if (menuItemRef.current) {
7355        untrack(() => menuItemRef.current.focus());
7356      } else if (true) {
7357        console.error("MUI: Unable to set focus to a MenuItem whose component has not been rendered.");
7358      }
7359    }
7360  });
7361  const ownerState = mergeProps(props, {
7362    get dense() {
7363      return childContext.dense;
7364    },
7365    get divider() {
7366      return baseProps.divider;
7367    },
7368    get disableGutters() {
7369      return baseProps.disableGutters;
7370    }
7371  });
7372  const classes = $30.useClasses(props);
7373  const tabIndex = () => {
7374    if (!props.disabled) {
7375      return props.tabIndex !== void 0 ? props.tabIndex : -1;
7376    }
7377  };
7378  return createComponent(ListContext_default.Provider, {
7379    value: childContext,
7380    get children() {
7381      return createComponent(MenuItemRoot, mergeProps({
7382        ref: menuItemRef,
7383        get role() {
7384          return baseProps.role;
7385        },
7386        get tabIndex() {
7387          return tabIndex();
7388        },
7389        get component() {
7390          return baseProps.component;
7391        },
7392        get focusVisibleClassName() {
7393          return clsx_m_default(ownerState.classes?.focusVisible, props.focusVisibleClassName);
7394        }
7395      }, other, {
7396        ownerState,
7397        classes
7398      }));
7399    }
7400  });
7401});
7402var MenuItem_default = MenuItem;
7403

vendor: 161 bytes, lines 7404-7407

7404// node_modules/@suid/material/FormControl/FormControlContext.js
7405var FormControlContext = createContext();
7406var FormControlContext_default = FormControlContext;
7407

vendor: 831 bytes, lines 7408-7438

7408// node_modules/@suid/material/FormControl/formControlState.js
7409function formControlState(data) {
7410  const compose = () => {
7411    return data.states.reduce((acc, state) => {
7412      acc[state] = data.props[state];
7413      if (data.muiFormControl) {
7414        if (typeof data.props[state] === "undefined") {
7415          acc[state] = data.muiFormControl[state];
7416        }
7417      }
7418      return acc;
7419    }, {});
7420  };
7421  const object = createMutable({});
7422  createComputed(() => {
7423    const newObject = compose();
7424    batch(() => {
7425      for (const key in newObject) {
7426        if (object[key] !== newObject[key])
7427          object[key] = newObject[key];
7428      }
7429      const newKeys = Object.keys(newObject);
7430      for (const key in object) {
7431        if (!newKeys.includes(key))
7432          delete object[key];
7433      }
7434    });
7435  });
7436  return object;
7437}
7438

vendor: 141 bytes, lines 7439-7443

7439// node_modules/@suid/material/FormControl/useFormControl.js
7440function useFormControl() {
7441  return useContext(FormControlContext_default);
7442}
7443

vendor: 367 bytes, lines 7444-7458

7444// node_modules/@suid/material/GlobalStyles/GlobalStyles.jsx
7445var $31 = createComponentFactory_default()({
7446  name: "MuiGlobalStyles",
7447  selfPropNames: ["styles"]
7448});
7449var GlobalStyles = $31.component(function GlobalStyles2({
7450  props
7451}) {
7452  createStyle_default(() => ({
7453    "@global": props.styles || {}
7454  }));
7455  return [];
7456});
7457var GlobalStyles_default = GlobalStyles;
7458

vendor: 1,720 bytes, lines 7459-7499

7459// node_modules/@suid/material/utils/useControlled.js
7460function useControlled(props) {
7461  const isControlled = props.controlled() !== void 0;
7462  const [valueState, setValue] = createSignal(props.default());
7463  const value = createMemo(() => isControlled ? props.controlled() : valueState());
7464  if (isControlled)
7465    createEffect(() => {
7466      setValue(() => value());
7467    });
7468  if (true) {
7469    createEffect(() => {
7470      if (isControlled !== (props.controlled() !== void 0)) {
7471        console.error([
7472          `MUI: A component is changing the ${isControlled ? "" : "un"}controlled ${props.state ?? "value"} state of ${props.name} to be ${isControlled ? "un" : ""}controlled.`,
7473          "Elements should not switch from uncontrolled to controlled (or vice versa).",
7474          `Decide between using a controlled or uncontrolled ${props.name} element for the lifetime of the component.`,
7475          "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.",
7476          "More info: https://fb.me/react-controlled-components"
7477        ].join("\n"));
7478      }
7479    });
7480    let first = true;
7481    createEffect(on(() => props.default(), () => {
7482      if (first) {
7483        first = false;
7484        return;
7485      } else if (!isControlled) {
7486        console.error([
7487          `MUI: A component is changing the default ${props.state ?? "value"} state of an uncontrolled ${props.name} after being initialized. To suppress this warning opt to use a controlled ${props.name}.`
7488        ].join("\n"));
7489      }
7490    }));
7491  }
7492  const setValueIfUncontrolled = (newValue) => {
7493    if (!isControlled) {
7494      setValue(newValue);
7495    }
7496  };
7497  return [value, setValueIfUncontrolled];
7498}
7499

vendor: 594 bytes, lines 7500-7526

7500// node_modules/@suid/material/InputBase/inputBaseClasses.js
7501function getInputBaseUtilityClass(slot) {
7502  return generateUtilityClass("MuiInputBase", slot);
7503}
7504var inputBaseClasses = generateUtilityClasses("MuiInputBase", [
7505  "root",
7506  "formControl",
7507  "focused",
7508  "disabled",
7509  "adornedStart",
7510  "adornedEnd",
7511  "error",
7512  "sizeSmall",
7513  "multiline",
7514  "colorSecondary",
7515  "fullWidth",
7516  "hiddenLabel",
7517  "input",
7518  "inputSizeSmall",
7519  "inputMultiline",
7520  "inputTypeSearch",
7521  "inputAdornedStart",
7522  "inputAdornedEnd",
7523  "inputHiddenLabel"
7524]);
7525var inputBaseClasses_default = inputBaseClasses;
7526

vendor: 316 bytes, lines 7527-7534

7527// node_modules/@suid/material/InputBase/utils.js
7528function hasValue(value) {
7529  return value != null && !(Array.isArray(value) && value.length === 0);
7530}
7531function isFilled(obj, SSR = false) {
7532  return obj && (hasValue(obj.value) && obj.value !== "" || SSR && hasValue(obj.defaultValue) && obj.defaultValue !== "");
7533}
7534

vendor: 379 bytes, lines 7535-7548

7535// node_modules/@suid/system/createEffectWithCleaning.js
7536function createEffectWithCleaning(effect) {
7537  let lastCleanup;
7538  onCleanup(() => lastCleanup?.());
7539  createEffect((prevCleanup) => {
7540    if (prevCleanup) {
7541      lastCleanup = void 0;
7542      prevCleanup?.();
7543    }
7544    return lastCleanup = effect();
7545  });
7546}
7547var createEffectWithCleaning_default = createEffectWithCleaning;
7548

vendor: 4,888 bytes, lines 7549-7692

7549// node_modules/@suid/base/TextareaAutosize/TextareaAutosize.jsx
7550var _tmpl$5 = /* @__PURE__ */ template(`<textarea>`);
7551var _tmpl$22 = /* @__PURE__ */ template(`<textarea aria-hidden readonly tabindex="-1">`);
7552var $32 = createComponentFactory_default()({
7553  name: "MuiTextareaAutosize",
7554  selfPropNames: ["ref", "maxRows", "minRows"]
7555});
7556function getStyleValue(computedStyle, property) {
7557  return parseInt(computedStyle[property], 10) || 0;
7558}
7559var styles2 = {
7560  shadow: {
7561    // Visibility needed to hide the extra text area on iPads
7562    visibility: "hidden",
7563    // Remove from the content flow
7564    position: "absolute",
7565    // Ignore the scrollbar width
7566    overflow: "hidden",
7567    height: 0,
7568    top: 0,
7569    left: 0,
7570    // Create a new layer, increase the isolation of the computed values
7571    transform: "translateZ(0)"
7572  }
7573};
7574var TextareaAutosize = $32.defineComponent(function(props) {
7575  const ref = createRef_default(props);
7576  const [, other] = splitProps(props, ["maxRows", "minRows", "style", "value"]);
7577  const baseProps = mergeProps({
7578    minRows: 1
7579  }, props);
7580  let shadowRef;
7581  const renders = {
7582    current: 0
7583  };
7584  const [state, setState] = createSignal({});
7585  const syncHeight = () => {
7586    const input = ref.current;
7587    const containerWindow = ownerWindow(input);
7588    const computedStyle = containerWindow.getComputedStyle(input);
7589    if (computedStyle.width === "0px") {
7590      return;
7591    }
7592    shadowRef.style.width = computedStyle.width;
7593    shadowRef.value = input.value || props.placeholder || "x";
7594    if (shadowRef.value.slice(-1) === "\n") {
7595      shadowRef.value += " ";
7596    }
7597    const boxSizing = computedStyle["boxSizing"];
7598    const padding = getStyleValue(computedStyle, "paddingBottom") + getStyleValue(computedStyle, "paddingTop");
7599    const border = getStyleValue(computedStyle, "borderBottomWidth") + getStyleValue(computedStyle, "borderTopWidth");
7600    const innerHeight = shadowRef.scrollHeight;
7601    shadowRef.value = "x";
7602    const singleRowHeight = shadowRef.scrollHeight;
7603    let outerHeight = innerHeight;
7604    if (baseProps.minRows) {
7605      outerHeight = Math.max(Number(baseProps.minRows) * singleRowHeight, outerHeight);
7606    }
7607    if (props.maxRows) {
7608      outerHeight = Math.min(Number(props.maxRows) * singleRowHeight, outerHeight);
7609    }
7610    outerHeight = Math.max(outerHeight, singleRowHeight);
7611    const outerHeightStyle = outerHeight + (boxSizing === "border-box" ? padding + border : 0);
7612    const overflow = Math.abs(outerHeight - innerHeight) <= 1;
7613    setState((prevState) => {
7614      if (renders.current < 20 && (outerHeightStyle > 0 && Math.abs((prevState.outerHeightStyle || 0) - outerHeightStyle) > 1 || prevState.overflow !== overflow)) {
7615        renders.current += 1;
7616        return {
7617          overflow,
7618          outerHeightStyle
7619        };
7620      }
7621      if (true) {
7622        if (renders.current === 20) {
7623          console.error(["MUI: Too many re-renders. The layout is unstable.", "TextareaAutosize limits the number of renders to prevent an infinite loop."].join("\n"));
7624        }
7625      }
7626      return prevState;
7627    });
7628  };
7629  createEffectWithCleaning_default(() => {
7630    syncHeight();
7631    const handleResize = debounce(() => {
7632      renders.current = 0;
7633      syncHeight();
7634    });
7635    const containerWindow = ownerWindow(ref.current);
7636    containerWindow.addEventListener("resize", handleResize);
7637    let resizeObserver;
7638    if (typeof ResizeObserver !== "undefined") {
7639      resizeObserver = new ResizeObserver(handleResize);
7640      resizeObserver.observe(ref.current);
7641    }
7642    return () => {
7643      handleResize.clear();
7644      containerWindow.removeEventListener("resize", handleResize);
7645      if (resizeObserver) {
7646        resizeObserver.disconnect();
7647      }
7648    };
7649  });
7650  createEffect(on(() => [props.value], () => {
7651    renders.current = 0;
7652    syncHeight();
7653  }));
7654  const style1 = mergeProps({
7655    get height() {
7656      return `${state().outerHeightStyle}px`;
7657    },
7658    get overflow() {
7659      return state().overflow ? "hidden" : null;
7660    }
7661  }, () => props.style);
7662  const style2 = mergeProps(styles2.shadow, () => props.style, {
7663    padding: 0
7664  });
7665  return [(() => {
7666    const _el$ = _tmpl$5();
7667    use(ref, _el$);
7668    spread(_el$, mergeProps({
7669      get rows() {
7670        return baseProps.minRows;
7671      }
7672    }, other), false, false);
7673    createRenderEffect((_$p) => style(_el$, style1, _$p));
7674    return _el$;
7675  })(), (() => {
7676    const _el$2 = _tmpl$22();
7677    const _ref$ = shadowRef;
7678    typeof _ref$ === "function" ? use(_ref$, _el$2) : shadowRef = _el$2;
7679    createRenderEffect((_p$) => {
7680      const _v$ = props.class, _v$2 = style2;
7681      _v$ !== _p$._v$ && className(_el$2, _p$._v$ = _v$);
7682      _p$._v$2 = style(_el$2, _v$2, _p$._v$2);
7683      return _p$;
7684    }, {
7685      _v$: void 0,
7686      _v$2: void 0
7687    });
7688    return _el$2;
7689  })()];
7690}, false);
7691var TextareaAutosize_default = TextareaAutosize;
7692

vendor: 16,716 bytes, lines 7693-8173

7693// node_modules/@suid/material/InputBase/InputBase.jsx
7694var $33 = createComponentFactory_default()({
7695  name: "MuiInputBase",
7696  propDefaults: ({
7697    set
7698  }) => set({
7699    components: {},
7700    componentsProps: {},
7701    fullWidth: false,
7702    inputComponent: "input",
7703    inputProps: {},
7704    multiline: false,
7705    type: "text",
7706    disableInjectingGlobalStyles: false
7707  }),
7708  selfPropNames: ["aria-describedby", "autoComplete", "autoFocus", "classes", "color", "components", "componentsProps", "defaultValue", "disableInjectingGlobalStyles", "disabled", "endAdornment", "error", "fullWidth", "id", "inputComponent", "inputProps", "inputProps", "inputRef", "margin", "maxRows", "minRows", "multiline", "name", "onBlur", "onChange", "onFocus", "onKeyDown", "onKeyUp", "placeholder", "readOnly", "renderSuffix", "required", "rows", "size", "startAdornment", "type", "value"],
7709  utilityClass: getInputBaseUtilityClass,
7710  autoCallUseClasses: false,
7711  slotClasses: (ownerState) => ({
7712    root: ["root", `color${capitalize_default(ownerState.color)}`, !!ownerState.disabled && "disabled", !!ownerState.error && "error", !!ownerState.fullWidth && "fullWidth", ownerState.focused && "focused", !!ownerState.formControl && "formControl", ownerState.size === "small" && "sizeSmall", ownerState.multiline && "multiline", !!ownerState.startAdornment && "adornedStart", !!ownerState.endAdornment && "adornedEnd", !!ownerState.hiddenLabel && "hiddenLabel"],
7713    input: ["input", !!ownerState.disabled && "disabled", ownerState.type === "search" && "inputTypeSearch", ownerState.multiline && "inputMultiline", ownerState.size === "small" && "inputSizeSmall", !!ownerState.hiddenLabel && "inputHiddenLabel", !!ownerState.startAdornment && "inputAdornedStart", !!ownerState.endAdornment && "inputAdornedEnd"]
7714  })
7715});
7716var rootOverridesResolver = (props, styles3) => {
7717  const ownerState = props.ownerState;
7718  return [styles3.root, !!ownerState.formControl && styles3.formControl, !!ownerState.startAdornment && styles3.adornedStart, !!ownerState.endAdornment && styles3.adornedEnd, !!ownerState.error && styles3.error, ownerState.size === "small" && styles3.sizeSmall, ownerState.multiline && styles3.multiline, ownerState.color && styles3[`color${capitalize_default(ownerState.color)}`], !!ownerState.fullWidth && styles3.fullWidth, !!ownerState.hiddenLabel && styles3.hiddenLabel];
7719};
7720var inputOverridesResolver = (props, styles3) => {
7721  const ownerState = props.ownerState;
7722  return [styles3.input, ownerState.size === "small" && styles3.inputSizeSmall, ownerState.multiline && styles3.inputMultiline, ownerState.type === "search" && styles3.inputTypeSearch, !!ownerState.startAdornment && styles3.inputAdornedStart, !!ownerState.endAdornment && styles3.inputAdornedEnd, !!ownerState.hiddenLabel && styles3.inputHiddenLabel];
7723};
7724var InputBaseRoot = styled_default("div", {
7725  name: "MuiInputBase",
7726  slot: "Root",
7727  overridesResolver: rootOverridesResolver
7728})(({
7729  theme,
7730  ownerState
7731}) => ({
7732  ...theme.typography.body1,
7733  color: theme.palette.text.primary,
7734  lineHeight: "1.4375em",
7735  boxSizing: "border-box",
7736  position: "relative",
7737  cursor: "text",
7738  display: "inline-flex",
7739  alignItems: "center",
7740  [`&.${inputBaseClasses_default.disabled}`]: {
7741    color: theme.palette.text.disabled,
7742    cursor: "default"
7743  },
7744  ...ownerState.multiline && {
7745    padding: "4px 0 5px",
7746    ...ownerState.size === "small" && {
7747      paddingTop: 1
7748    }
7749  },
7750  ...ownerState.fullWidth && {
7751    width: "100%"
7752  }
7753}));
7754var InputBaseComponent = styled_default("input", {
7755  name: "MuiInputBase",
7756  slot: "Input",
7757  overridesResolver: inputOverridesResolver
7758})(({
7759  theme,
7760  ownerState
7761}) => {
7762  const light = theme.palette.mode === "light";
7763  const placeholder = {
7764    color: "currentColor",
7765    opacity: light ? 0.42 : 0.5,
7766    transition: theme.transitions.create("opacity", {
7767      duration: theme.transitions.duration.shorter
7768    })
7769  };
7770  const placeholderHidden = {
7771    opacity: "0 !important"
7772  };
7773  const placeholderVisible = {
7774    opacity: light ? 0.42 : 0.5
7775  };
7776  return {
7777    font: "inherit",
7778    letterSpacing: "inherit",
7779    color: "currentColor",
7780    padding: "4px 0 5px",
7781    border: 0,
7782    boxSizing: "content-box",
7783    background: "none",
7784    height: "1.4375em",
7785    margin: 0,
7786    WebkitTapHighlightColor: "transparent",
7787    display: "block",
7788    // Make the flex item shrink with Firefox
7789    minWidth: 0,
7790    width: "100%",
7791    animationName: "mui-auto-fill-cancel",
7792    animationDuration: "10ms",
7793    "&::-webkit-input-placeholder": placeholder,
7794    "&::-moz-placeholder": placeholder,
7795    "&:-ms-input-placeholder": placeholder,
7796    "&::-ms-input-placeholder": placeholder,
7797    "&:focus": {
7798      outline: 0
7799    },
7800    // Reset Firefox invalid required input style
7801    "&:invalid": {
7802      boxShadow: "none"
7803    },
7804    "&::-webkit-search-decoration": {
7805      // Remove the padding when type=search.
7806      WebkitAppearance: "none"
7807    },
7808    // Show and hide the placeholder logic
7809    [`label[data-shrink=false] + .${inputBaseClasses_default.formControl} &`]: {
7810      "&::-webkit-input-placeholder": placeholderHidden,
7811      "&::-moz-placeholder": placeholderHidden,
7812      "&:-ms-input-placeholder": placeholderHidden,
7813      "&::-ms-input-placeholder": placeholderHidden,
7814      "&:focus::-webkit-input-placeholder": placeholderVisible,
7815      "&:focus::-moz-placeholder": placeholderVisible,
7816      "&:focus:-ms-input-placeholder": placeholderVisible,
7817      "&:focus::-ms-input-placeholder": placeholderVisible
7818      // Edge
7819    },
7820    [`&.${inputBaseClasses_default.disabled}`]: {
7821      opacity: 1,
7822      WebkitTextFillColor: theme.palette.text.disabled
7823      // Fix opacity Safari bug
7824    },
7825    "&:-webkit-autofill": {
7826      animationDuration: "5000s",
7827      animationName: "mui-auto-fill"
7828    },
7829    ...ownerState.size === "small" && {
7830      paddingTop: 1
7831    },
7832    ...ownerState.multiline && {
7833      height: "auto",
7834      resize: "none",
7835      padding: 0,
7836      paddingTop: 0
7837    },
7838    ...ownerState.type === "search" && {
7839      // Improve type search style.
7840      MozAppearance: "textfield"
7841    }
7842  };
7843});
7844var inputGlobalStyles = () => createComponent(GlobalStyles_default, {
7845  styles: {
7846    "@keyframes mui-auto-fill": {
7847      from: {
7848        display: "block"
7849      }
7850    },
7851    "@keyframes mui-auto-fill-cancel": {
7852      from: {
7853        display: "block"
7854      }
7855    }
7856  }
7857});
7858var selectionTypes = /* @__PURE__ */ new Set(["text", "search", "password", "tel", "url"]);
7859var InputBase = $33.component(function InputBase2({
7860  allProps,
7861  otherProps,
7862  props
7863}) {
7864  const inputValue = () => props.inputProps.value != null ? props.inputProps.value : props.value;
7865  const isControlled = (inputValue() ?? null) !== null;
7866  const [value, setValue] = useControlled({
7867    controlled: () => inputValue(),
7868    default: () => props.defaultValue,
7869    name: "InputBase"
7870  });
7871  const inputRef = createRef_default({
7872    ref: (instance) => {
7873      if (true) {
7874        if (instance && instance.nodeName !== "INPUT" && !instance.focus) {
7875          console.error(["MUI: You have provided a `inputComponent` to the input component", "that does not correctly handle the `ref` prop.", "Make sure the `ref` prop is called with a HTMLInputElement."].join("\n"));
7876        }
7877      }
7878      if (typeof props.inputRef === "function") props.inputRef(instance);
7879    }
7880  });
7881  let lastSelectionStart;
7882  let controlledValueUpdated = false;
7883  onMount(() => {
7884    const isElement = inputRef.ref instanceof HTMLElement;
7885    inputRef.ref.addEventListener("input", (event) => {
7886      const nodeValue = inputRef.ref.value;
7887      if (isElement) {
7888        const start = inputRef.ref.selectionStart ?? nodeValue.length;
7889        lastSelectionStart = start;
7890      }
7891      controlledValueUpdated = false;
7892      if (typeof props.inputProps.onChange === "function") {
7893        props.inputProps.onChange(event);
7894      }
7895      setValue(nodeValue);
7896      if (typeof props.onChange === "function") {
7897        props.onChange(event, nodeValue);
7898      }
7899      if (isControlled && !controlledValueUpdated) {
7900        const v = value();
7901        inputRef.ref.value = isElement ? v ?? "" : v;
7902      }
7903    });
7904  });
7905  createEffect((loadDefaultValue) => {
7906    if (isControlled || loadDefaultValue) {
7907      controlledValueUpdated = true;
7908      const v = value();
7909      const isElement = inputRef.ref instanceof HTMLElement;
7910      if (!isElement) {
7911        if (v !== inputRef.ref.value) {
7912          inputRef.ref.value = v;
7913        }
7914      } else if (typeof v === "string") {
7915        const inputElement = inputRef.ref;
7916        const type = inputElement.type ?? "text";
7917        const isSelectionType = inputElement.nodeName === "TEXTAREA" || selectionTypes.has(type);
7918        const selectionStart = lastSelectionStart ?? v.length;
7919        if (v !== inputRef.ref.value) {
7920          inputRef.ref.value = v;
7921        }
7922        if (!isSelectionType) inputElement.type = "text";
7923        if (inputRef.ref.selectionStart !== selectionStart) {
7924          inputRef.ref.setSelectionRange(selectionStart, selectionStart);
7925        }
7926        if (!isSelectionType) inputElement.type = type;
7927      }
7928    }
7929    return false;
7930  }, true);
7931  const [focused, setFocused] = createSignal(false);
7932  const muiFormControl = useFormControl();
7933  if (true) {
7934    createEffect(() => {
7935      muiFormControl?.registerEffect?.();
7936    });
7937  }
7938  const partialFcs = formControlState({
7939    props: allProps,
7940    muiFormControl,
7941    states: ["color", "disabled", "error", "hiddenLabel", "size", "required", "filled"]
7942  });
7943  const fcs = mergeProps(partialFcs, {
7944    get focused() {
7945      return muiFormControl ? muiFormControl.focused : focused();
7946    }
7947  });
7948  createEffect(() => {
7949    if (!muiFormControl && props.disabled && focused()) {
7950      setFocused(false);
7951      if (typeof props.onBlur === "function") props.onBlur?.(null);
7952    }
7953  });
7954  const onFilled = () => muiFormControl && muiFormControl.onFilled;
7955  const onEmpty = () => muiFormControl && muiFormControl.onEmpty;
7956  const checkDirty = (obj) => {
7957    if (isFilled(obj)) {
7958      onFilled()?.();
7959    } else {
7960      onEmpty()?.();
7961    }
7962  };
7963  createRenderEffect(() => {
7964    if (isControlled) {
7965      checkDirty({
7966        value: value()
7967      });
7968    }
7969  });
7970  onMount(() => {
7971    checkDirty(inputRef.ref);
7972  });
7973  const isMultilineInput = () => props.multiline && props.inputComponent === "input";
7974  const InputComponent = () => isMultilineInput() ? TextareaAutosize_default : props.inputComponent;
7975  const inputProps = createMemo(() => {
7976    let inputProps2 = props.inputProps;
7977    if (isMultilineInput()) {
7978      if (props.rows) {
7979        if (true) {
7980          if (props.minRows || props.maxRows) {
7981            console.warn("MUI: You can not use the `minRows` or `maxRows` props when the input `rows` prop is set.");
7982          }
7983        }
7984        inputProps2 = {
7985          type: void 0,
7986          ["minRows"]: props.rows,
7987          ["maxRows"]: props.rows,
7988          ...inputProps2
7989        };
7990      } else {
7991        inputProps2 = {
7992          type: void 0,
7993          ["maxRows"]: props.maxRows,
7994          ["minRows"]: props.minRows,
7995          ...inputProps2
7996        };
7997      }
7998    }
7999    return mergeProps(inputProps2, () => props.componentsProps.input || {});
8000  });
8001  createEffect(() => {
8002    muiFormControl?.setAdornedStart(Boolean(props.startAdornment));
8003  });
8004  const ownerState = mergeProps(allProps, {
8005    get color() {
8006      return fcs.color || "primary";
8007    },
8008    get disabled() {
8009      return fcs.disabled;
8010    },
8011    get error() {
8012      return fcs.error;
8013    },
8014    get focused() {
8015      return fcs.focused;
8016    },
8017    get formControl() {
8018      return muiFormControl;
8019    },
8020    get hiddenLabel() {
8021      return fcs.hiddenLabel;
8022    },
8023    get size() {
8024      return fcs.size;
8025    }
8026  });
8027  const classes = $33.useClasses(ownerState);
8028  const Root = () => props.components.Root || InputBaseRoot;
8029  const rootProps = () => props.componentsProps.root || {};
8030  const Input3 = () => props.components.Input || InputBaseComponent;
8031  const rootOwnerState = mergeProps(ownerState, () => rootProps()["ownerState"] || {});
8032  const inputOwnerState = mergeProps(ownerState, () => inputProps()["ownerState"] || {});
8033  const renderSuffixProps = mergeProps(fcs, {
8034    get startAdornment() {
8035      return props.startAdornment;
8036    }
8037  });
8038  const suffix = createMemo(() => props.renderSuffix?.(renderSuffixProps));
8039  return [memo((() => {
8040    const _c$ = memo(() => !!!props.disableInjectingGlobalStyles);
8041    return () => _c$() && inputGlobalStyles();
8042  })()), createComponent(Dynamic_default, mergeProps(rootProps, otherProps, {
8043    get $component() {
8044      return Root();
8045    }
8046  }, () => !isHostComponent_default(Root()) && {
8047    ownerState: rootOwnerState
8048  }, {
8049    onClick: (event) => {
8050      if (inputRef.ref && event.currentTarget === event.target) {
8051        inputRef.ref.focus();
8052      }
8053      if (typeof otherProps.onClick === "function") {
8054        otherProps.onClick(event);
8055      }
8056    },
8057    get ["class"]() {
8058      return clsx_m_default(classes.root, rootProps().class, otherProps.class);
8059    },
8060    get children() {
8061      return [memo(() => props.startAdornment), createComponent(FormControlContext_default.Provider, {
8062        value: void 0,
8063        get children() {
8064          return createComponent(Dynamic_default, mergeProps({
8065            get $component() {
8066              return Input3();
8067            },
8068            ownerState,
8069            get ["aria-invalid"]() {
8070              return fcs.error;
8071            },
8072            get ["aria-describedby"]() {
8073              return props["aria-describedby"];
8074            },
8075            get autocomplete() {
8076              return props.autoComplete;
8077            },
8078            get autofocus() {
8079              return props.autoFocus;
8080            },
8081            get disabled() {
8082              return fcs.disabled;
8083            },
8084            get id() {
8085              return props.id;
8086            },
8087            onAnimationStart: (event) => {
8088              checkDirty(event.animationName === "mui-auto-fill-cancel" ? inputRef.ref : {
8089                value: "x"
8090              });
8091            },
8092            get name() {
8093              return props.name;
8094            },
8095            get placeholder() {
8096              return props.placeholder;
8097            },
8098            get readOnly() {
8099              return props.readOnly;
8100            },
8101            get required() {
8102              return fcs.required;
8103            }
8104          }, () => ({
8105            rows: props.rows
8106          }), {
8107            get value() {
8108              return value();
8109            },
8110            get onKeyDown() {
8111              return props.onKeyDown;
8112            },
8113            get onKeyUp() {
8114              return props.onKeyUp;
8115            },
8116            get type() {
8117              return props.type;
8118            }
8119          }, inputProps, () => !isHostComponent_default(Input3()) && {
8120            as: InputComponent(),
8121            ownerState: inputOwnerState
8122          }, {
8123            ref: inputRef,
8124            get ["class"]() {
8125              return clsx_m_default(classes.input, inputProps().class);
8126            },
8127            onBlur: (event) => {
8128              props.onBlur?.(event);
8129              if (typeof props.inputProps.onBlur === "function") {
8130                props.inputProps.onBlur(event);
8131              }
8132              if (muiFormControl && muiFormControl.onBlur) {
8133                muiFormControl.onBlur();
8134              } else {
8135                setFocused(false);
8136              }
8137            },
8138            onInput: (event) => {
8139              if (!isControlled) {
8140                const element = event.target || inputRef.ref;
8141                if (element == null) {
8142                  throw new Error("MUI: Expected valid input target. Did you use a custom `inputComponent` and forget to forward refs? See https://mui.com/r/input-component-ref-interface for more info.");
8143                }
8144                checkDirty({
8145                  value: element.value
8146                });
8147              }
8148            },
8149            onFocus: (event) => {
8150              if (fcs.disabled) {
8151                event.stopPropagation();
8152                return;
8153              }
8154              if (typeof props.onFocus === "function") {
8155                props.onFocus(event);
8156              }
8157              if (typeof props.inputProps.onFocus === "function") {
8158                props.inputProps.onFocus(event);
8159              }
8160              if (muiFormControl && muiFormControl.onFocus) {
8161                muiFormControl.onFocus();
8162              } else {
8163                setFocused(true);
8164              }
8165            }
8166          }));
8167        }
8168      }), memo(() => props.endAdornment), memo(() => suffix())];
8169    }
8170  }))];
8171});
8172var InputBase_default = InputBase;
8173

vendor: 359 bytes, lines 8174-8183

8174// node_modules/@suid/material/FilledInput/filledInputClasses.js
8175function getFilledInputUtilityClass(slot) {
8176  return generateUtilityClass("MuiFilledInput", slot);
8177}
8178var filledInputClasses = {
8179  ...inputBaseClasses_default,
8180  ...generateUtilityClasses("MuiFilledInput", ["root", "underline", "input"])
8181};
8182var filledInputClasses_default = filledInputClasses;
8183

vendor: 6,057 bytes, lines 8184-8386

8184// node_modules/@suid/material/FilledInput/FilledInput.jsx
8185var $34 = createComponentFactory_default()({
8186  name: "MuiFilledInput",
8187  propDefaults: ({
8188    set
8189  }) => set({
8190    components: {},
8191    fullWidth: false,
8192    inputComponent: "input",
8193    multiline: false,
8194    type: "text",
8195    hiddenLabel: false
8196  }),
8197  selfPropNames: ["classes", "disableUnderline", "hiddenLabel"],
8198  utilityClass: getFilledInputUtilityClass,
8199  slotClasses: (ownerState) => ({
8200    root: ["root", !ownerState.disableUnderline && "underline"],
8201    input: ["input"]
8202  })
8203});
8204var FilledInputRoot = styled_default(InputBaseRoot, {
8205  /*shouldForwardProp: (prop) =>
8206    rootShouldForwardProp(prop) || prop === "classes",*/
8207  name: "MuiFilledInput",
8208  slot: "Root",
8209  overridesResolver: (props, styles3) => {
8210    const {
8211      ownerState
8212    } = props;
8213    return [...rootOverridesResolver(props, styles3), !ownerState.disableUnderline && styles3.underline];
8214  }
8215})(({
8216  theme,
8217  ownerState
8218}) => {
8219  const light = theme.palette.mode === "light";
8220  const bottomLineColor = light ? "rgba(0, 0, 0, 0.42)" : "rgba(255, 255, 255, 0.7)";
8221  const backgroundColor = light ? "rgba(0, 0, 0, 0.06)" : "rgba(255, 255, 255, 0.09)";
8222  return {
8223    position: "relative",
8224    backgroundColor,
8225    borderTopLeftRadius: theme.shape.borderRadius,
8226    borderTopRightRadius: theme.shape.borderRadius,
8227    transition: theme.transitions.create("background-color", {
8228      duration: theme.transitions.duration.shorter,
8229      easing: theme.transitions.easing.easeOut
8230    }),
8231    "&:hover": {
8232      backgroundColor: light ? "rgba(0, 0, 0, 0.09)" : "rgba(255, 255, 255, 0.13)",
8233      // Reset on touch devices, it doesn't add specificity
8234      "@media (hover: none)": {
8235        backgroundColor
8236      }
8237    },
8238    [`&.${filledInputClasses_default.focused}`]: {
8239      backgroundColor
8240    },
8241    [`&.${filledInputClasses_default.disabled}`]: {
8242      backgroundColor: light ? "rgba(0, 0, 0, 0.12)" : "rgba(255, 255, 255, 0.12)"
8243    },
8244    ...!ownerState.disableUnderline && {
8245      "&:after": {
8246        borderBottom: `2px solid ${theme.palette[ownerState.color].main}`,
8247        left: 0,
8248        bottom: 0,
8249        // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
8250        content: '""',
8251        position: "absolute",
8252        right: 0,
8253        transform: "scaleX(0)",
8254        transition: theme.transitions.create("transform", {
8255          duration: theme.transitions.duration.shorter,
8256          easing: theme.transitions.easing.easeOut
8257        }),
8258        pointerEvents: "none"
8259        // Transparent to the hover style.
8260      },
8261      [`&.${filledInputClasses_default.focused}:after`]: {
8262        transform: "scaleX(1)"
8263      },
8264      [`&.${filledInputClasses_default.error}:after`]: {
8265        borderBottomColor: theme.palette.error.main,
8266        transform: "scaleX(1)"
8267        // error is always underlined in red
8268      },
8269      "&:before": {
8270        borderBottom: `1px solid ${bottomLineColor}`,
8271        left: 0,
8272        bottom: 0,
8273        // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
8274        content: '"\\00a0"',
8275        position: "absolute",
8276        right: 0,
8277        transition: theme.transitions.create("border-bottom-color", {
8278          duration: theme.transitions.duration.shorter
8279        }),
8280        pointerEvents: "none"
8281        // Transparent to the hover style.
8282      },
8283      [`&:hover:not(.${filledInputClasses_default.disabled}):before`]: {
8284        borderBottom: `1px solid ${theme.palette.text.primary}`
8285      },
8286      [`&.${filledInputClasses_default.disabled}:before`]: {
8287        borderBottomStyle: "dotted"
8288      }
8289    },
8290    ...ownerState.startAdornment && {
8291      paddingLeft: 12
8292    },
8293    ...ownerState.endAdornment && {
8294      paddingRight: 12
8295    },
8296    ...ownerState.multiline && {
8297      padding: "25px 12px 8px",
8298      ...ownerState.size === "small" && {
8299        paddingTop: 21,
8300        paddingBottom: 4
8301      },
8302      ...ownerState.hiddenLabel && {
8303        paddingTop: 16,
8304        paddingBottom: 17
8305      }
8306    }
8307  };
8308});
8309var FilledInputInput = styled_default(InputBaseComponent, {
8310  name: "MuiFilledInput",
8311  slot: "Input",
8312  overridesResolver: inputOverridesResolver
8313})(({
8314  theme,
8315  ownerState
8316}) => ({
8317  paddingTop: 25,
8318  paddingRight: 12,
8319  paddingBottom: 8,
8320  paddingLeft: 12,
8321  "&:-webkit-autofill": {
8322    WebkitBoxShadow: theme.palette.mode === "light" ? null : "0 0 0 100px #266798 inset",
8323    WebkitTextFillColor: theme.palette.mode === "light" ? null : "#fff",
8324    caretColor: theme.palette.mode === "light" ? null : "#fff",
8325    borderTopLeftRadius: "inherit",
8326    borderTopRightRadius: "inherit"
8327  },
8328  ...ownerState.size === "small" && {
8329    paddingTop: 21,
8330    paddingBottom: 4
8331  },
8332  ...ownerState.hiddenLabel && {
8333    paddingTop: 16,
8334    paddingBottom: 17
8335  },
8336  ...ownerState.multiline && {
8337    paddingTop: 0,
8338    paddingBottom: 0,
8339    paddingLeft: 0,
8340    paddingRight: 0
8341  },
8342  ...ownerState.startAdornment && {
8343    paddingLeft: 0
8344  },
8345  ...ownerState.endAdornment && {
8346    paddingRight: 0
8347  },
8348  ...ownerState.hiddenLabel && ownerState.size === "small" && {
8349    paddingTop: 8,
8350    paddingBottom: 9
8351  }
8352}));
8353var FilledInput = $34.component(function FilledInput2({
8354  allProps,
8355  classes,
8356  otherProps,
8357  props
8358}) {
8359  const componentProps = createMemo(() => {
8360    const filledInputComponentsProps = {
8361      root: {
8362        ownerState: allProps
8363      },
8364      input: {
8365        ownerState: allProps
8366      }
8367    };
8368    return otherProps.componentsProps ? deepmerge(otherProps.componentsProps, filledInputComponentsProps) : filledInputComponentsProps;
8369  });
8370  const allClasses = mergeProps(() => props.classes || {}, classes);
8371  return createComponent(InputBase_default, mergeProps(otherProps, {
8372    get components() {
8373      return {
8374        Root: FilledInputRoot,
8375        Input: FilledInputInput,
8376        ...otherProps.components || {}
8377      };
8378    },
8379    get componentsProps() {
8380      return componentProps();
8381    },
8382    classes: allClasses
8383  }));
8384});
8385var FilledInput_default = FilledInput;
8386

vendor: 316 bytes, lines 8387-8392

8387// node_modules/@suid/material/FormControl/formControlClasses.js
8388function getFormControlUtilityClasses(slot) {
8389  return generateUtilityClass("MuiFormControl", slot);
8390}
8391var formControlClasses = generateUtilityClasses("MuiFormControl", ["root", "marginNone", "marginNormal", "marginDense", "fullWidth", "disabled"]);
8392

vendor: 3,791 bytes, lines 8393-8545

8393// node_modules/@suid/material/FormControl/FormControl.jsx
8394var $35 = createComponentFactory_default()({
8395  name: "MuiFormControl",
8396  selfPropNames: ["children", "classes", "color", "disabled", "error", "focused", "fullWidth", "hiddenLabel", "margin", "required", "size", "variant"],
8397  propDefaults: ({
8398    set
8399  }) => set({
8400    color: "primary",
8401    component: "div",
8402    disabled: false,
8403    error: false,
8404    fullWidth: false,
8405    hiddenLabel: false,
8406    margin: "none",
8407    required: false,
8408    size: "medium",
8409    variant: "outlined"
8410  }),
8411  utilityClass: getFormControlUtilityClasses,
8412  slotClasses: (ownerState) => ({
8413    root: ["root", ownerState.margin !== "none" && `margin${capitalize_default(ownerState.margin)}`, ownerState.fullWidth && "fullWidth"]
8414  })
8415});
8416var FormControlRoot = styled_default("div", {
8417  name: "MuiFormControl",
8418  slot: "Root",
8419  overridesResolver: ({
8420    ownerState
8421  }, styles3) => {
8422    return {
8423      ...styles3.root,
8424      ...styles3[`margin${capitalize_default(ownerState.margin)}`],
8425      ...ownerState.fullWidth && styles3.fullWidth
8426    };
8427  }
8428})(({
8429  ownerState
8430}) => ({
8431  display: "inline-flex",
8432  flexDirection: "column",
8433  position: "relative",
8434  // Reset fieldset default style.
8435  minWidth: 0,
8436  padding: 0,
8437  margin: 0,
8438  border: 0,
8439  verticalAlign: "top",
8440  ...ownerState.margin === "normal" && {
8441    marginTop: 16,
8442    marginBottom: 8
8443  },
8444  ...ownerState.margin === "dense" && {
8445    marginTop: 8,
8446    marginBottom: 4
8447  },
8448  ...ownerState.fullWidth && {
8449    width: "100%"
8450  }
8451}));
8452var FormControl = $35.component(function FormControl2({
8453  allProps,
8454  classes,
8455  otherProps,
8456  props
8457}) {
8458  const [filled, setFilled] = createSignal(false);
8459  const [focusedState, setFocused] = createSignal(false);
8460  createEffect(() => {
8461    if (props.disabled && focusedState()) setFocused(false);
8462  });
8463  const focused = () => props.focused !== void 0 && !props.disabled ? props.focused : focusedState();
8464  let registerEffect;
8465  if (true) {
8466    const registeredInput = {
8467      ref: false
8468    };
8469    registerEffect = () => {
8470      if (registeredInput.ref) {
8471        console.error(["MUI: There are multiple `InputBase` components inside a FormControl.", "This creates visual inconsistencies, only use one `InputBase`."].join("\n"));
8472      }
8473      registeredInput.ref = true;
8474    };
8475  }
8476  return createComponent(FormControlContext_default.Provider, {
8477    value: {
8478      get adornedStart() {
8479        return false;
8480      },
8481      setAdornedStart: () => {
8482        return void 0;
8483      },
8484      get margin() {
8485        return props.margin;
8486      },
8487      get color() {
8488        return props.color;
8489      },
8490      get disabled() {
8491        return props.disabled;
8492      },
8493      get error() {
8494        return props.error;
8495      },
8496      get filled() {
8497        return filled();
8498      },
8499      get focused() {
8500        return focused();
8501      },
8502      get fullWidth() {
8503        return props.fullWidth;
8504      },
8505      get hiddenLabel() {
8506        return props.hiddenLabel;
8507      },
8508      get size() {
8509        return props.size;
8510      },
8511      onBlur: () => {
8512        setFocused(false);
8513      },
8514      onEmpty: () => {
8515        setFilled(false);
8516      },
8517      onFilled: () => {
8518        setFilled(true);
8519      },
8520      onFocus: () => {
8521        setFocused(true);
8522      },
8523      registerEffect,
8524      get required() {
8525        return props.required;
8526      },
8527      get variant() {
8528        return props.variant;
8529      }
8530    },
8531    get children() {
8532      return createComponent(FormControlRoot, mergeProps(otherProps, {
8533        ownerState: allProps,
8534        get ["class"]() {
8535          return clsx_m_default(classes.root, otherProps.class);
8536        },
8537        get children() {
8538          return props.children;
8539        }
8540      }));
8541    }
8542  });
8543});
8544var FormControl_default = FormControl;
8545

vendor: 437 bytes, lines 8546-8562

8546// node_modules/@suid/material/FormHelperText/formHelperTextClasses.js
8547function getFormHelperTextUtilityClasses(slot) {
8548  return generateUtilityClass("MuiFormHelperText", slot);
8549}
8550var formHelperTextClasses = generateUtilityClasses("MuiFormHelperText", [
8551  "root",
8552  "error",
8553  "disabled",
8554  "sizeSmall",
8555  "sizeMedium",
8556  "contained",
8557  "focused",
8558  "filled",
8559  "required"
8560]);
8561var formHelperTextClasses_default = formHelperTextClasses;
8562

vendor: 3,119 bytes, lines 8563-8669

8563// node_modules/@suid/material/FormHelperText/FormHelperText.jsx
8564var _tmpl$6 = /* @__PURE__ */ template(`<span class="notranslate">&#8203;`);
8565var $36 = createComponentFactory_default()({
8566  name: "MuiFormHelperText",
8567  propDefaults: ({
8568    set
8569  }) => set({
8570    component: "p"
8571  }),
8572  selfPropNames: ["children", "classes", "disabled", "error", "filled", "focused", "margin", "required", "variant"],
8573  utilityClass: getFormHelperTextUtilityClasses,
8574  autoCallUseClasses: false,
8575  slotClasses: (ownerState) => ({
8576    root: ["root", !!ownerState.disabled && "disabled", !!ownerState.error && "error", !!ownerState.size && `size${capitalize_default(ownerState.size)}`, ownerState.contained && "contained", !!ownerState.focused && "focused", !!ownerState.filled && "filled", !!ownerState.required && "required"]
8577  })
8578});
8579var FormHelperTextRoot = styled_default("p", {
8580  name: "MuiFormHelperText",
8581  slot: "Root",
8582  overridesResolver: (props, styles3) => {
8583    const {
8584      ownerState
8585    } = props;
8586    return [styles3.root, ownerState.size && styles3[`size${capitalize_default(ownerState.size)}`], ownerState.contained && styles3.contained, ownerState.filled && styles3.filled];
8587  }
8588})(({
8589  theme,
8590  ownerState
8591}) => ({
8592  color: theme.palette.text.secondary,
8593  ...theme.typography.caption,
8594  textAlign: "left",
8595  marginTop: 3,
8596  marginRight: 0,
8597  marginBottom: 0,
8598  marginLeft: 0,
8599  [`&.${formHelperTextClasses_default.disabled}`]: {
8600    color: theme.palette.text.disabled
8601  },
8602  [`&.${formHelperTextClasses_default.error}`]: {
8603    color: theme.palette.error.main
8604  },
8605  ...ownerState.size === "small" && {
8606    marginTop: 4
8607  },
8608  ...ownerState.contained && {
8609    marginLeft: 14,
8610    marginRight: 14
8611  }
8612}));
8613var FormHelperText = $36.component(function FormHelperText2({
8614  allProps,
8615  otherProps,
8616  props
8617}) {
8618  const muiFormControl = useFormControl();
8619  const fcs = formControlState({
8620    props: allProps,
8621    muiFormControl,
8622    states: ["variant", "size", "disabled", "error", "filled", "focused", "required"]
8623  });
8624  const ownerState = mergeProps(allProps, {
8625    get contained() {
8626      return fcs.variant === "filled" || fcs.variant === "outlined";
8627    },
8628    get variant() {
8629      return fcs.variant;
8630    },
8631    get size() {
8632      return fcs.size;
8633    },
8634    get disabled() {
8635      return fcs.disabled;
8636    },
8637    get error() {
8638      return fcs.error;
8639    },
8640    get filled() {
8641      return fcs.filled;
8642    },
8643    get focused() {
8644      return fcs.focused;
8645    },
8646    get required() {
8647      return fcs.required;
8648    }
8649  });
8650  const classes = $36.useClasses(ownerState);
8651  const resolved = children(() => props.children);
8652  return createComponent(FormHelperTextRoot, mergeProps(otherProps, {
8653    get as() {
8654      return otherProps.component;
8655    },
8656    ownerState,
8657    get ["class"]() {
8658      return clsx_m_default(classes.root, otherProps.class);
8659    },
8660    get children() {
8661      return memo(() => resolved() === " ")() ? (
8662        // notranslate needed while Google Translate will not fix zero-width space issue
8663        _tmpl$6()
8664      ) : resolved();
8665    }
8666  }));
8667});
8668var FormHelperText_default = FormHelperText;
8669

vendor: 311 bytes, lines 8670-8679

8670// node_modules/@suid/material/Input/inputClasses.js
8671function getInputUtilityClass(slot) {
8672  return generateUtilityClass("MuiInput", slot);
8673}
8674var inputClasses = {
8675  ...inputBaseClasses_default,
8676  ...generateUtilityClasses("MuiInput", ["root", "underline", "input"])
8677};
8678var inputClasses_default = inputClasses;
8679

vendor: 3,938 bytes, lines 8680-8811

8680// node_modules/@suid/material/Input/Input.jsx
8681var $37 = createComponentFactory_default()({
8682  name: "MuiInput",
8683  propDefaults: ({
8684    set
8685  }) => set({
8686    components: {},
8687    fullWidth: false,
8688    inputComponent: "input",
8689    multiline: false,
8690    type: "text"
8691  }),
8692  selfPropNames: ["classes", "disableUnderline"],
8693  utilityClass: getInputUtilityClass,
8694  slotClasses: (ownerState) => ({
8695    root: ["root", !ownerState.disableUnderline && "underline"],
8696    input: ["input"]
8697  })
8698});
8699var InputRoot = styled_default(InputBaseRoot, {
8700  skipProps: skipRootProps.filter((v) => v !== "classes"),
8701  name: "MuiInput",
8702  slot: "Root",
8703  overridesResolver: (props, styles3) => {
8704    const {
8705      ownerState
8706    } = props;
8707    return [...rootOverridesResolver(props, styles3), !ownerState.disableUnderline && styles3.underline];
8708  }
8709})(({
8710  theme,
8711  ownerState
8712}) => {
8713  const light = theme.palette.mode === "light";
8714  const bottomLineColor = light ? "rgba(0, 0, 0, 0.42)" : "rgba(255, 255, 255, 0.7)";
8715  return {
8716    position: "relative",
8717    ...ownerState.formControl && {
8718      "label + &": {
8719        marginTop: 16
8720      }
8721    },
8722    ...!ownerState.disableUnderline && {
8723      "&:after": {
8724        borderBottom: `2px solid ${theme.palette[ownerState.color].main}`,
8725        left: 0,
8726        bottom: 0,
8727        // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
8728        content: '""',
8729        position: "absolute",
8730        right: 0,
8731        transform: "scaleX(0)",
8732        transition: theme.transitions.create("transform", {
8733          duration: theme.transitions.duration.shorter,
8734          easing: theme.transitions.easing.easeOut
8735        }),
8736        pointerEvents: "none"
8737        // Transparent to the hover style.
8738      },
8739      [`&.${inputClasses_default.focused}:after`]: {
8740        transform: "scaleX(1)"
8741      },
8742      [`&.${inputClasses_default.error}:after`]: {
8743        borderBottomColor: theme.palette.error.main,
8744        transform: "scaleX(1)"
8745        // error is always underlined in red
8746      },
8747      "&:before": {
8748        borderBottom: `1px solid ${bottomLineColor}`,
8749        left: 0,
8750        bottom: 0,
8751        // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
8752        content: '"\\00a0"',
8753        position: "absolute",
8754        right: 0,
8755        transition: theme.transitions.create("border-bottom-color", {
8756          duration: theme.transitions.duration.shorter
8757        }),
8758        pointerEvents: "none"
8759        // Transparent to the hover style.
8760      },
8761      [`&:hover:not(.${inputClasses_default.disabled}):before`]: {
8762        borderBottom: `2px solid ${theme.palette.text.primary}`,
8763        // Reset on touch devices, it doesn't add specificity
8764        "@media (hover: none)": {
8765          borderBottom: `1px solid ${bottomLineColor}`
8766        }
8767      },
8768      [`&.${inputClasses_default.disabled}:before`]: {
8769        borderBottomStyle: "dotted"
8770      }
8771    }
8772  };
8773});
8774var InputInput = styled_default(InputBaseComponent, {
8775  name: "MuiInput",
8776  slot: "Input",
8777  overridesResolver: inputOverridesResolver
8778})({});
8779var Input = $37.component(function Input2({
8780  classes,
8781  otherProps,
8782  props
8783}) {
8784  const componentsProps = createMemo(() => {
8785    const ownerState = {
8786      disableUnderline: props.disableUnderline
8787    };
8788    const inputComponentsProps = {
8789      root: {
8790        ownerState
8791      }
8792    };
8793    return otherProps.componentsProps ? deepmerge(otherProps.componentsProps, inputComponentsProps) : inputComponentsProps;
8794  });
8795  const allClasses = mergeProps(classes, () => props.classes || {});
8796  return createComponent(InputBase_default, mergeProps(otherProps, {
8797    get components() {
8798      return {
8799        Root: InputRoot,
8800        Input: InputInput,
8801        ...otherProps.components || {}
8802      };
8803    },
8804    get componentsProps() {
8805      return componentsProps();
8806    },
8807    classes: allClasses
8808  }));
8809});
8810var Input_default = Input;
8811

vendor: 385 bytes, lines 8812-8827

8812// node_modules/@suid/material/FormLabel/formLabelClasses.js
8813function getFormLabelUtilityClasses(slot) {
8814  return generateUtilityClass("MuiFormLabel", slot);
8815}
8816var formLabelClasses = generateUtilityClasses("MuiFormLabel", [
8817  "root",
8818  "colorSecondary",
8819  "focused",
8820  "disabled",
8821  "error",
8822  "filled",
8823  "required",
8824  "asterisk"
8825]);
8826var formLabelClasses_default = formLabelClasses;
8827

vendor: 3,211 bytes, lines 8828-8948

8828// node_modules/@suid/material/FormLabel/FormLabel.jsx
8829var $38 = createComponentFactory_default()({
8830  name: "MuiFormLabel",
8831  propDefaults: ({
8832    set
8833  }) => set({
8834    component: "label"
8835  }),
8836  selfPropNames: ["children", "classes", "color", "disabled", "error", "filled", "focused", "required"],
8837  autoCallUseClasses: false,
8838  utilityClass: getFormLabelUtilityClasses,
8839  slotClasses: (ownerState) => ({
8840    root: ["root", `color${capitalize_default(ownerState.color)}`, !!ownerState.disabled && "disabled", !!ownerState.error && "error", !!ownerState.filled && "filled", !!ownerState.focused && "focused", !!ownerState.required && "required"],
8841    asterisk: ["asterisk", !!ownerState.error && "error"]
8842  })
8843});
8844var FormLabelRoot = styled_default("label", {
8845  name: "MuiFormLabel",
8846  slot: "Root",
8847  overridesResolver: ({
8848    ownerState
8849  }, styles3) => {
8850    return {
8851      ...styles3.root,
8852      ...ownerState.color === "secondary" && styles3.colorSecondary,
8853      ...ownerState.filled && styles3.filled
8854    };
8855  }
8856})(({
8857  theme,
8858  ownerState
8859}) => ({
8860  color: theme.palette.text.secondary,
8861  ...theme.typography.body1,
8862  lineHeight: "1.4375em",
8863  padding: 0,
8864  position: "relative",
8865  [`&.${formLabelClasses_default.focused}`]: {
8866    color: theme.palette[ownerState.color].main
8867  },
8868  [`&.${formLabelClasses_default.disabled}`]: {
8869    color: theme.palette.text.disabled
8870  },
8871  [`&.${formLabelClasses_default.error}`]: {
8872    color: theme.palette.error.main
8873  }
8874}));
8875var AsteriskComponent = styled_default("span", {
8876  name: "MuiFormLabel",
8877  slot: "Asterisk",
8878  overridesResolver: (props, styles3) => styles3.asterisk
8879})(({
8880  theme
8881}) => ({
8882  [`&.${formLabelClasses_default.error}`]: {
8883    color: theme.palette.error.main
8884  }
8885}));
8886var FormLabel = $38.component(function FormLabel2({
8887  allProps,
8888  otherProps,
8889  props
8890}) {
8891  const muiFormControl = useFormControl();
8892  const fcs = formControlState({
8893    props: allProps,
8894    muiFormControl,
8895    states: ["color", "required", "focused", "disabled", "error", "filled"]
8896  });
8897  const ownerState = mergeProps(allProps, {
8898    get color() {
8899      return fcs.color || "primary";
8900    },
8901    get disabled() {
8902      return fcs.disabled;
8903    },
8904    get error() {
8905      return fcs.error;
8906    },
8907    get filled() {
8908      return fcs.filled;
8909    },
8910    get focused() {
8911      return fcs.focused;
8912    },
8913    get required() {
8914      return fcs.required;
8915    }
8916  });
8917  const classes = $38.useClasses(ownerState);
8918  return createComponent(FormLabelRoot, mergeProps(otherProps, {
8919    get as() {
8920      return otherProps.component;
8921    },
8922    ownerState,
8923    get ["class"]() {
8924      return clsx_m_default(classes.root, otherProps.class);
8925    },
8926    get children() {
8927      return [memo(() => props.children), createComponent(Show, {
8928        get when() {
8929          return fcs.required;
8930        },
8931        get children() {
8932          return createComponent(AsteriskComponent, {
8933            ownerState,
8934            "aria-hidden": true,
8935            get ["class"]() {
8936              return classes.asterisk;
8937            },
8938            get children() {
8939              return ["\u2009", "*"];
8940            }
8941          });
8942        }
8943      })];
8944    }
8945  }));
8946});
8947var FormLabel_default = FormLabel;
8948

vendor: 408 bytes, lines 8949-8968

8949// node_modules/@suid/material/InputLabel/inputLabelClasses.js
8950function getInputLabelUtilityClasses(slot) {
8951  return generateUtilityClass("MuiInputLabel", slot);
8952}
8953var inputLabelClasses = generateUtilityClasses("MuiInputLabel", [
8954  "root",
8955  "focused",
8956  "disabled",
8957  "error",
8958  "required",
8959  "asterisk",
8960  "formControl",
8961  "sizeSmall",
8962  "shrink",
8963  "animated",
8964  "standard",
8965  "filled",
8966  "outlined"
8967]);
8968

vendor: 4,803 bytes, lines 8969-9114

8969// node_modules/@suid/material/InputLabel/InputLabel.jsx
8970var $39 = createComponentFactory_default()({
8971  name: "MuiInputLabel",
8972  propDefaults: ({
8973    set
8974  }) => set({
8975    disableAnimation: false
8976  }),
8977  selfPropNames: ["children", "classes", "color", "disableAnimation", "disabled", "error", "focused", "margin", "required", "shrink", "variant"],
8978  autoCallUseClasses: false,
8979  utilityClass: getInputLabelUtilityClasses,
8980  slotClasses: (ownerState) => ({
8981    root: ["root", !!ownerState.formControl && "formControl", !ownerState.disableAnimation && "animated", !!ownerState.shrink && "shrink", ownerState.size === "small" && "sizeSmall", !!ownerState.variant && ownerState.variant],
8982    asterisk: [!!ownerState.required && "asterisk"]
8983  })
8984});
8985var InputLabelRoot = styled_default(FormLabel_default, {
8986  skipProps: skipRootProps.filter((v) => v !== "classes"),
8987  name: "MuiInputLabel",
8988  slot: "Root",
8989  overridesResolver: (props, styles3) => {
8990    const {
8991      ownerState
8992    } = props;
8993    return [{
8994      [`& .${formLabelClasses_default.asterisk}`]: styles3.asterisk
8995    }, styles3.root, ownerState.formControl && styles3.formControl, ownerState.size === "small" && styles3.sizeSmall, ownerState.shrink && styles3.shrink, !ownerState.disableAnimation && styles3.animated, styles3[ownerState.variant]];
8996  }
8997})(({
8998  theme,
8999  ownerState
9000}) => ({
9001  display: "block",
9002  transformOrigin: "top left",
9003  whiteSpace: "nowrap",
9004  overflow: "hidden",
9005  textOverflow: "ellipsis",
9006  maxWidth: "100%",
9007  ...ownerState.formControl && {
9008    position: "absolute",
9009    left: 0,
9010    top: 0,
9011    // slight alteration to spec spacing to match visual spec result
9012    transform: "translate(0, 20px) scale(1)"
9013  },
9014  ...ownerState.size === "small" && {
9015    // Compensation for the `Input.inputSizeSmall` style.
9016    transform: "translate(0, 17px) scale(1)"
9017  },
9018  ...ownerState.shrink && {
9019    transform: "translate(0, -1.5px) scale(0.75)",
9020    transformOrigin: "top left",
9021    maxWidth: "133%"
9022  },
9023  ...!ownerState.disableAnimation && {
9024    transition: theme.transitions.create(["color", "transform", "max-width"], {
9025      duration: theme.transitions.duration.shorter,
9026      easing: theme.transitions.easing.easeOut
9027    })
9028  },
9029  ...ownerState.variant === "filled" && {
9030    // Chrome's autofill feature gives the input field a yellow background.
9031    // Since the input field is behind the label in the HTML tree,
9032    // the input field is drawn last and hides the label with an opaque background color.
9033    // zIndex: 1 will raise the label above opaque background-colors of input.
9034    zIndex: 1,
9035    pointerEvents: "none",
9036    transform: "translate(12px, 16px) scale(1)",
9037    maxWidth: "calc(100% - 24px)",
9038    ...ownerState.size === "small" && {
9039      transform: "translate(12px, 13px) scale(1)"
9040    },
9041    ...ownerState.shrink && {
9042      userSelect: "none",
9043      pointerEvents: "auto",
9044      transform: "translate(12px, 7px) scale(0.75)",
9045      maxWidth: "calc(133% - 24px)",
9046      ...ownerState.size === "small" && {
9047        transform: "translate(12px, 4px) scale(0.75)"
9048      }
9049    }
9050  },
9051  ...ownerState.variant === "outlined" && {
9052    // see comment above on filled.zIndex
9053    zIndex: 1,
9054    pointerEvents: "none",
9055    transform: "translate(14px, 16px) scale(1)",
9056    maxWidth: "calc(100% - 24px)",
9057    ...ownerState.size === "small" && {
9058      transform: "translate(14px, 9px) scale(1)"
9059    },
9060    ...ownerState.shrink && {
9061      userSelect: "none",
9062      pointerEvents: "auto",
9063      maxWidth: "calc(133% - 24px)",
9064      transform: "translate(14px, -9px) scale(0.75)"
9065    }
9066  }
9067}));
9068var InputLabel = $39.component(function InputLabel2({
9069  allProps,
9070  props
9071}) {
9072  const muiFormControl = useFormControl();
9073  const [, baseProps] = splitProps(allProps, ["disableAnimation", "margin", "shrink", "variant"]);
9074  const shrink = () => {
9075    let shrink2 = props.shrink;
9076    if (typeof shrink2 === "undefined" && muiFormControl) {
9077      shrink2 = muiFormControl.filled || muiFormControl.focused || muiFormControl.adornedStart;
9078    }
9079    return shrink2;
9080  };
9081  const fcs = formControlState({
9082    props: allProps,
9083    muiFormControl,
9084    states: ["size", "variant", "required"]
9085  });
9086  const ownerState = mergeProps(allProps, {
9087    get formControl() {
9088      return muiFormControl;
9089    },
9090    get shrink() {
9091      return shrink();
9092    },
9093    get size() {
9094      return fcs.size;
9095    },
9096    get variant() {
9097      return fcs.variant;
9098    },
9099    get required() {
9100      return fcs.required;
9101    }
9102  });
9103  const classes = $39.useClasses(ownerState);
9104  const allClasses = mergeProps(classes, () => props.classes || {});
9105  return createComponent(InputLabelRoot, mergeProps(baseProps, {
9106    get ["data-shrink"]() {
9107      return shrink();
9108    },
9109    ownerState,
9110    classes: allClasses
9111  }));
9112});
9113var InputLabel_default = InputLabel;
9114

vendor: 2,762 bytes, lines 9115-9222

9115// node_modules/@suid/material/OutlinedInput/NotchedOutline.jsx
9116var _tmpl$7 = /* @__PURE__ */ template(`<span>`);
9117var _tmpl$23 = /* @__PURE__ */ template(`<span class="notranslate">&#8203;`);
9118var $40 = createComponentFactory_default()({
9119  name: "MuiNotchedOutline",
9120  selfPropNames: ["disabled", "error", "focused", "label", "notched"]
9121});
9122var NotchedOutlineRoot = styled_default("fieldset")({
9123  textAlign: "left",
9124  position: "absolute",
9125  bottom: 0,
9126  right: 0,
9127  top: -5,
9128  left: 0,
9129  margin: 0,
9130  padding: "0 8px",
9131  pointerEvents: "none",
9132  borderRadius: "inherit",
9133  borderStyle: "solid",
9134  borderWidth: 1,
9135  overflow: "hidden",
9136  minWidth: "0%"
9137});
9138var NotchedOutlineLegend = styled_default("legend")(({
9139  ownerState,
9140  theme
9141}) => ({
9142  float: "unset",
9143  ...!ownerState.withLabel && {
9144    padding: 0,
9145    lineHeight: "11px",
9146    transition: theme.transitions.create("width", {
9147      duration: 150,
9148      easing: theme.transitions.easing.easeOut
9149    })
9150  },
9151  ...ownerState.withLabel && {
9152    display: "block",
9153    width: "auto",
9154    padding: 0,
9155    height: 11,
9156    fontSize: "0.75em",
9157    visibility: "hidden",
9158    maxWidth: 0.01,
9159    transition: theme.transitions.create("max-width", {
9160      duration: 50,
9161      easing: theme.transitions.easing.easeOut
9162    }),
9163    whiteSpace: "nowrap",
9164    "& > span": {
9165      paddingLeft: 5,
9166      paddingRight: 5,
9167      display: "inline-block"
9168    },
9169    ...ownerState.notched && {
9170      maxWidth: "100%",
9171      transition: theme.transitions.create("max-width", {
9172        duration: 100,
9173        easing: theme.transitions.easing.easeOut,
9174        delay: 50
9175      })
9176    }
9177  }
9178}));
9179var NotchedOutline = $40.component(function NotchedOutline2({
9180  allProps,
9181  otherProps,
9182  props
9183}) {
9184  const withLabel = () => props.label != null && props.label !== "";
9185  const ownerState = mergeProps(allProps, {
9186    get withLabel() {
9187      return withLabel();
9188    }
9189  });
9190  return createComponent(NotchedOutlineRoot, mergeProps(otherProps, {
9191    "aria-hidden": true,
9192    get ["class"]() {
9193      return otherProps.class;
9194    },
9195    ownerState,
9196    get children() {
9197      return createComponent(NotchedOutlineLegend, {
9198        ownerState,
9199        get children() {
9200          return createComponent(Show, {
9201            get when() {
9202              return withLabel();
9203            },
9204            get fallback() {
9205              return (
9206                // notranslate needed while Google Translate will not fix zero-width space issue
9207                _tmpl$23()
9208              );
9209            },
9210            get children() {
9211              const _el$ = _tmpl$7();
9212              insert(_el$, () => props.label);
9213              return _el$;
9214            }
9215          });
9216        }
9217      });
9218    }
9219  }));
9220});
9221var NotchedOutline_default = NotchedOutline;
9222

vendor: 396 bytes, lines 9223-9236

9223// node_modules/@suid/material/OutlinedInput/outlinedInputClasses.js
9224function getOutlinedInputUtilityClass(slot) {
9225  return generateUtilityClass("MuiOutlinedInput", slot);
9226}
9227var outlinedInputClasses = {
9228  ...inputBaseClasses_default,
9229  ...generateUtilityClasses("MuiOutlinedInput", [
9230    "root",
9231    "notchedOutline",
9232    "input"
9233  ])
9234};
9235var outlinedInputClasses_default = outlinedInputClasses;
9236

vendor: 4,360 bytes, lines 9237-9384

9237// node_modules/@suid/material/OutlinedInput/OutlinedInput.jsx
9238var $41 = createComponentFactory_default()({
9239  name: "MuiOutlinedInput",
9240  propDefaults: ({
9241    set
9242  }) => set({
9243    components: {},
9244    fullWidth: false,
9245    inputComponent: "input",
9246    multiline: false,
9247    type: "text"
9248  }),
9249  selfPropNames: ["classes", "label", "notched"],
9250  utilityClass: getOutlinedInputUtilityClass,
9251  slotClasses: () => ({
9252    root: ["root"],
9253    notchedOutline: ["notchedOutline"],
9254    input: ["input"]
9255  })
9256});
9257var OutlinedInputRoot = styled_default(InputBaseRoot, {
9258  skipProps: skipRootProps.filter((v) => v !== "classes"),
9259  name: "MuiOutlinedInput",
9260  slot: "Root",
9261  overridesResolver: rootOverridesResolver
9262})(({
9263  theme,
9264  ownerState
9265}) => {
9266  const borderColor = theme.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)";
9267  return {
9268    position: "relative",
9269    borderRadius: theme.shape.borderRadius,
9270    [`&:hover .${outlinedInputClasses_default.notchedOutline}`]: {
9271      borderColor: theme.palette.text.primary
9272    },
9273    // Reset on touch devices, it doesn't add specificity
9274    "@media (hover: none)": {
9275      [`&:hover .${outlinedInputClasses_default.notchedOutline}`]: {
9276        borderColor
9277      }
9278    },
9279    [`&.${outlinedInputClasses_default.focused} .${outlinedInputClasses_default.notchedOutline}`]: {
9280      // [review] ownerState.color is not required by MUI
9281      borderColor: theme.palette[ownerState.color].main,
9282      borderWidth: 2
9283    },
9284    [`&.${outlinedInputClasses_default.error} .${outlinedInputClasses_default.notchedOutline}`]: {
9285      borderColor: theme.palette.error.main
9286    },
9287    [`&.${outlinedInputClasses_default.disabled} .${outlinedInputClasses_default.notchedOutline}`]: {
9288      borderColor: theme.palette.action.disabled
9289    },
9290    ...ownerState.startAdornment && {
9291      paddingLeft: 14
9292    },
9293    ...ownerState.endAdornment && {
9294      paddingRight: 14
9295    },
9296    ...ownerState.multiline && {
9297      padding: "16.5px 14px",
9298      ...ownerState.size === "small" && {
9299        padding: "8.5px 14px"
9300      }
9301    }
9302  };
9303});
9304var NotchedOutlineRoot2 = styled_default(NotchedOutline_default, {
9305  name: "MuiOutlinedInput",
9306  slot: "NotchedOutline",
9307  overridesResolver: (props, styles3) => styles3.notchedOutline
9308})(({
9309  theme
9310}) => ({
9311  borderColor: theme.palette.mode === "light" ? "rgba(0, 0, 0, 0.23)" : "rgba(255, 255, 255, 0.23)"
9312}));
9313var OutlinedInputInput = styled_default(InputBaseComponent, {
9314  name: "MuiOutlinedInput",
9315  slot: "Input",
9316  overridesResolver: inputOverridesResolver
9317})(({
9318  theme,
9319  ownerState
9320}) => ({
9321  padding: "16.5px 14px",
9322  "&:-webkit-autofill": {
9323    WebkitBoxShadow: theme.palette.mode === "light" ? null : "0 0 0 100px #266798 inset",
9324    WebkitTextFillColor: theme.palette.mode === "light" ? null : "#fff",
9325    caretColor: theme.palette.mode === "light" ? null : "#fff",
9326    borderRadius: "inherit"
9327  },
9328  ...ownerState.size === "small" && {
9329    padding: "8.5px 14px"
9330  },
9331  ...ownerState.multiline && {
9332    padding: 0
9333  },
9334  ...ownerState.startAdornment && {
9335    paddingLeft: 0
9336  },
9337  ...ownerState.endAdornment && {
9338    paddingRight: 0
9339  }
9340}));
9341var OutlinedInput = $41.component(function OutlinedInput2({
9342  allProps,
9343  classes,
9344  otherProps,
9345  props
9346}) {
9347  const muiFormControl = useFormControl();
9348  const fcs = formControlState({
9349    props: allProps,
9350    muiFormControl,
9351    states: ["required"]
9352  });
9353  const label = createMemo(() => {
9354    const label2 = props.label;
9355    return label2 != null && label2 !== "" && fcs.required ? [label2, "\xA0", "*"] : label2;
9356  });
9357  const allClasses = mergeProps(classes, () => props.classes || {}, {
9358    notchedOutline: null
9359  });
9360  return createComponent(InputBase_default, mergeProps({
9361    renderSuffix: (state) => createComponent(NotchedOutlineRoot2, {
9362      get ["class"]() {
9363        return classes.notchedOutline;
9364      },
9365      get label() {
9366        return label();
9367      },
9368      get notched() {
9369        return memo(() => typeof props.notched !== "undefined")() ? props.notched : Boolean(state.startAdornment || state.filled || state.focused);
9370      }
9371    })
9372  }, otherProps, {
9373    get components() {
9374      return {
9375        Root: OutlinedInputRoot,
9376        Input: OutlinedInputInput,
9377        ...otherProps.components || {}
9378      };
9379    },
9380    classes: allClasses
9381  }));
9382});
9383var OutlinedInput_default = OutlinedInput;
9384

vendor: 232 bytes, lines 9385-9390

9385// node_modules/@suid/material/TextField/textFieldClasses.js
9386function getTextFieldUtilityClass(slot) {
9387  return generateUtilityClass("MuiTextField", slot);
9388}
9389var textFieldClasses = generateUtilityClasses("MuiTextField", ["root"]);
9390

vendor: 4,665 bytes, lines 9391-9567

9391// node_modules/@suid/material/TextField/TextField.jsx
9392var $42 = createComponentFactory_default()({
9393  name: "MuiTextField",
9394  propDefaults: ({
9395    set
9396  }) => set({
9397    autoFocus: false,
9398    color: "primary",
9399    disabled: false,
9400    error: false,
9401    fullWidth: false,
9402    multiline: false,
9403    required: false,
9404    select: false,
9405    variant: "outlined"
9406  }),
9407  selfPropNames: ["FormHelperTextProps", "InputLabelProps", "InputProps", "autoComplete", "autoFocus", "children", "classes", "color", "defaultValue", "disabled", "error", "fullWidth", "helperText", "id", "inputProps", "inputRef", "label", "maxRows", "minRows", "multiline", "name", "onBlur", "onChange", "onFocus", "placeholder", "required", "rows", "select", "size", "type", "value", "variant"],
9408  utilityClass: getTextFieldUtilityClass,
9409  slotClasses: () => ({
9410    root: ["root"]
9411  })
9412});
9413var variantComponent = {
9414  standard: Input_default,
9415  filled: FilledInput_default,
9416  outlined: OutlinedInput_default
9417};
9418var TextFieldRoot = styled_default(FormControl_default, {
9419  name: "MuiTextField",
9420  slot: "Root",
9421  overridesResolver: (props, styles3) => styles3.root
9422})({});
9423var TextField = $42.component(function TextField2({
9424  allProps,
9425  classes,
9426  otherProps,
9427  props
9428}) {
9429  if (true) {
9430    createEffect(() => {
9431      if (props.select && !props.children) {
9432        console.error("MUI: `children` must be passed when using the `TextField` component with `select`.");
9433      }
9434    });
9435  }
9436  const id = createUniqueId3(() => props.id);
9437  const helperTextId = () => props.helperText && id() ? `${id()}-helper-text` : void 0;
9438  const inputLabelId = () => props.label && id() ? `${id()}-label` : void 0;
9439  const InputComponent = () => variantComponent[props.variant];
9440  const InputElement = () => createComponent(Dynamic_default, mergeProps({
9441    get $component() {
9442      return InputComponent();
9443    },
9444    get ["aria-describedby"]() {
9445      return helperTextId();
9446    },
9447    get autoComplete() {
9448      return props.autoComplete;
9449    },
9450    get autoFocus() {
9451      return props.autoFocus;
9452    },
9453    get defaultValue() {
9454      return props.defaultValue;
9455    },
9456    get fullWidth() {
9457      return props.fullWidth;
9458    },
9459    get multiline() {
9460      return props.multiline;
9461    },
9462    get name() {
9463      return props.name;
9464    },
9465    get rows() {
9466      return props.rows;
9467    },
9468    get maxRows() {
9469      return props.maxRows;
9470    },
9471    get minRows() {
9472      return props.minRows;
9473    },
9474    get type() {
9475      return props.type;
9476    },
9477    get value() {
9478      return props.value;
9479    },
9480    get id() {
9481      return id();
9482    },
9483    get inputRef() {
9484      return props.inputRef;
9485    },
9486    get onBlur() {
9487      return props.onBlur;
9488    },
9489    get onChange() {
9490      return props.onChange;
9491    },
9492    get onFocus() {
9493      return props.onFocus;
9494    },
9495    get placeholder() {
9496      return props.placeholder;
9497    },
9498    get inputProps() {
9499      return props.inputProps;
9500    },
9501    get size() {
9502      return props.size;
9503    },
9504    get notched() {
9505      return props.variant === "outlined" && props.InputLabelProps && typeof props.InputLabelProps.shrink !== "undefined" ? props.InputLabelProps.shrink : void 0;
9506    },
9507    get label() {
9508      return props.variant === "outlined" ? props.label : void 0;
9509    }
9510  }, () => props.InputProps || {}));
9511  const label = () => {
9512    const label2 = props.label;
9513    return label2 != null && label2 !== "" && createComponent(InputLabel_default, mergeProps({
9514      get ["for"]() {
9515        return id();
9516      },
9517      get id() {
9518        return inputLabelId();
9519      }
9520    }, () => props.InputLabelProps || {}, {
9521      children: label2
9522    }));
9523  };
9524  const helperText = () => {
9525    const helperText2 = props.helperText;
9526    if (helperText2) return createComponent(FormHelperText_default, mergeProps({
9527      get id() {
9528        return helperTextId();
9529      }
9530    }, () => props.FormHelperTextProps || {}, {
9531      children: helperText2
9532    }));
9533  };
9534  return createComponent(TextFieldRoot, mergeProps({
9535    get ["class"]() {
9536      return clsx_m_default(classes.root, otherProps.class);
9537    },
9538    get disabled() {
9539      return props.disabled;
9540    },
9541    get error() {
9542      return props.error;
9543    },
9544    get fullWidth() {
9545      return props.fullWidth;
9546    },
9547    get required() {
9548      return props.required;
9549    },
9550    get color() {
9551      return props.color;
9552    },
9553    get variant() {
9554      return props.variant;
9555    },
9556    get size() {
9557      return props.size;
9558    },
9559    ownerState: allProps
9560  }, otherProps, {
9561    get children() {
9562      return [memo(() => label()), memo(() => InputElement()), memo(() => helperText())];
9563    }
9564  }));
9565});
9566var TextField_default = TextField;
9567

vendor: 186 bytes, lines 9568-9571

9568// node_modules/@suid/material/FormControlLabel/FormControlLabelContext.js
9569var FormControlLabelContext = createContext();
9570var FormControlLabelContext_default = FormControlLabelContext;
9571

vendor: 453 bytes, lines 9572-9586

9572// node_modules/@suid/material/FormControlLabel/formControlLabelClasses.js
9573function getFormControlLabelUtilityClasses(slot) {
9574  return generateUtilityClass("MuiFormControlLabel", slot);
9575}
9576var formControlLabelClasses = generateUtilityClasses("MuiFormControlLabel", [
9577  "root",
9578  "labelPlacementStart",
9579  "labelPlacementTop",
9580  "labelPlacementBottom",
9581  "disabled",
9582  "label",
9583  "error"
9584]);
9585var formControlLabelClasses_default = formControlLabelClasses;
9586

vendor: 3,930 bytes, lines 9587-9714

9587// node_modules/@suid/material/FormControlLabel/FormControlLabel.jsx
9588var $43 = createComponentFactory_default()({
9589  name: "MuiFormControlLabel",
9590  propDefaults: ({
9591    set
9592  }) => set({
9593    componentsProps: {},
9594    labelPlacement: "end"
9595  }),
9596  selfPropNames: ["checked", "classes", "componentsProps", "control", "disableTypography", "disabled", "inputRef", "label", "labelPlacement", "name", "onChange", "value"],
9597  autoCallUseClasses: false,
9598  utilityClass: getFormControlLabelUtilityClasses,
9599  slotClasses: (ownerState) => ({
9600    root: ["root", !!ownerState.disabled && "disabled", `labelPlacement${capitalize_default(ownerState.labelPlacement)}`, !!ownerState.error && "error"],
9601    label: ["label", !!ownerState.disabled && "disabled"]
9602  })
9603});
9604var FormControlLabelRoot = styled_default("label", {
9605  name: "MuiFormControlLabel",
9606  slot: "Root",
9607  overridesResolver: (props, styles3) => {
9608    const {
9609      ownerState
9610    } = props;
9611    return [{
9612      [`& .${formControlLabelClasses_default.label}`]: styles3.label
9613    }, styles3.root, styles3[`labelPlacement${capitalize_default(ownerState.labelPlacement)}`]];
9614  }
9615})(({
9616  theme,
9617  ownerState
9618}) => ({
9619  display: "inline-flex",
9620  alignItems: "center",
9621  cursor: "pointer",
9622  // For correct alignment with the text.
9623  verticalAlign: "middle",
9624  WebkitTapHighlightColor: "transparent",
9625  marginLeft: -11,
9626  marginRight: 16,
9627  [`&.${formControlLabelClasses_default.disabled}`]: {
9628    cursor: "default"
9629  },
9630  ...ownerState.labelPlacement === "start" && {
9631    flexDirection: "row-reverse",
9632    marginLeft: 16,
9633    marginRight: -11
9634  },
9635  ...ownerState.labelPlacement === "top" && {
9636    flexDirection: "column-reverse",
9637    marginLeft: 16
9638  },
9639  ...ownerState.labelPlacement === "bottom" && {
9640    flexDirection: "column",
9641    marginLeft: 16
9642  },
9643  [`& .${formControlLabelClasses_default.label}`]: {
9644    [`&.${formControlLabelClasses_default.disabled}`]: {
9645      color: theme.palette.text.disabled
9646    }
9647  }
9648}));
9649var FormControlLabel = $43.component(function FormControlLabel2({
9650  allProps,
9651  otherProps,
9652  props
9653}) {
9654  const muiFormControl = useFormControl();
9655  const [partialContextProps] = splitProps(props, ["checked", "name", "onChange", "value", "inputRef", "disabled"]);
9656  const [childDisabled, setChildDisabled] = createSignal(props.disabled);
9657  const contextProps = mergeProps(partialContextProps, {
9658    setDisabled: (state) => setChildDisabled(state)
9659  });
9660  const fcs = formControlState({
9661    props: allProps,
9662    muiFormControl,
9663    states: ["error"]
9664  });
9665  const ownerState = mergeProps(allProps, {
9666    get error() {
9667      return fcs.error;
9668    },
9669    get disabled() {
9670      return childDisabled();
9671    }
9672  });
9673  const classes = $43.useClasses(ownerState);
9674  const isTypography = (v) => v instanceof HTMLElement && v.classList.contains(Typography_default.toString());
9675  const Label = () => {
9676    const label = children(() => props.label);
9677    return createComponent(Show, {
9678      get when() {
9679        return isTypography(label()) || props.disableTypography;
9680      },
9681      get fallback() {
9682        return createComponent(Typography_default, mergeProps({
9683          component: "span",
9684          get ["class"]() {
9685            return classes.label;
9686          }
9687        }, () => props.componentsProps.typography, {
9688          get children() {
9689            return label();
9690          }
9691        }));
9692      },
9693      get children() {
9694        return label();
9695      }
9696    });
9697  };
9698  return createComponent(FormControlLabelContext_default.Provider, {
9699    value: contextProps,
9700    get children() {
9701      return createComponent(FormControlLabelRoot, mergeProps(otherProps, {
9702        get ["class"]() {
9703          return clsx_m_default(classes.root, otherProps.class);
9704        },
9705        ownerState,
9706        get children() {
9707          return [memo(() => props.control), createComponent(Label, {})];
9708        }
9709      }));
9710    }
9711  });
9712});
9713var FormControlLabel_default = FormControlLabel;
9714

vendor: 248 bytes, lines 9715-9720

9715// node_modules/@suid/material/FormGroup/formGroupClasses.js
9716function getFormGroupUtilityClass(slot) {
9717  return generateUtilityClass("MuiFormGroup", slot);
9718}
9719var formGroupClasses = generateUtilityClasses("MuiFormGroup", ["root", "row", "error"]);
9720

vendor: 1,400 bytes, lines 9721-9782

9721// node_modules/@suid/material/FormGroup/FormGroup.jsx
9722var $44 = createComponentFactory_default()({
9723  name: "MuiFormGroup",
9724  propDefaults: ({
9725    set
9726  }) => set({
9727    row: false
9728  }),
9729  selfPropNames: ["children", "classes", "row"],
9730  utilityClass: getFormGroupUtilityClass,
9731  slotClasses: (ownerState) => ({
9732    root: ["root", ownerState.row && "row", !!ownerState.error && "error"]
9733  })
9734});
9735var FormGroupRoot = styled_default("div", {
9736  name: "MuiFormGroup",
9737  slot: "Root",
9738  overridesResolver: (props, styles3) => {
9739    const {
9740      ownerState
9741    } = props;
9742    return [styles3.root, ownerState.row && styles3.row];
9743  }
9744})(({
9745  ownerState
9746}) => ({
9747  display: "flex",
9748  flexDirection: "column",
9749  flexWrap: "wrap",
9750  ...ownerState.row && {
9751    flexDirection: "row"
9752  }
9753}));
9754var FormGroup = $44.component(function FormGroup2({
9755  props,
9756  allProps,
9757  classes,
9758  otherProps
9759}) {
9760  const muiFormControl = useFormControl();
9761  const fcs = formControlState({
9762    props: allProps,
9763    muiFormControl,
9764    states: ["error"]
9765  });
9766  const ownerState = mergeProps(allProps, {
9767    get error() {
9768      return fcs.error;
9769    }
9770  });
9771  return createComponent(FormGroupRoot, mergeProps(otherProps, {
9772    get ["class"]() {
9773      return clsx_m_default(classes.root, otherProps.class);
9774    },
9775    ownerState,
9776    get children() {
9777      return props.children;
9778    }
9779  }));
9780});
9781var FormGroup_default = FormGroup;
9782

vendor: 162 bytes, lines 9783-9786

9783// node_modules/@suid/material/RadioGroup/RadioGroupContext.js
9784var RadioGroupContext = createContext(void 0);
9785var RadioGroupContext_default = RadioGroupContext;
9786

vendor: 1,163 bytes, lines 9787-9831

9787// node_modules/@suid/material/RadioGroup/RadioGroup.jsx
9788var $45 = createComponentFactory_default()({
9789  name: "MuiRadioGroup",
9790  selfPropNames: ["defaultValue", "name", "onChange", "value"]
9791});
9792var RadioGroup = $45.component(function RadioGroup2({
9793  props,
9794  otherProps
9795}) {
9796  const element = createRef_default();
9797  const [value, setValueState] = useControlled({
9798    controlled: () => props.value,
9799    default: () => props.defaultValue,
9800    name: "RadioGroup"
9801  });
9802  const name = createUniqueId3(() => props.name);
9803  return createComponent(RadioGroupContext_default.Provider, {
9804    value: {
9805      get name() {
9806        return name();
9807      },
9808      onChange(event) {
9809        setValueState(event.target.value);
9810        if (props.onChange) {
9811          props.onChange(event, event.target.value);
9812        }
9813      },
9814      get value() {
9815        return value();
9816      }
9817    },
9818    get children() {
9819      return createComponent(FormGroup_default, mergeProps({
9820        role: "radiogroup",
9821        ref: element
9822      }, otherProps, {
9823        get children() {
9824          return otherProps.children;
9825        }
9826      }));
9827    }
9828  });
9829});
9830var RadioGroup_default = RadioGroup;
9831

vendor: 137 bytes, lines 9832-9836

9832// node_modules/@suid/material/RadioGroup/useRadioGroup.js
9833function useRadioGroup() {
9834  return useContext(RadioGroupContext_default);
9835}
9836

vendor: 145 bytes, lines 9837-9840

9837// node_modules/@suid/material/SvgIcon/SvgIconContext.jsx
9838var SvgIconContext2 = createContext();
9839var SvgIconContext_default2 = SvgIconContext2;
9840

vendor: 161 bytes, lines 9841-9845

9841// node_modules/@suid/material/FormControlLabel/useFormControlLabel.js
9842function useFormControlLabel() {
9843  return useContext(FormControlLabelContext_default);
9844}
9845

vendor: 300 bytes, lines 9846-9851

9846// node_modules/@suid/material/internal/switchBaseClasses.js
9847function getSwitchBaseUtilityClass(slot) {
9848  return generateUtilityClass("PrivateSwitchBase", slot);
9849}
9850var switchBaseClasses = generateUtilityClasses("PrivateSwitchBase", ["root", "checked", "disabled", "input", "edgeStart", "edgeEnd"]);
9851

vendor: 5,144 bytes, lines 9852-10023

9852// node_modules/@suid/material/internal/SwitchBase.jsx
9853var $46 = createComponentFactory_default()({
9854  name: "MuiSwitchBase",
9855  selfPropNames: ["autoFocus", "checked", "checkedIcon", "classes", "defaultChecked", "disableFocusRipple", "disableRipple", "disabled", "edge", "icon", "id", "inputProps", "inputRef", "name", "onChange", "readOnly", "required", "tabIndex", "type", "value"],
9856  autoCallUseClasses: false,
9857  propDefaults: ({
9858    set
9859  }) => set({
9860    disableFocusRipple: false,
9861    edge: false
9862  }),
9863  utilityClass: getSwitchBaseUtilityClass,
9864  slotClasses: (ownerState) => ({
9865    root: ["root", !!ownerState.checked && "checked", !!ownerState.disabled && "disabled", ownerState.edge && `edge${capitalize_default(ownerState.edge)}`],
9866    input: ["input"]
9867  })
9868});
9869var SwitchBaseRoot = styled_default(ButtonBase_default)(({
9870  ownerState
9871}) => ({
9872  padding: 9,
9873  borderRadius: "50%",
9874  ...ownerState.edge === "start" && {
9875    marginLeft: ownerState.size === "small" ? -3 : -12
9876  },
9877  ...ownerState.edge === "end" && {
9878    marginRight: ownerState.size === "small" ? -3 : -12
9879  }
9880}));
9881var SwitchBaseInput = styled_default("input")({
9882  cursor: "inherit",
9883  position: "absolute",
9884  opacity: 0,
9885  width: "100%",
9886  height: "100%",
9887  top: 0,
9888  left: 0,
9889  margin: 0,
9890  padding: 0,
9891  zIndex: 1
9892});
9893var SwitchBase = $46.component(function SwitchBase2({
9894  allProps,
9895  otherProps,
9896  props
9897}) {
9898  const formControlLabel = useFormControlLabel();
9899  const [checked, setCheckedState] = useControlled({
9900    controlled: () => props.checked ?? formControlLabel?.checked,
9901    default: () => Boolean(props.defaultChecked),
9902    name: "SwitchBase",
9903    state: "checked"
9904  });
9905  const muiFormControl = useFormControl();
9906  const disabled = () => {
9907    if (typeof formControlLabel?.disabled !== "undefined") {
9908      return formControlLabel.disabled;
9909    } else if (muiFormControl && typeof props.disabled === "undefined") {
9910      return muiFormControl.disabled;
9911    } else {
9912      return props.disabled;
9913    }
9914  };
9915  createEffect(() => {
9916    if (formControlLabel) {
9917      formControlLabel.setDisabled(!!disabled());
9918    }
9919  });
9920  const hasLabelFor = () => props.type === "checkbox" || props.type === "radio";
9921  const ownerState = mergeProps(allProps, {
9922    get checked() {
9923      return checked();
9924    },
9925    get disabled() {
9926      return disabled();
9927    }
9928  });
9929  const classes = $46.useClasses(ownerState);
9930  const element = createRef_default(() => props.inputRef);
9931  const inputValue = () => props.value ?? formControlLabel?.value;
9932  createEffect(() => {
9933    if (typeof props.defaultChecked === "boolean") element.ref.defaultChecked = props.defaultChecked;
9934  });
9935  createEffect(() => {
9936    const value = checked();
9937    if (typeof value === "boolean") element.ref.checked = value;
9938  });
9939  return createComponent(SwitchBaseRoot, mergeProps(otherProps, {
9940    component: "span",
9941    get ["class"]() {
9942      return clsx_m_default(classes.root, otherProps.class);
9943    },
9944    centerRipple: true,
9945    get focusRipple() {
9946      return !props.disableFocusRipple;
9947    },
9948    get disabled() {
9949      return disabled();
9950    },
9951    tabIndex: null,
9952    role: void 0,
9953    onFocus: (event) => {
9954      if (typeof otherProps.onFocus === "function") {
9955        otherProps.onFocus(event);
9956      }
9957      muiFormControl?.onFocus?.();
9958    },
9959    onBlur: (event) => {
9960      if (typeof otherProps.onBlur === "function") {
9961        otherProps.onBlur(event);
9962      }
9963      muiFormControl?.onBlur?.();
9964    },
9965    ownerState,
9966    get children() {
9967      return [createComponent(SwitchBaseInput, mergeProps({
9968        as: "input",
9969        get autofocus() {
9970          return props.autoFocus;
9971        },
9972        get ["class"]() {
9973          return classes.input;
9974        },
9975        get disabled() {
9976          return disabled();
9977        },
9978        get id() {
9979          return hasLabelFor() ? props.id : void 0;
9980        },
9981        get name() {
9982          return props.name ?? formControlLabel?.name;
9983        },
9984        onClick: (event) => {
9985          if (event.defaultPrevented) {
9986            return;
9987          }
9988          const newChecked = event.currentTarget.checked;
9989          event.currentTarget.checked = !newChecked;
9990          setCheckedState(newChecked);
9991          if (typeof props.onChange === "function") {
9992            props.onChange(event, newChecked);
9993          } else {
9994            formControlLabel?.onChange?.(event, newChecked);
9995          }
9996          if (typeof otherProps.onClick === "function") otherProps.onClick(event);
9997        },
9998        get readOnly() {
9999          return props.readOnly;
10000        },
10001        ref: (e) => {
10002          element(e);
10003          if (!props.inputRef) formControlLabel?.inputRef?.(e);
10004        },
10005        get required() {
10006          return props.required;
10007        },
10008        ownerState,
10009        get tabIndex() {
10010          return props.tabIndex;
10011        },
10012        get type() {
10013          return props.type;
10014        },
10015        get value() {
10016          return inputValue();
10017        }
10018      }, () => props.inputProps || {})), memo(() => checked() ? props.checkedIcon : props.icon), memo(() => otherProps.children)];
10019    }
10020  }));
10021});
10022var SwitchBase_default = SwitchBase;
10023

vendor: 395 bytes, lines 10024-10040

10024// node_modules/@suid/material/SvgIcon/svgIconClasses.js
10025function getSvgIconUtilityClass2(slot) {
10026  return generateUtilityClass("MuiSvgIcon", slot);
10027}
10028var svgIconClasses2 = generateUtilityClasses("MuiSvgIcon", [
10029  "root",
10030  "colorPrimary",
10031  "colorSecondary",
10032  "colorAction",
10033  "colorError",
10034  "colorDisabled",
10035  "fontSizeInherit",
10036  "fontSizeSmall",
10037  "fontSizeMedium",
10038  "fontSizeLarge"
10039]);
10040

vendor: 2,863 bytes, lines 10041-10142

10041// node_modules/@suid/material/SvgIcon/SvgIcon.jsx
10042var _tmpl$8 = /* @__PURE__ */ template(`<title>`);
10043var $47 = createComponentFactory_default()({
10044  name: "MuiSvgIcon",
10045  selfPropNames: ["children", "classes", "color", "fontSize", "htmlColor", "inheritViewBox", "shapeRendering", "titleAccess", "viewBox"],
10046  propDefaults: ({
10047    set
10048  }) => {
10049    const context = useContext(SvgIconContext_default2);
10050    return set({
10051      component: "svg",
10052      color: "inherit",
10053      get fontSize() {
10054        return context?.fontSize ?? "medium";
10055      },
10056      inheritViewBox: false,
10057      viewBox: "0 0 24 24"
10058    });
10059  },
10060  utilityClass: getSvgIconUtilityClass2,
10061  slotClasses: (o) => ({
10062    root: ["root", o.color !== "inherit" && `color${capitalize(o.color)}`, `fontSize${capitalize(o.fontSize)}`]
10063  })
10064});
10065var SvgIconRoot2 = styled_default("svg", {
10066  name: "MuiSvgIcon",
10067  slot: "Root",
10068  overridesResolver: (props, styles3) => {
10069    const {
10070      ownerState
10071    } = props;
10072    return [styles3.root, ownerState.color !== "inherit" && styles3[`color${capitalize(ownerState.color)}`], styles3[`fontSize${capitalize(ownerState.fontSize)}`]];
10073  }
10074})(({
10075  theme,
10076  ownerState
10077}) => ({
10078  userSelect: "none",
10079  width: "1em",
10080  height: "1em",
10081  display: "inline-block",
10082  fill: "currentColor",
10083  flexShrink: 0,
10084  transition: theme.transitions?.create?.("fill", {
10085    duration: theme.transitions?.duration?.shorter
10086  }),
10087  fontSize: {
10088    inherit: "inherit",
10089    small: theme.typography?.pxToRem?.(20) || "1.25rem",
10090    medium: theme.typography?.pxToRem?.(24) || "1.5rem",
10091    large: theme.typography?.pxToRem?.(35) || "2.1875"
10092  }[ownerState.fontSize],
10093  // TODO v5 deprecate, v6 remove for sx
10094  color: theme.palette?.[ownerState.color]?.main ?? {
10095    action: theme.palette?.action?.active,
10096    disabled: theme.palette?.action?.disabled,
10097    inherit: void 0
10098  }[ownerState.color]
10099}));
10100var SvgIcon3 = $47.component(function SvgIcon4({
10101  allProps,
10102  props,
10103  otherProps,
10104  classes
10105}) {
10106  return createComponent(SvgIconRoot2, mergeProps({
10107    get ["aria-hidden"]() {
10108      return props.titleAccess ? void 0 : true;
10109    },
10110    get role() {
10111      return props.titleAccess ? "img" : void 0;
10112    },
10113    get viewBox() {
10114      return !props.inheritViewBox ? props.viewBox : void 0;
10115    }
10116  }, {
10117    ["focusable"]: "false"
10118  }, {
10119    get color() {
10120      return props.htmlColor;
10121    }
10122  }, otherProps, {
10123    get ["class"]() {
10124      return clsx_m_default(classes.root, otherProps.class);
10125    },
10126    ownerState: allProps,
10127    get children() {
10128      return [memo(() => props.children), createComponent(Show, {
10129        get when() {
10130          return props.titleAccess;
10131        },
10132        children: (titleAccess) => (() => {
10133          const _el$ = _tmpl$8();
10134          insert(_el$, titleAccess);
10135          return _el$;
10136        })()
10137      })];
10138    }
10139  }));
10140});
10141var SvgIcon_default2 = SvgIcon3;
10142

vendor: 310 bytes, lines 10143-10154

10143// node_modules/@suid/material/utils/createSvgIcon.jsx
10144function createSvgIcon2(path, displayName) {
10145  const Component = (props) => createComponent(SvgIcon_default2, mergeProps({
10146    "data-testid": `${displayName}Icon`
10147  }, props, {
10148    get children() {
10149      return path();
10150    }
10151  }));
10152  return Component;
10153}
10154

vendor: 412 bytes, lines 10155-10158

10155// node_modules/@suid/material/internal/svg-icons/RadioButtonChecked.jsx
10156var _tmpl$9 = /* @__PURE__ */ template(`<svg><path d="M8.465 8.465C9.37 7.56 10.62 7 12 7C14.76 7 17 9.24 17 12C17 13.38 16.44 14.63 15.535 15.535C14.63 16.44 13.38 17 12 17C9.24 17 7 14.76 7 12C7 10.62 7.56 9.37 8.465 8.465Z"></svg>`, false, true);
10157var RadioButtonChecked_default = createSvgIcon2(() => _tmpl$9(), "RadioButtonChecked");
10158

vendor: 373 bytes, lines 10159-10162

10159// node_modules/@suid/material/internal/svg-icons/RadioButtonUnchecked.jsx
10160var _tmpl$10 = /* @__PURE__ */ template(`<svg><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></svg>`, false, true);
10161var RadioButtonUnchecked_default = createSvgIcon2(() => _tmpl$10(), "RadioButtonUnchecked");
10162

vendor: 1,651 bytes, lines 10163-10223

10163// node_modules/@suid/material/Radio/RadioButtonIcon.jsx
10164var RadioButtonIconRoot = styled_default("span")({
10165  position: "relative",
10166  display: "flex"
10167});
10168var RadioButtonIconBackground = styled_default(RadioButtonUnchecked_default)({
10169  // Scale applied to prevent dot misalignment in Safari
10170  transform: "scale(1)"
10171});
10172var RadioButtonIconDot = styled_default(RadioButtonChecked_default)(({
10173  theme,
10174  ownerState
10175}) => ({
10176  left: 0,
10177  position: "absolute",
10178  transform: "scale(0)",
10179  transition: theme.transitions.create("transform", {
10180    easing: theme.transitions.easing.easeIn,
10181    duration: theme.transitions.duration.shortest
10182  }),
10183  ...ownerState.checked && {
10184    transform: "scale(1)",
10185    transition: theme.transitions.create("transform", {
10186      easing: theme.transitions.easing.easeOut,
10187      duration: theme.transitions.duration.shortest
10188    })
10189  }
10190}));
10191function RadioButtonIcon(props) {
10192  const ownerState = mergeProps({
10193    checked: false,
10194    classes: {}
10195  }, props);
10196  return createComponent(RadioButtonIconRoot, {
10197    get ["class"]() {
10198      return ownerState.classes.root;
10199    },
10200    ownerState,
10201    get children() {
10202      return [createComponent(RadioButtonIconBackground, {
10203        get fontSize() {
10204          return props.fontSize;
10205        },
10206        get ["class"]() {
10207          return ownerState.classes.background;
10208        },
10209        ownerState
10210      }), createComponent(RadioButtonIconDot, {
10211        get fontSize() {
10212          return props.fontSize;
10213        },
10214        get ["class"]() {
10215          return ownerState.classes.dot;
10216        },
10217        ownerState
10218      })];
10219    }
10220  });
10221}
10222var RadioButtonIcon_default = RadioButtonIcon;
10223

vendor: 318 bytes, lines 10224-10236

10224// node_modules/@suid/material/Radio/radioClasses.js
10225function getRadioUtilityClass(slot) {
10226  return generateUtilityClass("MuiRadio", slot);
10227}
10228var radioClasses = generateUtilityClasses("MuiRadio", [
10229  "root",
10230  "checked",
10231  "disabled",
10232  "colorPrimary",
10233  "colorSecondary"
10234]);
10235var radioClasses_default = radioClasses;
10236

vendor: 3,551 bytes, lines 10237-10356

10237// node_modules/@suid/material/Radio/Radio.jsx
10238var $48 = createComponentFactory_default()({
10239  name: "MuiRadio",
10240  propDefaults: ({
10241    set
10242  }) => set({
10243    checkedIcon: defaultCheckedIcon,
10244    color: "primary",
10245    icon: defaultIcon,
10246    size: "medium"
10247  }),
10248  selfPropNames: ["checkedIcon", "classes", "color", "disabled", "icon", "size"],
10249  utilityClass: getRadioUtilityClass,
10250  slotClasses: (ownerState) => ({
10251    root: ["root", `color${capitalize_default(ownerState.color)}`]
10252  })
10253});
10254var RadioRoot = styled_default(SwitchBase_default, {
10255  skipProps: skipRootProps.filter((v) => v !== "classes"),
10256  name: "MuiRadio",
10257  slot: "Root",
10258  overridesResolver: (props, styles3) => {
10259    return [styles3.root, styles3[`color${capitalize_default(props.ownerState.color)}`]];
10260  }
10261})(({
10262  theme,
10263  ownerState
10264}) => ({
10265  color: theme.palette.text.secondary,
10266  "&:hover": {
10267    backgroundColor: alpha(ownerState.color === "default" ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
10268    // Reset on touch devices, it doesn't add specificity
10269    "@media (hover: none)": {
10270      backgroundColor: "transparent"
10271    }
10272  },
10273  ...ownerState.color !== "default" && {
10274    [`&.${radioClasses_default.checked}`]: {
10275      color: theme.palette[ownerState.color].main
10276    }
10277  },
10278  [`&.${radioClasses_default.disabled}`]: {
10279    color: theme.palette.action.disabled
10280  }
10281}));
10282function areEqualValues(a, b) {
10283  if (typeof b === "object" && b !== null) {
10284    return a === b;
10285  }
10286  return String(a) === String(b);
10287}
10288var defaultCheckedIcon = () => createComponent(RadioButtonIcon_default, {
10289  checked: true
10290});
10291var defaultIcon = () => createComponent(RadioButtonIcon_default, {});
10292var Radio = $48.component(function Radio2({
10293  classes,
10294  allProps,
10295  otherProps,
10296  props
10297}) {
10298  const radioGroup = useRadioGroup();
10299  const formControlLabelContext = useContext(FormControlLabelContext_default);
10300  const name = () => otherProps.name ?? formControlLabelContext?.name ?? radioGroup?.name;
10301  const value = () => otherProps.value ?? formControlLabelContext?.value;
10302  const checked = () => otherProps.checked ?? formControlLabelContext?.checked ?? areEqualValues(radioGroup?.value, value());
10303  const haveDefaultIcons = () => props.checkedIcon === defaultCheckedIcon && props.icon === defaultIcon;
10304  return createComponent(SvgIconContext_default2.Provider, {
10305    value: {
10306      get fontSize() {
10307        return props.size;
10308      }
10309    },
10310    get children() {
10311      return createComponent(RadioRoot, mergeProps({
10312        type: "radio"
10313      }, otherProps, {
10314        ownerState: allProps,
10315        classes,
10316        get name() {
10317          return name();
10318        },
10319        get value() {
10320          return value();
10321        },
10322        get checked() {
10323          return checked();
10324        },
10325        onChange: (event, checked2) => {
10326          otherProps.onChange?.(event, checked2);
10327          formControlLabelContext?.onChange?.(event, checked2);
10328          radioGroup?.onChange?.(event, checked2);
10329        }
10330      }, () => haveDefaultIcons() ? {
10331        get children() {
10332          return createComponent(RadioButtonIcon_default, {
10333            get checked() {
10334              return checked();
10335            }
10336          });
10337        },
10338        get icon() {
10339          return [];
10340        },
10341        get checkedIcon() {
10342          return [];
10343        }
10344      } : {
10345        get icon() {
10346          return props.icon;
10347        },
10348        get checkedIcon() {
10349          return props.checkedIcon;
10350        }
10351      }));
10352    }
10353  });
10354});
10355var Radio_default = Radio;
10356

10357// src/app/classic/dialogs/shapes.jsx
10358var ShapesDialog = (props) => {
10359  const {
10360    controllerAction
10361  } = useEditor();
10362  const styles3 = () => controllerProperty(props.controller, "styles", "styles", true);
10363  const currStyle = () => controllerProperty(props.controller, "renderingStyle", "renderingStyle", false) || "";
10364  const handleChange = (event) => {
10365    controllerAction(props.controller, `setStyle.${event.target.value}`);
10366  };
10367  return createComponent(Dialog_default, {
10368    onClose: () => props.close(),
10369    get open() {
10370      return props.open;
10371    },
10372    get children() {
10373      return [createComponent(DialogTitle_default, {
10374        id: "shapes-dialog",
10375        children: "Select Shapes"
10376      }), createComponent(DialogContent_default, {
10377        get children() {
10378          return createComponent(FormControl_default, {
10379            get children() {
10380              return createComponent(RadioGroup_default, {
10381                "aria-labelledby": "shapes-dialog",
10382                name: "shapes-dialog-radio-buttons-group",
10383                get value() {
10384                  return currStyle();
10385                },
10386                onChange: handleChange,
10387                get children() {
10388                  return createComponent(For, {
10389                    get each() {
10390                      return styles3();
10391                    },
10392                    children: (style2) => createComponent(FormControlLabel_default, {
10393                      value: style2,
10394                      get control() {
10395                        return createComponent(Radio_default, {});
10396                      },
10397                      label: style2
10398                    })
10399                  });
10400                }
10401              });
10402            }
10403          });
10404        }
10405      }), createComponent(DialogActions_default, {
10406        get children() {
10407          return createComponent(Button_default, {
10408            size: "small",
10409            onClick: () => props.close(),
10410            color: "primary",
10411            children: "Close"
10412          });
10413        }
10414      })];
10415    }
10416  });
10417};
10418

vendor: 275 bytes, lines 10419-10427

10419// node_modules/@suid/system/mergeSxObjects.js
10420function mergeSxObjects(object, ...sources) {
10421  return sources.reduce((target, source, index) => deepmerge2(target, source, {
10422    clone: !!index,
10423    sortKeys: true
10424  }), object);
10425}
10426var mergeSxObjects_default = mergeSxObjects;
10427

vendor: 2,839 bytes, lines 10428-10537

10428// node_modules/@suid/material/Stack/Stack.jsx
10429var $49 = createComponentFactory_default()({
10430  name: "MuiStack",
10431  selfPropNames: ["children", "direction", "divider", "spacing"],
10432  propDefaults: ({
10433    set
10434  }) => set({
10435    component: "div",
10436    direction: "column",
10437    spacing: 0
10438  })
10439});
10440function joinChildren(children2, separator) {
10441  const childrenArray = (Array.isArray(children2) ? children2 : [children2]).filter(Boolean);
10442  return childrenArray.reduce((output, child, index) => {
10443    output.push(child);
10444    if (index < childrenArray.length - 1) {
10445      output.push(separator());
10446    }
10447    return output;
10448  }, []);
10449}
10450var getSideFromDirection = (direction) => {
10451  return {
10452    row: "Left",
10453    "row-reverse": "Right",
10454    column: "Top",
10455    "column-reverse": "Bottom"
10456  }[direction];
10457};
10458var StackRoot = styled_default("div", {
10459  name: "MuiStack",
10460  slot: "Root",
10461  overridesResolver: (props, styles3) => {
10462    return [styles3.root];
10463  }
10464})(({
10465  theme,
10466  ownerState
10467}) => {
10468  let styles3 = {
10469    display: "flex",
10470    ...handleBreakpoints({
10471      theme
10472    }, resolveBreakpointValues({
10473      values: ownerState.direction,
10474      breakpoints: theme.breakpoints.values
10475    }), (propValue) => ({
10476      flexDirection: propValue
10477    }))
10478  };
10479  if (ownerState.spacing) {
10480    const transformer = createUnarySpacing(theme);
10481    const base = theme.breakpoints.keys.reduce((acc, breakpoint) => {
10482      if (ownerState.spacing[breakpoint] != null || ownerState.direction[breakpoint] != null) {
10483        acc[breakpoint] = true;
10484      }
10485      return acc;
10486    }, {});
10487    const directionValues = resolveBreakpointValues({
10488      values: ownerState.direction,
10489      base
10490    });
10491    const spacingValues = resolveBreakpointValues({
10492      values: ownerState.spacing,
10493      base
10494    });
10495    const styleFromPropValue = (propValue, breakpoint) => {
10496      return {
10497        "& > :not(style) + :not(style)": {
10498          margin: 0,
10499          [`margin${getSideFromDirection(breakpoint ? directionValues[breakpoint] : ownerState.direction)}`]: transformer(propValue)
10500        }
10501      };
10502    };
10503    styles3 = mergeSxObjects_default(styles3, handleBreakpoints({
10504      theme
10505    }, spacingValues, styleFromPropValue));
10506  }
10507  return styles3;
10508});
10509var Stack = $49.component(function Stack2({
10510  allProps,
10511  otherProps,
10512  props
10513}) {
10514  otherProps = extendSxProp(otherProps);
10515  return createComponent(StackRoot, mergeProps({
10516    get as() {
10517      return otherProps.component;
10518    },
10519    ownerState: allProps
10520  }, otherProps, {
10521    get children() {
10522      return createComponent(Show, {
10523        get when() {
10524          return props.divider;
10525        },
10526        get fallback() {
10527          return props.children;
10528        },
10529        get children() {
10530          return joinChildren(props.children, () => props.divider);
10531        }
10532      });
10533    }
10534  }));
10535});
10536var Stack_default = Stack;
10537

vendor: 434 bytes, lines 10538-10558

10538// node_modules/@suid/material/Switch/switchClasses.js
10539function getSwitchUtilityClass(slot) {
10540  return generateUtilityClass("MuiSwitch", slot);
10541}
10542var switchClasses = generateUtilityClasses("MuiSwitch", [
10543  "root",
10544  "edgeStart",
10545  "edgeEnd",
10546  "switchBase",
10547  "colorPrimary",
10548  "colorSecondary",
10549  "sizeSmall",
10550  "sizeMedium",
10551  "checked",
10552  "disabled",
10553  "input",
10554  "thumb",
10555  "track"
10556]);
10557var switchClasses_default = switchClasses;
10558

vendor: 6,164 bytes, lines 10559-10778

10559// node_modules/@suid/material/Switch/Switch.jsx
10560var $50 = createComponentFactory_default()({
10561  name: "MuiSwitch",
10562  selfPropNames: ["checkedIcon", "classes", "color", "disabled", "icon", "size", "value"],
10563  propDefaults: ({
10564    set
10565  }) => set({
10566    color: "primary",
10567    size: "medium"
10568  }),
10569  utilityClass: getSwitchUtilityClass,
10570  slotClasses: (ownerState) => ({
10571    root: ["root", !!ownerState.edge && `edge${capitalize_default(ownerState.edge)}`, `size${capitalize_default(ownerState.size)}`],
10572    switchBase: ["switchBase", `color${capitalize_default(ownerState.color)}`, !!ownerState.checked && "checked", !!ownerState.disabled && "disabled"],
10573    thumb: ["thumb"],
10574    track: ["track"],
10575    input: ["input"]
10576  })
10577});
10578var SwitchRoot = styled_default("span", {
10579  name: "MuiSwitch",
10580  slot: "Root",
10581  overridesResolver: (props, styles3) => {
10582    const {
10583      ownerState
10584    } = props;
10585    return [styles3.root, ownerState.edge && styles3[`edge${capitalize_default(ownerState.edge)}`], styles3[`size${capitalize_default(ownerState.size)}`]];
10586  }
10587})(({
10588  ownerState
10589}) => ({
10590  display: "inline-flex",
10591  width: 34 + 12 * 2,
10592  height: 14 + 12 * 2,
10593  overflow: "hidden",
10594  padding: 12,
10595  boxSizing: "border-box",
10596  position: "relative",
10597  flexShrink: 0,
10598  zIndex: 0,
10599  verticalAlign: "middle",
10600  "@media print": {
10601    colorAdjust: "exact"
10602  },
10603  ...ownerState.edge === "start" && {
10604    marginLeft: -8
10605  },
10606  ...ownerState.edge === "end" && {
10607    marginRight: -8
10608  },
10609  ...ownerState.size === "small" && {
10610    width: 40,
10611    height: 24,
10612    padding: 7,
10613    [`& .${switchClasses_default.thumb}`]: {
10614      width: 16,
10615      height: 16
10616    },
10617    [`& .${switchClasses_default.switchBase}`]: {
10618      padding: 4,
10619      [`&.${switchClasses_default.checked}`]: {
10620        transform: "translateX(16px)"
10621      }
10622    }
10623  }
10624}));
10625var SwitchSwitchBase = styled_default(SwitchBase_default, {
10626  name: "MuiSwitch",
10627  slot: "SwitchBase",
10628  overridesResolver: (props, styles3) => {
10629    const {
10630      ownerState
10631    } = props;
10632    return [styles3.switchBase, {
10633      [`& .${switchClasses_default.input}`]: styles3.input
10634    }, ownerState.color !== "default" && styles3[`color${capitalize_default(ownerState.color)}`]];
10635  }
10636})(({
10637  theme
10638}) => ({
10639  position: "absolute",
10640  top: 0,
10641  left: 0,
10642  zIndex: 1,
10643  color: theme.palette.mode === "light" ? theme.palette.common.white : theme.palette.grey[300],
10644  transition: theme.transitions.create(["left", "transform"], {
10645    duration: theme.transitions.duration.shortest
10646  }),
10647  [`&.${switchClasses_default.checked}`]: {
10648    transform: "translateX(20px)"
10649  },
10650  [`&.${switchClasses_default.disabled}`]: {
10651    color: theme.palette.mode === "light" ? theme.palette.grey[100] : theme.palette.grey[600]
10652  },
10653  [`&.${switchClasses_default.checked} + .${switchClasses_default.track}`]: {
10654    opacity: 0.5
10655  },
10656  [`&.${switchClasses_default.disabled} + .${switchClasses_default.track}`]: {
10657    opacity: theme.palette.mode === "light" ? 0.12 : 0.2
10658  },
10659  [`& .${switchClasses_default.input}`]: {
10660    left: "-100%",
10661    width: "300%"
10662  }
10663}), ({
10664  theme,
10665  ownerState
10666}) => ({
10667  "&:hover": {
10668    backgroundColor: alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),
10669    // Reset on touch devices, it doesn't add specificity
10670    "@media (hover: none)": {
10671      backgroundColor: "transparent"
10672    }
10673  },
10674  ...ownerState.color !== "default" && {
10675    [`&.${switchClasses_default.checked}`]: {
10676      color: theme.palette[ownerState.color].main,
10677      "&:hover": {
10678        backgroundColor: alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
10679        "@media (hover: none)": {
10680          backgroundColor: "transparent"
10681        }
10682      },
10683      [`&.${switchClasses_default.disabled}`]: {
10684        color: theme.palette.mode === "light" ? lighten(theme.palette[ownerState.color].main, 0.62) : darken(theme.palette[ownerState.color].main, 0.55)
10685      }
10686    },
10687    [`&.${switchClasses_default.checked} + .${switchClasses_default.track}`]: {
10688      backgroundColor: theme.palette[ownerState.color].main
10689    }
10690  }
10691}));
10692var SwitchTrack = styled_default("span", {
10693  name: "MuiSwitch",
10694  slot: "Track",
10695  overridesResolver: (props, styles3) => styles3.track
10696})(({
10697  theme
10698}) => ({
10699  height: "100%",
10700  width: "100%",
10701  borderRadius: 14 / 2,
10702  zIndex: -1,
10703  transition: theme.transitions.create(["opacity", "background-color"], {
10704    duration: theme.transitions.duration.shortest
10705  }),
10706  backgroundColor: theme.palette.mode === "light" ? theme.palette.common.black : theme.palette.common.white,
10707  opacity: theme.palette.mode === "light" ? 0.38 : 0.3
10708}));
10709var SwitchThumb = styled_default("span", {
10710  name: "MuiSwitch",
10711  slot: "Thumb",
10712  overridesResolver: (props, styles3) => styles3.thumb
10713})(({
10714  theme
10715}) => ({
10716  boxShadow: theme.shadows[1],
10717  backgroundColor: "currentColor",
10718  width: 20,
10719  height: 20,
10720  borderRadius: "50%"
10721}));
10722var Switch2 = $50.component(function Switch3({
10723  allProps,
10724  props,
10725  classes,
10726  otherProps
10727}) {
10728  const icon = () => createComponent(SwitchThumb, {
10729    get ["class"]() {
10730      return classes.thumb;
10731    },
10732    ownerState: allProps
10733  });
10734  const allClasses = mergeProps(classes, {
10735    get root() {
10736      return classes.switchBase;
10737    }
10738  });
10739  const [, otherPropsWithoutSx] = splitProps(otherProps, ["sx"]);
10740  const baseProps = mergeProps(otherPropsWithoutSx, {
10741    get checkedIcon() {
10742      return props.checkedIcon || icon;
10743    },
10744    get disabled() {
10745      return props.disabled;
10746    },
10747    get icon() {
10748      return props.icon || icon;
10749    },
10750    get value() {
10751      return props.value;
10752    }
10753  });
10754  return createComponent(SwitchRoot, {
10755    get ["class"]() {
10756      return clsx_m_default(classes.root, otherProps.class);
10757    },
10758    get sx() {
10759      return otherProps.sx;
10760    },
10761    ownerState: allProps,
10762    get children() {
10763      return [createComponent(SwitchSwitchBase, mergeProps({
10764        type: "checkbox",
10765        ownerState: allProps
10766      }, baseProps, {
10767        classes: allClasses
10768      })), createComponent(SwitchTrack, {
10769        get ["class"]() {
10770          return classes.track;
10771        },
10772        ownerState: allProps
10773      })];
10774    }
10775  });
10776});
10777var Switch_default = Switch2;
10778

vendor: 484 bytes, lines 10779-10799

10779// node_modules/@suid/material/NativeSelect/nativeSelectClasses.js
10780function getNativeSelectUtilityClasses(slot) {
10781  return generateUtilityClass("MuiNativeSelect", slot);
10782}
10783var nativeSelectClasses = generateUtilityClasses("MuiNativeSelect", [
10784  "root",
10785  "select",
10786  "multiple",
10787  "filled",
10788  "outlined",
10789  "standard",
10790  "disabled",
10791  "icon",
10792  "iconOpen",
10793  "iconFilled",
10794  "iconOutlined",
10795  "iconStandard",
10796  "nativeInput"
10797]);
10798var nativeSelectClasses_default = nativeSelectClasses;
10799

vendor: 4,214 bytes, lines 10800-10948

10800// node_modules/@suid/material/NativeSelect/NativeSelectInput.jsx
10801var useUtilityClasses = (ownerState) => {
10802  const slots = {
10803    select: ["select", ownerState.variant, ownerState.disabled && "disabled", ownerState.multiple && "multiple"],
10804    icon: ["icon", ownerState.variant && `icon${capitalize_default(ownerState.variant)}`, ownerState.open && "iconOpen", ownerState.disabled && "disabled"]
10805  };
10806  return composeClasses(slots, getNativeSelectUtilityClasses, ownerState.classes);
10807};
10808var nativeSelectSelectStyles = ({
10809  ownerState,
10810  theme
10811}) => ({
10812  MozAppearance: "none",
10813  WebkitAppearance: "none",
10814  // When interacting quickly, the text can end up selected.
10815  // Native select can't be selected either.
10816  userSelect: "none",
10817  borderRadius: 0,
10818  cursor: "pointer",
10819  "&:focus": {
10820    // Show that it's not an text input
10821    backgroundColor: theme.palette.mode === "light" ? "rgba(0, 0, 0, 0.05)" : "rgba(255, 255, 255, 0.05)",
10822    borderRadius: 0
10823    // Reset Chrome style
10824  },
10825  // Remove IE11 arrow
10826  "&::-ms-expand": {
10827    display: "none"
10828  },
10829  [`&.${nativeSelectClasses_default.disabled}`]: {
10830    cursor: "default"
10831  },
10832  "&[multiple]": {
10833    height: "auto"
10834  },
10835  "&:not([multiple]) option, &:not([multiple]) optgroup": {
10836    backgroundColor: theme.palette.background.paper
10837  },
10838  // Bump specificity to allow extending custom inputs
10839  "&&&": {
10840    paddingRight: 24,
10841    minWidth: 16
10842    // So it doesn't collapse.
10843  },
10844  ...ownerState.variant === "filled" && {
10845    "&&&": {
10846      paddingRight: 32
10847    }
10848  },
10849  ...ownerState.variant === "outlined" && {
10850    borderRadius: theme.shape.borderRadius,
10851    "&:focus": {
10852      borderRadius: theme.shape.borderRadius
10853      // Reset the reset for Chrome style
10854    },
10855    "&&&": {
10856      paddingRight: 32
10857    }
10858  }
10859});
10860var NativeSelectSelect = styled_default("select", {
10861  name: "MuiNativeSelect",
10862  slot: "Select",
10863  skipProps: skipRootProps,
10864  overridesResolver: (props, styles3) => {
10865    const {
10866      ownerState
10867    } = props;
10868    return [styles3.select, styles3[ownerState.variant], {
10869      [`&.${nativeSelectClasses_default.multiple}`]: styles3.multiple
10870    }];
10871  }
10872})(nativeSelectSelectStyles);
10873var nativeSelectIconStyles = ({
10874  ownerState,
10875  theme
10876}) => ({
10877  // We use a position absolute over a flexbox in order to forward the pointer events
10878  // to the input and to support wrapping tags..
10879  position: "absolute",
10880  right: 0,
10881  top: "calc(50% - .5em)",
10882  pointerEvents: "none",
10883  color: theme.palette.action.active,
10884  [`&.${nativeSelectClasses_default.disabled}`]: {
10885    color: theme.palette.action.disabled
10886  },
10887  ...ownerState.open && {
10888    transform: "rotate(180deg)"
10889  },
10890  ...ownerState.variant === "filled" && {
10891    right: 7
10892  },
10893  ...ownerState.variant === "outlined" && {
10894    right: 7
10895  }
10896});
10897var NativeSelectIcon = styled_default("svg", {
10898  name: "MuiNativeSelect",
10899  slot: "Icon",
10900  overridesResolver: (props, styles3) => {
10901    const {
10902      ownerState
10903    } = props;
10904    return [styles3.icon, ownerState.variant && styles3[`icon${capitalize_default(ownerState.variant)}`], ownerState.open && styles3.iconOpen];
10905  }
10906})(nativeSelectIconStyles);
10907var NativeSelectInput = function NativeSelectInput2(props) {
10908  const ref = createRef_default(props);
10909  const [, other] = splitProps(props, ["class", "disabled", "IconComponent", "inputRef", "variant"]);
10910  const baseProps = mergeProps({
10911    variant: "standard"
10912  }, props);
10913  const ownerState = mergeProps(props, {
10914    get disabled() {
10915      return props.disabled;
10916    },
10917    get variant() {
10918      return baseProps.variant;
10919    }
10920  });
10921  const classes = useUtilityClasses(ownerState);
10922  return [createComponent(NativeSelectSelect, mergeProps({
10923    ownerState,
10924    get ["class"]() {
10925      return clsx_m_default(classes.select, props.class);
10926    },
10927    get disabled() {
10928      return props.disabled;
10929    }
10930  }, other)), createComponent(Show, {
10931    get when() {
10932      return !props.multiple;
10933    },
10934    get children() {
10935      return createComponent(NativeSelectIcon, {
10936        get as() {
10937          return props.IconComponent;
10938        },
10939        ownerState,
10940        get ["class"]() {
10941          return classes.icon;
10942        }
10943      });
10944    }
10945  })];
10946};
10947var NativeSelectInput_default = NativeSelectInput;
10948

vendor: 242 bytes, lines 10949-10952

10949// node_modules/@suid/material/internal/svg-icons/ArrowDropDown.jsx
10950var _tmpl$11 = /* @__PURE__ */ template(`<svg><path d="M7 10l5 5 5-5z"></svg>`, false, true);
10951var ArrowDropDown_default = createSvgIcon2(() => _tmpl$11(), "ArrowDropDown");
10952

vendor: 439 bytes, lines 10953-10973

10953// node_modules/@suid/material/Select/selectClasses.js
10954function getSelectUtilityClasses(slot) {
10955  return generateUtilityClass("MuiSelect", slot);
10956}
10957var selectClasses = generateUtilityClasses("MuiSelect", [
10958  "select",
10959  "multiple",
10960  "filled",
10961  "outlined",
10962  "standard",
10963  "disabled",
10964  "focused",
10965  "icon",
10966  "iconOpen",
10967  "iconFilled",
10968  "iconOutlined",
10969  "iconStandard",
10970  "nativeInput"
10971]);
10972var selectClasses_default = selectClasses;
10973

vendor: 14,570 bytes, lines 10974-11460

10974// node_modules/@suid/material/Select/SelectInput.jsx
10975var _tmpl$12 = /* @__PURE__ */ template(`<span class="notranslate">&#8203;`);
10976var $51 = createComponentFactory_default()({
10977  name: "MuiSelectInput",
10978  selfPropNames: ["autoFocus", "autoWidth", "defaultOpen", "disabled", "IconComponent", "inputRef", "MenuProps", "multiple", "name", "native", "onBlur", "onChange", "onClose", "onFocus", "onOpen", "open", "readOnly", "renderValue", "SelectDisplayProps", "tabIndex", "value", "variant"],
10979  utilityClass: getSelectUtilityClasses,
10980  slotClasses: (ownerState) => ({
10981    select: ["select", ownerState.variant, ownerState.disabled && "disabled", ownerState.multiple && "multiple"],
10982    icon: ["icon", `icon${capitalize(ownerState.variant)}`, ownerState.open && "iconOpen", ownerState.disabled && "disabled"],
10983    nativeInput: ["nativeInput"]
10984  })
10985});
10986var SelectSelect = styled_default("div", {
10987  name: "MuiSelect",
10988  slot: "Select",
10989  overridesResolver: (props, styles3) => {
10990    const {
10991      ownerState
10992    } = props;
10993    return [
10994      // Win specificity over the input base
10995      {
10996        [`&.${selectClasses_default.select}`]: styles3.select
10997      },
10998      {
10999        [`&.${selectClasses_default.select}`]: styles3[ownerState.variant]
11000      },
11001      {
11002        [`&.${selectClasses_default.multiple}`]: styles3.multiple
11003      }
11004    ];
11005  }
11006})(nativeSelectSelectStyles, {
11007  // Win specificity over the input base
11008  [`&.${selectClasses_default.select}`]: {
11009    height: "auto",
11010    minHeight: "1.4375em",
11011    textOverflow: "ellipsis",
11012    whiteSpace: "nowrap",
11013    overflow: "hidden"
11014  }
11015});
11016var SelectIcon = styled_default("svg", {
11017  name: "MuiSelect",
11018  slot: "Icon",
11019  overridesResolver: (props, styles3) => {
11020    const {
11021      ownerState
11022    } = props;
11023    return [styles3.icon, ownerState.variant && styles3[`icon${capitalize(ownerState.variant)}`], ownerState.open && styles3.iconOpen];
11024  }
11025})(nativeSelectIconStyles);
11026var SelectNativeInput = styled_default("input", {
11027  skipProps: skipRootProps,
11028  name: "MuiSelect",
11029  slot: "NativeInput",
11030  overridesResolver: (props, styles3) => styles3.nativeInput
11031})({
11032  bottom: 0,
11033  left: 0,
11034  position: "absolute",
11035  opacity: 0,
11036  pointerEvents: "none",
11037  width: "100%",
11038  boxSizing: "border-box"
11039});
11040function areEqualValues2(a, b) {
11041  if (typeof b === "object" && b !== null) {
11042    return a === b;
11043  }
11044  return String(a) === String(b);
11045}
11046function isEmpty(display) {
11047  return display == null || typeof display === "string" && !display.trim();
11048}
11049var SelectInput = $51.defineComponent(function SelectInput2(props) {
11050  const ref = createRef_default(props);
11051  const [, other] = splitProps(props, ["ref", "sx", "aria-describedby", "aria-label", "autoFocus", "autoWidth", "children", "class", "defaultOpen", "defaultValue", "disabled", "displayEmpty", "IconComponent", "inputRef", "labelId", "MenuProps", "multiple", "name", "onBlur", "onChange", "onClose", "onFocus", "onOpen", "open", "readOnly", "renderValue", "SelectDisplayProps", "tabIndex", "type", "value", "variant"]);
11052  const baseProps = mergeProps({
11053    MenuProps: {},
11054    SelectDisplayProps: {},
11055    variant: "standard"
11056  }, props);
11057  const [value, setValueState] = useControlled({
11058    controlled: () => props.value,
11059    default: () => props.defaultValue,
11060    name: "Select"
11061  });
11062  const [openState, setOpenState] = useControlled({
11063    controlled: () => props.open,
11064    default: () => props.defaultOpen,
11065    name: "Select"
11066  });
11067  const inputRef = createRef_default();
11068  const displayRef = createRef_default();
11069  const [displayNode, setDisplayNode] = createSignal(null);
11070  const isOpenControlled = props.open != null;
11071  const [menuMinWidthState, setMenuMinWidthState] = createSignal(null);
11072  const handleDisplayRef = (node) => {
11073    displayRef.current = node;
11074    setDisplayNode(node);
11075  };
11076  const action = {
11077    nodeName: "INPUT",
11078    get node() {
11079      return inputRef.current;
11080    },
11081    addEventListener(eventName, callback) {
11082      if (eventName !== "input") throw new Error(`Invalid event name: ${eventName}`);
11083      inputRef.current.addEventListener(eventName, callback);
11084    },
11085    get value() {
11086      return value();
11087    },
11088    set value(v) {
11089      setValueState(v);
11090    },
11091    focus() {
11092      inputRef.current.focus();
11093    }
11094  };
11095  createEffect(on(() => [displayNode(), props.autoWidth], () => {
11096    if (props.defaultOpen && openState() && displayNode() && !isOpenControlled) {
11097      setMenuMinWidthState(props.autoWidth ? null : displayNode().clientWidth);
11098      displayRef.current.focus();
11099    }
11100  }));
11101  createEffect(() => {
11102    if (props.autoFocus) {
11103      displayRef.current.focus();
11104    }
11105  });
11106  let clickHandler;
11107  createEffect(() => {
11108    if (!props.labelId) {
11109      return;
11110    }
11111    const label = ownerDocument2(displayRef.current).getElementById(props.labelId);
11112    if (label) {
11113      if (clickHandler) label.removeEventListener("click", clickHandler);
11114      clickHandler = () => {
11115        if (getSelection().isCollapsed) {
11116          displayRef.current.focus();
11117        }
11118      };
11119      label.addEventListener("click", clickHandler);
11120    }
11121  });
11122  const update = (open2, event) => {
11123    if (!open2) displayRef.current.focus();
11124    if (open2) {
11125      if (props.onOpen) {
11126        props.onOpen(event);
11127      }
11128    } else if (props.onClose) {
11129      props.onClose(event);
11130    }
11131    if (!isOpenControlled) {
11132      setMenuMinWidthState(props.autoWidth ? null : displayNode().clientWidth);
11133      setOpenState(open2);
11134    }
11135  };
11136  const handleMouseDown = (event) => {
11137    if (props.disabled || props.readOnly) return;
11138    if (event.button !== 0) {
11139      return;
11140    }
11141    event.preventDefault();
11142    displayRef.current.focus();
11143    update(true, event);
11144  };
11145  const handleClose = (event) => {
11146    update(false, event);
11147  };
11148  const childrenArray = inspectChildren(() => props.children);
11149  const selected = (child) => {
11150    const v = value();
11151    if (props.multiple) {
11152      if (!Array.isArray(v)) {
11153        throw new Error("MUI: The `value` prop must be an array when using the `Select` component with `multiple`.");
11154      }
11155      return v.some((v2) => areEqualValues2(v2, child.props.value));
11156    } else {
11157      return areEqualValues2(v, child.props.value);
11158    }
11159  };
11160  const items = mapArray(childrenArray, (child) => {
11161    if (isComponentObject(child, MenuItem_default)) {
11162      setMenuItemProps((prev) => [...prev, child.props]);
11163      onCleanup(() => setMenuItemProps((prev) => prev.filter((v) => v !== child.props)));
11164      const isSelected = createMemo(() => selected(child));
11165      const childProps = mergeProps(child.props, {
11166        get "aria-selected"() {
11167          return isSelected();
11168        },
11169        onClick: (event) => handleItemClick(event, childProps, child.props),
11170        onKeyUp: (event) => {
11171          if (event.key === " ") {
11172            event.preventDefault();
11173          }
11174          if (typeof child.props.onKeyUp === "function") {
11175            child.props.onKeyUp(event);
11176          }
11177        },
11178        role: "option",
11179        get selected() {
11180          return isSelected();
11181        },
11182        value: void 0,
11183        "data-value": child.props.value
11184        // Instead, we provide it as a data attribute.
11185      });
11186      return createComponent(child.Component, childProps);
11187    } else {
11188      return isComponentObject(child) ? createComponent(child.Component, child.props) : child;
11189    }
11190  });
11191  const handleItemClick = (event, itemProps, prevProps) => {
11192    let newValue;
11193    const child = {
11194      props: itemProps
11195    };
11196    const multiple = props.multiple;
11197    if (!event.currentTarget.hasAttribute("tabindex")) {
11198      return;
11199    }
11200    if (multiple) {
11201      newValue = Array.isArray(value()) ? value().slice() : [];
11202      const itemIndex = value().indexOf(child.props.value);
11203      if (itemIndex === -1) {
11204        newValue.push(child.props.value);
11205      } else {
11206        newValue.splice(itemIndex, 1);
11207      }
11208    } else {
11209      newValue = child.props.value;
11210    }
11211    if (typeof prevProps.onClick === "function") {
11212      prevProps.onClick(event);
11213    }
11214    if (value() !== newValue) {
11215      const inputEvent = new CustomEvent("input");
11216      Object.defineProperty(inputEvent, "target", {
11217        writable: false,
11218        value: {
11219          name: itemProps.name,
11220          get value() {
11221            return newValue;
11222          },
11223          set value(v) {
11224            action.value = v;
11225          }
11226        }
11227      });
11228      inputRef.current.dispatchEvent(inputEvent);
11229      setValueState(newValue);
11230      if (typeof itemProps.onChange === "function") {
11231        itemProps.onChange(inputEvent, inputEvent.target);
11232      }
11233    }
11234    if (!multiple) {
11235      update(false, event);
11236    }
11237  };
11238  const handleKeyDown2 = (event) => {
11239    if (!props.readOnly) {
11240      const validKeys = [
11241        " ",
11242        "ArrowUp",
11243        "ArrowDown",
11244        // The native select doesn't respond to enter on MacOS, but it's recommended by
11245        // https://www.w3.org/TR/wai-aria-practices/examples/listbox/listbox-collapsible.html
11246        "Enter"
11247      ];
11248      if (validKeys.indexOf(event.key) !== -1) {
11249        event.preventDefault();
11250        update(true, event);
11251      }
11252    }
11253  };
11254  const open = () => displayNode() !== null && !!openState();
11255  const handleBlur = (event) => {
11256    if (!open() && props.onBlur) {
11257      Object.defineProperty(event, "target", {
11258        writable: true,
11259        value: {
11260          value: value(),
11261          name: props.name
11262        }
11263      });
11264      props.onBlur(event);
11265    }
11266  };
11267  const [menuItemProps, setMenuItemProps] = createStore([]);
11268  const display = () => {
11269    const v = value();
11270    if (isFilled({
11271      value: v
11272    }) || props.displayEmpty) {
11273      if (props.renderValue) {
11274        return props.renderValue(v);
11275      } else if (props.multiple) {
11276        const result = [];
11277        for (const itemProps of menuItemProps) {
11278          if (!Array.isArray(v)) {
11279            throw new Error("MUI: The `value` prop must be an array when using the `Select` component with `multiple`.");
11280          }
11281          if (v.some((v2) => areEqualValues2(v2, itemProps.value))) result.push(itemProps.children);
11282        }
11283        return result.reduce((output, child, index) => {
11284          output.push(child);
11285          if (index < result.length - 1) {
11286            output.push(", ");
11287          }
11288          return output;
11289        }, []);
11290      } else {
11291        for (const itemProps of menuItemProps) {
11292          if (areEqualValues2(v, itemProps.value)) {
11293            return itemProps.children;
11294          }
11295        }
11296      }
11297    }
11298  };
11299  const menuMinWidth = () => {
11300    let menuMinWidth2 = menuMinWidthState();
11301    if (!props.autoWidth && isOpenControlled && displayNode()) {
11302      menuMinWidth2 = displayNode().clientWidth;
11303    }
11304    return menuMinWidth2;
11305  };
11306  const PaperProps = mergeProps(() => baseProps.MenuProps.PaperProps, {
11307    style: mergeProps({
11308      get "min-width"() {
11309        const v = menuMinWidth();
11310        return typeof v === "number" ? `${v}px` : void 0;
11311      }
11312    }, () => baseProps.MenuProps.PaperProps != null ? baseProps.MenuProps.PaperProps.style : null)
11313  });
11314  const MenuListProps = mergeProps({
11315    get "aria-labelledby"() {
11316      return props.labelId;
11317    },
11318    ["role"]: "listbox",
11319    disableListWrap: true
11320  }, () => baseProps.MenuProps.MenuListProps);
11321  const tabIndex = () => {
11322    if (typeof props.tabIndex !== "undefined") {
11323      return props.tabIndex;
11324    } else {
11325      return props.disabled ? void 0 : 0;
11326    }
11327  };
11328  const buttonId = () => baseProps.SelectDisplayProps.id || (props.name ? `mui-component-select-${props.name}` : void 0);
11329  const ownerState = mergeProps(props, {
11330    get variant() {
11331      return baseProps.variant;
11332    },
11333    get value() {
11334      return value();
11335    },
11336    get open() {
11337      return open();
11338    }
11339  });
11340  const classes = $51.useClasses(ownerState);
11341  const nativeSelectValue = () => {
11342    const v = value();
11343    return Array.isArray(v) ? v.join(",") : v;
11344  };
11345  const displayValue = () => {
11346    const v = display();
11347    return isEmpty(v) ? (
11348      // notranslate needed while Google Translate will not fix zero-width space issue
11349      _tmpl$12()
11350    ) : v;
11351  };
11352  return [createComponent(SelectSelect, mergeProps({
11353    ref: handleDisplayRef,
11354    get tabIndex() {
11355      return tabIndex();
11356    },
11357    role: "button",
11358    get ["aria-disabled"]() {
11359      return props.disabled ? "true" : void 0;
11360    },
11361    get ["aria-expanded"]() {
11362      return open() ? "true" : "false";
11363    },
11364    "aria-haspopup": "listbox",
11365    get ["aria-label"]() {
11366      return props["aria-label"];
11367    },
11368    get ["aria-labelledby"]() {
11369      return [props.labelId, buttonId()].filter(Boolean).join(" ") || void 0;
11370    },
11371    get ["aria-describedby"]() {
11372      return props["aria-describedby"];
11373    },
11374    onKeyDown: handleKeyDown2,
11375    onMouseDown: handleMouseDown,
11376    onBlur: handleBlur,
11377    get onFocus() {
11378      return props.onFocus;
11379    }
11380  }, () => baseProps.SelectDisplayProps, {
11381    ownerState,
11382    get sx() {
11383      return props.sx;
11384    },
11385    get ["class"]() {
11386      return clsx_m_default(classes.select, props.class, baseProps.SelectDisplayProps.class);
11387    },
11388    get id() {
11389      return buttonId();
11390    },
11391    get children() {
11392      return displayValue();
11393    }
11394  })), createComponent(SelectNativeInput, mergeProps({
11395    get value() {
11396      return nativeSelectValue();
11397    },
11398    get ["data-value"]() {
11399      return nativeSelectValue();
11400    },
11401    get name() {
11402      return props.name;
11403    },
11404    "aria-hidden": true,
11405    ref: (e) => {
11406      inputRef(e);
11407      if (typeof props.inputRef === "function") props.inputRef(action);
11408      ref(action);
11409    },
11410    get onChange() {
11411      return props.onChange;
11412    },
11413    tabIndex: -1,
11414    get disabled() {
11415      return props.disabled;
11416    },
11417    get ["class"]() {
11418      return classes.nativeInput;
11419    },
11420    get autofocus() {
11421      return props.autoFocus;
11422    },
11423    ownerState
11424  }, other)), createComponent(SelectIcon, {
11425    get as() {
11426      return props.IconComponent;
11427    },
11428    get ["class"]() {
11429      return classes.icon;
11430    },
11431    ownerState
11432  }), createComponent(Menu_default, mergeProps({
11433    get id() {
11434      return `menu-${props.name || ""}`;
11435    },
11436    get anchorEl() {
11437      return displayNode();
11438    },
11439    get open() {
11440      return open();
11441    },
11442    onClose: handleClose,
11443    anchorOrigin: {
11444      vertical: "bottom",
11445      horizontal: "center"
11446    },
11447    transformOrigin: {
11448      vertical: "top",
11449      horizontal: "center"
11450    }
11451  }, () => baseProps.MenuProps, {
11452    MenuListProps,
11453    PaperProps,
11454    get children() {
11455      return items();
11456    }
11457  }))];
11458});
11459var SelectInput_default = SelectInput;
11460

vendor: 3,915 bytes, lines 11461-11579

11461// node_modules/@suid/material/Select/Select.jsx
11462var $52 = createComponentFactory_default()({
11463  name: "MuiSelect",
11464  selfPropNames: ["autoWidth", "children", "classes", "defaultOpen", "defaultValue", "displayEmpty", "IconComponent", "id", "input", "inputProps", "label", "labelId", "MenuProps", "multiple", "native", "onChange", "onClose", "onOpen", "open", "renderValue", "SelectDisplayProps", "value", "variant"]
11465});
11466var styledRootConfig = {
11467  name: "MuiSelect",
11468  overridesResolver: (props, styles3) => styles3.root,
11469  skipProps: [...skipRootProps, "variant"],
11470  slot: "Root"
11471};
11472var StyledInput = styled_default(Input_default, styledRootConfig)({});
11473var StyledOutlinedInput = styled_default(OutlinedInput_default, styledRootConfig)({});
11474var StyledFilledInput = styled_default(FilledInput_default, styledRootConfig)({});
11475var Select = $52.defineComponent(function Select2(inProps) {
11476  const props = $52.useThemeProps({
11477    props: inProps
11478  });
11479  const [, other] = splitProps(props, ["autoWidth", "children", "classes", "class", "defaultOpen", "displayEmpty", "IconComponent", "id", "input", "inputProps", "label", "labelId", "MenuProps", "multiple", "native", "onClose", "onOpen", "open", "renderValue", "SelectDisplayProps", "variant"]);
11480  const baseProps = mergeProps({
11481    autoWidth: false,
11482    classes: {},
11483    defaultOpen: false,
11484    displayEmpty: false,
11485    IconComponent: ArrowDropDown_default,
11486    multiple: false,
11487    native: false,
11488    variant: "outlined"
11489  }, props);
11490  const inputComponent = () => baseProps.native ? NativeSelectInput_default : SelectInput_default;
11491  const muiFormControl = useFormControl();
11492  const fcs = formControlState({
11493    props,
11494    muiFormControl,
11495    states: ["variant"]
11496  });
11497  const variant = () => fcs.variant || baseProps.variant;
11498  const inputElements = inspectChildren(() => props.input);
11499  const inputElement = () => {
11500    const [item] = inputElements();
11501    if (item) {
11502      if (isComponentObject(item)) return item;
11503      throw new Error(`Invalid component`);
11504    }
11505  };
11506  const InputComponent = () => inputElement()?.Component || {
11507    standard: StyledInput,
11508    outlined: StyledOutlinedInput,
11509    filled: StyledFilledInput
11510  }[variant()];
11511  const ownerState = mergeProps(props, {
11512    get variant() {
11513      return variant();
11514    },
11515    get classes() {
11516      return baseProps.classes;
11517    }
11518  });
11519  const classes = $52.useClasses(ownerState);
11520  const inputProps = mergeProps({
11521    get children() {
11522      return props.children;
11523    },
11524    get IconComponent() {
11525      return baseProps.IconComponent;
11526    },
11527    get variant() {
11528      return variant();
11529    },
11530    type: void 0,
11531    get multiple() {
11532      return baseProps.multiple;
11533    }
11534  }, () => baseProps.native ? {
11535    id: props.id
11536  } : {
11537    autoWidth: baseProps.autoWidth,
11538    defaultOpen: baseProps.defaultOpen,
11539    displayEmpty: baseProps.displayEmpty,
11540    labelId: props.labelId,
11541    MenuProps: props.MenuProps,
11542    onClose: props.onClose,
11543    onOpen: props.onOpen,
11544    open: props.open,
11545    renderValue: props.renderValue,
11546    SelectDisplayProps: {
11547      id: props.id,
11548      ...props.SelectDisplayProps
11549    }
11550  }, () => props.inputProps, {
11551    get classes() {
11552      return props.inputProps ? deepmerge(classes, props.inputProps.classes) : classes;
11553    }
11554  }, () => inputElement()?.props?.inputProps);
11555  return createComponent(Dynamic_default, mergeProps({
11556    get $component() {
11557      return InputComponent();
11558    }
11559  }, () => inputElement()?.props, {
11560    get inputComponent() {
11561      return inputComponent();
11562    },
11563    inputProps,
11564    get notched() {
11565      return props.multiple && props.native && variant() === "outlined" ? true : void 0;
11566    },
11567    get label() {
11568      return !inputElement() && variant() === "outlined" ? props.label : void 0;
11569    },
11570    get ["class"]() {
11571      return props.class;
11572    },
11573    get variant() {
11574      return variant();
11575    }
11576  }, other));
11577});
11578var Select_default = Select;
11579

11580// src/app/classic/components/length.jsx
11581var _tmpl$13 = /* @__PURE__ */ template(`<div class="slider"><div class="slider-indicator">`);
11582var _tmpl$24 = /* @__PURE__ */ template(`<div>`);
11583var _tmpl$32 = /* @__PURE__ */ template(`<div id="scale-factors">`);
11584var _tmpl$42 = /* @__PURE__ */ template(`<span>`);
11585var _tmpl$52 = /* @__PURE__ */ template(`<math>`);
11586var _tmpl$62 = /* @__PURE__ */ template(`<div id="strut-length" class="grid-rows-fr-min"><div id="change-size" class="grid-cols-2-1"><div id="scales-and-slider" class="grid-rows-min-1"><div id="up-down-slider" class="grid-cols-min-1 orbit-scale"><div id="up-down" class="grid-rows-1-1 pad-4px"><button aria-label="scale-up" class="scale-button"><img></button><button aria-label="scale-down" class="scale-button"><img></button></div><div id="scale-slider" class="scale-slider"></div></div></div><div id="scale-predefs"></div></div><div id="length-display"><div><span>unit = </span><span class="bold"></span></div><div> unit</div><div>= <span class="bold">`);
11587var sliderLimit = 6;
11588var sliderMarks = Array.from({
11589  length: 2 * sliderLimit + 1
11590}, (_, i) => i - sliderLimit).map((i) => ({
11591  value: i
11592}));
11593sliderMarks[sliderLimit].label = "unit";
11594var Slider = (props) => (() => {
11595  const _el$ = _tmpl$13(), _el$2 = _el$.firstChild;
11596  _el$2.style.setProperty("background-color", "black");
11597  _el$2.style.setProperty("position", "absolute");
11598  _el$2.style.setProperty("left", "25%");
11599  _el$2.style.setProperty("height", "6px");
11600  _el$2.style.setProperty("width", "18px");
11601  insert(_el$, createComponent(For, {
11602    each: sliderMarks,
11603    children: ({
11604      value,
11605      label
11606    }) => (() => {
11607      const _el$3 = _tmpl$24();
11608      _el$3.style.setProperty("background-color", "black");
11609      _el$3.style.setProperty("position", "absolute");
11610      `${50 - 7 * value}%` != null ? _el$3.style.setProperty("top", `${50 - 7 * value}%`) : _el$3.style.removeProperty("top");
11611      _el$3.style.setProperty("left", "50%");
11612      _el$3.style.setProperty("height", "1px");
11613      _el$3.style.setProperty("width", "12px");
11614      return _el$3;
11615    })()
11616  }), null);
11617  createRenderEffect(() => `${50 - 7 * props.defaultValue - 2}%` != null ? _el$2.style.setProperty("top", `${50 - 7 * props.defaultValue - 2}%`) : _el$2.style.removeProperty("top"));
11618  return _el$;
11619})();
11620var hexToWebColor = (colorHex) => {
11621  const color = colorHex.substring(2);
11622  if (color.length === 2) return `#0000${color}`;
11623  else if (color.length === 4) return `#00${color}`;
11624  else return `#${color}`;
11625};
11626var ScaleBy = (props) => {
11627  const {
11628    controllerAction
11629  } = useEditor();
11630  const multipliers = () => controllerProperty(props.controller, "field.multipliers", "field.multipliers", true) || [" "];
11631  const number = () => multipliers().length;
11632  const setMultiplier = (evt) => {
11633    const multiplier = evt.target.value;
11634    controllerAction(props.controller, `setMultiplier.${multiplier}`);
11635  };
11636  return (() => {
11637    const _el$4 = _tmpl$32();
11638    _el$4.style.setProperty("background-color", "whitesmoke");
11639    _el$4.style.setProperty("padding", "0.4em");
11640    _el$4.style.setProperty("margin", "0.4em");
11641    insert(_el$4, createComponent(FormControl_default, {
11642      sx: {
11643        m: 1,
11644        minWidth: 90,
11645        margin: "3px"
11646      },
11647      size: "small",
11648      get children() {
11649        return [createComponent(FormLabel_default, {
11650          id: "scale-by-label",
11651          children: "Scale by"
11652        }), createComponent(Switch, {
11653          get fallback() {
11654            return (() => {
11655              const _el$5 = _tmpl$42();
11656              insert(_el$5, () => multipliers()[0]);
11657              return _el$5;
11658            })();
11659          },
11660          get children() {
11661            return [createComponent(Match, {
11662              get when() {
11663                return [2, 3].includes(number());
11664              },
11665              get children() {
11666                return createComponent(RadioGroup_default, {
11667                  row: true,
11668                  name: "scale-radio-group",
11669                  "aria-labelledby": "scale-by-label",
11670                  defaultValue: 0,
11671                  onChange: setMultiplier,
11672                  get children() {
11673                    return createComponent(For, {
11674                      get each() {
11675                        return multipliers();
11676                      },
11677                      children: (m, i) => {

11678                        return createComponent(FormControlLabel_default, {
11679                          get value() {
11680                            return i();
11681                          },
11682                          get control() {
11683                            return createComponent(Radio_default, {});
11684                          },
11685                          label: m
11686                        });
11687                      }
11688                    });
11689                  }
11690                });
11691              }
11692            }), createComponent(Match, {
11693              get when() {
11694                return number() > 3;
11695              },
11696              get children() {
11697                return createComponent(Select_default, {
11698                  id: "multiplier",
11699                  label: "multiplier",
11700                  defaultValue: 0,
11701                  onChange: setMultiplier,
11702                  get children() {
11703                    return createComponent(For, {
11704                      get each() {
11705                        return multipliers();
11706                      },
11707                      children: (m, i) => createComponent(MenuItem_default, {
11708                        get value() {
11709                          return i();
11710                        },
11711                        children: m
11712                      })
11713                    });
11714                  }
11715                });
11716              }
11717            })];
11718          }
11719        })];
11720      }
11721    }));
11722    return _el$4;
11723  })();
11724};
11725var resourceUrl = (resourcePath) => "/app/classic/resources/" + resourcePath;
11726var StrutLengthPanel = (props) => {
11727  const {
11728    controllerAction
11729  } = useEditor();
11730  const orbit = () => controllerProperty(props.controller, "selectedOrbit");
11731  const halfSizes = () => controllerProperty(props.controller, "halfSizes", "selectedOrbit", false) === "true";
11732  const color = () => controllerProperty(props.controller, "color", "selectedOrbit", false);
11733  const backgroundColor = () => color() && hexToWebColor(color()) || "whitesmoke";
11734  const longName = () => controllerProperty(props.controller, "scaleName.long", "selectedOrbit", false);
11735  const mediumName = () => controllerProperty(props.controller, "scaleName.medium", "selectedOrbit", false);
11736  const shortName = () => controllerProperty(props.controller, "scaleName.short", "selectedOrbit", false);
11737  const supershortName = () => controllerProperty(props.controller, "scaleName.superShort", "selectedOrbit", false);
11738  const lengthController = () => subController(props.controller, `length.${orbit()}`);
11739  const realScale = () => controllerProperty(lengthController(), "scale", "length", false);
11740  const unitText = () => controllerProperty(lengthController(), "unitText", "length", false);
11741  const scaleFactorHtml = () => controllerProperty(lengthController(), "scaleFactorHtml", "length", false);
11742  const lengthText = () => controllerProperty(lengthController(), "lengthMathML", "length", false);
11743  const mathML = createMemo(() => {
11744    if (!orbit()) return;
11745    const el = _tmpl$52();
11746    el.innerHTML = lengthText();
11747    return el;
11748  });
11749  const [scale, setScale] = createSignal(0);
11750  createEffect(() => {
11751    if (orbit()) {
11752      const value = realScale();
11753      value && setScale(value);
11754    }
11755  });
11756  const changeScale = (change) => (evt) => {
11757    setScale(change);
11758    controllerAction(lengthController(), "setProperty", {
11759      name: "scale",
11760      value: scale()
11761    });
11762  };
11763  const scaleUp = () => {
11764    setScale((s) => ++s);
11765    controllerAction(lengthController(), "scaleUp");
11766  };
11767  const scaleDown = () => {
11768    setScale((s) => --s);
11769    controllerAction(lengthController(), "scaleDown");
11770  };
11771  const predefinedScale = (scale2, action) => (evt) => {
11772    setScale(scale2);
11773    controllerAction(lengthController(), action);
11774  };
11775  const half = () => controllerProperty(lengthController(), "half", "length", false) === "true";
11776  const toggleHalf = () => controllerAction(lengthController(), "toggleHalf");
11777  const PredefButton = (props2) => createComponent(Button_default, {
11778    variant: "outlined",
11779    sx: {
11780      padding: "2px 9px",
11781      color: "black",
11782      border: "1px solid black",
11783      margin: "4px",
11784      backgroundColor: "whitesmoke"
11785    },
11786    get onClick() {
11787      return predefinedScale(props2.scale, props2.action);
11788    },
11789    get children() {
11790      return props2.label;
11791    }
11792  });
11793  return createComponent(Show, {
11794    get when() {
11795      return orbit();
11796    },
11797    get children() {
11798      const _el$7 = _tmpl$62(), _el$8 = _el$7.firstChild, _el$9 = _el$8.firstChild, _el$10 = _el$9.firstChild, _el$11 = _el$10.firstChild, _el$12 = _el$11.firstChild, _el$13 = _el$12.firstChild, _el$14 = _el$12.nextSibling, _el$15 = _el$14.firstChild, _el$16 = _el$11.nextSibling, _el$17 = _el$9.nextSibling, _el$18 = _el$8.nextSibling, _el$19 = _el$18.firstChild, _el$20 = _el$19.firstChild, _el$21 = _el$20.nextSibling, _el$22 = _el$19.nextSibling, _el$23 = _el$22.firstChild, _el$24 = _el$22.nextSibling, _el$25 = _el$24.firstChild, _el$26 = _el$25.nextSibling;
11799      _el$9.style.setProperty("border-radius", "5px");
11800      insert(_el$9, createComponent(ScaleBy, {
11801        get controller() {
11802          return lengthController();
11803        }
11804      }), _el$10);
11805      _el$12.$$click = scaleUp;
11806      _el$14.$$click = scaleDown;
11807      insert(_el$16, createComponent(Slider, {
11808        orientation: "vertical",
11809        get defaultValue() {
11810          return realScale();
11811        },
11812        "aria-labelledby": "strut-scale-slider",
11813        valueLabelDisplay: "off",
11814        step: 1,
11815        marks: sliderMarks,
11816        track: false,
11817        min: -sliderLimit,
11818        max: sliderLimit
11819      }));
11820      _el$17.style.setProperty("grid-template-rows", "1fr 1fr 1fr 1fr 1fr");
11821      _el$17.style.setProperty("margin-block-start", "auto");
11822      _el$17.style.setProperty("align-content", "space-around");
11823      _el$17.style.setProperty("display", "grid");
11824      insert(_el$17, createComponent(Show, {
11825        get when() {
11826          return halfSizes();
11827        },
11828        get fallback() {
11829          return _tmpl$24();
11830        },
11831        get children() {

11832          return createComponent(FormControlLabel_default, {
11833            label: "half",
11834            sx: {
11835              margin: "auto"
11836            },
11837            get control() {
11838              return createComponent(Switch_default, {
11839                get checked() {
11840                  return half();
11841                },
11842                onChange: toggleHalf,
11843                size: "small",
11844                inputProps: {
11845                  "aria-label": "half-sizes"
11846                }
11847              });
11848            }
11849          });
11850        }
11851      }), null);
11852      insert(_el$17, createComponent(PredefButton, {
11853        scale: 3,
11854        action: "long",
11855        get label() {
11856          return longName();
11857        }
11858      }), null);
11859      insert(_el$17, createComponent(PredefButton, {
11860        scale: 2,
11861        action: "medium",
11862        get label() {
11863          return mediumName();
11864        }
11865      }), null);
11866      insert(_el$17, createComponent(PredefButton, {
11867        scale: 1,
11868        action: "short",
11869        get label() {
11870          return shortName();
11871        }
11872      }), null);
11873      insert(_el$17, createComponent(PredefButton, {
11874        scale: 0,
11875        action: "supershort",
11876        get label() {
11877          return supershortName();
11878        }
11879      }), null);
11880      _el$18.style.setProperty("background-color", "whitesmoke");
11881      _el$18.style.setProperty("margin-left", "1em");
11882      _el$19.style.setProperty("min-height", "22px");
11883      insert(_el$21, unitText);
11884      _el$22.style.setProperty("min-height", "22px");
11885      insert(_el$22, scaleFactorHtml, _el$23);
11886      _el$24.style.setProperty("min-height", "30px");
11887      _el$24.style.setProperty("margin-left", "1em");
11888      insert(_el$26, mathML);
11889      createRenderEffect((_p$) => {
11890        const _v$ = backgroundColor(), _v$2 = resourceUrl("org/vorthmann/zome/ui/scaleUp.gif"), _v$3 = resourceUrl("org/vorthmann/zome/ui/scaleDown.gif");
11891        _v$ !== _p$._v$ && ((_p$._v$ = _v$) != null ? _el$9.style.setProperty("background-color", _v$) : _el$9.style.removeProperty("background-color"));
11892        _v$2 !== _p$._v$2 && setAttribute(_el$13, "src", _p$._v$2 = _v$2);
11893        _v$3 !== _p$._v$3 && setAttribute(_el$15, "src", _p$._v$3 = _v$3);
11894        return _p$;
11895      }, {
11896        _v$: void 0,
11897        _v$2: void 0,
11898        _v$3: void 0
11899      });
11900      return _el$7;
11901    }
11902  });
11903};
11904delegateEvents(["click"]);
11905

11906// src/app/classic/components/orbitpanel.jsx
11907var _tmpl$14 = /* @__PURE__ */ template(`<svg><circle r="0.05"></svg>`, false, true);
11908var _tmpl$25 = /* @__PURE__ */ template(`<svg><circle r="0.0185" fill="black"></svg>`, false, true);
11909var _tmpl$33 = /* @__PURE__ */ template(`<svg><circle r="0.07850000000000001" fill="none"></svg>`, false, true);
11910var _tmpl$43 = /* @__PURE__ */ template(`<div class="orbit-panel"><div><svg viewBox="-0.1 -0.1 1.2 0.792" stroke="black" stroke-width="0.005"><g><polygon fill="none" points="0,0.6 1,0.6 0,0"></polygon> `);
11911var OrbitDot = (props) => {
11912  const {
11913    controllerAction
11914  } = useEditor();
11915  const propName = () => `orbitDot.${props.orbit}`;
11916  const orbits = () => controllerProperty(props.controller, "orbits", "orbits", true) || [];
11917  const selectedOrbit = () => controllerProperty(props.controller, "selectedOrbit", "orbits", false);
11918  const selected = () => orbits().indexOf(props.orbit) >= 0;
11919  const isLastSelected = () => props.orbit === selectedOrbit();
11920  const details = () => {
11921    const value = controllerProperty(props.controller, propName(), "orbits", false) || "";
11922    const [colorHex, x2 = 0, y2 = 0] = value.split("/");
11923    const color2 = colorHex && hexToWebColor(colorHex);
11924    return {
11925      color: color2,
11926      x: x2,
11927      y: y2
11928    };
11929  };
11930  const r = 0.05;
11931  const color = () => details().color;
11932  const x = () => details().x;
11933  const y = () => props.relativeHeight * (1 - details().y);
11934  const toggleDot = (evt) => controllerAction(props.controller, `toggleDirection.${props.orbit}`);
11935  return createComponent(Show, {
11936    get when() {
11937      return color();
11938    },
11939    get children() {
11940      return [(() => {
11941        const _el$ = _tmpl$14();
11942        _el$.$$click = toggleDot;
11943        createRenderEffect((_p$) => {
11944          const _v$ = x(), _v$2 = y(), _v$3 = color();
11945          _v$ !== _p$._v$ && setAttribute(_el$, "cx", _p$._v$ = _v$);
11946          _v$2 !== _p$._v$2 && setAttribute(_el$, "cy", _p$._v$2 = _v$2);
11947          _v$3 !== _p$._v$3 && setAttribute(_el$, "fill", _p$._v$3 = _v$3);
11948          return _p$;
11949        }, {
11950          _v$: void 0,
11951          _v$2: void 0,
11952          _v$3: void 0
11953        });
11954        return _el$;
11955      })(), memo(() => memo(() => !!selected())() && (() => {
11956        const _el$2 = _tmpl$25();
11957        _el$2.$$click = toggleDot;
11958        createRenderEffect((_p$) => {
11959          const _v$4 = x(), _v$5 = y();
11960          _v$4 !== _p$._v$4 && setAttribute(_el$2, "cx", _p$._v$4 = _v$4);
11961          _v$5 !== _p$._v$5 && setAttribute(_el$2, "cy", _p$._v$5 = _v$5);
11962          return _p$;
11963        }, {
11964          _v$4: void 0,
11965          _v$5: void 0
11966        });
11967        return _el$2;
11968      })()), memo(() => memo(() => !!isLastSelected())() && (() => {
11969        const _el$3 = _tmpl$33();
11970        createRenderEffect((_p$) => {
11971          const _v$6 = x(), _v$7 = y();
11972          _v$6 !== _p$._v$6 && setAttribute(_el$3, "cx", _p$._v$6 = _v$6);
11973          _v$7 !== _p$._v$7 && setAttribute(_el$3, "cy", _p$._v$7 = _v$7);
11974          return _p$;
11975        }, {
11976          _v$6: void 0,
11977          _v$7: void 0
11978        });
11979        return _el$3;
11980      })())];
11981    }
11982  });
11983};
11984var OrbitPanel = (props) => {
11985  const {
11986    controllerAction
11987  } = useEditor();
11988  const oneAtATime = () => controllerProperty(props.controller, "oneAtATime", "orbits", false) === "true";
11989  const selectNone = () =>

11989 controllerAction(props.controller, "setNoDirections");
11990  const selectAll = () => controllerAction(props.controller, "setAllDirections");
11991  const singleAction = (evt, value) => controllerAction(props.controller, `setSingleOrbit.${value}`);
11992  const marginedStyle = {
11993    padding: "0px",
11994    margin: "5px"
11995  };
11996  const relativeHeight = 0.6;
11997  const triangleCorners = `0,${relativeHeight} 1,${relativeHeight} 0,0`;
11998  const viewBox = `-0.1 -0.1 1.2 ${relativeHeight * 1.32}`;
11999  return (() => {
12000    const _el$4 = _tmpl$43(), _el$5 = _el$4.firstChild, _el$6 = _el$5.firstChild, _el$7 = _el$6.firstChild, _el$8 = _el$7.firstChild, _el$9 = _el$8.nextSibling;
12001    insert(_el$4, createComponent(InputLabel_default, {
12002      id: "orbits-label",
12003      get children() {
12004        return props.label;
12005      }
12006    }), _el$5);
12007    insert(_el$4, createComponent(Stack_default, {
12008      spacing: 2,
12009      direction: "row",
12010      get children() {
12011        return [createComponent(Button_default, {
12012          variant: "outlined",
12013          size: "small",
12014          style: marginedStyle,
12015          onClick: selectNone,
12016          children: "None"
12017        }), createComponent(Button_default, {
12018          variant: "outlined",
12019          size: "small",
12020          style: marginedStyle,
12021          onClick: selectAll,
12022          children: "All"
12023        }), createComponent(Show, {
12024          get when() {
12025            return props.lastSelected;
12026          },
12027          get children() {
12028            return createComponent(FormControlLabel_default, {
12029              style: marginedStyle,
12030              label: "single",
12031              get control() {
12032                return createComponent(Switch_default, {
12033                  get checked() {
12034                    return oneAtATime();
12035                  },
12036                  onChange: singleAction,
12037                  size: "small",
12038                  inputProps: {
12039                    "aria-label": "controlled"
12040                  }
12041                });
12042              }
12043            });
12044          }
12045        })];
12046      }
12047    }), _el$5);
12048    _el$5.style.setProperty("background-color", "white");
12049    insert(_el$7, createComponent(For, {
12050      get each() {
12051        return props.orbits;
12052      },
12053      children: (orbit) => createComponent(OrbitDot, {
12054        orbit,
12055        relativeHeight,
12056        get controller() {
12057          return props.controller;
12058        }
12059      })
12060    }), null);
12061    insert(_el$5, () => props.children, null);
12062    return _el$4;
12063  })();
12064};
12065delegateEvents(["click"]);
12066

12067// src/app/classic/dialogs/orbits.jsx
12068var _tmpl$15 = /* @__PURE__ */ template(`<div>`);
12069var OrbitsDialog = (props) => {
12070  const availableOrbits = () => subController(props.controller, "availableOrbits");
12071  const snapOrbits = () => subController(props.controller, "snapOrbits");
12072  const allOrbits = () => controllerProperty(props.controller, "orbits", "orbits", true);
12073  const orbits = () => controllerProperty(availableOrbits(), "orbits", "orbits", true);
12074  const lastAvailable = () => controllerProperty(availableOrbits(), "selectedOrbit", "orbits", false);
12075  const lastSnap = () => controllerProperty(snapOrbits(), "selectedOrbit", "orbits", false);
12076  return createComponent(Dialog_default, {
12077    onClose: () => props.close(),
12078    get open() {
12079      return props.open;
12080    },
12081    maxWidth: "md",
12082    fullWidth: "true",
12083    get children() {
12084      return [createComponent(DialogTitle_default, {
12085        id: "orbits-dialog",
12086        children: "Direction Configuration"
12087      }), createComponent(DialogContent_default, {
12088        get children() {
12089          const _el$ = _tmpl$15();
12090          _el$.style.setProperty("display", "grid");
12091          _el$.style.setProperty("grid-template-columns", "1fr 1fr");
12092          _el$.style.setProperty("min-width", "550px");
12093          insert(_el$, createComponent(OrbitPanel, {
12094            get orbits() {
12095              return allOrbits();
12096            },
12097            get controller() {
12098              return availableOrbits();
12099            },
12100            get lastSelected() {
12101              return lastAvailable();
12102            },
12103            label: "available directions",
12104            style: {
12105              height: "100%"
12106            }
12107          }), null);
12108          insert(_el$, createComponent(OrbitPanel, {
12109            get orbits() {
12110              return orbits();
12111            },
12112            get controller() {
12113              return snapOrbits();
12114            },
12115            get lastSelected() {
12116              return lastSnap();
12117            },
12118            label: "snap directions",
12119            style: {
12120              height: "100%"
12121            }
12122          }), null);
12123          return _el$;
12124        }
12125      }), createComponent(DialogActions_default, {
12126        get children() {
12127          return createComponent(Button_default, {
12128            size: "small",
12129            onClick: () => props.close(),
12130            color: "primary",
12131            children: "Close"
12132          });
12133        }
12134      })];
12135    }
12136  });
12137};
12138

12139// src/app/classic/dialogs/polytopes.jsx
12140var _tmpl$16 = /* @__PURE__ */ template(`<div><svg viewBox="0 -0.5 5 3" stroke="black" stroke-width="0.03"><style>.label { font: .35px sans-serif; }</style><g><text x="1.4" y="1.5" class="label" stroke-width="0.03"></text><text x="2.4" y="1.5" class="label" stroke-width="0.03">`);
12141var _tmpl$26 = /* @__PURE__ */ template(`<svg><g><line stroke="black" stroke-width="0.05"></line><circle r="0.1" fill="black"></circle><circle r="0.5" fill="none" stroke="none" pointer-events="all"></svg>`, false, true);
12142var _tmpl$34 = /* @__PURE__ */ template(`<svg><circle r="0.3" fill="none"></svg>`, false, true);
12143var indices = [0, 1, 2, 3];
12144var alt = Math.sqrt(3) / 2;
12145var x_D4 = [2, 2, 2.5, 3.5];
12146var y_D4 = [1 - alt, 1 + alt, 1, 1];
12147var x_others = [1, 2, 3, 4];
12148var y_others = [1, 1, 1, 1];
12149var CoxeterDiagram = (props) => {
12150  const {
12151    controllerAction
12152  } = useEditor();
12153  const useMirror = (i) => () => controllerProperty(props.controller, `edge.${i}`) === "true";
12154  const toggleMirror = (i) => (evt) => {
12155    controllerAction(props.controller, `edge.${i}`);
12156  };
12157  const isD4 = () => props.group === "D4";
12158  const x = (i) => isD4() ? x_D4[i] : x_others[i];
12159  const y = (i) => isD4() ? y_D4[i] : y_others[i];
12160  return (() => {
12161    const _el$ = _tmpl$16(), _el$2 = _el$.firstChild, _el$3 = _el$2.firstChild, _el$4 = _el$3.nextSibling, _el$5 = _el$4.firstChild, _el$6 = _el$5.nextSibling;
12162    _el$.style.setProperty("position", "relative");
12163    _el$.style.setProperty("background-color", "white");
12164    _el$.style.setProperty("cursor", "pointer");
12165    insert(_el$5, () => props.group === "H4" ? "5" : props.group === "B4/C4" ? "4" : "");
12166    insert(_el$6, () => props.group === "F4" ? "4" : "");
12167    insert(_el$4, createComponent(For, {
12168      each: indices,
12169      children: (i) => (() => {
12170        const _el$7 = _tmpl$26(), _el$8 = _el$7.firstChild, _el$9 = _el$8.nextSibling, _el$10 = _el$9.nextSibling;
12171        insert(_el$7, (() => {
12172          const _c$ = memo(() => !!useMirror(3 - i)());
12173          return () => _c$() && // reversed
12174          (() => {
12175            const _el$11 = _tmpl$34();
12176            createRenderEffect((_p$) => {
12177              const _v$9 = x(i), _v$10 = y(i);
12178              _v$9 !== _p$._v$9 && setAttribute(_el$11, "cx", _p$._v$9 = _v$9);
12179              _v$10 !== _p$._v$10 && setAttribute(_el$11, "cy", _p$._v$10 = _v$10);
12180              return _p$;
12181            }, {
12182              _v$9: void 0,
12183              _v$10: void 0
12184            });
12185            return _el$11;
12186          })();
12187        })(), _el$10);
12188        addEventListener(_el$10, "click", toggleMirror(3 - i), true);
12189        createRenderEffect((_p$) => {
12190          const _v$ = x(i), _v$2 = y(i), _v$3 = x(2), _v$4 = y(2), _v$5 = x(i), _v$6 = y(i), _v$7 = x(i), _v$8 = y(i);
12191          _v$ !== _p$._v$ && setAttribute(_el$8, "x1", _p$._v$ = _v$);
12192          _v$2 !== _p$._v$2 && setAttribute(_el$8, "y1", _p$._v$2 = _v$2);
12193          _v$3 !== _p$._v$3 && setAttribute(_el$8, "x2", _p$._v$3 = _v$3);
12194          _v$4 !== _p$._v$4 && setAttribute(_el$8, "y2", _p$._v$4 = _v$4);
12195          _v$5 !== _p$._v$5 && setAttribute(_el$9, "cx", _p$._v$5 = _v$5);
12196          _v$6 !== _p$._v$6 && setAttribute(_el$9, "cy", _p$._v$6 = _v$6);
12197          _v$7 !== _p$._v$7 && setAttribute(_el$10, "cx", _p$._v$7 = _v$7);
12198          _v$8 !== _p$._v$8 && setAttribute(_el$10, "cy", _p$._v$8 = _v$8);
12199          return _p$;
12200        }, {
12201          _v$: void 0,
12202          _v$2: void 0,
12203          _v$3: void 0,
12204          _v$4: void 0,
12205          _v$5: void 0,
12206          _v$6: void 0,
12207          _v$7: void 0,
12208          _v$8: void 0
12209        });
12210        return _el$7;
12211      })()
12212    }), null);
12213    return _el$;
12214  })();
12215};
12216var PolytopesDialog = (props) => {
12217  const {
12218    controllerAction
12219  } = useEditor();
12220  const controller = () => subController(props.controller, "polytopes");
12221  const groups = () => controllerProperty(controller(), "groups", "groups", true);
12222  const group = () => controllerProperty(controller(), "group", "group", false) || "H4";
12223  const changeGroup = (event) => {
12224    controllerAction(controller(), `setGroup.${event.target.value}`);
12225  };
12226  const generate = (event) => {
12227    props.close();
12228    controllerAction(controller(), "generate");
12229  };
12230  return createComponent(Dialog_default, {
12231    onClose: () => props.close(),
12232    get open() {
12233      return props.open;
12234    },
12235    get children() {
12236      return [createComponent(DialogTitle_default, {
12237        id: "polytopes-dialog",
12238        children: "Generate a 4D Polytope"
12239      }), createComponent(DialogContent_default, {
12240        sx: {
12241          "padding-bottom": "0px"
12242        },
12243        get children() {
12244          return createComponent(FormControl_default, {
12245            fullWidth: true,
12246            sx: {
12247              "padding-top": "20px"
12248            },
12249            get children() {
12250              return [createComponent(InputLabel_default, {
12251                id: "symmetry-group-label",
12252                sx: {
12253                  "padding-top": "20px"
12254                },
12255                children: "group"
12256              }), createComponent(Show, {
12257                get when() {
12258                  return groups().length > 0;
12259                },
12260                get children() {
12261                  return [createComponent(Select_default, {
12262                    labelId: "symmetry-group-label",
12263                    id: "symmetry-group",
12264                    label: "group",
12265                    get value() {
12266                      return group();
12267                    },
12268                    onChange: changeGroup,
12269                    get children() {
12270                      return createComponent(For, {
12271                        get each() {
12272                          return groups();
12273                        },
12274                        children: (g) => createComponent(MenuItem_default, {
12275                          value: g,
12276                          children: g
12277                        })
12278                      });
12279                    }
12280                  }

12280), createComponent(CoxeterDiagram, {
12281                    get controller() {
12282                      return controller();
12283                    },
12284                    get group() {
12285                      return group();
12286                    }
12287                  })];
12288                }
12289              })];
12290            }
12291          });
12292        }
12293      }), createComponent(DialogActions_default, {
12294        get children() {
12295          return [createComponent(Button_default, {
12296            variant: "outlined",
12297            size: "medium",
12298            onClick: () => props.close(),
12299            color: "secondary",
12300            children: "Close"
12301          }), createComponent(Button_default, {
12302            variant: "contained",
12303            size: "medium",
12304            onClick: generate,
12305            color: "primary",
12306            children: "Apply"
12307          })];
12308        }
12309      })];
12310    }
12311  });
12312};
12313delegateEvents(["click"]);
12314

12315// src/app/classic/context/symmetry.jsx
12316var SymmetryContext = createContext();
12317var SymmetryProvider = (props) => {
12318  const {
12319    subscribeFor
12320  } = useWorkerClient();
12321  const {
12322    state,
12323    setCamera
12324  } = useCamera();
12325  const {
12326    rootController,
12327    controllerAction
12328  } = useEditor();
12329  const symmetry = () => controllerProperty(rootController(), "symmetry");
12330  const strutBuilder = () => subController(rootController(), "strutBuilder");
12331  const symmController = () => subController(strutBuilder(), `symmetry.${symmetry()}`);
12332  const [showShapesDialog, setShowShapesDialog] = createSignal(false);
12333  const [showOrbitsDialog, setShowOrbitsDialog] = createSignal(false);
12334  const [showPolytopesDialog, setShowPolytopesDialog] = createSignal(false);
12335  const [snapping, setSnapping] = createSignal(false);
12336  const snapCamera = () => {
12337    if (snapping()) {
12338      const {
12339        up,
12340        lookDir
12341      } = state.camera;
12342      controllerAction(symmController(), "snapCamera", {
12343        up: unwrap(up),
12344        lookDir: unwrap(lookDir)
12345      });
12346    }
12347  };
12348  const api = {
12349    snapping,
12350    snapCamera,
12351    toggleSnapping: () => {
12352      setSnapping((v) => !v);
12353      snapCamera();
12354    },
12355    symmetryDefined: () => !!symmetry(),
12356    symmetryController: () => symmController(),
12357    showShapesDialog: () => setShowShapesDialog(true),
12358    showOrbitsDialog: () => setShowOrbitsDialog(true),
12359    showPolytopesDialog: () => {
12360      controllerAction(subController(symmController(), "polytopes"), "setQuaternion");
12361      setShowPolytopesDialog(true);
12362    }
12363  };
12364  subscribeFor("SYMMETRY_CHANGED", () => setTimeout(() => snapCamera()));
12365  subscribeFor("CAMERA_SNAPPED", (data) => {
12366    const {
12367      up,
12368      lookDir
12369    } = data;
12370    setCamera(data);
12371  });
12372  return createComponent(SymmetryContext.Provider, {
12373    value: api,
12374    get children() {
12375      return [memo(() => props.children), createComponent(Show, {
12376        get when() {
12377          return !!symmetry();
12378        },
12379        get children() {
12380          return [createComponent(ShapesDialog, {
12381            get controller() {
12382              return symmController();
12383            },
12384            get open() {
12385              return showShapesDialog();
12386            },
12387            close: () => setShowShapesDialog(false)
12388          }), createComponent(OrbitsDialog, {
12389            get controller() {
12390              return symmController();
12391            },
12392            get open() {
12393              return showOrbitsDialog();
12394            },
12395            close: () => setShowOrbitsDialog(false)
12396          }), createComponent(PolytopesDialog, {
12397            get controller() {
12398              return symmController();
12399            },
12400            get open() {
12401              return showPolytopesDialog();
12402            },
12403            close: () => setShowPolytopesDialog(false)
12404          })];
12405        }
12406      })];
12407    }
12408  });
12409};
12410var useSymmetry = () => useContext(SymmetryContext);
12411

12412// src/app/framework/keyevents.js
12413var suspended = false;
12414var suspendMenuKeyEvents = () => suspended = true;
12415var resumeMenuKeyEvents = () => suspended = false;
12416var menuKeyEventsSuspended = () => suspended;
12417

12418// src/app/classic/context/commands.jsx
12419var CommandsContext = createContext();
12420var CommandsProvider = (props) => {
12421  const {
12422    rootController,
12423    controllerAction,
12424    state,
12425    setState,
12426    setEdited
12427  } = useEditor();
12428  const {
12429    showPolytopesDialog,
12430    symmetryController
12431  } = useSymmetry();
12432  const {
12433    exportAs
12434  } = useViewer();
12435  const globalAction = (action) => () => controllerAction(rootController(), action);
12436  const undoRedoAction = (action) => () => controllerAction(subController(rootController(), "undoRedo"), action);
12437  const symmetryAction = (symm, action) => () => controllerAction(subController(rootController(), `symmetry.${symm}`), action);
12438  const doSave = (chooseFile = false) => {
12439    let name;
12440    exportAs("vZome").then((text) => {
12441      name = state?.designName || "untitled";
12442      const mimeType = "application/xml";
12443      if (state.fileHandle && !chooseFile) return saveTextFile(state.fileHandle, text, mimeType);
12444      else return saveTextFileAs(name + ".vZome", text, mimeType);
12445    }).then((result) => {
12446      const {
12447        handle,
12448        success
12449      } = result;
12450      if (success) {
12451        if (!!handle) {
12452          setState("fileHandle", handle);
12453          name = handle.name;
12454          if (name.toLowerCase().endsWith(".vZome".toLowerCase())) name = name.substring(0, name.length - 6);
12455        }
12456        setState("designName", name);
12457        controllerAction(rootController(), "clearChanges");
12458        setEdited(false);
12459      }
12460    });
12461  };
12462  const doCut = () => {
12463    exportAs("cmesh", {
12464      selection: true
12465    }).then((text) => {
12466      navigator.clipboard.writeText(text);
12467      controllerAction(rootController(), "Delete");
12468    });
12469  };
12470  const doCopy = () => {
12471    exportAs("cmesh", {
12472      selection: true
12473    }).then((text) => {
12474      navigator.clipboard.writeText(text);
12475    });
12476  };
12477  const doPaste = () => {
12478    if (!navigator.clipboard.readText) {
12479      console.warn("Clipboard paste is not supported in this browser.");
12480      setState("problem", "Clipboard paste is not supported in this browser.");
12481      return;
12482    }
12483    navigator.clipboard.readText().then((text) => {
12484      controllerAction(rootController(), "ImportColoredMeshJson/clipboard", {
12485        vef: text
12486      });
12487    });
12488  };
12489  const commands = {};
12490  const listeners = /* @__PURE__ */ new Set();
12491  const registerKeyListener = (modifiers, deleteKey, key, handler) => {
12492    const listenerName = deleteKey ? "\u232B" : modifiers + key;
12493    if (!listeners.has(listenerName)) {
12494      console.log(`addEventListener ${listenerName}`);
12495      const targetCodes = deleteKey ? ["Delete", "Backspace"] : ["Key" + key.toUpperCase()];
12496      const hasMeta = !!modifiers?.includes("\u2318");
12497      const hasControl = !!modifiers?.includes("\u2303");
12498      const hasShift = !!modifiers?.includes("\u21E7");
12499      const hasOption = !!modifiers?.includes("\u2325");
12500      document.body.addEventListener("keydown", (evt) => {
12501        if (menuKeyEventsSuspended()) return;
12502        if (targetCodes.indexOf(evt.code) < 0) return;
12503        if (hasMeta !== evt.metaKey) return;
12504        if (hasControl !== evt.ctrlKey) return;
12505        if (hasShift !== evt.shiftKey) return;
12506        if (hasOption !== evt.altKey) return;
12507        evt.preventDefault();
12508        handler();
12509      });
12510      listeners.add(listenerName);
12511    }
12512  };
12513  const isMac = navigator.userAgentData?.platform === "macOS" || navigator.userAgent.includes("Macintosh");
12514  const createCommand = (action, keyEquiv, handler = globalAction(action)) => {
12515    let keystroke = "";
12516    if (!!keyEquiv) {
12517      let modifiers = keyEquiv.mods;
12518      let prefix = modifiers;
12519      if (!isMac && modifiers) {
12520        modifiers = modifiers.replace("\u2318", "\u2303");
12521        prefix = "";
12522        if (modifiers.includes("\u2303")) prefix += "Ctrl";
12523        if (modifiers.includes("\u21E7")) prefix += prefix ? "+Shift" : "Shift";
12524        if (modifiers.includes("\u2325")) prefix += prefix ? "+Alt" : "Alt";
12525        if (prefix) prefix += "-";
12526      }
12527      registerKeyListener(modifiers, keyEquiv.deleteKey, keyEquiv.key, handler);
12528      keystroke = !keyEquiv ? "" : keyEquiv.deleteKey ? "\u232B" : prefix + keyEquiv.key;
12529    }
12530    if (!!commands[action]) {
12531      console.warn(`Command for action ${action} is being replaced; original key binding may be lost.`);
12532    }
12533    commands[action] = {
12534      keystroke,
12535      handler
12536    };
12537    return commands[action];
12538  };
12539  const getCommand = (action) => {

12540    let command = commands[action];
12541    if (!command) {
12542      command = createCommand(action);
12543    }
12544    return command;
12545  };
12546  createCommand("Save", {
12547    mods: "\u2318",
12548    key: "S"
12549  }, doSave);
12550  createCommand("SaveAs", {
12551    mods: "\u2325\u2318",
12552    key: "S"
12553  }, () => doSave(true));
12554  createCommand("undo", {
12555    mods: "\u2318",
12556    key: "Z"
12557  }, undoRedoAction("undo"));
12558  createCommand("undoAll", {
12559    mods: "\u2325\u2318",
12560    key: "Z"
12561  }, undoRedoAction("undoAll"));
12562  createCommand("redo", {
12563    mods: "\u2318",
12564    key: "Y"
12565  }, undoRedoAction("redo"));
12566  createCommand("redoAll", {
12567    mods: "\u2325\u2318",
12568    key: "Y"
12569  }, undoRedoAction("redoAll"));
12570  createCommand("Cut", {
12571    mods: "\u2318",
12572    key: "X"
12573  }, doCut);
12574  createCommand("Copy", {
12575    mods: "\u2318",
12576    key: "C"
12577  }, doCopy);
12578  createCommand("Paste", {
12579    mods: "\u2318",
12580    key: "V"
12581  }, doPaste);
12582  createCommand("Delete", {
12583    deleteKey: true
12584  });
12585  createCommand("SelectAll", {
12586    mods: "\u2318",
12587    key: "A"
12588  });
12589  createCommand("SelectNeighbors", {
12590    mods: "\u2325\u2318",
12591    key: "A"
12592  });
12593  createCommand("InvertSelection");
12594  createCommand("GroupSelection/group", {
12595    mods: "\u2318",
12596    key: "G"
12597  });
12598  createCommand("GroupSelection/ungroup", {
12599    mods: "\u2325\u2318",
12600    key: "G"
12601  });
12602  createCommand("hideball", {
12603    mods: "\u2303",
12604    key: "H"
12605  });
12606  createCommand("ShowHidden", {
12607    mods: "\u2325\u2303",
12608    key: "H"
12609  });
12610  createCommand("JoinPoints/CLOSED_LOOP", {
12611    mods: "\u2318",
12612    key: "J"
12613  });
12614  createCommand("JoinPoints/CHAIN_BALLS", {
12615    mods: "\u2325\u2318",
12616    key: "J"
12617  });
12618  createCommand("panel", {
12619    mods: "\u2318",
12620    key: "P"
12621  });
12622  createCommand("Parallelepiped", {
12623    mods: "\u21E7\u2318",
12624    key: "P"
12625  });
12626  createCommand("icosasymm", {
12627    mods: "\u2318",
12628    key: "I"
12629  }, symmetryAction("icosahedral", "icosasymm"));
12630  createCommand("octasymm", {
12631    mods: "\u2325\u2318",
12632    key: "C"
12633  }, symmetryAction("octahedral", "octasymm"));
12634  createCommand("tetrasymm", {
12635    mods: "\u2325\u2318",
12636    key: "T"
12637  }, symmetryAction("octahedral", "tetrasymm"));
12638  createCommand("showPolytopeDialog", {
12639    mods: "\u2325\u2318",
12640    key: "P"
12641  }, showPolytopesDialog);
12642  createCommand("ReplaceWithShape", void 0, () => controllerAction(symmetryController(), "ReplaceWithShape"));
12643  const createCustomCommands = (items) => {
12644    items.forEach((item) => {
12645      if (item.action && !commands[item.action]) {
12646        createCommand(item.action, item.key ? {
12647          mods: item.mods || "\u2325\u2303",
12648          key: item.key
12649        } : void 0);
12650      } else if (!!item.submenu) {
12651        createCustomCommands(item.submenu);
12652      }
12653    });
12654  };
12655  const customMenuItems = localStorage.getItem("vzome-custom-menu");
12656  if (customMenuItems) {
12657    try {
12658      const items = JSON.parse(customMenuItems);
12659      createCustomCommands(items);
12660    } catch (e) {
12661      console.error("Error parsing custom menu items from localStorage:", e);
12662    }
12663  }
12664  return createComponent(CommandsContext.Provider, {
12665    value: {
12666      registerKeyListener,
12667      getCommand
12668    },
12669    get children() {
12670      return props.children;
12671    }
12672  });
12673};
12674var useCommands = () => useContext(CommandsContext);
12675

12676// src/app/classic/dialogs/webloader.jsx
12677var UrlDialog = (props) => {
12678  const [url, setUrl] = createSignal("");
12679  const handleCancel = () => {
12680    resumeMenuKeyEvents();
12681    props.setShow(false);
12682  };
12683  const handleOpen = () => {
12684    resumeMenuKeyEvents();
12685    props.setShow(false);
12686    props.openDesign(url());
12687  };
12688  const handleChange = (event) => setUrl(event.target.value);
12689  return createComponent(Dialog_default, {
12690    get open() {
12691      return props.show;
12692    },
12693    onClose: handleCancel,
12694    "aria-labelledby": "form-dialog-title",
12695    maxWidth: "lg",
12696    fullWidth: true,
12697    get children() {
12698      return [createComponent(DialogTitle_default, {
12699        id: "form-dialog-title",
12700        children: "Load a Remote vZome Design"
12701      }), createComponent(DialogContent_default, {
12702        get children() {
12703          return [createComponent(DialogContentText_default, {
12704            children: "The URL must be open to public access."
12705          }), createComponent(TextField_default, {
12706            onChange: handleChange,
12707            autoFocus: true,
12708            margin: "dense",
12709            id: "name",
12710            label: "vZome design URL",
12711            type: "url",
12712            fullWidth: true
12713          })];
12714        }
12715      }), createComponent(DialogActions_default, {
12716        get children() {
12717          return [createComponent(Button_default, {
12718            onClick: handleCancel,
12719            color: "secondary",
12720            children: "Cancel"
12721          }), createComponent(Button_default, {
12722            onClick: handleOpen,
12723            color: "primary",
12724            children: "Open"
12725          })];
12726        }
12727      })];
12728    }
12729  });
12730};
12731

12732// src/app/framework/tooltip.jsx
12733var Tooltip = (props) => {
12734  return memo(() => props.children);
12735};
12736

12737// src/app/classic/components/folder.jsx
12738var _tmpl$17 = /* @__PURE__ */ template(`<input type="file" accept=".vZome">`);
12739var queryParams = new URLSearchParams(window.location.search);
12740var enableDropbox = !!queryParams.get("enableDropbox");
12741if (enableDropbox) {
12742  window.localStorage.setItem("vzome.enable.dropbox", true);
12743}
12744var models = [{
12745  key: "vZomeLogo",
12746  label: "vZome Logo",
12747  description: "The vZome logo, one tetrahedral cell of the 4D 600-cell (cell-first projection)"
12748}, {
12749  key: "affineDodec",
12750  label: "Stretched Dodecahedron",
12751  description: "A regular dodecahedron stretched by a linear transformation"
12752}, {
12753  key: "120-cell",
12754  label: "Hyper-dodecahedron",
12755  description: "The 4D analogue of a dodecahedron, with 120 dodecahedral cells"
12756}, {
12757  key: "bluePlaneArches1",
12758  label: "Arched Rhombic Triacontahedron",
12759  description: "A sculpture built using just the blue planes"
12760}, {
12761  key: "C240",
12762  label: "C-240 Buckyball",
12763  description: "C-240 Buckyball"
12764}, {
12765  key: "orangePurpleChiral",
12766  label: "Orange and Purple Tangle",
12767  description: "A design by Brian Hall"
12768}, {
12769  key: "truncated5Cell",
12770  url: "https://www.vzome.com/models/2007/04-Apr/5cell/A4_3C.vZome",
12771  label: "Truncated 5-Cell",
12772  description: "Truncated 5-Cell"
12773}];
12774var getModelURL = (key, pathToRoot = "./models") => new URL(`${pathToRoot}/${key}.vZome`, window.location).toString();
12775var OpenMenu = (props) => {
12776  const {
12777    fetchDesignUrl,
12778    openDesignFile: openDesignFile2
12779  } = useEditor();
12780  const [anchor, setAnchor] = createSignal(null);
12781  const [showDialog, setShowDialog] = createSignal(false);
12782  const acceptFiles = ".vZome";
12783  let inputRef;
12784  const dropboxEnabled = window.Dropbox && window.localStorage.getItem("vzome.enable.dropbox");
12785  const chooseFile = () => {
12786    setAnchor(null);
12787    inputRef.click();
12788  };
12789  const showDropboxChooser = () => {
12790    setAnchor(null);
12791    window.Dropbox.choose({
12792      linkType: "direct",
12793      extensions: [".vzome"],
12794      success: (files) => {
12795        fetchDesignUrl(files[0].link, {
12796          preview: false,
12797          debug: props.forDebugger
12798        });
12799      }
12800    });
12801  };
12802  const onFileSelected = (e) => {
12803    const selected = e.target.files && e.target.files[0];
12804    if (selected) openDesignFile2(selected, props.forDebugger);
12805    inputRef.value = null;
12806  };
12807  const openUrl = (url) => {
12808    if (url && url.endsWith(".vZome")) {
12809      fetchDesignUrl(url, {
12810        preview: false,
12811        debug: props.forDebugger
12812      });
12813    }
12814  };
12815  const handleClickOpen = (event) => {
12816    setAnchor(event.currentTarget);
12817  };
12818  const handleSelectModel = (model) => {
12819    setAnchor(null);
12820    const {
12821      url,
12822      key
12823    } = model;
12824    openUrl(url || getModelURL(key, props.pathToRoot), key);
12825  };
12826  const handleClose = () => {
12827    setAnchor(null);
12828  };
12829  const handleShowUrlDialog = () => {
12830    setAnchor(null);
12831    setShowDialog(true);
12832  };
12833  return [createComponent(Tooltip, {
12834    title: "Open a design",
12835    "aria-label": "open",
12836    get children() {
12837      return createComponent(IconButton_default, {
12838        color: "inherit",
12839        "aria-label": "open",
12840        onClick: handleClickOpen,
12841        get children() {
12842          return createComponent(FolderOpenRounded_default, {
12843            fontSize: "large"
12844          });
12845        }
12846      });
12847    }
12848  }), createComponent(Menu_default, {
12849    get anchorEl() {
12850      return anchor();
12851    },
12852    get open() {
12853      return Boolean(anchor());
12854    },
12855    onClose: handleClose,
12856    get children() {
12857      return [createComponent(MenuItem_default, {
12858        onClick: chooseFile,
12859        get children() {
12860          return ["Local vZome file", (() => {
12861            const _el$ = _tmpl$17();
12862            _el$.addEventListener("change", onFileSelected);
12863            const _ref$ = inputRef;
12864            typeof _ref$ === "function" ? use(_ref$, _el$) : inputRef = _el$;
12865            _el$.style.setProperty("display", "none");
12866            return _el$;
12867          })()];
12868        }
12869      }), createComponent(MenuItem_default, {
12870        onClick: handleShowUrlDialog,
12871        children: "Remote vZome URL"
12872      }), memo(() => dropboxEnabled && createComponent(MenuItem_default, {
12873        onClick: showDropboxChooser,
12874        children: "Choose from Dropbox"
12875      })), createComponent(Divider_default, {}), createComponent(For, {
12876        each: models,
12877        children: (model) => createComponent(MenuItem_default, {
12878          onClick: () => handleSelectModel(model),
12879          get children() {
12880            return model.label;
12881          }
12882        })
12883      })];
12884    }
12885  }), createComponent(UrlDialog, {
12886    get show() {
12887      return showDialog();
12888    },
12889    setShow: setShowDialog,
12890    openDesign: openUrl
12891  })];
12892};
12893

12894// src/app/classic/components/logo.jsx
12895var _tmpl$18 = /* @__PURE__ */ template(`<svg><path fill="#3e3e3e" d="M 269.02 277.8 L 272.46 283.83 L 287.98 296.29 L 286.3 291.64  z"></svg>`, false, true);
12896var _tmpl$27 = /* @__PURE__ */ template(`<svg><path fill="#e7e7e1" d="M 278.1 234.58 L 267.43 243.11 L 275.89 238.56 L 287.57 229.43  z"></svg>`, false, true);
12897var _tmpl$35 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 337.14 259.25 L 331.34 244.39 L 328.71 237.77 L 334.6 252.83  z"></svg>`, false, true);
12898var _tmpl$44 = /* @__PURE__ */ template(`<svg><path fill="#7c7c7f" d="M 312.8 292.04 L 323.06 288.12 L 301.1 296.41  z"></svg>`, false, true);
12899var _tmpl$53 = /* @__PURE__ */ template(`<svg><path fill="#c7c7c3" d="M 299.53 226.34 L 287.57 229.43 L 301.91 228.56 L 312.64 225.73  z"></svg>`, false, true);
12900var _tmpl$63 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 337.14 259.25 L 334.6 252.83 L 330.46 274.92 L 333.45 279.09  z"></svg>`, false, true);
12901var _tmpl$72 = /* @__PURE__ */ template(`<svg><path fill="#231b33" d="M 247.91 235.51 L 267.43 243.11 L 275.89 238.56 L 256.03 230.78  z"></svg>`, false, true);
12902var _tmpl$82 = /* @__PURE__ */ template(`<svg><path fill="#fbfbf5" d="M 275.89 238.56 L 267.43 243.11 L 263.23 262.81 L 271.67 258.63  z"></svg>`, false, true);
12903var _tmpl$92 = /* @__PURE__ */ template(`<svg><path fill="#333333" d="M 301.1 296.41 L 299.6 291.72 L 286.3 291.64 L 287.98 296.29  z"></svg>`, false, true);
12904var _tmpl$102 = /* @__PURE__ */ template(`<svg><path fill="#ac85fa" d="M 258.98 217.29 L 275.89 238.56 L 287.57 229.43  z"></svg>`, false, true);
12905var _tmpl$112 = /* @__PURE__ */ template(`<svg><path fill="#b8b8b4" d="M 269.02 277.8 L 278.45 273.52 L 271.67 258.63 L 263.23 262.81  z"></svg>`, false, true);
12906var _tmpl$122 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 301.91 228.56 L 318.16 240.84 L 328.71 237.77 L 312.64 225.73  z"></svg>`, false, true);
12907var _tmpl$132 = /* @__PURE__ */ template(`<svg><path fill="#828280" d="M 269.02 277.8 L 286.3 291.64 L 278.45 273.52  z"></svg>`, false, true);
12908var _tmpl$142 = /* @__PURE__ */ template(`<svg><path fill="#d8d8dd" d="M 319.88 284.05 L 323.06 288.12 L 333.45 279.09 L 330.46 274.92  z"></svg>`, false, true);
12909var _tmpl$152 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 301.91 228.56 L 287.57 229.43 L 275.89 238.56 L 290.21 237.76  z"></svg>`, false, true);
12910var _tmpl$162 = /* @__PURE__ */ template(`<svg><path fill="#78787a" d="M 319.88 284.05 L 299.6 291.72 L 301.1 296.41 L 323.06 288.12  z"></svg>`, false, true);
12911var _tmpl$172 = /* @__PURE__ */ template(`<svg><path fill="#f9f9fe" d="M 318.16 240.84 L 323.09 256.52 L 334.6 252.83 L 328.71 237.77  z"></svg>`, false, true);
12912var _tmpl$182 = /* @__PURE__ */ template(`<svg><path fill="#f3f3f9" d="M 330.46 274.92 L 334.6 252.83 L 323.09 256.52  z"></svg>`, false, true);
12913var _tmpl$19 = /* @__PURE__ */ template(`<svg><path fill="#302546" d="M 146.76 150.32 L 140.67 156.75 L 247.91 235.51 L 256.03 230.78  z"></svg>`, false, true);
12914var _tmpl$20 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 275.89 238.56 L 271.67 258.63 L 285.64 260.03 L 290.21 237.76  z"></svg>`, false, true);
12915var _tmpl$21 = /* @__PURE__ */ template(`<svg><path fill="#858583" d="M 286.3 291.64 L 299.6 291.72 L 292.53 275.07 L 278.45 273.52  z"></svg>`, false, true);
12916var _tmpl$222 = /* @__PURE__ */ template(`<svg><path fill="#fffffd" d="M 301.91 228.56 L 290.21 237.76 L 308.08 251.46 L 318.16 240.84  z"></svg>`, false, true);
12917var _tmpl$232 = /* @__PURE__ */ template(`<svg><path fill="#d1d1d5" d="M 319.88 284.05 L 330.46 274.92 L 323.09 256.52 L 313.02 267.28  z"></svg>`, false, true);
12918var _tmpl$242 = /* @__PURE__ */ template(`<svg><path fill="#af87ff" d="M 146.76 150.32 L 256.03 230.78 L 275.89 238.56 L 258.98 217.29 L 150.34 136.97 L 129.32 128.43  z"></svg>`, false, true);
12919var _tmpl$252 = /* @__PURE__ */ template(`<svg><path fill="#eeeee9" d="M 278.45 273.52 L 292.53 275.07 L 285.64 260.03 L 271.67 258.63  z"></svg>`, false, true);
12920var _tmpl$262 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 308.08 251.46 L 290.21 237.76 L 285.64 260.03  z"></svg>`, false, true);
12921var _tmpl$272 = /* @__PURE__ */ template(`<svg><path fill="#838383" d="M 319.88 284.05 L 313.02 267.28 L 292.53 27

129215.07 L 299.6 291.72  z"></svg>`, false, true);
12922var _tmpl$28 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 318.16 240.84 L 308.08 251.46 L 313.02 267.28 L 323.09 256.52  z"></svg>`, false, true);
12923var _tmpl$29 = /* @__PURE__ */ template(`<svg><path fill="#434344" d="M 110.72 143.96 L 94.46 145.51 L 83.09 147.02 L 97.95 145.6  z"></svg>`, false, true);
12924var _tmpl$30 = /* @__PURE__ */ template(`<svg><path fill="#efefea" d="M 313.02 267.28 L 308.08 251.46 L 285.64 260.03 L 292.53 275.07  z"></svg>`, false, true);
12925var _tmpl$31 = /* @__PURE__ */ template(`<svg><path fill="#231b33" d="M 146.76 150.32 L 116.8 136.54 L 110.72 143.96 L 140.67 156.75  z"></svg>`, false, true);
12926var _tmpl$322 = /* @__PURE__ */ template(`<svg><path fill="#b0b0b4" d="M 123.58 135.31 L 129.32 128.43 L 116.8 136.54 L 110.72 143.96  z"></svg>`, false, true);
12927var _tmpl$332 = /* @__PURE__ */ template(`<svg><path fill="#637000" d="M 252.8 271.39 L 266.84 272.95 L 285.64 260.03 L 271.67 258.63  z"></svg>`, false, true);
12928var _tmpl$342 = /* @__PURE__ */ template(`<svg><path fill="#67002d" d="M 309.25 236.52 L 308.08 251.46 L 318.16 240.84  z"></svg>`, false, true);
12929var _tmpl$352 = /* @__PURE__ */ template(`<svg><path fill="#3e001a" d="M 309.25 236.52 L 292.66 223.95 L 290.21 237.76 L 308.08 251.46  z"></svg>`, false, true);
12930var _tmpl$36 = /* @__PURE__ */ template(`<svg><path fill="#3e3e3e" d="M 62.41 127.1 L 68.96 135.53 L 83.09 147.02 L 78.11 139.83  z"></svg>`, false, true);
12931var _tmpl$37 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 134.72 108.98 L 128.86 93.68 L 123.15 84.58 L 129.09 100.1  z"></svg>`, false, true);
12932var _tmpl$38 = /* @__PURE__ */ template(`<svg><path fill="#7c7c7f" d="M 110.72 143.96 L 116.8 136.54 L 94.46 145.51  z"></svg>`, false, true);
12933var _tmpl$39 = /* @__PURE__ */ template(`<svg><path fill="#63002b" d="M 309.25 236.52 L 318.16 240.84 L 319.12 227.83  z"></svg>`, false, true);
12934var _tmpl$40 = /* @__PURE__ */ template(`<svg><path fill="#647100" d="M 273.8 288.3 L 292.53 275.07 L 285.64 260.03 L 266.84 272.95  z"></svg>`, false, true);
12935var _tmpl$41 = /* @__PURE__ */ template(`<svg><path fill="#af87ff" d="M 146.76 150.32 L 129.32 128.43 L 116.8 136.54  z"></svg>`, false, true);
12936var _tmpl$422 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 134.72 108.98 L 129.09 100.1 L 123.02 121.74 L 129.32 128.43  z"></svg>`, false, true);
12937var _tmpl$432 = /* @__PURE__ */ template(`<svg><path fill="#fbfbf5" d="M 67.08 84.51 L 62.52 92.36 L 56.57 111.66 L 61.04 104.16  z"></svg>`, false, true);
12938var _tmpl$442 = /* @__PURE__ */ template(`<svg><path fill="#333333" d="M 94.46 145.51 L 89.61 138.22 L 78.11 139.83 L 83.09 147.02  z"></svg>`, false, true);
12939var _tmpl$45 = /* @__PURE__ */ template(`<svg><path fill="#b8b8b4" d="M 62.41 127.1 L 67.47 119.18 L 61.04 104.16 L 56.57 111.66  z"></svg>`, false, true);
12940var _tmpl$46 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 93.53 73.69 L 108.32 84.9 L 123.15 84.58 L 108.48 73.58  z"></svg>`, false, true);
12941var _tmpl$47 = /* @__PURE__ */ template(`<svg><path fill="#828280" d="M 62.41 127.1 L 78.11 139.83 L 67.47 119.18  z"></svg>`, false, true);
12942var _tmpl$48 = /* @__PURE__ */ template(`<svg><path fill="#d8d8dd" d="M 110.24 129.91 L 116.8 136.54 L 129.32 128.43 L 123.02 121.74  z"></svg>`, false, true);
12943var _tmpl$49 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 93.53 73.69 L 80.55 76.02 L 67.08 84.51 L 80.02 82.25  z"></svg>`, false, true);
12944var _tmpl$50 = /* @__PURE__ */ template(`<svg><path fill="#78787a" d="M 110.24 129.91 L 89.61 138.22 L 94.46 145.51 L 116.8 136.54  z"></svg>`, false, true);
12945var _tmpl$51 = /* @__PURE__ */ template(`<svg><path fill="#f9f9fe" d="M 108.32 84.9 L 112.87 100.77 L 129.09 100.1 L 123.15 84.58  z"></svg>`, false, true);
12946var _tmpl$522 = /* @__PURE__ */ template(`<svg><path fill="#f3f3f9" d="M 123.02 121.74 L 129.09 100.1 L 112.87 100.77  z"></svg>`, false, true);
12947var _tmpl$532 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 121.5 156.95 L 116.8 136.54 L 110.24 129.91  z"></svg>`, false, true);
12948var _tmpl$54 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 67.08 84.51 L 61.04 104.16 L 73.43 104.05 L 80.02 82.25  z"></svg>`, false, true);
12949var _tmpl$55 = /* @__PURE__ */ template(`<svg><path fill="#858583" d="M 78.11 139.83 L 89.61 138.22 L 79.96 119.22 L 67.47 119.18  z"></svg>`, false, true);
12950var _tmpl$56 = /* @__PURE__ */ template(`<svg><path fill="#fffffd" d="M 93.53 73.69 L 80.02 82.25 L 96.25 94.76 L 108.32 84.9  z"></svg>`, false, true);
12951var _tmpl$57 = /* @__PURE__ */ template(`<svg><path fill="#d1d1d5" d="M 110.24 129.91 L 123.02 121.74 L 112.87 100.77 L 100.8 110.78  z"></svg>`, false, true);
12952var _tmpl$58 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 116.44 150.41 L 121.5 156.95 L 110.24 129.91  z"></svg>`, false, true);
12953var _tmpl$59 = /* @__PURE__ */ template(`<svg><path fill="#eeeee9" d="M 67.47 119.18 L 79.96 119.22 L 73.43 104.05 L 61.04 104.16  z"></svg>`, false, true);
12954var _tmpl$60 = /* @__PURE__ */ template(`<svg><path fill="#332200" d="M 132.25 105.95 L 123.02 121.74 L 145.32 116.11  z"></svg>`, false, true);
12955var _tmpl$61 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 96.25 94.76 L 80.02 82.25 L 73.43 104.05  z"></svg>`, false, true);
12956var _tmpl$622 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 116.44 150.41 L 110.24 129.91 L 89.61 138.22 L 95.59 158.76  z"></svg>`, false, true);
12957var _tmpl$632 = /* @__PURE__ */ template(`<svg><path fill="#7d5300" d="M 132.25 105.95 L 112.87 100.77 L 123.02 121.74  z"></svg>`, false, true);
12958var _tmpl$64 = /* @__PURE__ */ template(`<svg><path fill="#838383" d="M 110.24 129.91 L 100.8 110.78 L 79.96 119.22 L 89.61 138.22  z"></svg>`, false, true);
12959var _tmpl$65 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 108.32 84.9 L 96.25 94.76 L 100.8 110.78 L 112.87 100.77  z"></svg>`, false, true);
12960var _tmpl$66 = /* @__PURE__ */ template(`<svg><path fill="#f0a000" d="M 132.25 105.95 L 143.38 94.58 L 112.87 100.77  z"></svg>`, false, true);
12961var _tmpl$67 = /* @__PURE__ */ template(`<svg><path fill="#efefea" d="M 100.8 110.78 L 96.25 94.76 L 73.43 104.05 L 79.96 119.22  z"></svg>`, false, true);
12962var _tmpl$68 = /* @__PURE__ */ template(`<svg><path fill="#586300" d="M 207.26 302.74 L 266.84 272.95 L 252.8 271.39 L 192.8 300.75  z"></svg>`, false, true);
12963var _tmpl$69 = /* @__PURE__ */ template(`<svg><path fill="#647100" d="M 273.8 288.3 L 266.84 272.95 L 207.26 302.74 L 214.56 319.34  z"></svg>`, false, true);
12964var _tmpl$70 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 149.11 268.55 L 154.05 273.81 L 121.5 156.95 L 116.44 150.41  z"></svg>`, false, true);
12965var _tmpl$71 = /* @__PURE__ */ template(`<svg><path fill="#41001b" d="M 309.25 236.52 L 324.33 145 L 305.62 131.97 L 292.66 223.95  z"></svg>`, false, true);
12966var _tmpl$722 = /* @__PURE__ */ template(`<svg><path fill="#63002b" d="M 309.25 236.52 L 319.12 227.83 L 335.25 135.97 L 324.33 145  z"></svg>`, false, true);
12967var _tmpl$73 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 149.11 268.55 L 116.44 150.41 L 95.59 158.76 L 126.62 277.24  z"></svg>`, false, true);
12968var _tmpl$74 = /* @__PURE__ */ template(`<svg><path fill="#302000" d="M 274.29 103.43 L 262.24 92 L 132.25 105.95 L 145.32 116.11  z"></svg>`, false, true);
12969var _tmpl$75 = /* @__PURE__ */ template(`<svg><path fill="#f0a000" d="M 132.25 105.95 L 262.24 92 L 272.39 79.71 L 143.38 94.58  z"></svg>`, false, true);
12970var _tmpl$76 = /* @__PURE__ */ template(`<svg><path fill="#637000" d="M 207.26 302.74 L 192.8 300.75 L 170.56 315.58 L 185.06 317.77  z"></svg>`, false, true);
12971var _tmpl$77 = /* @__PURE__ */ template(`<svg><path fill="#647100" d="M 214.56 319.34 L 207.26 302.74 L 185.06 317.77 L 192.43 334.75  z"></svg>`, false, true);
12972var _tmpl$78 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 149.11 268.55 L 161.16 297.3 L 154.05 273.81  z"></svg>`, false, true);
12973var _tmpl$79 = /* @__PURE__ */ template(`<svg><path fill="#740032" d="M 149.11 268.55 L 156.99 291.93 L 161.16 297.3  z"></svg>`, false, true);
12974var _tmpl$80 = /* @__PURE__ */ template(`<svg><path fill="#750032" d="M 149.11 268.55 L 126.62 277.24 L 131.93 301.55 L 156.99 291.93  z"></svg>`, false, true);
12975var _tmpl$81 = /* @__PURE__ */ template(`<svg><path fill="#63002b" d="M 324.33 145 L 335.25 135.97 L 325.57 127.82  z"></svg>`, false, true);
12976var _tmpl$822 = /* @__PURE__ */ template(`<svg><path fill="#370017" d="M 324.33 145 L 325.57 127.82 L 306.43 114.69 L 305.62 131.97  z"></svg>`, false, true);
12977var _tmpl$83 = /* @__PURE__ */ template(`<svg><path fill="#e7e7e1" d="M 131.93 301.55 L 117.86 312.32 L 124.41 308.54 L 139.43 297.14  z"></svg>`, false, true);
12978var _tmpl$84 = /* @__PURE__ */ template(`<svg><path fill="#5e0029" d="M 335.25 135.97 L 339.08 117.79 L 325.57 127.82  z"></svg>`, false, true);
12979var _tmpl$85 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 200.56 331.58 L 193.79 313.85 L 188.34 307.13 L 195.22 325.15  z"></svg>`, false, true);
12980var _tmpl$86 = /* @__PURE__ */ template(`<svg><path fill="#9271da" d="M 209.63 282.91 L 188.34 307.13 L 193.79 313.85  z"></svg>`, false, true);
12981var _tmpl$87 = /* @__PURE__ */ template(`<svg><path fill="#f0a000" d="M 272.39 79.71 L 262.24 92 L 291.75 73.03  z"></svg>`, false, true);
12982var _tmpl$88 = /* @__PURE__ */ template(`<svg><path fill="#513600" d="M 274.29 103.43 L 300.77 96.96 L 286.37 97.65  z"></svg>`, false, true);
12983var _tmpl$89 = /* @__PURE__ */ template(`<svg><path fill="#c7c7c3" d="M 156.99 291.93 L 139.43 297.14 L 154.97 296.82 L 170.81 292.03  z"></svg>`, false, true);
12984var _tmpl$90 = /* @__PURE__ */ template(`<svg><path fill="#2b1d00" d="M 274.29 103.43 L 286.37 97.65 L 262.24 92  z"></svg>`, false, true);
12985var _tmpl$91 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 200.56 331.58 L 195.22 325.15 L 188.9 352.23 L 194.96 355.84  z"></svg>`, false, true);
12986var _tmpl$922 = /* @__PURE__ */ template(`<svg><path fill="#a781ee" d="M 170.81 292.03 L 188.34 307.13 L 199.43 286.03 L 181.6 271.03  z"></svg>`, false, true);
12987var _tmpl$93 = /* @__PURE__ */ template(`<svg><path fill="#fbfbf5" d="M 124.41 308.54 L 117.86 312.32 L 111.54 336.38 L 117.99 333.14  z"></svg>`, false, true);
12988var _tmpl$94 = /* @__PURE__ */ template(`<svg><path fill="#333333" d="M 155.44 377.01 L 150.98 372.88 L 137 371.75 L 141.65 375.86  z"></svg>`, false, true);
12989var _tmpl$95 = /* @__PURE__ */ template(`<svg><path fill="#f0a000" d="M 286.37 97.65 L 291.75 73.03 L 262.24 92  z"></svg>`, false, true);
12990var _tmpl$96 = /* @__PURE__ */ template(`<svg><path fill="#b8b8b4" d="M 118.29 354.29 L 125.58 351.19 L 117.99 333.14 L 111.54 336.38  z"></svg>`, false, true);
12991var _tmpl$97 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 154.97 296.82 L 172.69 312.3 L 188.34 307.13 L 170.81 292.03  z"></svg>`, false, true);
12992var _tmpl$98 = /* @__PURE__ */ template(`<svg><path fill="#828280" d="M 118.29 354.29 L 137 371.75 L 125.58 351.19  z"></svg>`, false, true);
12993var _tmpl$99 = /* @__PURE__ */ template(`<svg><path fill="#d8d8dd" d="M 174.86 363.91 L 181.23 367.34 L 194.96 355.84 L 188.9 352.23  z"></svg>`, false, true);
12994var _tmpl$100 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 154.97 296.82 L 139.43 297.14 L 124.41 308.54 L 139.89 308.33  z"></svg>`, false, true);
12995var _tmpl$101 = /* @__PURE__ */ template(`<svg><path fill="#78787a" d="M 174.86 363.91 L 150.98 372.88 L 155.44 377.01 L 181.23 367.34  z"></svg>`, false, true);
12996var _tmpl$1022 = /* @__PURE__ */ template(`<svg><path fill="#f9f9fe" d="M 172.69 312.3 L 178.13 331.29 L 195.22 325.15 L 188.34 307.13  z"></svg>`, false, true);
12997var _tmpl$103 = /* @__PURE__ */ template(`<svg><path fill="#f3f3f9" d="M 188.9 352.23 L 195.22 325.15 L 178.13 331.29  z"></svg>`, false, true);
12998var _tmpl$104 = /* @__PURE__ */ template(`<svg><path fill="#9472dd" d="M 209.63 282.91 L 300.46 152.09 L 312.84 129.12 L 291.4 153.34 L 199.43 286.03 L 188.34 307.13  z"></svg>`, false, true);
12999var _tmpl$105 = /* @__PURE__ */ template(`<svg><path fill="#af87ff" d="M 181.6 271.03 L 199.43 286.03 L 291.4 153.34 L 272.15 139.57  z"></svg>`, false, true);
13000var _tmpl$106 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 124.41 308.54 L 117.99 333.14 L 132.91 335.69 L 139.89 308.33  z"></svg>`, false, true);
13001var _tmpl$107 = /* @__PURE__ */ template(`<svg><path fill="#858583" d="M 137 371.75 L 150.98 372.88 L 140.64 353.96 L 125.58 351.19  z"></svg>`, false, true);
13002var _tmpl$108 = /* @__PURE__ */ template(`<svg><path fill="#fffffd" d="M 154.97 296.82 L 139.89 308.33 L 159.36 325.64 L 172.69 312.3  z"></svg>`, false, true);
13003var _tmpl$109 = /* @__PURE__ */ template(`<svg><path fill="#434344" d="M 343.16 125.69 L 329.41 127.09 L 312.84 129.12 L 325.57 127.82  z"></svg>`, false, true);
13004var _tmpl$110 = /* @__PURE__ */ template(`<svg><path fill="#686867" d="M 286.37 97.65 L 293.44 115.7 L 289.55 105.32 L 282.36 86.97  z"></svg>`, false, true);
13005var _tmpl$111 = /* @__PURE__ */ template(`<svg><path fill="#d1d1d5" d="M 174.86 363.91 L 188.9 352.23 L 178.13 331.29 L 164.8 344.83  z"></svg>`, false, true);
13006var _tmpl$1122 = /* @__PURE__ */ template(`<svg><path fill="#eeeee9" d="M 125.58 351.19 L 140.64 353.96 L 132.91 335.69 L 117.99 333.14  z"></svg>`, false, true);
13007var _tmpl$113 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 159.36 325.64 L 139.89 308.33 L 132.91 335.69  z"></svg>`, false, true);
13008var _tmpl$114 = /* @__PURE__ */ template(`<svg><path fill="#838383" d="M 174.86 363.91 L 164.8 344.83 L 140.64 353.96 L 150.98 372.88  z"></svg>`, false, true);
13009var _tmpl$115 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 172.69 312.3 L 159.36 325.64 L 164.8 344.83 L 178.13 331.29  z"></svg>`, false, true);
13010var _tmpl$116 = /* @__PURE__ */ template(`<svg><path fill="#3e3e3e" d="M 289.55 105.32 L 293.44 115.7 L 312.84 129.12 L 311.23 120.22  z"></svg>`, false, true);
13011var _tmpl$117 = /* @__PURE__ */ template(`<svg><path fill="#efefea" d="M 164.8 344.83 L 159.36 325.64 L 132.91 335.69 L 140.64 353.96  z"></svg>`, false, true);
13012var _tmpl$118 = /* @__PURE__ */ template(`<svg><path fill="#aa83f3" d="M 272.15 139.57 L 291.4 153.34 L 311.23 120.22 L 289.55 105.32  z"></svg>`, false, true);
13013var _tmpl$119 = /* @__PURE__ */ template(`<svg><path fill="#7c7c7f" d="M 343.16 125.69 L 356.69 116.35 L 329.41 127.09  z"></svg>`, false, true);
13014var _tmpl$120 = /* @__PURE__ */ template(`<svg><path fill="#9573de" d="M 291.4 153.34 L 312.84 129.12 L 311.23 120.22  z"></svg>`, false, true);
13015var _tmpl$121 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 373.43 83.98 L 370.91 72.96 L 366.15 98.51 L 369.2 106.91  z"></svg>`, false, true);
13016var _tmpl$1222 = /* @__PURE__ */ template(`<svg><path fill="#fbfbf5" d="M 298.36 54.21 L 287.38 64.26 L 282.36 86.97 L 293.33 77.39  z"></svg>`, false, true);
13017var _tmpl$123 = /* @__PURE__ */ template(`<svg><path fill="#333333" d="M 329.41 127.09 L 328.09 118.03 L 311.23 120.22 L 312.84 129.12  z"></svg>`, false, true);
13018var _tmpl$124 = /* @__PURE__ */ template(`<svg><path fill="#b8b8b4" d="M 289.55 105.32 L 301.83 95.26 L 293.33 77.39 L 282.36 86.97  z"></svg>`, false, true);
13019var _tmpl$125 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 330.7 41.19 L 351.25 54.2 L 363.58 54.5 L 343.33 41.77  z"></svg>`, false, true);
13020var _tmpl$126 = /* @__PURE__ */ template(`<svg><path fill="#828280" d="M 289.55 105.32 L 311.23 120.22 L 301.83 95.26  z"></svg>`, false, true);
13021var _tmpl$127 = /* @__PURE__ */ template(`<svg>

13021<path fill="#d8d8dd" d="M 353.37 108.05 L 356.69 116.35 L 369.2 106.91 L 366.15 98.51  z"></svg>`, false, true);
13022var _tmpl$128 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 330.7 41.19 L 312.64 44.32 L 298.36 54.21 L 316.4 51.17  z"></svg>`, false, true);
13023var _tmpl$129 = /* @__PURE__ */ template(`<svg><path fill="#78787a" d="M 353.37 108.05 L 328.09 118.03 L 329.41 127.09 L 356.69 116.35  z"></svg>`, false, true);
13024var _tmpl$130 = /* @__PURE__ */ template(`<svg><path fill="#f9f9fe" d="M 351.25 54.2 L 357.49 73.1 L 370.91 72.96 L 363.58 54.5  z"></svg>`, false, true);
13025var _tmpl$131 = /* @__PURE__ */ template(`<svg><path fill="#f3f3f9" d="M 366.15 98.51 L 370.91 72.96 L 357.49 73.1  z"></svg>`, false, true);
13026var _tmpl$1322 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 298.36 54.21 L 293.33 77.39 L 310.98 76.93 L 316.4 51.17  z"></svg>`, false, true);
13027var _tmpl$133 = /* @__PURE__ */ template(`<svg><path fill="#858583" d="M 311.23 120.22 L 328.09 118.03 L 319.66 95.01 L 301.83 95.26  z"></svg>`, false, true);
13028var _tmpl$134 = /* @__PURE__ */ template(`<svg><path fill="#fffffd" d="M 330.7 41.19 L 316.4 51.17 L 339 65.73 L 351.25 54.2  z"></svg>`, false, true);
13029var _tmpl$135 = /* @__PURE__ */ template(`<svg><path fill="#d1d1d5" d="M 353.37 108.05 L 366.15 98.51 L 357.49 73.1 L 345.25 84.84  z"></svg>`, false, true);
13030var _tmpl$136 = /* @__PURE__ */ template(`<svg><path fill="#eeeee9" d="M 301.83 95.26 L 319.66 95.01 L 310.98 76.93 L 293.33 77.39  z"></svg>`, false, true);
13031var _tmpl$137 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 339 65.73 L 316.4 51.17 L 310.98 76.93  z"></svg>`, false, true);
13032var _tmpl$138 = /* @__PURE__ */ template(`<svg><path fill="#838383" d="M 353.37 108.05 L 345.25 84.84 L 319.66 95.01 L 328.09 118.03  z"></svg>`, false, true);
13033var _tmpl$139 = /* @__PURE__ */ template(`<svg><path fill="#ffffff" d="M 351.25 54.2 L 339 65.73 L 345.25 84.84 L 357.49 73.1  z"></svg>`, false, true);
13034var _tmpl$140 = /* @__PURE__ */ template(`<svg><path fill="#efefea" d="M 345.25 84.84 L 339 65.73 L 310.98 76.93 L 319.66 95.01  z"></svg>`, false, true);
13035var VZomeLogo = () => {
13036  return createComponent(IconButton_default, {
13037    sx: {
13038      padding: "12px"
13039    },
13040    component: Link_default,
13041    href: "https://vzome.com",
13042    target: "_blank",
13043    rel: "noopener",
13044    get children() {
13045      return createComponent(SvgIcon_default2, {
13046        fontSize: "large",
13047        stroke: "black",
13048        strokeLinejoin: "round",
13049        strokeWidth: "0.5",

13050        viewBox: "55 40 340.0 340.0",
13051        get children() {
13052          return [_tmpl$18(), _tmpl$27(), _tmpl$35(), _tmpl$44(), _tmpl$53(), _tmpl$63(), _tmpl$72(), _tmpl$82(), _tmpl$92(), _tmpl$102(), _tmpl$112(), _tmpl$122(), _tmpl$132(), _tmpl$142(), _tmpl$152(), _tmpl$162(), _tmpl$172(), _tmpl$182(), _tmpl$19(), _tmpl$20(), _tmpl$21(), _tmpl$222(), _tmpl$232(), _tmpl$242(), _tmpl$252(), _tmpl$262(), _tmpl$272(), _tmpl$28(), _tmpl$29(), _tmpl$30(), _tmpl$31(), _tmpl$322(), _tmpl$332(), _tmpl$342(), _tmpl$352(), _tmpl$36(), _tmpl$37(), _tmpl$38(), _tmpl$39(), _tmpl$40(), _tmpl$41(), _tmpl$422(), _tmpl$432(), _tmpl$442(), _tmpl$45(), _tmpl$46(), _tmpl$47(), _tmpl$48(), _tmpl$49(), _tmpl$50(), _tmpl$51(), _tmpl$522(), _tmpl$532(), _tmpl$54(), _tmpl$55(), _tmpl$56(), _tmpl$57(), _tmpl$58(), _tmpl$59(), _tmpl$60(), _tmpl$61(), _tmpl$622(), _tmpl$632(), _tmpl$64(), _tmpl$65(), _tmpl$66(), _tmpl$67(), _tmpl$68(), _tmpl$69(), _tmpl$70(), _tmpl$71(), _tmpl$722(), _tmpl$73(), _tmpl$74(), _tmpl$75(), _tmpl$76(), _tmpl$77(), _tmpl$78(), _tmpl$79(), _tmpl$80(), _tmpl$81(), _tmpl$822(), _tmpl$83(), _tmpl$84(), _tmpl$85(), _tmpl$86(), _tmpl$87(), _tmpl$88(), _tmpl$89(), _tmpl$90(), _tmpl$91(), _tmpl$922(), _tmpl$93(), _tmpl$94(), _tmpl$95(), _tmpl$96(), _tmpl$97(), _tmpl$98(), _tmpl$99(), _tmpl$100(), _tmpl$101(), _tmpl$1022(), _tmpl$103(), _tmpl$104(), _tmpl$105(), _tmpl$106(), _tmpl$107(), _tmpl$108(), _tmpl$109(), _tmpl$110(), _tmpl$111(), _tmpl$1122(), _tmpl$113(), _tmpl$114(), _tmpl$115(), _tmpl$116(), _tmpl$117(), _tmpl$118(), _tmpl$119(), _tmpl$120(), _tmpl$121(), _tmpl$1222(), _tmpl$123(), _tmpl$124(), _tmpl$125(), _tmpl$126(), _tmpl$127(), _tmpl$128(), _tmpl$129(), _tmpl$130(), _tmpl$131(), _tmpl$1322(), _tmpl$133(), _tmpl$134(), _tmpl$135(), _tmpl$136(), _tmpl$137(), _tmpl$138(), _tmpl$139(), _tmpl$140()];
13053        }
13054      });
13055    }
13056  });
13057};
13058

vendor: 359 bytes, lines 13059-13062

13059// node_modules/@suid/icons-material/InfoRounded.jsx
13060var _tmpl$141 = /* @__PURE__ */ template(`<svg><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 15c-.55 0-1-.45-1-1v-4c0-.55.45-1 1-1s1 .45 1 1v4c0 .55-.45 1-1 1zm1-8h-2V7h2v2z"></svg>`, false, true);
13061var InfoRounded_default = createSvgIcon(() => _tmpl$141(), "InfoRounded");
13062

13063// src/app/classic/dialogs/about.jsx
13064var AboutDialog = ({
13065  title,
13066  about
13067}) => {
13068  const [open, setOpen] = createSignal(true);
13069  const handleClickOpen = () => {
13070    setOpen(true);
13071  };
13072  const handleClose = () => {
13073    setOpen(false);
13074  };
13075  return [createComponent(Tooltip, {
13076    title: `About ${title}`,
13077    "aria-label": "about",
13078    get children() {
13079      return createComponent(IconButton_default, {
13080        color: "inherit",
13081        "aria-label": "about",
13082        onClick: handleClickOpen,
13083        get children() {
13084          return createComponent(InfoRounded_default, {
13085            fontSize: "large"
13086          });
13087        }
13088      });
13089    }
13090  }), createComponent(Dialog_default, {
13091    onClose: handleClose,
13092    "aria-labelledby": "about-dialog-title",
13093    get open() {
13094      return open();
13095    },
13096    get children() {
13097      return [createComponent(DialogTitle_default, {
13098        id: "customized-dialog-title",
13099        get children() {
13100          return ["About ", title, " (rev ", REVISION, ")"];
13101        }
13102      }), createComponent(DialogContent_default, {
13103        get children() {
13104          return createComponent(DialogContentText_default, {
13105            id: "about-dialog-description",
13106            children: about
13107          });
13108        }
13109      }), createComponent(DialogActions_default, {
13110        get children() {
13111          return createComponent(Button_default, {
13112            onClick: handleClose,
13113            children: "Close"
13114          });
13115        }
13116      })];
13117    }
13118  })];
13119};
13120

vendor: 346 bytes, lines 13121-13124

13121// node_modules/@suid/material/internal/svg-icons/CheckBox.jsx
13122var _tmpl$143 = /* @__PURE__ */ template(`<svg><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></svg>`, false, true);
13123var CheckBox_default = createSvgIcon2(() => _tmpl$143(), "CheckBox");
13124

vendor: 341 bytes, lines 13125-13128

13125// node_modules/@suid/material/internal/svg-icons/CheckBoxOutlineBlank.jsx
13126var _tmpl$144 = /* @__PURE__ */ template(`<svg><path d="M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></svg>`, false, true);
13127var CheckBoxOutlineBlank_default = createSvgIcon2(() => _tmpl$144(), "CheckBoxOutlineBlank");
13128

vendor: 347 bytes, lines 13129-13132

13129// node_modules/@suid/material/internal/svg-icons/IndeterminateCheckBox.jsx
13130var _tmpl$145 = /* @__PURE__ */ template(`<svg><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"></svg>`, false, true);
13131var IndeterminateCheckBox_default = createSvgIcon2(() => _tmpl$145(), "IndeterminateCheckBox");
13132

vendor: 361 bytes, lines 13133-13146

13133// node_modules/@suid/material/Checkbox/checkboxClasses.js
13134function getCheckboxUtilityClass(slot) {
13135  return generateUtilityClass("MuiCheckbox", slot);
13136}
13137var checkboxClasses = generateUtilityClasses("MuiCheckbox", [
13138  "root",
13139  "checked",
13140  "disabled",
13141  "indeterminate",
13142  "colorPrimary",
13143  "colorSecondary"
13144]);
13145var checkboxClasses_default = checkboxClasses;
13146

vendor: 3,168 bytes, lines 13147-13237

13147// node_modules/@suid/material/Checkbox/Checkbox.jsx
13148var $53 = createComponentFactory_default()({
13149  name: "MuiCheckbox",
13150  propDefaults: ({
13151    set
13152  }) => set({
13153    color: "primary",
13154    indeterminate: false,
13155    size: "medium",
13156    checkedIcon: () => createComponent(CheckBox_default, {}),
13157    icon: () => createComponent(CheckBoxOutlineBlank_default, {}),
13158    indeterminateIcon: () => createComponent(IndeterminateCheckBox_default, {})
13159  }),
13160  selfPropNames: ["checked", "checkedIcon", "classes", "color", "disableRipple", "disabled", "icon", "id", "indeterminate", "indeterminateIcon", "inputProps", "inputRef", "onChange", "required", "size", "value"],
13161  utilityClass: getCheckboxUtilityClass,
13162  slotClasses: (ownerState) => ({
13163    root: ["root", ownerState.indeterminate && "indeterminate", `color${capitalize_default(ownerState.color)}`]
13164  })
13165});
13166var CheckboxRoot = styled_default(SwitchBase_default, {
13167  skipProps: skipRootProps.filter((v) => v !== "classes"),
13168  name: "MuiCheckbox",
13169  slot: "Root",
13170  overridesResolver: (props, styles3) => {
13171    const {
13172      ownerState
13173    } = props;
13174    return [styles3.root, ownerState.indeterminate && styles3.indeterminate, ownerState.color !== "default" && styles3[`color${capitalize_default(ownerState.color)}`]];
13175  }
13176})(({
13177  theme,
13178  ownerState
13179}) => ({
13180  color: theme.palette.text.secondary,
13181  ...!ownerState.disableRipple && {
13182    "&:hover": {
13183      backgroundColor: alpha(ownerState.color === "default" ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
13184      // Reset on touch devices, it doesn't add specificity
13185      "@media (hover: none)": {
13186        backgroundColor: "transparent"
13187      }
13188    }
13189  },
13190  ...ownerState.color !== "default" && {
13191    [`&.${checkboxClasses_default.checked}, &.${checkboxClasses_default.indeterminate}`]: {
13192      color: theme.palette[ownerState.color].main
13193    },
13194    [`&.${checkboxClasses_default.disabled}`]: {
13195      color: theme.palette.action.disabled
13196    }
13197  }
13198}));
13199var Checkbox = $53.component(function Checkbox2({
13200  allProps,
13201  classes,
13202  props
13203}) {
13204  const icon = () => props.indeterminate ? props.indeterminateIcon : props.icon;
13205  const indeterminateIcon = () => props.indeterminate ? props.indeterminateIcon : props.checkedIcon;
13206  const [, baseProps] = splitProps(allProps, ["checkedIcon", "color", "icon", "indeterminate", "indeterminateIcon", "inputProps", "size"]);
13207  const allClasses = mergeProps(() => props.classes || {}, classes);
13208  return createComponent(SvgIconContext_default2.Provider, {
13209    value: {
13210      get fontSize() {
13211        return props.size;
13212      }
13213    },
13214    get children() {
13215      return createComponent(CheckboxRoot, mergeProps({
13216        type: "checkbox"
13217      }, baseProps, {
13218        classes: allClasses,
13219        get inputProps() {
13220          return {
13221            ["data-indeterminate"]: props.indeterminate,
13222            ...props.inputProps || {}
13223          };
13224        },
13225        get icon() {
13226          return icon();
13227        },
13228        get checkedIcon() {
13229          return indeterminateIcon();
13230        },
13231        ownerState: allProps
13232      }));
13233    }
13234  });
13235});
13236var Checkbox_default = Checkbox;
13237

vendor: 672 bytes, lines 13238-13242

13238// node_modules/@suid/icons-material/Share.jsx
13239var _tmpl$146 = /* @__PURE__ */ template(`<svg><path d="M0 0h24v24H0z" fill="none"></svg>`, false, true);
13240var _tmpl$210 = /* @__PURE__ */ template(`<svg><path d="M18 16.08c-.76 0-1.44.3-1.96.77L8.91 12.7c.05-.23.09-.46.09-.7s-.04-.47-.09-.7l7.05-4.11c.54.5 1.25.81 2.04.81 1.66 0 3-1.34 3-3s-1.34-3-3-3-3 1.34-3 3c0 .24.04.47.09.7L8.04 9.81C7.5 9.31 6.79 9 6 9c-1.66 0-3 1.34-3 3s1.34 3 3 3c.79 0 1.5-.31 2.04-.81l7.12 4.16c-.05.21-.08.43-.08.65 0 1.61 1.31 2.92 2.92 2.92 1.61 0 2.92-1.31 2.92-2.92s-1.31-2.92-2.92-2.92z"></svg>`, false, true);
13241var Share_default = createSvgIcon(() => [_tmpl$146(), _tmpl$210()], "Share");
13242

13243// src/app/classic/dialogs/sharing.jsx
13244var _tmpl$147 = /* @__PURE__ */ template(`<div class="vzome-viewer-buttons"><button class="vzome-viewer-prev-button">Previous</button><button class="vzome-viewer-next-button">Next`);
13245var _tmpl$211 = /* @__PURE__ */ template(`<div><style>`);
13246var _tmpl$310 = /* @__PURE__ */ template(`<div class="sharing-config"><div class="sharing-config-controls"></div><fieldset class="viewer-preview"><legend><span>viewer preview</span></legend><div class="viewer-preview-inner">`);
13247var CONFIGURING = 1;
13248var AUTHENTICATING = 2;
13249var CHOOSING_REPO = 3;
13250var UPLOADING = 4;
13251var IndexButtons = (props) => {
13252  const {
13253    scenes
13254  } = useViewer();
13255  const {
13256    showIndexedScene
13257  } = useSceneIndexing();
13258  const [index, setIndex] = createSignal(1);
13259  createEffect(() => {
13260    showIndexedScene(index(), {
13261      camera: props.loadCamera
13262    });
13263  });
13264  const changeScene = (delta) => (evt) => setIndex((i) => i + delta);
13265  return (() => {
13266    const _el$ = _tmpl$147(), _el$2 = _el$.firstChild, _el$3 = _el$2.nextSibling;
13267    addEventListener(_el$2, "click", changeScene(-1), true);
13268    addEventListener(_el$3, "click", changeScene(1), true);
13269    createRenderEffect((_p$) => {
13270      const _v$ = index() === 1, _v$2 = index() === scenes.length - 1;
13271      _v$ !== _p$._v$ && (_el$2.disabled = _p$._v$ = _v$);
13272      _v$2 !== _p$._v$2 && (_el$3.disabled = _p$._v$2 = _v$2);
13273      return _p$;
13274    }, {
13275      _v$: void 0,
13276      _v$2: void 0
13277    });
13278    return _el$;
13279  })();
13280};
13281var ViewerPreview = (props) => {
13282  const normalizedStyle = () => props.scenesStyle === "indexed-camera" ? "indexed" : props.scenesStyle === "zometool" ? "none" : props.scenesStyle;
13283  const viewerConfig = () => ({
13284    allowFullViewport: true,
13285    showScenes: normalizedStyle()
13286  });
13287  let zometoolRef;
13288  createEffect(() => {
13289    if (props.scenesStyle === "zometool") zometoolRef.textContent = urlViewerCSS + instructionsCSS;
13290  });
13291  return createComponent(SceneIndexingProvider, {
13292    get children() {
13293      return createComponent(Show, {
13294        get when() {
13295          return props.scenesStyle !== "zometool";
13296        },
13297        get fallback() {
13298          return (() => {
13299            const _el$4 = _tmpl$211(), _el$5 = _el$4.firstChild;
13300            _el$4.style.setProperty("height", "100%");
13301            const _ref$ = zometoolRef;
13302            typeof _ref$ === "function" ? use(_ref$, _el$5) : zometoolRef = _el$5;
13303            insert(_el$4, createComponent(ZometoolInstructions, {
13304              style: {
13305                position: "relative",
13306                height: "100%"
13307              },
13308              height: "100%",
13309              width: "100%",
13310              get config() {
13311                return viewerConfig();
13312              }
13313            }), null);
13314            return _el$4;
13315          })();
13316        },
13317        get children() {
13318          return [createComponent(Show, {
13319            get when() {
13320              return props.scenesStyle === "indexed";
13321            },
13322            get children() {
13323              return createComponent(IndexButtons, {

13324                loadCamera: false
13325              });
13326            }
13327          }), createComponent(Show, {
13328            get when() {
13329              return props.scenesStyle === "indexed-camera";
13330            },
13331            get children() {
13332              return createComponent(IndexButtons, {
13333                loadCamera: true
13334              });
13335            }
13336          }), createComponent(DesignViewer, {
13337            get config() {
13338              return viewerConfig();
13339            },
13340            style: {
13341              position: "relative",
13342              height: "100%"
13343            },
13344            height: "100%",
13345            width: "100%"
13346          })];
13347        }
13348      });
13349    }
13350  });
13351};
13352var ConfigPage = () => {
13353  const {
13354    state,
13355    setState,
13356    sceneIndex
13357  } = useEditor();
13358  const {
13359    scenes,
13360    setScenes
13361  } = useViewer();
13362  const {
13363    state: {
13364      camera: mainCamera
13365    }
13366  } = useCamera();
13367  const noScenes = () => scenes.length < 2;
13368  createEffect(() => {
13369    setScenes(0, "camera", unwrap(mainCamera));
13370  });
13371  const handleTitleEntered = (event) => {
13372    setState("sharing", "title", event.target.value);
13373  };
13374  const handleDescriptionEntered = (event) => {
13375    setState("sharing", "description", event.target.value);
13376  };
13377  const handleStyleChange = (event) => {
13378    setState("sharing", "style", event.target.value);
13379  };
13380  return (() => {
13381    const _el$6 = _tmpl$310(), _el$7 = _el$6.firstChild, _el$8 = _el$7.nextSibling, _el$9 = _el$8.firstChild, _el$10 = _el$9.nextSibling;
13382    insert(_el$7, createComponent(TextField_default, {
13383      onChange: handleTitleEntered,
13384      autoFocus: true,
13385      margin: "dense",
13386      id: "title",
13387      label: "title",
13388      type: "text",
13389      get value() {
13390        return state?.sharing?.title;
13391      },
13392      fullWidth: true
13393    }), null);
13394    insert(_el$7, createComponent(TextField_default, {
13395      onChange: handleDescriptionEntered,
13396      autoFocus: true,
13397      margin: "normal",
13398      id: "title",
13399      label: "description",
13400      type: "text",
13401      get value() {
13402        return state?.sharing?.description;
13403      },
13404      multiline: true,
13405      rows: 4,
13406      fullWidth: true
13407    }), null);
13408    insert(_el$7, createComponent(FormControl_default, {
13409      sx: {
13410        "padding-top": "20px",
13411        m: 1,
13412        minWidth: 290
13413      },
13414      size: "medium",
13415      get children() {
13416        return [createComponent(InputLabel_default, {
13417          id: "style-label",
13418          sx: {
13419            "padding-top": "20px"
13420          },
13421          children: "scenes style"
13422        }), createComponent(Select_default, {
13423          labelId: "style-label",
13424          label: "scenes style",
13425          get disabled() {
13426            return noScenes();
13427          },
13428          get value() {
13429            return state?.sharing?.style;
13430          },
13431          onChange: handleStyleChange,
13432          get children() {
13433            return [createComponent(MenuItem_default, {
13434              value: "indexed",
13435              children: "Next/Prev Buttons"
13436            }), createComponent(MenuItem_default, {
13437              value: "indexed-camera",
13438              children: "Next/Prev Buttons (load-camera)"
13439            }), createComponent(MenuItem_default, {
13440              value: "titled",
13441              children: "Menu (titled)"
13442            }), createComponent(MenuItem_default, {
13443              value: "all",
13444              children: "Menu (all)"
13445            }), createComponent(MenuItem_default, {
13446              value: "zometool",
13447              children: "Zometool Instructions"
13448            }), createComponent(MenuItem_default, {
13449              value: "none",
13450              children: "None"
13451            })];
13452          }
13453        })];
13454      }
13455    }), null);
13456    insert(_el$10, createComponent(ImageCaptureProvider, {
13457      get children() {
13458        return createComponent(CameraProvider, {
13459          get children() {
13460            return createComponent(SceneProvider, {
13461              get index() {
13462                return sceneIndex();
13463              },
13464              passive: true,
13465              config: {
13466                preview: true,
13467                debug: false,
13468                labels: true,
13469                source: false
13470              },
13471              get children() {
13472                return createComponent(ViewerPreview, {
13473                  get scenesStyle() {
13474                    return state.sharing.style;
13475                  }
13476                });
13477              }
13478            });
13479          }
13480        });
13481      }
13482    }));
13483    return _el$6;
13484  })();
13485};
13486var SharingDialog = (props) => {
13487  const [open, setOpen] = createSignal(false);
13488  const [target, setTarget] = createSignal({});
13489  const [repo, setRepo] = createSignal(null);
13490  const [repos, setRepos] = createSignal([]);
13491  const [error, setError] = createSignal("");
13492  const [stage, setStage] = createSignal(CONFIGURING);
13493  const [disabled, setDisabled] = createSignal(true);
13494  const [blog, setBlog] = createSignal(false);
13495  const [publish, setPublish] = createSignal(false);
13496  const {
13497    setProblem
13498  } = useViewer();
13499  const {
13500    shareToGitHub
13501  } = useEditor();
13502  const {
13503    captureImage
13504  } = useImageCapture();
13505  const TARGET_KEY = "classic-github-target-details";
13506  let image = null;
13507  const handleClickOpen = () => {
13508    captureImage("image/png").then((blob) => {
13509      if (blob.size === 0) {
13510        setProblem("Captured image is empty; please report this as a defect");
13511        return;
13512      }
13513      const reader = new FileReader();
13514      reader.onloadend = () => {
13515        const imageDataUrl = reader.result;
13516        image = imageDataUrl.substring(22);
13517        setError("");
13518        suspendMenuKeyEvents();
13519        setDisabled(false);
13520        setStage(CONFIGURING);
13521        setOpen(true);
13522      };

13523      reader.readAsDataURL(blob);
13524    });
13525  };
13526  const handleCancel = () => {
13527    setOpen(false);
13528    resumeMenuKeyEvents();
13529  };
13530  const reportError = (message, forUser = message) => {
13531    setError(forUser);
13532    console.log(`Error during GitHub share: ${message}`);
13533  };
13534  const nextStage = () => {
13535    const priorStage = stage();
13536    if (priorStage === CONFIGURING) {
13537      const target2 = localStorage.getItem(TARGET_KEY);
13538      setDisabled(true);
13539      if (!target2) {
13540        setStage(AUTHENTICATING);
13541        return;
13542      }
13543      const stored = JSON.parse(target2);
13544      setTarget(stored);
13545      getUserRepos(stored).then((repos2) => {
13546        if (repos2.length === 0) {
13547          setError("You are authenticated to GitHub, but no repositories were found.  Please create a repository.");
13548        } else {
13549          const {
13550            orgName,
13551            repoName
13552          } = stored;
13553          setRepo(orgName + "/" + repoName);
13554          setRepos(repos2);
13555          setStage(CHOOSING_REPO);
13556          setDisabled(false);
13557        }
13558      }).catch(({
13559        message,
13560        status
13561      }) => {
13562        if (status === 500) reportError(message, "Your Internet may be disconnected.");
13563        else {
13564          console.warn(`Unable to list GitHub repos: ${error.message}; requested a new token from user`);
13565          setStage(AUTHENTICATING);
13566        }
13567      });
13568      return;
13569    }
13570    if (priorStage === AUTHENTICATING) {
13571      getUserRepos(target()).then((repos2) => {
13572        setRepo(repos2[0]);
13573        setRepos(repos2);
13574        setStage(CHOOSING_REPO);
13575      }).catch(({
13576        message,
13577        status
13578      }) => {
13579        if (status === 500) reportError(message, "Your Internet may be disconnected.");
13580        else reportError(message, `Getting repositories failed.`);
13581      });
13582      return;
13583    }
13584    if (priorStage === CHOOSING_REPO) {
13585      const [orgName, repoName] = repo().split("/");
13586      const {
13587        token,
13588        branchName
13589      } = target();
13590      const newTarget = {
13591        token,
13592        orgName,
13593        repoName,
13594        branchName
13595      };
13596      setTarget(newTarget);
13597      localStorage.setItem(TARGET_KEY, JSON.stringify(newTarget));
13598      setStage(UPLOADING);
13599      setDisabled(true);
13600      shareToGitHub(unwrap(target()), blog(), publish(), image).then((url) => {
13601        window.open(url, "_blank");
13602        setOpen(false);
13603        resumeMenuKeyEvents();
13604      }).catch(({
13605        message,
13606        status
13607      }) => {
13608        if (status === 500) {
13609          reportError(message, "Your Internet may be disconnected.");
13610        } else {
13611          reportError(message, 'Did you grant the "repo" scope to the token?');
13612        }
13613      });
13614    }
13615  };
13616  const handleTokenEntered = (event) => {
13617    setTarget({
13618      token: event.target.value,
13619      branchName: "main"
13620    });
13621    setDisabled(false);
13622  };
13623  const handleRepoChange = (event) => {
13624    setRepo(event.target.value);
13625  };
13626  return [createComponent(Tooltip, {
13627    title: "Share to GitHub",
13628    "aria-label": "share",
13629    get children() {
13630      return createComponent(IconButton_default, {
13631        color: "primary",
13632        "aria-label": "share",
13633        onClick: handleClickOpen,
13634        get children() {
13635          return createComponent(Share_default, {
13636            fontSize: "large"
13637          });
13638        }
13639      });
13640    }
13641  }), createComponent(Dialog_default, {
13642    get open() {
13643      return open();
13644    },
13645    onClose: handleCancel,
13646    "aria-labelledby": "form-dialog-title",
13647    maxWidth: "lg",
13648    fullWidth: false,
13649    get children() {
13650      return [createComponent(DialogTitle_default, {
13651        id: "form-dialog-title",
13652        get children() {
13653          return error() ? "GitHub Sharing Error" : "Share to GitHub";
13654        }
13655      }), createComponent(DialogContent_default, {
13656        get children() {
13657          return createComponent(Switch, {
13658            get fallback() {
13659              return createComponent(DialogContentText_default, {
13660                children: "Uploading content to GitHub..."
13661              });
13662            },
13663            get children() {
13664              return [createComponent(Match, {
13665                get when() {
13666                  return error();
13667                },
13668                get children() {
13669                  return createComponent(DialogContentText_default, {
13670                    get children() {
13671                      return error();
13672                    }
13673                  });
13674                }
13675              }), createComponent(Match, {
13676                get when() {
13677                  return stage() === AUTHENTICATING;
13678                },
13679                get children() {
13680                  return [createComponent(DialogContentText_default, {
13681                    get children() {
13682                      return ["Sharing requires a GitHub account, and you must generate a Personal Access Token (classic) for the account. GitHub accounts are free of charge. ", createComponent(Link_default, {
13683                        href: "https://github.com/settings/tokens",
13684                        target: "_blank",
13685                        rel: "noopener",
13686                        children: "Click here to sign in (or sign up) and generate the token."
13687                      }), ' Be sure to select "classic" token generation, and give the token "repo" scope.'];
13688                    }
13689                  }), createComponent(TextField_default, {
13690                    onChange: handleTokenEntered,
13691                    autoFocus: true,

13692                    margin: "normal",
13693                    id: "access-token",
13694                    label: "Personal Access Token",
13695                    type: "password",
13696                    fullWidth: true
13697                  })];
13698                }
13699              }), createComponent(Match, {
13700                get when() {
13701                  return stage() === CHOOSING_REPO;
13702                },
13703                get children() {
13704                  return [createComponent(FormControl_default, {
13705                    sx: {
13706                      "padding-block": "20px",
13707                      m: 1,
13708                      minWidth: 290
13709                    },
13710                    get children() {
13711                      return createComponent(FormGroup_default, {
13712                        "aria-label": "blog",
13713                        row: true,
13714                        get children() {
13715                          return [createComponent(FormControlLabel_default, {
13716                            get control() {
13717                              return createComponent(Checkbox_default, {
13718                                get checked() {
13719                                  return blog();
13720                                },
13721                                onChange: () => setBlog((v) => !v)
13722                              });
13723                            },
13724                            label: "Create blog post"
13725                          }), createComponent(FormControlLabel_default, {
13726                            get control() {
13727                              return createComponent(Checkbox_default, {
13728                                get disabled() {
13729                                  return !blog();
13730                                },
13731                                get checked() {
13732                                  return publish();
13733                                },
13734                                onChange: () => setPublish((v) => !v)
13735                              });
13736                            },
13737                            label: "Publish immediately"
13738                          })];
13739                        }
13740                      });
13741                    }
13742                  }), createComponent(DialogContentText_default, {
13743                    children: "Select a GitHub repository:"
13744                  }), createComponent(FormControl_default, {
13745                    sx: {
13746                      "padding-block": "20px",
13747                      m: 1,
13748                      minWidth: 290
13749                    },
13750                    size: "medium",
13751                    get children() {
13752                      return createComponent(Show, {
13753                        get when() {
13754                          return repos().length > 0;
13755                        },
13756                        get fallback() {
13757                          return createComponent(DialogContentText_default, {
13758                            sx: {
13759                              "font-style": "italic"
13760                            },
13761                            children: "loading..."
13762                          });
13763                        },
13764                        get children() {
13765                          return [createComponent(InputLabel_default, {
13766                            id: "repository-label",
13767                            sx: {
13768                              "padding-top": "20px"
13769                            },
13770                            children: "repository"
13771                          }), createComponent(Select_default, {
13772                            labelId: "repository-label",
13773                            id: "repository",
13774                            label: "repository",
13775                            get value() {
13776                              return repo();
13777                            },
13778                            onChange: handleRepoChange,
13779                            get children() {
13780                              return createComponent(For, {
13781                                get each() {
13782                                  return repos();
13783                                },
13784                                children: (r) => createComponent(MenuItem_default, {
13785                                  value: r,
13786                                  children: r
13787                                })
13788                              });
13789                            }
13790                          })];
13791                        }
13792                      });
13793                    }
13794                  })];
13795                }
13796              }), createComponent(Match, {
13797                get when() {
13798                  return stage() === CONFIGURING;
13799                },
13800                get children() {
13801                  return createComponent(ConfigPage, {});
13802                }
13803              })];
13804            }
13805          });
13806        }
13807      }), createComponent(DialogActions_default, {
13808        get children() {
13809          return [createComponent(Button_default, {
13810            onClick: handleCancel,
13811            color: "secondary",
13812            children: "Cancel"
13813          }), createComponent(Button_default, {
13814            get disabled() {
13815              return disabled() || error();
13816            },
13817            onClick: nextStage,
13818            color: "primary",
13819            get children() {
13820              return memo(() => stage() === AUTHENTICATING)() ? "Authenticate" : stage() === CONFIGURING ? "Confirm" : "Share";
13821            }
13822          })];
13823        }
13824      })];
13825    }
13826  })];
13827};
13828delegateEvents(["click"]);
13829

13830// src/app/classic/components/appbar.jsx
13831var _tmpl$148 = /* @__PURE__ */ template(`<div>`);
13832var _tmpl$212 = /* @__PURE__ */ template(`<div id="appbar">`);
13833var Spacer = () => (() => {
13834  const _el$ = _tmpl$148();
13835  _el$.style.setProperty("flex", "1 1 auto");
13836  return _el$;
13837})();
13838var VZomeAppBar = (props) => {
13839  const spacer = createComponent(Spacer, {});
13840  const merged = mergeProps({
13841    showOpen: false,
13842    pathToRoot: "./models",
13843    forDebugger: false,
13844    customTitle: false,
13845    spacer
13846  }, props);
13847  return (() => {
13848    const _el$2 = _tmpl$212();
13849    insert(_el$2, createComponent(AppBar_default, {
13850      position: "static",
13851      sx: {
13852        backgroundColor: "#01203d"
13853      },
13854      get children() {
13855        return createComponent(Toolbar_default, {
13856          get children() {
13857            return [createComponent(Show, {
13858              get when() {
13859                return !merged.customTitle;
13860              },
13861              get fallback() {
13862                return createComponent(Typography_default, {
13863                  "class": "appbar-title",
13864                  variant: "h5",
13865                  sx: {
13866                    paddingLeft: "12px",
13867                    paddingRight: "40px"
13868                  },
13869                  get children() {
13870                    return props.title;
13871                  }
13872                });
13873              },
13874              get children() {
13875                return [createComponent(VZomeLogo, {}), createComponent(Typography_default, {
13876                  "class": "appbar-title",
13877                  variant: "h5",
13878                  sx: {
13879                    paddingLeft: "12px",
13880                    paddingRight: "40px"
13881                  },
13882                  get children() {
13883                    return ["vZome ", createComponent(Box_default2, {
13884                      component: "span",
13885                      fontStyle: "oblique",
13886                      get children() {
13887                        return props.title;
13888                      }
13889                    })];
13890                  }
13891                })];
13892              }
13893            }), memo(() => merged.spacer), createComponent(Show, {
13894              get when() {
13895                return merged.showOpen;
13896              },
13897              get children() {
13898                return createComponent(OpenMenu, {
13899                  get pathToRoot() {
13900                    return merged.pathToRoot;
13901                  },
13902                  get forDebugger() {
13903                    return merged.forDebugger;
13904                  }
13905                });
13906              }
13907            }), createComponent(Show, {
13908              get when() {
13909                return !merged.title;
13910              },
13911              get children() {
13912                return createComponent(SharingDialog, {});
13913              }
13914            }), createComponent(AboutDialog, {
13915              get title() {
13916                return props.customTitle ? props.title : "vZome " + props.title;
13917              },
13918              get about() {
13919                return props.about;
13920              }
13921            })];
13922          }
13923        });
13924      }
13925    }));
13926    return _el$2;
13927  })();
13928};
13929
13930export {
13931  Typography_default,
13932  Link_default,
13933  createElementRef_default,
13934  ButtonBase_default,
13935  IconButton_default,
13936  createSvgIcon,
13937  useListContext,
13938  ListContext_default,
13939  List_default,
13940  isHostComponent_default,
13941  Backdrop_default,
13942  Popover_default,
13943  Menu_default,
13944  Divider_default,
13945  ListItemText_default,
13946  MenuItem_default,
13947  Input_default,
13948  TextField_default,
13949  randomString2 as randomString,
13950  Dialog_default,
13951  DialogActions_default,
13952  DialogContent_default,
13953  DialogTitle_default,
13954  Button_default,
13955  useEditor,
13956  EditorProvider,
13957  subController,
13958  controllerProperty,
13959  FormControlLabel_default,
13960  FormGroup_default,
13961  SvgIcon_default2 as SvgIcon_default,
13962  createSvgIcon2,
13963  Stack_default,
13964  Switch_default,
13965  resourceUrl,
13966  StrutLengthPanel,
13967  OrbitPanel,
13968  SymmetryProvider,
13969  useSymmetry,
13970  suspendMenuKeyEvents,
13971  resumeMenuKeyEvents,
13972  CommandsProvider,
13973  useCommands,
13974  UrlDialog,
13975  Tooltip,
13976  getModelURL,
13977  Checkbox_default,
13978  VZomeAppBar
13979};

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.