1st Version

vrpmdvfrontend/tmpDir/vscode-firefox-debug-profile-11775616-b228-42e3-b4e6-27d43f31aaa2/cache2/entries/00BDD0E393B4DCA56150E4AACE07C727099A6A0F

@@ -0,0 +1,494 @@
+import {
+  __commonJS
+} from "/node_modules/.vite/deps/chunk-AUZ3RYOM.js?v=e565559a";
+
+// node_modules/strict-uri-encode/index.js
+var require_strict_uri_encode = __commonJS({
+  "node_modules/strict-uri-encode/index.js"(exports, module) {
+    "use strict";
+    module.exports = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+  }
+});
+
+// node_modules/decode-uri-component/index.js
+var require_decode_uri_component = __commonJS({
+  "node_modules/decode-uri-component/index.js"(exports, module) {
+    "use strict";
+    var token = "%[a-f0-9]{2}";
+    var singleMatcher = new RegExp("(" + token + ")|([^%]+?)", "gi");
+    var multiMatcher = new RegExp("(" + token + ")+", "gi");
+    function decodeComponents(components, split) {
+      try {
+        return [decodeURIComponent(components.join(""))];
+      } catch (err) {
+      }
+      if (components.length === 1) {
+        return components;
+      }
+      split = split || 1;
+      var left = components.slice(0, split);
+      var right = components.slice(split);
+      return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+    }
+    function decode(input) {
+      try {
+        return decodeURIComponent(input);
+      } catch (err) {
+        var tokens = input.match(singleMatcher) || [];
+        for (var i = 1; i < tokens.length; i++) {
+          input = decodeComponents(tokens, i).join("");
+          tokens = input.match(singleMatcher) || [];
+        }
+        return input;
+      }
+    }
+    function customDecodeURIComponent(input) {
+      var replaceMap = {
+        "%FE%FF": "<22><>",
+        "%FF%FE": "<22><>"
+      };
+      var match = multiMatcher.exec(input);
+      while (match) {
+        try {
+          replaceMap[match[0]] = decodeURIComponent(match[0]);
+        } catch (err) {
+          var result = decode(match[0]);
+          if (result !== match[0]) {
+            replaceMap[match[0]] = result;
+          }
+        }
+        match = multiMatcher.exec(input);
+      }
+      replaceMap["%C2"] = "<22>";
+      var entries = Object.keys(replaceMap);
+      for (var i = 0; i < entries.length; i++) {
+        var key = entries[i];
+        input = input.replace(new RegExp(key, "g"), replaceMap[key]);
+      }
+      return input;
+    }
+    module.exports = function(encodedURI) {
+      if (typeof encodedURI !== "string") {
+        throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
+      }
+      try {
+        encodedURI = encodedURI.replace(/\+/g, " ");
+        return decodeURIComponent(encodedURI);
+      } catch (err) {
+        return customDecodeURIComponent(encodedURI);
+      }
+    };
+  }
+});
+
+// node_modules/split-on-first/index.js
+var require_split_on_first = __commonJS({
+  "node_modules/split-on-first/index.js"(exports, module) {
+    "use strict";
+    module.exports = (string, separator) => {
+      if (!(typeof string === "string" && typeof separator === "string")) {
+        throw new TypeError("Expected the arguments to be of type `string`");
+      }
+      if (separator === "") {
+        return [string];
+      }
+      const separatorIndex = string.indexOf(separator);
+      if (separatorIndex === -1) {
+        return [string];
+      }
+      return [
+        string.slice(0, separatorIndex),
+        string.slice(separatorIndex + separator.length)
+      ];
+    };
+  }
+});
+
+// node_modules/filter-obj/index.js
+var require_filter_obj = __commonJS({
+  "node_modules/filter-obj/index.js"(exports, module) {
+    "use strict";
+    module.exports = function(obj, predicate) {
+      var ret = {};
+      var keys = Object.keys(obj);
+      var isArr = Array.isArray(predicate);
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var val = obj[key];
+        if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
+          ret[key] = val;
+        }
+      }
+      return ret;
+    };
+  }
+});
+
+// node_modules/query-string/index.js
+var require_query_string = __commonJS({
+  "node_modules/query-string/index.js"(exports) {
+    var strictUriEncode = require_strict_uri_encode();
+    var decodeComponent = require_decode_uri_component();
+    var splitOnFirst = require_split_on_first();
+    var filterObject = require_filter_obj();
+    var isNullOrUndefined = (value) => value === null || value === void 0;
+    var encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
+    function encoderForArrayFormat(options) {
+      switch (options.arrayFormat) {
+        case "index":
+          return (key) => (result, value) => {
+            const index = result.length;
+            if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+              return result;
+            }
+            if (value === null) {
+              return [...result, [encode(key, options), "[", index, "]"].join("")];
+            }
+            return [
+              ...result,
+              [encode(key, options), "[", encode(index, options), "]=", encode(value, options)].join("")
+            ];
+          };
+        case "bracket":
+          return (key) => (result, value) => {
+            if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+              return result;
+            }
+            if (value === null) {
+              return [...result, [encode(key, options), "[]"].join("")];
+            }
+            return [...result, [encode(key, options), "[]=", encode(value, options)].join("")];
+          };
+        case "colon-list-separator":
+          return (key) => (result, value) => {
+            if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+              return result;
+            }
+            if (value === null) {
+              return [...result, [encode(key, options), ":list="].join("")];
+            }
+            return [...result, [encode(key, options), ":list=", encode(value, options)].join("")];
+          };
+        case "comma":
+        case "separator":
+        case "bracket-separator": {
+          const keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
+          return (key) => (result, value) => {
+            if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+              return result;
+            }
+            value = value === null ? "" : value;
+            if (result.length === 0) {
+              return [[encode(key, options), keyValueSep, encode(value, options)].join("")];
+            }
+            return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+          };
+        }
+        default:
+          return (key) => (result, value) => {
+            if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+              return result;
+            }
+            if (value === null) {
+              return [...result, encode(key, options)];
+            }
+            return [...result, [encode(key, options), "=", encode(value, options)].join("")];
+          };
+      }
+    }
+    function parserForArrayFormat(options) {
+      let result;
+      switch (options.arrayFormat) {
+        case "index":
+          return (key, value, accumulator) => {
+            result = /\[(\d*)\]$/.exec(key);
+            key = key.replace(/\[\d*\]$/, "");
+            if (!result) {
+              accumulator[key] = value;
+              return;
+            }
+            if (accumulator[key] === void 0) {
+              accumulator[key] = {};
+            }
+            accumulator[key][result[1]] = value;
+          };
+        case "bracket":
+          return (key, value, accumulator) => {
+            result = /(\[\])$/.exec(key);
+            key = key.replace(/\[\]$/, "");
+            if (!result) {
+              accumulator[key] = value;
+              return;
+            }
+            if (accumulator[key] === void 0) {
+              accumulator[key] = [value];
+              return;
+            }
+            accumulator[key] = [].concat(accumulator[key], value);
+          };
+        case "colon-list-separator":
+          return (key, value, accumulator) => {
+            result = /(:list)$/.exec(key);
+            key = key.replace(/:list$/, "");
+            if (!result) {
+              accumulator[key] = value;
+              return;
+            }
+            if (accumulator[key] === void 0) {
+              accumulator[key] = [value];
+              return;
+            }
+            accumulator[key] = [].concat(accumulator[key], value);
+          };
+        case "comma":
+        case "separator":
+          return (key, value, accumulator) => {
+            const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+            const isEncodedArray = typeof value === "string" && !isArray && decode(value, options).includes(options.arrayFormatSeparator);
+            value = isEncodedArray ? decode(value, options) : value;
+            const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode(item, options)) : value === null ? value : decode(value, options);
+            accumulator[key] = newValue;
+          };
+        case "bracket-separator":
+          return (key, value, accumulator) => {
+            const isArray = /(\[\])$/.test(key);
+            key = key.replace(/\[\]$/, "");
+            if (!isArray) {
+              accumulator[key] = value ? decode(value, options) : value;
+              return;
+            }
+            const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map((item) => decode(item, options));
+            if (accumulator[key] === void 0) {
+              accumulator[key] = arrayValue;
+              return;
+            }
+            accumulator[key] = [].concat(accumulator[key], arrayValue);
+          };
+        default:
+          return (key, value, accumulator) => {
+            if (accumulator[key] === void 0) {
+              accumulator[key] = value;
+              return;
+            }
+            accumulator[key] = [].concat(accumulator[key], value);
+          };
+      }
+    }
+    function validateArrayFormatSeparator(value) {
+      if (typeof value !== "string" || value.length !== 1) {
+        throw new TypeError("arrayFormatSeparator must be single character string");
+      }
+    }
+    function encode(value, options) {
+      if (options.encode) {
+        return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+      }
+      return value;
+    }
+    function decode(value, options) {
+      if (options.decode) {
+        return decodeComponent(value);
+      }
+      return value;
+    }
+    function keysSorter(input) {
+      if (Array.isArray(input)) {
+        return input.sort();
+      }
+      if (typeof input === "object") {
+        return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
+      }
+      return input;
+    }
+    function removeHash(input) {
+      const hashStart = input.indexOf("#");
+      if (hashStart !== -1) {
+        input = input.slice(0, hashStart);
+      }
+      return input;
+    }
+    function getHash(url) {
+      let hash = "";
+      const hashStart = url.indexOf("#");
+      if (hashStart !== -1) {
+        hash = url.slice(hashStart);
+      }
+      return hash;
+    }
+    function extract(input) {
+      input = removeHash(input);
+      const queryStart = input.indexOf("?");
+      if (queryStart === -1) {
+        return "";
+      }
+      return input.slice(queryStart + 1);
+    }
+    function parseValue(value, options) {
+      if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
+        value = Number(value);
+      } else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+        value = value.toLowerCase() === "true";
+      }
+      return value;
+    }
+    function parse(query, options) {
+      options = Object.assign({
+        decode: true,
+        sort: true,
+        arrayFormat: "none",
+        arrayFormatSeparator: ",",
+        parseNumbers: false,
+        parseBooleans: false
+      }, options);
+      validateArrayFormatSeparator(options.arrayFormatSeparator);
+      const formatter = parserForArrayFormat(options);
+      const ret = /* @__PURE__ */ Object.create(null);
+      if (typeof query !== "string") {
+        return ret;
+      }
+      query = query.trim().replace(/^[?#&]/, "");
+      if (!query) {
+        return ret;
+      }
+      for (const param of query.split("&")) {
+        if (param === "") {
+          continue;
+        }
+        let [key, value] = splitOnFirst(options.decode ? param.replace(/\+/g, " ") : param, "=");
+        value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode(value, options);
+        formatter(decode(key, options), value, ret);
+      }
+      for (const key of Object.keys(ret)) {
+        const value = ret[key];
+        if (typeof value === "object" && value !== null) {
+          for (const k of Object.keys(value)) {
+            value[k] = parseValue(value[k], options);
+          }
+        } else {
+          ret[key] = parseValue(value, options);
+        }
+      }
+      if (options.sort === false) {
+        return ret;
+      }
+      return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+        const value = ret[key];
+        if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
+          result[key] = keysSorter(value);
+        } else {
+          result[key] = value;
+        }
+        return result;
+      }, /* @__PURE__ */ Object.create(null));
+    }
+    exports.extract = extract;
+    exports.parse = parse;
+    exports.stringify = (object, options) => {
+      if (!object) {
+        return "";
+      }
+      options = Object.assign({
+        encode: true,
+        strict: true,
+        arrayFormat: "none",
+        arrayFormatSeparator: ","
+      }, options);
+      validateArrayFormatSeparator(options.arrayFormatSeparator);
+      const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
+      const formatter = encoderForArrayFormat(options);
+      const objectCopy = {};
+      for (const key of Object.keys(object)) {
+        if (!shouldFilter(key)) {
+          objectCopy[key] = object[key];
+        }
+      }
+      const keys = Object.keys(objectCopy);
+      if (options.sort !== false) {
+        keys.sort(options.sort);
+      }
+      return keys.map((key) => {
+        const value = object[key];
+        if (value === void 0) {
+          return "";
+        }
+        if (value === null) {
+          return encode(key, options);
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0 && options.arrayFormat === "bracket-separator") {
+            return encode(key, options) + "[]";
+          }
+          return value.reduce(formatter(key), []).join("&");
+        }
+        return encode(key, options) + "=" + encode(value, options);
+      }).filter((x) => x.length > 0).join("&");
+    };
+    exports.parseUrl = (url, options) => {
+      options = Object.assign({
+        decode: true
+      }, options);
+      const [url_, hash] = splitOnFirst(url, "#");
+      return Object.assign(
+        {
+          url: url_.split("?")[0] || "",
+          query: parse(extract(url), options)
+        },
+        options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {}
+      );
+    };
+    exports.stringifyUrl = (object, options) => {
+      options = Object.assign({
+        encode: true,
+        strict: true,
+        [encodeFragmentIdentifier]: true
+      }, options);
+      const url = removeHash(object.url).split("?")[0] || "";
+      const queryFromUrl = exports.extract(object.url);
+      const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
+      const query = Object.assign(parsedQueryFromUrl, object.query);
+      let queryString = exports.stringify(query, options);
+      if (queryString) {
+        queryString = `?${queryString}`;
+      }
+      let hash = getHash(object.url);
+      if (object.fragmentIdentifier) {
+        hash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
+      }
+      return `${url}${queryString}${hash}`;
+    };
+    exports.pick = (input, filter, options) => {
+      options = Object.assign({
+        parseFragmentIdentifier: true,
+        [encodeFragmentIdentifier]: false
+      }, options);
+      const { url, query, fragmentIdentifier } = exports.parseUrl(input, options);
+      return exports.stringifyUrl({
+        url,
+        query: filterObject(query, filter),
+        fragmentIdentifier
+      }, options);
+    };
+    exports.exclude = (input, filter, options) => {
+      const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
+      return exports.pick(input, exclusionFilter, options);
+    };
+  }
+});
+export default require_query_string();
+//# sourceMappingURL=query-string.js.map
+3ɂte<>^<5E>e<EFBFBD>^<5E>F<EFBFBD>O1gՐ<67>vO^partitionKey=%28http%2Clocalhost%2C5173%29,:http://localhost:5173/node_modules/.vite/deps/query-string.js?v=e565559astrongly-framed1request-methodGETresponse-headHTTP/1.1 200 OK
+Access-Control-Allow-Origin: *
+Content-Type: application/javascript
+Cache-Control: max-age=31536000,immutable
+Etag: W/"43c4-MxI2NUTkbbNKbRJdi5zAv8LrAOQ"
+Date: Fri, 15 Mar 2024 14:37:23 GMT
+Content-Length: 17348
+original-response-headersAccess-Control-Allow-Origin: *
+Content-Type: application/javascript
+Cache-Control: max-age=31536000,immutable
+Etag: W/"43c4-MxI2NUTkbbNKbRJdi5zAv8LrAOQ"
+Date: Fri, 15 Mar 2024 14:37:23 GMT
+Connection: keep-alive
+Keep-Alive: timeout=5
+Content-Length: 17348
+ctid2uncompressed-len0net-response-time-onstart38net-response-time-onstop38C<>

vrpmdvfrontend/tmpDir/vscode-firefox-debug-profile-11775616-b228-42e3-b4e6-27d43f31aaa2/cache2/entries/3DBFA8AC9E78AD6101E877B520B704DB4555C8FE

@@ -0,0 +1,723 @@
+import {
+  getOverlayAlpha_default
+} from "/node_modules/.vite/deps/chunk-THS5IPV6.js?v=e565559a";
+import {
+  ThemeProvider_default,
+  createCssVarsProvider,
+  createGetCssVar,
+  prepareCssVars_default
+} from "/node_modules/.vite/deps/chunk-KZ7CH5EB.js?v=e565559a";
+import {
+  init_styled
+} from "/node_modules/.vite/deps/chunk-EALQ3RGL.js?v=e565559a";
+import {
+  init_useThemeProps
+} from "/node_modules/.vite/deps/chunk-A2ETMCKW.js?v=e565559a";
+import {
+  _extends,
+  _objectWithoutPropertiesLoose,
+  createBreakpoints,
+  createSpacing,
+  createTheme_default2 as createTheme_default,
+  createTypography,
+  deepmerge,
+  defaultSxConfig_default,
+  identifier_default,
+  init_createMixins,
+  init_createTheme2 as init_createTheme,
+  init_createTransitions,
+  init_createTypography,
+  init_deepmerge,
+  init_extends,
+  init_formatMuiErrorMessage,
+  init_identifier,
+  init_objectWithoutPropertiesLoose,
+  init_styleFunctionSx,
+  require_colorManipulator,
+  require_prop_types,
+  styleFunctionSx_default
+} from "/node_modules/.vite/deps/chunk-2K22GOZQ.js?v=e565559a";
+import {
+  require_jsx_runtime
+} from "/node_modules/.vite/deps/chunk-ZYX7IIE4.js?v=e565559a";
+import {
+  require_react
+} from "/node_modules/.vite/deps/chunk-HS5T2ZWL.js?v=e565559a";
+import {
+  __toESM
+} from "/node_modules/.vite/deps/chunk-AUZ3RYOM.js?v=e565559a";
+
+// node_modules/@mui/material/styles/index.js
+init_formatMuiErrorMessage();
+init_identifier();
+
+// node_modules/@mui/material/styles/adaptV4Theme.js
+init_extends();
+init_objectWithoutPropertiesLoose();
+var _excluded = ["defaultProps", "mixins", "overrides", "palette", "props", "styleOverrides"];
+var _excluded2 = ["type", "mode"];
+function adaptV4Theme(inputTheme) {
+  if (true) {
+    console.warn(["MUI: adaptV4Theme() is deprecated.", "Follow the upgrade guide on https://mui.com/r/migration-v4#theme."].join("\n"));
+  }
+  const {
+    defaultProps = {},
+    mixins = {},
+    overrides = {},
+    palette = {},
+    props = {},
+    styleOverrides = {}
+  } = inputTheme, other = _objectWithoutPropertiesLoose(inputTheme, _excluded);
+  const theme = _extends({}, other, {
+    components: {}
+  });
+  Object.keys(defaultProps).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.defaultProps = defaultProps[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(props).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.defaultProps = props[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(styleOverrides).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.styleOverrides = styleOverrides[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(overrides).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.styleOverrides = overrides[component];
+    theme.components[component] = componentValue;
+  });
+  theme.spacing = createSpacing(inputTheme.spacing);
+  const breakpoints = createBreakpoints(inputTheme.breakpoints || {});
+  const spacing = theme.spacing;
+  theme.mixins = _extends({
+    gutters: (styles = {}) => {
+      return _extends({
+        paddingLeft: spacing(2),
+        paddingRight: spacing(2)
+      }, styles, {
+        [breakpoints.up("sm")]: _extends({
+          paddingLeft: spacing(3),
+          paddingRight: spacing(3)
+        }, styles[breakpoints.up("sm")])
+      });
+    }
+  }, mixins);
+  const {
+    type: typeInput,
+    mode: modeInput
+  } = palette, paletteRest = _objectWithoutPropertiesLoose(palette, _excluded2);
+  const finalMode = modeInput || typeInput || "light";
+  theme.palette = _extends({
+    // theme.palette.text.hint
+    text: {
+      hint: finalMode === "dark" ? "rgba(255, 255, 255, 0.5)" : "rgba(0, 0, 0, 0.38)"
+    },
+    mode: finalMode,
+    type: finalMode
+  }, paletteRest);
+  return theme;
+}
+
+// node_modules/@mui/material/styles/index.js
+init_createTheme();
+
+// node_modules/@mui/material/styles/createMuiStrictModeTheme.js
+init_deepmerge();
+init_createTheme();
+function createMuiStrictModeTheme(options, ...args) {
+  return createTheme_default(deepmerge({
+    unstable_strictMode: true
+  }, options), ...args);
+}
+
+// node_modules/@mui/material/styles/createStyles.js
+var warnedOnce = false;
+function createStyles(styles) {
+  if (!warnedOnce) {
+    console.warn(["MUI: createStyles from @mui/material/styles is deprecated.", "Please use @mui/styles/createStyles"].join("\n"));
+    warnedOnce = true;
+  }
+  return styles;
+}
+
+// node_modules/@mui/material/styles/cssUtils.js
+function isUnitless(value) {
+  return String(parseFloat(value)).length === String(value).length;
+}
+function getUnit(input) {
+  return String(input).match(/[\d.\-+]*\s*(.*)/)[1] || "";
+}
+function toUnitless(length) {
+  return parseFloat(length);
+}
+function convertLength(baseFontSize) {
+  return (length, toUnit) => {
+    const fromUnit = getUnit(length);
+    if (fromUnit === toUnit) {
+      return length;
+    }
+    let pxLength = toUnitless(length);
+    if (fromUnit !== "px") {
+      if (fromUnit === "em") {
+        pxLength = toUnitless(length) * toUnitless(baseFontSize);
+      } else if (fromUnit === "rem") {
+        pxLength = toUnitless(length) * toUnitless(baseFontSize);
+      }
+    }
+    let outputLength = pxLength;
+    if (toUnit !== "px") {
+      if (toUnit === "em") {
+        outputLength = pxLength / toUnitless(baseFontSize);
+      } else if (toUnit === "rem") {
+        outputLength = pxLength / toUnitless(baseFontSize);
+      } else {
+        return length;
+      }
+    }
+    return parseFloat(outputLength.toFixed(5)) + toUnit;
+  };
+}
+function alignProperty({
+  size,
+  grid
+}) {
+  const sizeBelow = size - size % grid;
+  const sizeAbove = sizeBelow + grid;
+  return size - sizeBelow < sizeAbove - size ? sizeBelow : sizeAbove;
+}
+function fontGrid({
+  lineHeight,
+  pixels,
+  htmlFontSize
+}) {
+  return pixels / (lineHeight * htmlFontSize);
+}
+function responsiveProperty({
+  cssProperty,
+  min,
+  max,
+  unit = "rem",
+  breakpoints = [600, 900, 1200],
+  transform = null
+}) {
+  const output = {
+    [cssProperty]: `${min}${unit}`
+  };
+  const factor = (max - min) / breakpoints[breakpoints.length - 1];
+  breakpoints.forEach((breakpoint) => {
+    let value = min + factor * breakpoint;
+    if (transform !== null) {
+      value = transform(value);
+    }
+    output[`@media (min-width:${breakpoint}px)`] = {
+      [cssProperty]: `${Math.round(value * 1e4) / 1e4}${unit}`
+    };
+  });
+  return output;
+}
+
+// node_modules/@mui/material/styles/responsiveFontSizes.js
+init_extends();
+init_formatMuiErrorMessage();
+function responsiveFontSizes(themeInput, options = {}) {
+  const {
+    breakpoints = ["sm", "md", "lg"],
+    disableAlign = false,
+    factor = 2,
+    variants = ["h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "caption", "button", "overline"]
+  } = options;
+  const theme = _extends({}, themeInput);
+  theme.typography = _extends({}, theme.typography);
+  const typography = theme.typography;
+  const convert = convertLength(typography.htmlFontSize);
+  const breakpointValues = breakpoints.map((x) => theme.breakpoints.values[x]);
+  variants.forEach((variant) => {
+    const style = typography[variant];
+    const remFontSize = parseFloat(convert(style.fontSize, "rem"));
+    if (remFontSize <= 1) {
+      return;
+    }
+    const maxFontSize = remFontSize;
+    const minFontSize = 1 + (maxFontSize - 1) / factor;
+    let {
+      lineHeight
+    } = style;
+    if (!isUnitless(lineHeight) && !disableAlign) {
+      throw new Error(true ? `MUI: Unsupported non-unitless line height with grid alignment.
+Use unitless line heights instead.` : formatMuiErrorMessage(6));
+    }
+    if (!isUnitless(lineHeight)) {
+      lineHeight = parseFloat(convert(lineHeight, "rem")) / parseFloat(remFontSize);
+    }
+    let transform = null;
+    if (!disableAlign) {
+      transform = (value) => alignProperty({
+        size: value,
+        grid: fontGrid({
+          pixels: 4,
+          lineHeight,
+          htmlFontSize: typography.htmlFontSize
+        })
+      });
+    }
+    typography[variant] = _extends({}, style, responsiveProperty({
+      cssProperty: "fontSize",
+      min: minFontSize,
+      max: maxFontSize,
+      unit: "rem",
+      breakpoints: breakpointValues,
+      transform
+    }));
+  });
+  return theme;
+}
+
+// node_modules/@mui/material/styles/index.js
+init_createTransitions();
+init_useThemeProps();
+init_styled();
+init_styled();
+
+// node_modules/@mui/material/styles/ThemeProvider.js
+init_extends();
+init_objectWithoutPropertiesLoose();
+var React = __toESM(require_react());
+var import_prop_types = __toESM(require_prop_types());
+init_identifier();
+var import_jsx_runtime = __toESM(require_jsx_runtime());
+var _excluded3 = ["theme"];
+function ThemeProvider(_ref) {
+  let {
+    theme: themeInput
+  } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded3);
+  const scopedTheme = themeInput[identifier_default];
+  return (0, import_jsx_runtime.jsx)(ThemeProvider_default, _extends({}, props, {
+    themeId: scopedTheme ? identifier_default : void 0,
+    theme: scopedTheme || themeInput
+  }));
+}
+true ? ThemeProvider.propTypes = {
+  /**
+   * Your component tree.
+   */
+  children: import_prop_types.default.node,
+  /**
+   * A theme object. You can provide a function to extend the outer theme.
+   */
+  theme: import_prop_types.default.oneOfType([import_prop_types.default.object, import_prop_types.default.func]).isRequired
+} : void 0;
+
+// node_modules/@mui/material/styles/makeStyles.js
+init_formatMuiErrorMessage();
+function makeStyles() {
+  throw new Error(true ? `MUI: makeStyles is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : formatMuiErrorMessage(14));
+}
+
+// node_modules/@mui/material/styles/withStyles.js
+init_formatMuiErrorMessage();
+function withStyles() {
+  throw new Error(true ? `MUI: withStyles is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : formatMuiErrorMessage(15));
+}
+
+// node_modules/@mui/material/styles/withTheme.js
+init_formatMuiErrorMessage();
+function withTheme() {
+  throw new Error(true ? `MUI: withTheme is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : formatMuiErrorMessage(16));
+}
+
+// node_modules/@mui/material/styles/CssVarsProvider.js
+init_extends();
+init_styleFunctionSx();
+
+// node_modules/@mui/material/styles/experimental_extendTheme.js
+init_extends();
+init_objectWithoutPropertiesLoose();
+init_deepmerge();
+init_styleFunctionSx();
+var import_colorManipulator = __toESM(require_colorManipulator());
+
+// node_modules/@mui/material/styles/shouldSkipGeneratingVar.js
+function shouldSkipGeneratingVar(keys) {
+  var _keys$;
+  return !!keys[0].match(/(cssVarPrefix|typography|mixins|breakpoints|direction|transitions)/) || !!keys[0].match(/sxConfig$/) || // ends with sxConfig
+  keys[0] === "palette" && !!((_keys$ = keys[1]) != null && _keys$.match(/(mode|contrastThreshold|tonalOffset)/));
+}
+
+// node_modules/@mui/material/styles/experimental_extendTheme.js
+init_createTheme();
+var _excluded4 = ["colorSchemes", "cssVarPrefix", "shouldSkipGeneratingVar"];
+var _excluded22 = ["palette"];
+var defaultDarkOverlays = [...Array(25)].map((_, index) => {
+  if (index === 0) {
+    return void 0;
+  }
+  const overlay = getOverlayAlpha_default(index);
+  return `linear-gradient(rgba(255 255 255 / ${overlay}), rgba(255 255 255 / ${overlay}))`;
+});
+function assignNode(obj, keys) {
+  keys.forEach((k) => {
+    if (!obj[k]) {
+      obj[k] = {};
+    }
+  });
+}
+function setColor(obj, key, defaultValue) {
+  if (!obj[key] && defaultValue) {
+    obj[key] = defaultValue;
+  }
+}
+function toRgb(color) {
+  if (!color || !color.startsWith("hsl")) {
+    return color;
+  }
+  return (0, import_colorManipulator.hslToRgb)(color);
+}
+function setColorChannel(obj, key) {
+  if (!(`${key}Channel` in obj)) {
+    obj[`${key}Channel`] = (0, import_colorManipulator.private_safeColorChannel)(toRgb(obj[key]), `MUI: Can't create \`palette.${key}Channel\` because \`palette.${key}\` is not one of these formats: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().
+To suppress this warning, you need to explicitly provide the \`palette.${key}Channel\` as a string (in rgb format, e.g. "12 12 12") or undefined if you want to remove the channel token.`);
+  }
+}
+var silent = (fn) => {
+  try {
+    return fn();
+  } catch (error) {
+  }
+  return void 0;
+};
+var createGetCssVar2 = (cssVarPrefix = "mui") => createGetCssVar(cssVarPrefix);
+function extendTheme(options = {}, ...args) {
+  var _colorSchemesInput$li, _colorSchemesInput$da, _colorSchemesInput$li2, _colorSchemesInput$li3, _colorSchemesInput$da2, _colorSchemesInput$da3;
+  const {
+    colorSchemes: colorSchemesInput = {},
+    cssVarPrefix = "mui",
+    shouldSkipGeneratingVar: shouldSkipGeneratingVar2 = shouldSkipGeneratingVar
+  } = options, input = _objectWithoutPropertiesLoose(options, _excluded4);
+  const getCssVar = createGetCssVar2(cssVarPrefix);
+  const _createThemeWithoutVa = createTheme_default(_extends({}, input, colorSchemesInput.light && {
+    palette: (_colorSchemesInput$li = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li.palette
+  })), {
+    palette: lightPalette
+  } = _createThemeWithoutVa, muiTheme = _objectWithoutPropertiesLoose(_createThemeWithoutVa, _excluded22);
+  const {
+    palette: darkPalette
+  } = createTheme_default({
+    palette: _extends({
+      mode: "dark"
+    }, (_colorSchemesInput$da = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da.palette)
+  });
+  let theme = _extends({}, muiTheme, {
+    cssVarPrefix,
+    getCssVar,
+    colorSchemes: _extends({}, colorSchemesInput, {
+      light: _extends({}, colorSchemesInput.light, {
+        palette: lightPalette,
+        opacity: _extends({
+          inputPlaceholder: 0.42,
+          inputUnderline: 0.42,
+          switchTrackDisabled: 0.12,
+          switchTrack: 0.38
+        }, (_colorSchemesInput$li2 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li2.opacity),
+        overlays: ((_colorSchemesInput$li3 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li3.overlays) || []
+      }),
+      dark: _extends({}, colorSchemesInput.dark, {
+        palette: darkPalette,
+        opacity: _extends({
+          inputPlaceholder: 0.5,
+          inputUnderline: 0.7,
+          switchTrackDisabled: 0.2,
+          switchTrack: 0.3
+        }, (_colorSchemesInput$da2 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da2.opacity),
+        overlays: ((_colorSchemesInput$da3 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da3.overlays) || defaultDarkOverlays
+      })
+    })
+  });
+  Object.keys(theme.colorSchemes).forEach((key) => {
+    const palette = theme.colorSchemes[key].palette;
+    const setCssVarColor = (cssVar) => {
+      const tokens = cssVar.split("-");
+      const color = tokens[1];
+      const colorToken = tokens[2];
+      return getCssVar(cssVar, palette[color][colorToken]);
+    };
+    if (key === "light") {
+      setColor(palette.common, "background", "#fff");
+      setColor(palette.common, "onBackground", "#000");
+    } else {
+      setColor(palette.common, "background", "#000");
+      setColor(palette.common, "onBackground", "#fff");
+    }
+    assignNode(palette, ["Alert", "AppBar", "Avatar", "Button", "Chip", "FilledInput", "LinearProgress", "Skeleton", "Slider", "SnackbarContent", "SpeedDialAction", "StepConnector", "StepContent", "Switch", "TableCell", "Tooltip"]);
+    if (key === "light") {
+      setColor(palette.Alert, "errorColor", (0, import_colorManipulator.private_safeDarken)(palette.error.light, 0.6));
+      setColor(palette.Alert, "infoColor", (0, import_colorManipulator.private_safeDarken)(palette.info.light, 0.6));
+      setColor(palette.Alert, "successColor", (0, import_colorManipulator.private_safeDarken)(palette.success.light, 0.6));
+      setColor(palette.Alert, "warningColor", (0, import_colorManipulator.private_safeDarken)(palette.warning.light, 0.6));
+      setColor(palette.Alert, "errorFilledBg", setCssVarColor("palette-error-main"));
+      setColor(palette.Alert, "infoFilledBg", setCssVarColor("palette-info-main"));
+      setColor(palette.Alert, "successFilledBg", setCssVarColor("palette-success-main"));
+      setColor(palette.Alert, "warningFilledBg", setCssVarColor("palette-warning-main"));
+      setColor(palette.Alert, "errorFilledColor", silent(() => lightPalette.getContrastText(palette.error.main)));
+      setColor(palette.Alert, "infoFilledColor", silent(() => lightPalette.getContrastText(palette.info.main)));
+      setColor(palette.Alert, "successFilledColor", silent(() => lightPalette.getContrastText(palette.success.main)));
+      setColor(palette.Alert, "warningFilledColor", silent(() => lightPalette.getContrastText(palette.warning.main)));
+      setColor(palette.Alert, "errorStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.error.light, 0.9));
+      setColor(palette.Alert, "infoStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.info.light, 0.9));
+      setColor(palette.Alert, "successStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.success.light, 0.9));
+      setColor(palette.Alert, "warningStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.warning.light, 0.9));
+      setColor(palette.Alert, "errorIconColor", setCssVarColor("palette-error-main"));
+      setColor(palette.Alert, "infoIconColor", setCssVarColor("palette-info-main"));
+      setColor(palette.Alert, "successIconColor", setCssVarColor("palette-success-main"));
+      setColor(palette.Alert, "warningIconColor", setCssVarColor("palette-warning-main"));
+      setColor(palette.AppBar, "defaultBg", setCssVarColor("palette-grey-100"));
+      setColor(palette.Avatar, "defaultBg", setCssVarColor("palette-grey-400"));
+      setColor(palette.Button, "inheritContainedBg", setCssVarColor("palette-grey-300"));
+      setColor(palette.Button, "inheritContainedHoverBg", setCssVarColor("palette-grey-A100"));
+      setColor(palette.Chip, "defaultBorder", setCssVarColor("palette-grey-400"));
+      setColor(palette.Chip, "defaultAvatarColor", setCssVarColor("palette-grey-700"));
+      setColor(palette.Chip, "defaultIconColor", setCssVarColor("palette-grey-700"));
+      setColor(palette.FilledInput, "bg", "rgba(0, 0, 0, 0.06)");
+      setColor(palette.FilledInput, "hoverBg", "rgba(0, 0, 0, 0.09)");
+      setColor(palette.FilledInput, "disabledBg", "rgba(0, 0, 0, 0.12)");
+      setColor(palette.LinearProgress, "primaryBg", (0, import_colorManipulator.private_safeLighten)(palette.primary.main, 0.62));
+      setColor(palette.LinearProgress, "secondaryBg", (0, import_colorManipulator.private_safeLighten)(palette.secondary.main, 0.62));
+      setColor(palette.LinearProgress, "errorBg", (0, import_colorManipulator.private_safeLighten)(palette.error.main, 0.62));
+      setColor(palette.LinearProgress, "infoBg", (0, import_colorManipulator.private_safeLighten)(palette.info.main, 0.62));
+      setColor(palette.LinearProgress, "successBg", (0, import_colorManipulator.private_safeLighten)(palette.success.main, 0.62));
+      setColor(palette.LinearProgress, "warningBg", (0, import_colorManipulator.private_safeLighten)(palette.warning.main, 0.62));
+      setColor(palette.Skeleton, "bg", `rgba(${setCssVarColor("palette-text-primaryChannel")} / 0.11)`);
+      setColor(palette.Slider, "primaryTrack", (0, import_colorManipulator.private_safeLighten)(palette.primary.main, 0.62));
+      setColor(palette.Slider, "secondaryTrack", (0, import_colorManipulator.private_safeLighten)(palette.secondary.main, 0.62));
+      setColor(palette.Slider, "errorTrack", (0, import_colorManipulator.private_safeLighten)(palette.error.main, 0.62));
+      setColor(palette.Slider, "infoTrack", (0, import_colorManipulator.private_safeLighten)(palette.info.main, 0.62));
+      setColor(palette.Slider, "successTrack", (0, import_colorManipulator.private_safeLighten)(palette.success.main, 0.62));
+      setColor(palette.Slider, "warningTrack", (0, import_colorManipulator.private_safeLighten)(palette.warning.main, 0.62));
+      const snackbarContentBackground = (0, import_colorManipulator.private_safeEmphasize)(palette.background.default, 0.8);
+      setColor(palette.SnackbarContent, "bg", snackbarContentBackground);
+      setColor(palette.SnackbarContent, "color", silent(() => lightPalette.getContrastText(snackbarContentBackground)));
+      setColor(palette.SpeedDialAction, "fabHoverBg", (0, import_colorManipulator.private_safeEmphasize)(palette.background.paper, 0.15));
+      setColor(palette.StepConnector, "border", setCssVarColor("palette-grey-400"));
+      setColor(palette.StepContent, "border", setCssVarColor("palette-grey-400"));
+      setColor(palette.Switch, "defaultColor", setCssVarColor("palette-common-white"));
+      setColor(palette.Switch, "defaultDisabledColor", setCssVarColor("palette-grey-100"));
+      setColor(palette.Switch, "primaryDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.primary.main, 0.62));
+      setColor(palette.Switch, "secondaryDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.secondary.main, 0.62));
+      setColor(palette.Switch, "errorDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.error.main, 0.62));
+      setColor(palette.Switch, "infoDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.info.main, 0.62));
+      setColor(palette.Switch, "successDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.success.main, 0.62));
+      setColor(palette.Switch, "warningDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.warning.main, 0.62));
+      setColor(palette.TableCell, "border", (0, import_colorManipulator.private_safeLighten)((0, import_colorManipulator.private_safeAlpha)(palette.divider, 1), 0.88));
+      setColor(palette.Tooltip, "bg", (0, import_colorManipulator.private_safeAlpha)(palette.grey[700], 0.92));
+    } else {
+      setColor(palette.Alert, "errorColor", (0, import_colorManipulator.private_safeLighten)(palette.error.light, 0.6));
+      setColor(palette.Alert, "infoColor", (0, import_colorManipulator.private_safeLighten)(palette.info.light, 0.6));
+      setColor(palette.Alert, "successColor", (0, import_colorManipulator.private_safeLighten)(palette.success.light, 0.6));
+      setColor(palette.Alert, "warningColor", (0, import_colorManipulator.private_safeLighten)(palette.warning.light, 0.6));
+      setColor(palette.Alert, "errorFilledBg", setCssVarColor("palette-error-dark"));
+      setColor(palette.Alert, "infoFilledBg", setCssVarColor("palette-info-dark"));
+      setColor(palette.Alert, "successFilledBg", setCssVarColor("palette-success-dark"));
+      setColor(palette.Alert, "warningFilledBg", setCssVarColor("palette-warning-dark"));
+      setColor(palette.Alert, "errorFilledColor", silent(() => darkPalette.getContrastText(palette.error.dark)));
+      setColor(palette.Alert, "infoFilledColor", silent(() => darkPalette.getContrastText(palette.info.dark)));
+      setColor(palette.Alert, "successFilledColor", silent(() => darkPalette.getContrastText(palette.success.dark)));
+      setColor(palette.Alert, "warningFilledColor", silent(() => darkPalette.getContrastText(palette.warning.dark)));
+      setColor(palette.Alert, "errorStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.error.light, 0.9));
+      setColor(palette.Alert, "infoStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.info.light, 0.9));
+      setColor(palette.Alert, "successStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.success.light, 0.9));
+      setColor(palette.Alert, "warningStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.warning.light, 0.9));
+      setColor(palette.Alert, "errorIconColor", setCssVarColor("palette-error-main"));
+      setColor(palette.Alert, "infoIconColor", setCssVarColor("palette-info-main"));
+      setColor(palette.Alert, "successIconColor", setCssVarColor("palette-success-main"));
+      setColor(palette.Alert, "warningIconColor", setCssVarColor("palette-warning-main"));
+      setColor(palette.AppBar, "defaultBg", setCssVarColor("palette-grey-900"));
+      setColor(palette.AppBar, "darkBg", setCssVarColor("palette-background-paper"));
+      setColor(palette.AppBar, "darkColor", setCssVarColor("palette-text-primary"));
+      setColor(palette.Avatar, "defaultBg", setCssVarColor("palette-grey-600"));
+      setColor(palette.Button, "inheritContainedBg", setCssVarColor("palette-grey-800"));
+      setColor(palette.Button, "inheritContainedHoverBg", setCssVarColor("palette-grey-700"));
+      setColor(palette.Chip, "defaultBorder", setCssVarColor("palette-grey-700"));
+      setColor(palette.Chip, "defaultAvatarColor", setCssVarColor("palette-grey-300"));
+      setColor(palette.Chip, "defaultIconColor", setCssVarColor("palette-grey-300"));
+      setColor(palette.FilledInput, "bg", "rgba(255, 255, 255, 0.09)");
+      setColor(palette.FilledInput, "hoverBg", "rgba(255, 255, 255, 0.13)");
+      setColor(palette.FilledInput, "disabledBg", "rgba(255, 255, 255, 0.12)");
+      setColor(palette.LinearProgress, "primaryBg", (0, import_colorManipulator.private_safeDarken)(palette.primary.main, 0.5));
+      setColor(palette.LinearProgress, "secondaryBg", (0, import_colorManipulator.private_safeDarken)(palette.secondary.main, 0.5));
+      setColor(palette.LinearProgress, "errorBg", (0, import_colorManipulator.private_safeDarken)(palette.error.main, 0.5));
+      setColor(palette.LinearProgress, "infoBg", (0, import_colorManipulator.private_safeDarken)(palette.info.main, 0.5));
+      setColor(palette.LinearProgress, "successBg", (0, import_colorManipulator.private_safeDarken)(palette.success.main, 0.5));
+      setColor(palette.LinearProgress, "warningBg", (0, import_colorManipulator.private_safeDarken)(palette.warning.main, 0.5));
+      setColor(palette.Skeleton, "bg", `rgba(${setCssVarColor("palette-text-primaryChannel")} / 0.13)`);
+      setColor(palette.Slider, "primaryTrack", (0, import_colorManipulator.private_safeDarken)(palette.primary.main, 0.5));
+      setColor(palette.Slider, "secondaryTrack", (0, import_colorManipulator.private_safeDarken)(palette.secondary.main, 0.5));
+      setColor(palette.Slider, "errorTrack", (0, import_colorManipulator.private_safeDarken)(palette.error.main, 0.5));
+      setColor(palette.Slider, "infoTrack", (0, import_colorManipulator.private_safeDarken)(palette.info.main, 0.5));
+      setColor(palette.Slider, "successTrack", (0, import_colorManipulator.private_safeDarken)(palette.success.main, 0.5));
+      setColor(palette.Slider, "warningTrack", (0, import_colorManipulator.private_safeDarken)(palette.warning.main, 0.5));
+      const snackbarContentBackground = (0, import_colorManipulator.private_safeEmphasize)(palette.background.default, 0.98);
+      setColor(palette.SnackbarContent, "bg", snackbarContentBackground);
+      setColor(palette.SnackbarContent, "color", silent(() => darkPalette.getContrastText(snackbarContentBackground)));
+      setColor(palette.SpeedDialAction, "fabHoverBg", (0, import_colorManipulator.private_safeEmphasize)(palette.background.paper, 0.15));
+      setColor(palette.StepConnector, "border", setCssVarColor("palette-grey-600"));
+      setColor(palette.StepContent, "border", setCssVarColor("palette-grey-600"));
+      setColor(palette.Switch, "defaultColor", setCssVarColor("palette-grey-300"));
+      setColor(palette.Switch, "defaultDisabledColor", setCssVarColor("palette-grey-600"));
+      setColor(palette.Switch, "primaryDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.primary.main, 0.55));
+      setColor(palette.Switch, "secondaryDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.secondary.main, 0.55));
+      setColor(palette.Switch, "errorDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.error.main, 0.55));
+      setColor(palette.Switch, "infoDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.info.main, 0.55));
+      setColor(palette.Switch, "successDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.success.main, 0.55));
+      setColor(palette.Switch, "warningDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.warning.main, 0.55));
+      setColor(palette.TableCell, "border", (0, import_colorManipulator.private_safeDarken)((0, import_colorManipulator.private_safeAlpha)(palette.divider, 1), 0.68));
+      setColor(palette.Tooltip, "bg", (0, import_colorManipulator.private_safeAlpha)(palette.grey[700], 0.92));
+    }
+    setColorChannel(palette.background, "default");
+    setColorChannel(palette.background, "paper");
+    setColorChannel(palette.common, "background");
+    setColorChannel(palette.common, "onBackground");
+    setColorChannel(palette, "divider");
+    Object.keys(palette).forEach((color) => {
+      const colors = palette[color];
+      if (colors && typeof colors === "object") {
+        if (colors.main) {
+          setColor(palette[color], "mainChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.main)));
+        }
+        if (colors.light) {
+          setColor(palette[color], "lightChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.light)));
+        }
+        if (colors.dark) {
+          setColor(palette[color], "darkChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.dark)));
+        }
+        if (colors.contrastText) {
+          setColor(palette[color], "contrastTextChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.contrastText)));
+        }
+        if (color === "text") {
+          setColorChannel(palette[color], "primary");
+          setColorChannel(palette[color], "secondary");
+        }
+        if (color === "action") {
+          if (colors.active) {
+            setColorChannel(palette[color], "active");
+          }
+          if (colors.selected) {
+            setColorChannel(palette[color], "selected");
+          }
+        }
+      }
+    });
+  });
+  theme = args.reduce((acc, argument) => deepmerge(acc, argument), theme);
+  const parserConfig = {
+    prefix: cssVarPrefix,
+    shouldSkipGeneratingVar: shouldSkipGeneratingVar2
+  };
+  const {
+    vars: themeVars,
+    generateCssVars
+  } = prepareCssVars_default(theme, parserConfig);
+  theme.vars = themeVars;
+  theme.generateCssVars = generateCssVars;
+  theme.shouldSkipGeneratingVar = shouldSkipGeneratingVar2;
+  theme.unstable_sxConfig = _extends({}, defaultSxConfig_default, input == null ? void 0 : input.unstable_sxConfig);
+  theme.unstable_sx = function sx(props) {
+    return styleFunctionSx_default({
+      sx: props,
+      theme: this
+    });
+  };
+  return theme;
+}
+
+// node_modules/@mui/material/styles/CssVarsProvider.js
+init_createTypography();
+
+// node_modules/@mui/material/styles/excludeVariablesFromRoot.js
+var excludeVariablesFromRoot = (cssVarPrefix) => [...[...Array(24)].map((_, index) => `--${cssVarPrefix ? `${cssVarPrefix}-` : ""}overlays-${index + 1}`), `--${cssVarPrefix ? `${cssVarPrefix}-` : ""}palette-AppBar-darkBg`, `--${cssVarPrefix ? `${cssVarPrefix}-` : ""}palette-AppBar-darkColor`];
+var excludeVariablesFromRoot_default = excludeVariablesFromRoot;
+
+// node_modules/@mui/material/styles/CssVarsProvider.js
+init_identifier();
+var defaultTheme = extendTheme();
+var {
+  CssVarsProvider,
+  useColorScheme,
+  getInitColorSchemeScript
+} = createCssVarsProvider({
+  themeId: identifier_default,
+  theme: defaultTheme,
+  attribute: "data-mui-color-scheme",
+  modeStorageKey: "mui-mode",
+  colorSchemeStorageKey: "mui-color-scheme",
+  defaultColorScheme: {
+    light: "light",
+    dark: "dark"
+  },
+  resolveTheme: (theme) => {
+    const newTheme = _extends({}, theme, {
+      typography: createTypography(theme.palette, theme.typography)
+    });
+    newTheme.unstable_sx = function sx(props) {
+      return styleFunctionSx_default({
+        sx: props,
+        theme: this
+      });
+    };
+    return newTheme;
+  },
+  excludeVariablesFromRoot: excludeVariablesFromRoot_default
+});
+
+// node_modules/@mui/material/styles/index.js
+init_createTypography();
+init_createMixins();
+function experimental_sx() {
+  throw new Error(true ? `MUI: The \`experimental_sx\` has been moved to \`theme.unstable_sx\`.For more details, see https://github.com/mui/material-ui/pull/35150.` : formatMuiErrorMessage(20));
+}
+
+export {
+  adaptV4Theme,
+  createMuiStrictModeTheme,
+  createStyles,
+  getUnit,
+  toUnitless,
+  responsiveFontSizes,
+  ThemeProvider,
+  makeStyles,
+  withStyles,
+  withTheme,
+  shouldSkipGeneratingVar,
+  extendTheme,
+  excludeVariablesFromRoot_default,
+  CssVarsProvider,
+  useColorScheme,
+  getInitColorSchemeScript,
+  experimental_sx
+};
+//# sourceMappingURL=chunk-FUCRG4FR.js.map
+0<EFBFBD><EFBFBD>G<EFBFBD>e<>^<5E>e<EFBFBD>^<5E>F<EFBFBD>O1gՐ<67>xO^partitionKey=%28http%2Clocalhost%2C5173%29,:http://localhost:5173/node_modules/.vite/deps/chunk-FUCRG4FR.js?v=e565559anecko:classified1strongly-framed1request-methodGETresponse-headHTTP/1.1 200 OK
+Access-Control-Allow-Origin: *
+Content-Type: application/javascript
+Cache-Control: max-age=31536000,immutable
+Etag: W/"81c0-faAjnnAP8aEhj3Bwg/688GUHUFo"
+Date: Fri, 15 Mar 2024 14:37:23 GMT
+Content-Length: 33216
+original-response-headersAccess-Control-Allow-Origin: *
+Content-Type: application/javascript
+Cache-Control: max-age=31536000,immutable
+Etag: W/"81c0-faAjnnAP8aEhj3Bwg/688GUHUFo"
+Date: Fri, 15 Mar 2024 14:37:23 GMT
+Connection: keep-alive
+Keep-Alive: timeout=5
+Content-Length: 33216
+ctid2uncompressed-len0net-response-time-onstart74net-response-time-onstop75<00><>