@ix_waterford/lib 1.0.47 → 1.0.49

package/dist/utils.js

@@ -0,0 +1,1717 @@
+import * as __rspack_external_dayjs from "dayjs";
+var __webpack_modules__ = ({
+"./node_modules/react-refresh/cjs/react-refresh-runtime.development.js"(__unused_rspack_module, exports) {
+/**
+ * @license React
+ * react-refresh-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+ true &&
+  (function () {
+    function computeFullKey(signature) {
+      if (null !== signature.fullKey) return signature.fullKey;
+      var fullKey = signature.ownKey;
+      try {
+        var hooks = signature.getCustomHooks();
+      } catch (err) {
+        return (signature.forceReset = !0), (signature.fullKey = fullKey);
+      }
+      for (var i = 0; i < hooks.length; i++) {
+        var hook = hooks[i];
+        if ("function" !== typeof hook)
+          return (signature.forceReset = !0), (signature.fullKey = fullKey);
+        hook = allSignaturesByType.get(hook);
+        if (void 0 !== hook) {
+          var nestedHookKey = computeFullKey(hook);
+          hook.forceReset && (signature.forceReset = !0);
+          fullKey += "\n---\n" + nestedHookKey;
+        }
+      }
+      return (signature.fullKey = fullKey);
+    }
+    function resolveFamily(type) {
+      return updatedFamiliesByType.get(type);
+    }
+    function cloneMap(map) {
+      var clone = new Map();
+      map.forEach(function (value, key) {
+        clone.set(key, value);
+      });
+      return clone;
+    }
+    function cloneSet(set) {
+      var clone = new Set();
+      set.forEach(function (value) {
+        clone.add(value);
+      });
+      return clone;
+    }
+    function getProperty(object, property) {
+      try {
+        return object[property];
+      } catch (err) {}
+    }
+    function register(type, id) {
+      if (
+        !(
+          null === type ||
+          ("function" !== typeof type && "object" !== typeof type) ||
+          allFamiliesByType.has(type)
+        )
+      ) {
+        var family = allFamiliesByID.get(id);
+        void 0 === family
+          ? ((family = { current: type }), allFamiliesByID.set(id, family))
+          : pendingUpdates.push([family, type]);
+        allFamiliesByType.set(type, family);
+        if ("object" === typeof type && null !== type)
+          switch (getProperty(type, "$$typeof")) {
+            case REACT_FORWARD_REF_TYPE:
+              register(type.render, id + "$render");
+              break;
+            case REACT_MEMO_TYPE:
+              register(type.type, id + "$type");
+          }
+      }
+    }
+    function setSignature(type, key) {
+      var forceReset =
+          2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1,
+        getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
+      allSignaturesByType.has(type) ||
+        allSignaturesByType.set(type, {
+          forceReset: forceReset,
+          ownKey: key,
+          fullKey: null,
+          getCustomHooks:
+            getCustomHooks ||
+            function () {
+              return [];
+            }
+        });
+      if ("object" === typeof type && null !== type)
+        switch (getProperty(type, "$$typeof")) {
+          case REACT_FORWARD_REF_TYPE:
+            setSignature(type.render, key, forceReset, getCustomHooks);
+            break;
+          case REACT_MEMO_TYPE:
+            setSignature(type.type, key, forceReset, getCustomHooks);
+        }
+    }
+    function collectCustomHooksForSignature(type) {
+      type = allSignaturesByType.get(type);
+      void 0 !== type && computeFullKey(type);
+    }
+    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+      allFamiliesByID = new Map(),
+      allFamiliesByType = new PossiblyWeakMap(),
+      allSignaturesByType = new PossiblyWeakMap(),
+      updatedFamiliesByType = new PossiblyWeakMap(),
+      pendingUpdates = [],
+      helpersByRendererID = new Map(),
+      helpersByRoot = new Map(),
+      mountedRoots = new Set(),
+      failedRoots = new Set(),
+      rootElements = "function" === typeof WeakMap ? new WeakMap() : null,
+      isPerformingRefresh = !1;
+    exports._getMountedRootCount = function () {
+      return mountedRoots.size;
+    };
+    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
+    exports.createSignatureFunctionForTransform = function () {
+      var savedType,
+        hasCustomHooks,
+        didCollectHooks = !1;
+      return function (type, key, forceReset, getCustomHooks) {
+        if ("string" === typeof key)
+          return (
+            savedType ||
+              ((savedType = type),
+              (hasCustomHooks = "function" === typeof getCustomHooks)),
+            null == type ||
+              ("function" !== typeof type && "object" !== typeof type) ||
+              setSignature(type, key, forceReset, getCustomHooks),
+            type
+          );
+        !didCollectHooks &&
+          hasCustomHooks &&
+          ((didCollectHooks = !0), collectCustomHooksForSignature(savedType));
+      };
+    };
+    exports.getFamilyByID = function (id) {
+      return allFamiliesByID.get(id);
+    };
+    exports.getFamilyByType = function (type) {
+      return allFamiliesByType.get(type);
+    };
+    exports.hasUnrecoverableErrors = function () {
+      return !1;
+    };
+    exports.injectIntoGlobalHook = function (globalObject) {
+      var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (void 0 === hook) {
+        var nextID = 0;
+        globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+          renderers: new Map(),
+          supportsFiber: !0,
+          inject: function () {
+            return nextID++;
+          },
+          onScheduleFiberRoot: function () {},
+          onCommitFiberRoot: function () {},
+          onCommitFiberUnmount: function () {}
+        };
+      }
+      if (hook.isDisabled)
+        console.warn(
+          "Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled."
+        );
+      else {
+        var oldInject = hook.inject;
+        hook.inject = function (injected) {
+          var id = oldInject.apply(this, arguments);
+          "function" === typeof injected.scheduleRefresh &&
+            "function" === typeof injected.setRefreshHandler &&
+            helpersByRendererID.set(id, injected);
+          return id;
+        };
+        hook.renderers.forEach(function (injected, id) {
+          "function" === typeof injected.scheduleRefresh &&
+            "function" === typeof injected.setRefreshHandler &&
+            helpersByRendererID.set(id, injected);
+        });
+        var oldOnCommitFiberRoot = hook.onCommitFiberRoot,
+          oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
+        hook.onScheduleFiberRoot = function (id, root, children) {
+          isPerformingRefresh ||
+            (failedRoots.delete(root),
+            null !== rootElements && rootElements.set(root, children));
+          return oldOnScheduleFiberRoot.apply(this, arguments);
+        };
+        hook.onCommitFiberRoot = function (
+          id,
+          root,
+          maybePriorityLevel,
+          didError
+        ) {
+          var helpers = helpersByRendererID.get(id);
+          if (void 0 !== helpers) {
+            helpersByRoot.set(root, helpers);
+            helpers = root.current;
+            var alternate = helpers.alternate;
+            null !== alternate
+              ? ((alternate =
+                  null != alternate.memoizedState &&
+                  null != alternate.memoizedState.element &&
+                  mountedRoots.has(root)),
+                (helpers =
+                  null != helpers.memoizedState &&
+                  null != helpers.memoizedState.element),
+                !alternate && helpers
+                  ? (mountedRoots.add(root), failedRoots.delete(root))
+                  : (alternate && helpers) ||
+                    (alternate && !helpers
+                      ? (mountedRoots.delete(root),
+                        didError
+                          ? failedRoots.add(root)
+                          : helpersByRoot.delete(root))
+                      : alternate ||
+                        helpers ||
+                        (didError && failedRoots.add(root))))
+              : mountedRoots.add(root);
+          }
+          return oldOnCommitFiberRoot.apply(this, arguments);
+        };
+      }
+    };
+    exports.isLikelyComponentType = function (type) {
+      switch (typeof type) {
+        case "function":
+          if (null != type.prototype) {
+            if (type.prototype.isReactComponent) return !0;
+            var ownNames = Object.getOwnPropertyNames(type.prototype);
+            if (
+              1 < ownNames.length ||
+              "constructor" !== ownNames[0] ||
+              type.prototype.__proto__ !== Object.prototype
+            )
+              return !1;
+          }
+          type = type.name || type.displayName;
+          return "string" === typeof type && /^[A-Z]/.test(type);
+        case "object":
+          if (null != type)
+            switch (getProperty(type, "$$typeof")) {
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_MEMO_TYPE:
+                return !0;
+            }
+          return !1;
+        default:
+          return !1;
+      }
+    };
+    exports.performReactRefresh = function () {
+      if (0 === pendingUpdates.length || isPerformingRefresh) return null;
+      isPerformingRefresh = !0;
+      try {
+        var staleFamilies = new Set(),
+          updatedFamilies = new Set(),
+          updates = pendingUpdates;
+        pendingUpdates = [];
+        updates.forEach(function (_ref) {
+          var family = _ref[0];
+          _ref = _ref[1];
+          var prevType = family.current;
+          updatedFamiliesByType.set(prevType, family);
+          updatedFamiliesByType.set(_ref, family);
+          family.current = _ref;
+          (prevType.prototype && prevType.prototype.isReactComponent) ||
+          (_ref.prototype && _ref.prototype.isReactComponent)
+            ? (_ref = !1)
+            : ((prevType = allSignaturesByType.get(prevType)),
+              (_ref = allSignaturesByType.get(_ref)),
+              (_ref =
+                (void 0 === prevType && void 0 === _ref) ||
+                (void 0 !== prevType &&
+                  void 0 !== _ref &&
+                  computeFullKey(prevType) === computeFullKey(_ref) &&
+                  !_ref.forceReset)
+                  ? !0
+                  : !1));
+          _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
+        });
+        var update = {
+          updatedFamilies: updatedFamilies,
+          staleFamilies: staleFamilies
+        };
+        helpersByRendererID.forEach(function (helpers) {
+          helpers.setRefreshHandler(resolveFamily);
+        });
+        var didError = !1,
+          firstError = null,
+          failedRootsSnapshot = cloneSet(failedRoots),
+          mountedRootsSnapshot = cloneSet(mountedRoots),
+          helpersByRootSnapshot = cloneMap(helpersByRoot);
+        failedRootsSnapshot.forEach(function (root) {
+          var helpers = helpersByRootSnapshot.get(root);
+          if (void 0 === helpers)
+            throw Error(
+              "Could not find helpers for a root. This is a bug in React Refresh."
+            );
+          failedRoots.has(root);
+          if (null !== rootElements && rootElements.has(root)) {
+            var element = rootElements.get(root);
+            try {
+              helpers.scheduleRoot(root, element);
+            } catch (err) {
+              didError || ((didError = !0), (firstError = err));
+            }
+          }
+        });
+        mountedRootsSnapshot.forEach(function (root) {
+          var helpers = helpersByRootSnapshot.get(root);
+          if (void 0 === helpers)
+            throw Error(
+              "Could not find helpers for a root. This is a bug in React Refresh."
+            );
+          mountedRoots.has(root);
+          try {
+            helpers.scheduleRefresh(root, update);
+          } catch (err) {
+            didError || ((didError = !0), (firstError = err));
+          }
+        });
+        if (didError) throw firstError;
+        return update;
+      } finally {
+        isPerformingRefresh = !1;
+      }
+    };
+    exports.register = register;
+    exports.setSignature = setSignature;
+  })();
+
+
+},
+"./node_modules/react-refresh/runtime.js"(module, __unused_rspack_exports, __webpack_require__) {
+
+
+if (false) {} else {
+  module.exports = __webpack_require__("./node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+}
+
+
+},
+"./src/constants/dateConstants.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DEFAULT_DATE_FORMAT: () => (DEFAULT_DATE_FORMAT),
+  months: () => (months),
+  weekDays: () => (weekDays)
+});
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+const months = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec'
+];
+const weekDays = [
+    'Su',
+    'Mo',
+    'Tu',
+    'We',
+    'Th',
+    'Fr',
+    'Sa'
+];
+const DEFAULT_DATE_FORMAT = 'YYYY-MM-DD';
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"./src/utils/date.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  formatDate: () => (formatDate),
+  parseDate: () => (parseDate)
+});
+/* import */ var dayjs__rspack_import_0 = __webpack_require__("dayjs");
+/* import */ var _constants_dateConstants__rspack_import_1 = __webpack_require__("./src/constants/dateConstants.ts");
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+
+
+const formatDate = function(date) {
+    let format = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _constants_dateConstants__rspack_import_1.DEFAULT_DATE_FORMAT;
+    try {
+        return date ? (0,dayjs__rspack_import_0["default"])(date).format(format) : null;
+    } catch (_error) {
+        return null;
+    }
+};
+const parseDate = function(date) {
+    let format = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+    try {
+        if (!date) return null;
+        const d = format ? (0,dayjs__rspack_import_0["default"])(date, format, true) : (0,dayjs__rspack_import_0["default"])(date);
+        return d.isValid() ? d : null;
+    } catch (_error) {
+        return null;
+    }
+};
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"./src/utils/email.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  isValidEmail: () => (isValidEmail)
+});
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+/**
+ * Validates whether a given string is a valid email address
+ * @param email - The email string to validate
+ * @returns true if the email is valid, false otherwise
+ */ const isValidEmail = (email)=>{
+    if (!email || typeof email !== 'string') {
+        return false;
+    }
+    const emailRegex = RegExp("^(?!\\.)(?!.*\\.\\.)[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+(?<!\\.)@[A-Za-z0-9-]+(?:\\.[A-Za-z0-9-]+)*\\.[A-Za-z]{2,}$");
+    return emailRegex.test(email.trim());
+};
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"./src/utils/global.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  getColorFromId: () => (getColorFromId),
+  getFormattedName: () => (getFormattedName),
+  isEmpty: () => (isEmpty),
+  isEmptyArray: () => (isEmptyArray),
+  isEmptyObject: () => (isEmptyObject),
+  isEmptyString: () => (isEmptyString),
+  strEllipsis: () => (strEllipsis)
+});
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+/**
+ * Helper function to check if a value is null or undefined
+ */ const isNullOrUndefined = (value)=>{
+    return value === null || value === undefined;
+};
+/**
+ * Checks if a string is empty (after trimming whitespace)
+ * @param value - The string to check
+ * @returns true if the string is empty or only whitespace, false otherwise
+ */ const isEmptyString = (value)=>{
+    if (isNullOrUndefined(value)) {
+        return true;
+    }
+    if (typeof value !== 'string') {
+        return false;
+    }
+    return value.trim().length === 0;
+};
+/**
+ * Checks if an array is empty
+ * @param value - The array to check
+ * @returns true if the array is empty, false otherwise
+ */ const isEmptyArray = (value)=>{
+    if (isNullOrUndefined(value)) {
+        return true;
+    }
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.length === 0;
+};
+/**
+ * Checks if an object is empty (has no keys)
+ * @param value - The object to check
+ * @returns true if the object is empty, false otherwise
+ */ const isEmptyObject = (value)=>{
+    if (isNullOrUndefined(value)) {
+        return true;
+    }
+    if (Array.isArray(value) || value.constructor !== Object) {
+        return false;
+    }
+    return Object.keys(value).length === 0;
+};
+/**
+ * Checks if a value is empty
+ * @param value - The value to check (string, array, or object)
+ * @returns true if the value is empty, false otherwise
+ */ const isEmpty = (value)=>{
+    if (isNullOrUndefined(value)) {
+        return true;
+    }
+    // Handle strings
+    if (typeof value === 'string') {
+        return isEmptyString(value);
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        return isEmptyArray(value);
+    }
+    // Handle objects
+    if (typeof value === 'object') {
+        return isEmptyObject(value);
+    }
+    // For other types, consider them as not empty
+    return false;
+};
+const colors = [
+    '#e57373',
+    '#f06292',
+    '#ba68c8',
+    '#9575cd',
+    '#c5cae9',
+    '#7986cb',
+    '#4fc3f7',
+    '#4dd0e1',
+    '#4db6ac',
+    '#81c784',
+    '#aed581',
+    '#dce775',
+    '#ffee58',
+    '#ffca28',
+    '#ff7043',
+    '#8d6e63',
+    '#bdbdbd'
+];
+const getColorFromId = (id)=>{
+    if (!id && id !== 0) return colors[0];
+    const str = String(id);
+    const code = str.split('').reduce((acc, ch)=>acc + ch.charCodeAt(0), 0);
+    return colors[code % colors.length];
+};
+/**
+ * Extracts initials from a name string
+ * @param nameValue - The name string to extract initials from
+ * @returns A string containing up to 2 uppercase initials
+ */ const getFormattedName = (nameValue)=>{
+    if (!nameValue) return '';
+    return nameValue.slice().split(' ').map((word)=>word[0] || '').join('').slice(0, 2).toUpperCase();
+};
+/**
+ * Truncates a string to a specified length and adds ellipsis if needed
+ * @param str - The value to truncate (string, number, boolean, null, or undefined)
+ * @param length - Maximum length before truncation (default: 25)
+ * @returns Truncated string with ellipsis if needed, or the original string if shorter
+ */ const strEllipsis = function(str) {
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 25;
+    const stringValue = typeof str === 'string' ? str.trim() : String(str ?? '');
+    return stringValue.length > length ? `${stringValue.substring(0, length)}...` : stringValue;
+};
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"./src/utils/index.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  formatDate: () => (/* reexport safe */ _date__rspack_import_0.formatDate),
+  getColorFromId: () => (/* reexport safe */ _global__rspack_import_2.getColorFromId),
+  getFormattedName: () => (/* reexport safe */ _global__rspack_import_2.getFormattedName),
+  getLocalStorageItem: () => (/* reexport safe */ _localStorage__rspack_import_3.getLocalStorageItem),
+  getSessionStorageItem: () => (/* reexport safe */ _sessionStorage__rspack_import_4.getSessionStorageItem),
+  isEmpty: () => (/* reexport safe */ _global__rspack_import_2.isEmpty),
+  isEmptyArray: () => (/* reexport safe */ _global__rspack_import_2.isEmptyArray),
+  isEmptyObject: () => (/* reexport safe */ _global__rspack_import_2.isEmptyObject),
+  isEmptyString: () => (/* reexport safe */ _global__rspack_import_2.isEmptyString),
+  isValidEmail: () => (/* reexport safe */ _email__rspack_import_1.isValidEmail),
+  parseDate: () => (/* reexport safe */ _date__rspack_import_0.parseDate),
+  removeLocalStorageItem: () => (/* reexport safe */ _localStorage__rspack_import_3.removeLocalStorageItem),
+  removeSessionStorageItem: () => (/* reexport safe */ _sessionStorage__rspack_import_4.removeSessionStorageItem),
+  setLocalStorageItem: () => (/* reexport safe */ _localStorage__rspack_import_3.setLocalStorageItem),
+  setSessionStorageItem: () => (/* reexport safe */ _sessionStorage__rspack_import_4.setSessionStorageItem),
+  strEllipsis: () => (/* reexport safe */ _global__rspack_import_2.strEllipsis)
+});
+/* import */ var _date__rspack_import_0 = __webpack_require__("./src/utils/date.ts");
+/* import */ var _email__rspack_import_1 = __webpack_require__("./src/utils/email.ts");
+/* import */ var _global__rspack_import_2 = __webpack_require__("./src/utils/global.ts");
+/* import */ var _localStorage__rspack_import_3 = __webpack_require__("./src/utils/localStorage.ts");
+/* import */ var _sessionStorage__rspack_import_4 = __webpack_require__("./src/utils/sessionStorage.ts");
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+
+
+
+
+
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"./src/utils/localStorage.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  getLocalStorageItem: () => (getLocalStorageItem),
+  removeLocalStorageItem: () => (removeLocalStorageItem),
+  setLocalStorageItem: () => (setLocalStorageItem)
+});
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+/**
+ * Retrieves an item from localStorage and parses it as JSON
+ * @param key - The localStorage key to retrieve
+ * @returns The parsed value if found and valid, null otherwise
+ */ const getLocalStorageItem = (key)=>{
+    try {
+        const item = window.localStorage.getItem(key);
+        return item ? JSON.parse(item) : null;
+    } catch (_error) {
+        return null;
+    }
+};
+/**
+ * Sets an item in localStorage with JSON stringification
+ * @param key - The localStorage key to set
+ * @param value - The value to store (will be stringified as JSON)
+ * @returns true if successful, false if an error occurred
+ */ const setLocalStorageItem = (key, value)=>{
+    try {
+        window.localStorage.setItem(key, JSON.stringify(value));
+        return true;
+    } catch (_error) {
+        return false;
+    }
+};
+/**
+ * Removes an item from localStorage
+ * @param key - The localStorage key to remove
+ * @returns true if successful, false if an error occurred
+ */ const removeLocalStorageItem = (key)=>{
+    try {
+        window.localStorage.removeItem(key);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"./src/utils/sessionStorage.ts"(module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  getSessionStorageItem: () => (getSessionStorageItem),
+  removeSessionStorageItem: () => (removeSessionStorageItem),
+  setSessionStorageItem: () => (setSessionStorageItem)
+});
+/* provided dependency */ var $ReactRefreshRuntime$ = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js");
+/**
+ * Retrieves an item from sessionStorage and parses it as JSON
+ * @param key - The sessionStorage key to retrieve
+ * @returns The parsed value if found and valid, null otherwise
+ */ const getSessionStorageItem = (key)=>{
+    try {
+        const item = window.sessionStorage.getItem(key);
+        return item ? JSON.parse(item) : null;
+    } catch  {
+        return null;
+    }
+};
+/**
+ * Sets an item in sessionStorage with JSON stringification
+ * @param key - The sessionStorage key to set
+ * @param value - The value to store (will be stringified as JSON)
+ * @returns true if successful, false if an error occurred
+ */ const setSessionStorageItem = (key, value)=>{
+    try {
+        window.sessionStorage.setItem(key, JSON.stringify(value));
+        return true;
+    } catch  {
+        return false;
+    }
+};
+/**
+ * Removes an item from sessionStorage
+ * @param key - The sessionStorage key to remove
+ * @returns true if successful, false if an error occurred
+ */ const removeSessionStorageItem = (key)=>{
+    try {
+        window.sessionStorage.removeItem(key);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+
+function $RefreshSig$() { return $ReactRefreshRuntime$.createSignatureFunctionForTransform() }
+function $RefreshReg$(type, id) { $ReactRefreshRuntime$.register(type, module.id + "_" + id) }
+Promise.resolve().then(() => { $ReactRefreshRuntime$.refresh(module.id, module.hot) });
+
+
+},
+"dayjs"(module) {
+
+module.exports = __rspack_external_dayjs;
+
+
+},
+"./node_modules/@rspack/plugin-react-refresh/client/reactRefresh.js"(module, __unused_rspack_exports, __webpack_require__) {
+const RefreshUtils = __webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/refreshUtils.js");
+const RefreshRuntime = __webpack_require__("./node_modules/react-refresh/runtime.js");
+
+function refresh(moduleId, webpackHot) {
+  const currentExports = RefreshUtils.getModuleExports(moduleId);
+  const fn = (exports) => {
+    var errorOverlay;
+    if (true) {
+      errorOverlay = false;
+    }
+    var testMode;
+    if (typeof __react_refresh_test__ !== 'undefined') {
+      testMode = __react_refresh_test__;
+    }
+    RefreshUtils.executeRuntime(
+      exports,
+      moduleId,
+      webpackHot,
+      errorOverlay,
+      testMode,
+    );
+  };
+  if (typeof Promise !== 'undefined' && currentExports instanceof Promise) {
+    currentExports.then(fn);
+  } else {
+    fn(currentExports);
+  }
+}
+
+module.exports = {
+  refresh,
+  register: RefreshRuntime.register,
+  createSignatureFunctionForTransform:
+    RefreshRuntime.createSignatureFunctionForTransform,
+};
+
+
+},
+"./node_modules/@rspack/plugin-react-refresh/client/reactRefreshEntry.js"(__unused_rspack_module, __unused_rspack_exports, __webpack_require__) {
+var RefreshRuntime = __webpack_require__("./node_modules/react-refresh/runtime.js");
+var safeThis = (function () {
+  // copied from core-js-pure/features/global-this
+  'use strict';
+
+  var check = function (it) {
+    return it && it.Math == Math && it;
+  };
+
+  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+  // eslint-disable-next-line es/no-global-this -- safe
+  return (
+    check(typeof globalThis == 'object' && globalThis) ||
+    check(typeof window == 'object' && window) ||
+    // eslint-disable-next-line no-restricted-globals -- safe
+    check(typeof self == 'object' && self) ||
+    check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) ||
+    // eslint-disable-next-line no-new-func -- fallback
+    (function () {
+      return this;
+    })() ||
+    this ||
+    Function('return this')()
+  );
+})();
+
+if (true) {
+  if (typeof safeThis !== 'undefined') {
+    var $RefreshInjected$ = '__reactRefreshInjected';
+    // Namespace the injected flag (if necessary) for monorepo compatibility
+    if (
+      false
+    ) {}
+
+    // Only inject the runtime if it hasn't been injected
+    if (!safeThis[$RefreshInjected$]) {
+      RefreshRuntime.injectIntoGlobalHook(safeThis);
+
+      // Empty implementation to avoid "ReferenceError: variable is not defined" in module which didn't pass builtin:react-refresh-loader
+      safeThis.$RefreshSig$ = () => (type) => type;
+      safeThis.$RefreshReg$ = () => {};
+
+      // Mark the runtime as injected to prevent double-injection
+      safeThis[$RefreshInjected$] = true;
+    }
+  }
+}
+
+
+},
+"./node_modules/@rspack/plugin-react-refresh/client/refreshUtils.js"(module, __unused_rspack_exports, __webpack_require__) {
+/* global __webpack_require__ */
+var Refresh = __webpack_require__("./node_modules/react-refresh/runtime.js");
+
+/**
+ * Extracts exports from a webpack module object.
+ * @param {string} moduleId A Webpack module ID.
+ * @returns {*} An exports object from the module.
+ */
+function getModuleExports(moduleId) {
+  if (typeof moduleId === 'undefined') {
+    // `moduleId` is unavailable, which indicates that this module is not in the cache,
+    // which means we won't be able to capture any exports,
+    // and thus they cannot be refreshed safely.
+    // These are likely runtime or dynamically generated modules.
+    return {};
+  }
+
+  var maybeModule = __webpack_require__.c[moduleId];
+  if (typeof maybeModule === 'undefined') {
+    // `moduleId` is available but the module in cache is unavailable,
+    // which indicates the module is somehow corrupted (e.g. broken Webpacak `module` globals).
+    // We will warn the user (as this is likely a mistake) and assume they cannot be refreshed.
+    console.warn(
+      '[React Refresh] Failed to get exports for module: ' + moduleId + '.',
+    );
+    return {};
+  }
+
+  var exportsOrPromise = maybeModule.exports;
+  if (typeof Promise !== 'undefined' && exportsOrPromise instanceof Promise) {
+    return exportsOrPromise.then(function (exports) {
+      return exports;
+    });
+  }
+  return exportsOrPromise;
+}
+
+/**
+ * Calculates the signature of a React refresh boundary.
+ * If this signature changes, it's unsafe to accept the boundary.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/907d6af22ac6ebe58572be418e9253a90665ecbd/packages/metro/src/lib/polyfills/require.js#L795-L816).
+ * @param {*} moduleExports A Webpack module exports object.
+ * @returns {string[]} A React refresh boundary signature array.
+ */
+function getReactRefreshBoundarySignature(moduleExports) {
+  var signature = [];
+  signature.push(Refresh.getFamilyByType(moduleExports));
+
+  if (moduleExports == null || typeof moduleExports !== 'object') {
+    // Exit if we can't iterate over exports.
+    return signature;
+  }
+
+  for (var key in moduleExports) {
+    if (key === '__esModule') {
+      continue;
+    }
+
+    signature.push(key);
+    signature.push(Refresh.getFamilyByType(moduleExports[key]));
+  }
+
+  return signature;
+}
+
+/**
+ * Creates a helper that performs a delayed React refresh.
+ * @returns {function(function(): void): void} A debounced React refresh function.
+ */
+function createDebounceUpdate() {
+  /**
+   * A cached setTimeout handler.
+   * @type {number | undefined}
+   */
+  var refreshTimeout;
+
+  /**
+   * Performs react refresh on a delay and clears the error overlay.
+   * @param {function(): void} callback
+   * @returns {void}
+   */
+  function enqueueUpdate(callback) {
+    if (typeof refreshTimeout === 'undefined') {
+      refreshTimeout = setTimeout(function () {
+        refreshTimeout = undefined;
+        Refresh.performReactRefresh();
+        callback();
+      }, 30);
+    }
+  }
+
+  return enqueueUpdate;
+}
+
+/**
+ * Checks if all exports are likely a React component.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/febdba2383113c88296c61e28e4ef6a7f4939fda/packages/metro/src/lib/polyfills/require.js#L748-L774).
+ * @param {*} moduleExports A Webpack module exports object.
+ * @returns {boolean} Whether the exports are React component like.
+ */
+function isReactRefreshBoundary(moduleExports) {
+  if (Refresh.isLikelyComponentType(moduleExports)) {
+    return true;
+  }
+  if (
+    moduleExports === undefined ||
+    moduleExports === null ||
+    typeof moduleExports !== 'object'
+  ) {
+    // Exit if we can't iterate over exports.
+    return false;
+  }
+
+  var hasExports = false;
+  var areAllExportsComponents = true;
+  for (var key in moduleExports) {
+    hasExports = true;
+
+    // This is the ES Module indicator flag
+    if (key === '__esModule') {
+      continue;
+    }
+
+    // We can (and have to) safely execute getters here,
+    // as Webpack manually assigns harmony exports to getters,
+    // without any side-effects attached.
+    // Ref: https://github.com/webpack/webpack/blob/b93048643fe74de2a6931755911da1212df55897/lib/MainTemplate.js#L281
+    var exportValue = moduleExports[key];
+    if (!Refresh.isLikelyComponentType(exportValue)) {
+      areAllExportsComponents = false;
+    }
+  }
+
+  return hasExports && areAllExportsComponents;
+}
+
+/**
+ * Checks if exports are likely a React component and registers them.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/febdba2383113c88296c61e28e4ef6a7f4939fda/packages/metro/src/lib/polyfills/require.js#L818-L835).
+ * @param {*} moduleExports A Webpack module exports object.
+ * @param {string} moduleId A Webpack module ID.
+ * @returns {void}
+ */
+function registerExportsForReactRefresh(moduleExports, moduleId) {
+  if (Refresh.isLikelyComponentType(moduleExports)) {
+    // Register module.exports if it is likely a component
+    Refresh.register(moduleExports, moduleId + ' %exports%');
+  }
+
+  if (
+    moduleExports === undefined ||
+    moduleExports === null ||
+    typeof moduleExports !== 'object'
+  ) {
+    // Exit if we can't iterate over the exports.
+    return;
+  }
+
+  for (var key in moduleExports) {
+    // Skip registering the ES Module indicator
+    if (key === '__esModule') {
+      continue;
+    }
+
+    var exportValue = moduleExports[key];
+    if (Refresh.isLikelyComponentType(exportValue)) {
+      var typeID = moduleId + ' %exports% ' + key;
+      Refresh.register(exportValue, typeID);
+    }
+  }
+}
+
+/**
+ * Compares previous and next module objects to check for mutated boundaries.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/907d6af22ac6ebe58572be418e9253a90665ecbd/packages/metro/src/lib/polyfills/require.js#L776-L792).
+ * @param {*} prevExports The current Webpack module exports object.
+ * @param {*} nextExports The next Webpack module exports object.
+ * @returns {boolean} Whether the React refresh boundary should be invalidated.
+ */
+function shouldInvalidateReactRefreshBoundary(prevExports, nextExports) {
+  var prevSignature = getReactRefreshBoundarySignature(prevExports);
+  var nextSignature = getReactRefreshBoundarySignature(nextExports);
+
+  if (prevSignature.length !== nextSignature.length) {
+    return true;
+  }
+
+  for (var i = 0; i < nextSignature.length; i += 1) {
+    if (prevSignature[i] !== nextSignature[i]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+var enqueueUpdate = createDebounceUpdate();
+
+function executeRuntime(
+  moduleExports,
+  moduleId,
+  webpackHot,
+  refreshOverlay,
+  isTest,
+) {
+  registerExportsForReactRefresh(moduleExports, moduleId);
+
+  if (webpackHot) {
+    var isHotUpdate = !!webpackHot.data;
+    var prevExports;
+    if (isHotUpdate) {
+      prevExports = webpackHot.data.prevExports;
+    }
+
+    if (isReactRefreshBoundary(moduleExports)) {
+      webpackHot.dispose(
+        /**
+         * A callback to performs a full refresh if React has unrecoverable errors,
+         * and also caches the to-be-disposed module.
+         * @param {*} data A hot module data object from Webpack HMR.
+         * @returns {void}
+         */
+        function hotDisposeCallback(data) {
+          // We have to mutate the data object to get data registered and cached
+          data.prevExports = moduleExports;
+        },
+      );
+      webpackHot.accept(
+        /**
+         * An error handler to allow self-recovering behaviours.
+         * @param {Error} error An error occurred during evaluation of a module.
+         * @returns {void}
+         */
+        function hotErrorHandler(error) {
+          console.error(error);
+          if (
+            false
+          ) {}
+
+          if (typeof refreshOverlay !== 'undefined' && refreshOverlay) {
+            refreshOverlay.handleRuntimeError(error);
+          }
+
+          if (typeof isTest !== 'undefined' && isTest) {
+            if (window.onHotAcceptError) {
+              window.onHotAcceptError(error.message);
+            }
+          }
+
+          __webpack_require__.c[moduleId].hot.accept(hotErrorHandler);
+        },
+      );
+
+      if (isHotUpdate) {
+        if (
+          isReactRefreshBoundary(prevExports) &&
+          shouldInvalidateReactRefreshBoundary(prevExports, moduleExports)
+        ) {
+          webpackHot.invalidate();
+        } else {
+          enqueueUpdate(
+            /**
+             * A function to dismiss the error overlay after performing React refresh.
+             * @returns {void}
+             */
+            function updateCallback() {
+              if (typeof refreshOverlay !== 'undefined' && refreshOverlay) {
+                refreshOverlay.clearRuntimeErrors();
+              }
+            },
+          );
+        }
+      }
+    } else {
+      if (isHotUpdate && typeof prevExports !== 'undefined') {
+        webpackHot.invalidate();
+      }
+    }
+  }
+}
+
+function isUnrecoverableRuntimeError(error) {
+  return error.message.startsWith('RuntimeError: factory is undefined');
+}
+
+module.exports = Object.freeze({
+  enqueueUpdate: enqueueUpdate,
+  executeRuntime: executeRuntime,
+  getModuleExports: getModuleExports,
+  isReactRefreshBoundary: isReactRefreshBoundary,
+  shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary,
+  registerExportsForReactRefresh: registerExportsForReactRefresh,
+});
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+if (cachedModule.error !== undefined) throw cachedModule.error;
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+id: moduleId,
+exports: {}
+});
+// Execute the module function
+try {
+
+
+        var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };
+        __webpack_require__.i.forEach(function(handler) { handler(execOptions); });
+        module = execOptions.module;
+        if (!execOptions.factory) {
+          console.error("undefined factory", moduleId);
+          throw Error("RuntimeError: factory is undefined (" + moduleId + ")");
+        }
+        execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
+      
+} catch (e) {
+module.error = e;
+throw e;
+}
+// Return the exports of the module
+return module.exports;
+
+}
+
+// expose the module cache
+__webpack_require__.c = __webpack_module_cache__;
+
+// expose the module execution interceptor
+__webpack_require__.i = [];
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/get mini-css chunk filename
+(() => {
+// This function allow to reference chunks
+__webpack_require__.miniCssF = (chunkId) => {
+  // return url for filenames not based on template
+  
+  // return url for filenames based on template
+  return "" + chunkId + ".css"
+}
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/hot_module_replacement
+(() => {
+var currentModuleData = {};
+var installedModules = __webpack_require__.c;
+
+// module and require creation
+var currentChildModule;
+var currentParents = [];
+
+// status
+var registeredStatusHandlers = [];
+var currentStatus = "idle";
+
+// while downloading
+var blockingPromises = 0;
+var blockingPromisesWaiting = [];
+
+// The update info
+var currentUpdateApplyHandlers;
+var queuedInvalidatedModules;
+
+__webpack_require__.hmrD = currentModuleData;
+__webpack_require__.i.push(function (options) {
+	var module = options.module;
+	var require = createRequire(options.require, options.id);
+	module.hot = createModuleHotObject(options.id, module);
+	module.parents = currentParents;
+	module.children = [];
+	currentParents = [];
+	options.require = require;
+});
+
+__webpack_require__.hmrC = {};
+__webpack_require__.hmrI = {};
+
+function createRequire(require, moduleId) {
+	var me = installedModules[moduleId];
+	if (!me) return require;
+	var fn = function (request) {
+		if (me.hot.active) {
+			if (installedModules[request]) {
+				var parents = installedModules[request].parents;
+				if (parents.indexOf(moduleId) === -1) {
+					parents.push(moduleId);
+				}
+			} else {
+				currentParents = [moduleId];
+				currentChildModule = request;
+			}
+			if (me.children.indexOf(request) === -1) {
+				me.children.push(request);
+			}
+		} else {
+			console.warn(
+				"[HMR] unexpected require(" +
+				request +
+				") from disposed module " +
+				moduleId
+			);
+			currentParents = [];
+		}
+		return require(request);
+	};
+	var createPropertyDescriptor = function (name) {
+		return {
+			configurable: true,
+			enumerable: true,
+			get: function () {
+				return require[name];
+			},
+			set: function (value) {
+				require[name] = value;
+			}
+		};
+	};
+	for (var name in require) {
+		if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
+			Object.defineProperty(fn, name, createPropertyDescriptor(name));
+		}
+	}
+
+	fn.e = function (chunkId, fetchPriority) {
+		return trackBlockingPromise(require.e(chunkId, fetchPriority));
+	};
+
+	return fn;
+}
+
+function createModuleHotObject(moduleId, me) {
+	var _main = currentChildModule !== moduleId;
+	var hot = {
+		_acceptedDependencies: {},
+		_acceptedErrorHandlers: {},
+		_declinedDependencies: {},
+		_selfAccepted: false,
+		_selfDeclined: false,
+		_selfInvalidated: false,
+		_disposeHandlers: [],
+		_main: _main,
+		_requireSelf: function () {
+			currentParents = me.parents.slice();
+			currentChildModule = _main ? undefined : moduleId;
+			__webpack_require__(moduleId);
+		},
+		active: true,
+		accept: function (dep, callback, errorHandler) {
+			if (dep === undefined) hot._selfAccepted = true;
+			else if (typeof dep === "function") hot._selfAccepted = dep;
+			else if (typeof dep === "object" && dep !== null) {
+				for (var i = 0; i < dep.length; i++) {
+					hot._acceptedDependencies[dep[i]] = callback || function () { };
+					hot._acceptedErrorHandlers[dep[i]] = errorHandler;
+				}
+			} else {
+				hot._acceptedDependencies[dep] = callback || function () { };
+				hot._acceptedErrorHandlers[dep] = errorHandler;
+			}
+		},
+		decline: function (dep) {
+			if (dep === undefined) hot._selfDeclined = true;
+			else if (typeof dep === "object" && dep !== null)
+				for (var i = 0; i < dep.length; i++)
+					hot._declinedDependencies[dep[i]] = true;
+			else hot._declinedDependencies[dep] = true;
+		},
+		dispose: function (callback) {
+			hot._disposeHandlers.push(callback);
+		},
+		addDisposeHandler: function (callback) {
+			hot._disposeHandlers.push(callback);
+		},
+		removeDisposeHandler: function (callback) {
+			var idx = hot._disposeHandlers.indexOf(callback);
+			if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
+		},
+		invalidate: function () {
+			this._selfInvalidated = true;
+			switch (currentStatus) {
+				case "idle":
+					currentUpdateApplyHandlers = [];
+					Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+						__webpack_require__.hmrI[key](moduleId, currentUpdateApplyHandlers);
+					});
+					setStatus("ready");
+					break;
+				case "ready":
+					Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+						__webpack_require__.hmrI[key](moduleId, currentUpdateApplyHandlers);
+					});
+					break;
+				case "prepare":
+				case "check":
+				case "dispose":
+				case "apply":
+					(queuedInvalidatedModules = queuedInvalidatedModules || []).push(
+						moduleId
+					);
+					break;
+				default:
+					break;
+			}
+		},
+		check: hotCheck,
+		apply: hotApply,
+		status: function (l) {
+			if (!l) return currentStatus;
+			registeredStatusHandlers.push(l);
+		},
+		addStatusHandler: function (l) {
+			registeredStatusHandlers.push(l);
+		},
+		removeStatusHandler: function (l) {
+			var idx = registeredStatusHandlers.indexOf(l);
+			if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
+		},
+		data: currentModuleData[moduleId]
+	};
+	currentChildModule = undefined;
+	return hot;
+}
+
+function setStatus(newStatus) {
+	currentStatus = newStatus;
+	
+	var results = [];
+	for (var i = 0; i < registeredStatusHandlers.length; i++)
+		results[i] = registeredStatusHandlers[i].call(null, newStatus);
+
+	return Promise.all(results).then(function () { });
+}
+
+function unblock() {
+	if (--blockingPromises === 0) {
+		setStatus("ready").then(function () {
+			if (blockingPromises === 0) {
+				var list = blockingPromisesWaiting;
+				blockingPromisesWaiting = [];
+				for (var i = 0; i < list.length; i++) {
+					list[i]();
+				}
+			}
+		});
+	}
+}
+
+function trackBlockingPromise(promise) {
+	switch (currentStatus) {
+		case "ready":
+			setStatus("prepare");
+		case "prepare":
+			blockingPromises++;
+			promise.then(unblock, unblock);
+			return promise;
+		default:
+			return promise;
+	}
+}
+
+function waitForBlockingPromises(fn) {
+	if (blockingPromises === 0) return fn();
+	return new Promise(function (resolve) {
+		blockingPromisesWaiting.push(function () {
+			resolve(fn());
+		});
+	});
+}
+
+function hotCheck(applyOnUpdate) {
+	if (currentStatus !== "idle") {
+		throw new Error("check() is only allowed in idle status");
+	}
+	
+	return setStatus("check")
+		.then(__webpack_require__.hmrM)
+		.then(function (update) {
+			if (!update) {
+				return setStatus(applyInvalidatedModules() ? "ready" : "idle").then(
+					function () {
+						return null;
+					}
+				);
+			}
+
+			return setStatus("prepare").then(function () {
+				var updatedModules = [];
+				currentUpdateApplyHandlers = [];
+
+				return Promise.all(
+					Object.keys(__webpack_require__.hmrC).reduce(function (
+						promises,
+						key
+					) {
+						__webpack_require__.hmrC[key](
+							update.c,
+							update.r,
+							update.m,
+							promises,
+							currentUpdateApplyHandlers,
+							updatedModules
+						);
+						return promises;
+					},
+						[])
+				).then(function () {
+					return waitForBlockingPromises(function () {
+						if (applyOnUpdate) {
+							return internalApply(applyOnUpdate);
+						}
+						return setStatus("ready").then(function () {
+							return updatedModules;
+						});
+					});
+				});
+			});
+		});
+}
+
+function hotApply(options) {
+	if (currentStatus !== "ready") {
+		return Promise.resolve().then(function () {
+			throw new Error(
+				"apply() is only allowed in ready status (state: " + currentStatus + ")"
+			);
+		});
+	}
+	return internalApply(options);
+}
+
+function internalApply(options) {
+	options = options || {};
+	applyInvalidatedModules();
+	var results = currentUpdateApplyHandlers.map(function (handler) {
+		return handler(options);
+	});
+	currentUpdateApplyHandlers = undefined;
+	var errors = results
+		.map(function (r) {
+			return r.error;
+		})
+		.filter(Boolean);
+
+	if (errors.length > 0) {
+		return setStatus("abort").then(function () {
+			throw errors[0];
+		});
+	}
+
+	var disposePromise = setStatus("dispose");
+
+	results.forEach(function (result) {
+		if (result.dispose) result.dispose();
+	});
+
+	var applyPromise = setStatus("apply");
+
+	var error;
+	var reportError = function (err) {
+		if (!error) error = err;
+	};
+
+	var outdatedModules = [];
+	results.forEach(function (result) {
+		if (result.apply) {
+			var modules = result.apply(reportError);
+			if (modules) {
+				for (var i = 0; i < modules.length; i++) {
+					outdatedModules.push(modules[i]);
+				}
+			}
+		}
+	});
+
+	return Promise.all([disposePromise, applyPromise]).then(function () {
+		if (error) {
+			return setStatus("fail").then(function () {
+				throw error;
+			});
+		}
+
+		if (queuedInvalidatedModules) {
+			return internalApply(options).then(function (list) {
+				outdatedModules.forEach(function (moduleId) {
+					if (list.indexOf(moduleId) < 0) list.push(moduleId);
+				});
+				return list;
+			});
+		}
+
+		return setStatus("idle").then(function () {
+			return outdatedModules;
+		});
+	});
+}
+
+function applyInvalidatedModules() {
+	if (queuedInvalidatedModules) {
+		if (!currentUpdateApplyHandlers) currentUpdateApplyHandlers = [];
+		Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+			queuedInvalidatedModules.forEach(function (moduleId) {
+				__webpack_require__.hmrI[key](moduleId, currentUpdateApplyHandlers);
+			});
+		});
+		queuedInvalidatedModules = undefined;
+		return true;
+	}
+}
+
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+// webpack/runtime/public_path
+(() => {
+__webpack_require__.p = "/";
+})();
+// webpack/runtime/css loading
+(() => {
+if (typeof document === "undefined") return;
+var createStylesheet = function (
+	chunkId, fullhref, oldTag, resolve, reject
+) {
+	var linkTag = document.createElement("link");
+
+linkTag.rel = "stylesheet";
+
+linkTag.type = "text/css";
+
+if (__webpack_require__.nc) {
+  linkTag.nonce = __webpack_require__.nc;
+}
+linkTag.href = fullhref;
+
+	var onLinkComplete = function (event) {
+		// avoid mem leaks.
+		linkTag.onerror = linkTag.onload = null;
+		if (event.type === 'load') {
+			resolve();
+		} else {
+			var errorType = event && (event.type === 'load' ? 'missing' : event.type);
+			var realHref = event && event.target && event.target.href || fullhref;
+			var err = new Error("Loading CSS chunk " + chunkId + " failed.\\n(" + realHref + ")");
+			err.code = "CSS_CHUNK_LOAD_FAILED";
+			err.type = errorType;
+			err.request = realHref;
+			if (linkTag.parentNode) linkTag.parentNode.removeChild(linkTag)
+			reject(err);
+		}
+	}
+	linkTag.onerror = linkTag.onload = onLinkComplete;
+	if (oldTag) {
+            oldTag.parentNode.insertBefore(linkTag, oldTag.nextSibling);
+          } else {
+            document.head.appendChild(linkTag);
+          }
+	return linkTag;
+}
+var findStylesheet = function (href, fullhref) {
+	var existingLinkTags = document.getElementsByTagName("link");
+	for (var i = 0; i < existingLinkTags.length; i++) {
+		var tag = existingLinkTags[i];
+		var dataHref = tag.getAttribute("data-href") || tag.getAttribute("href");
+		if (dataHref) {
+			dataHref = dataHref.split('?')[0]
+		}
+		if (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return tag;
+	}
+
+	var existingStyleTags = document.getElementsByTagName("style");
+	for (var i = 0; i < existingStyleTags.length; i++) {
+		var tag = existingStyleTags[i];
+		var dataHref = tag.getAttribute("data-href");
+		if (dataHref === href || dataHref === fullhref) return tag;
+	}
+}
+
+var loadStylesheet = function (chunkId) {
+	return new Promise(function (resolve, reject) {
+		var href = __webpack_require__.miniCssF(chunkId);
+		var fullhref = __webpack_require__.p + href;
+		if (findStylesheet(href, fullhref)) return resolve();
+		createStylesheet(chunkId, fullhref, null, resolve, reject);
+	})
+}
+
+// no chunk loading
+var oldTags = [];
+var newTags = [];
+var applyHandler = function (options) {
+	return {
+		dispose: function () {
+			for (var i = 0; i < oldTags.length; i++) {
+				var oldTag = oldTags[i];
+				if (oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);
+			}
+			oldTags.length = 0;
+		},
+		apply: function () {
+			for (var i = 0; i < newTags.length; i++) newTags[i].rel = "stylesheet";
+			newTags.length = 0;
+		}
+	}
+}
+__webpack_require__.hmrC.miniCss = function (chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList) {
+	applyHandlers.push(applyHandler);
+	chunkIds.forEach(function (chunkId) {
+		var href = __webpack_require__.miniCssF(chunkId);
+		var fullhref = __webpack_require__.p + href;
+		var oldTag = findStylesheet(href, fullhref);
+		if (!oldTag) return;
+		promises.push(new Promise(function (resolve, reject) {
+			var tag = createStylesheet(
+				chunkId,
+
+				/**
+					If dynamically add link tag through dom API and there is already a loaded style link, browsers sometimes treats the new link tag as the same link, and won't fetch the new style.
+					Use query to avoid browser cache the link tag, force to re-fetch new style, this is the same strategy as updateCss API, this can happen during lazy compilation
+				 */
+				`${fullhref}?${Date.now()}`,
+				oldTag,
+				function () {
+					tag.as = "style";
+					tag.rel = "preload";
+					resolve();
+				},
+				reject
+			);
+			oldTags.push(oldTag);
+			newTags.push(tag);
+		}))
+	});
+}
+
+// no prefetch
+// no preload
+})();
+// module cache are used so entry inlining is disabled
+// startup
+// Load entry module and return exports
+__webpack_require__("./node_modules/@rspack/plugin-react-refresh/client/reactRefreshEntry.js");
+var __webpack_exports__ = __webpack_require__("./src/utils/index.ts");
+var __webpack_exports__formatDate = __webpack_exports__.formatDate;
+var __webpack_exports__getColorFromId = __webpack_exports__.getColorFromId;
+var __webpack_exports__getFormattedName = __webpack_exports__.getFormattedName;
+var __webpack_exports__getLocalStorageItem = __webpack_exports__.getLocalStorageItem;
+var __webpack_exports__getSessionStorageItem = __webpack_exports__.getSessionStorageItem;
+var __webpack_exports__isEmpty = __webpack_exports__.isEmpty;
+var __webpack_exports__isEmptyArray = __webpack_exports__.isEmptyArray;
+var __webpack_exports__isEmptyObject = __webpack_exports__.isEmptyObject;
+var __webpack_exports__isEmptyString = __webpack_exports__.isEmptyString;
+var __webpack_exports__isValidEmail = __webpack_exports__.isValidEmail;
+var __webpack_exports__parseDate = __webpack_exports__.parseDate;
+var __webpack_exports__removeLocalStorageItem = __webpack_exports__.removeLocalStorageItem;
+var __webpack_exports__removeSessionStorageItem = __webpack_exports__.removeSessionStorageItem;
+var __webpack_exports__setLocalStorageItem = __webpack_exports__.setLocalStorageItem;
+var __webpack_exports__setSessionStorageItem = __webpack_exports__.setSessionStorageItem;
+var __webpack_exports__strEllipsis = __webpack_exports__.strEllipsis;
+export { __webpack_exports__formatDate as formatDate, __webpack_exports__getColorFromId as getColorFromId, __webpack_exports__getFormattedName as getFormattedName, __webpack_exports__getLocalStorageItem as getLocalStorageItem, __webpack_exports__getSessionStorageItem as getSessionStorageItem, __webpack_exports__isEmpty as isEmpty, __webpack_exports__isEmptyArray as isEmptyArray, __webpack_exports__isEmptyObject as isEmptyObject, __webpack_exports__isEmptyString as isEmptyString, __webpack_exports__isValidEmail as isValidEmail, __webpack_exports__parseDate as parseDate, __webpack_exports__removeLocalStorageItem as removeLocalStorageItem, __webpack_exports__removeSessionStorageItem as removeSessionStorageItem, __webpack_exports__setLocalStorageItem as setLocalStorageItem, __webpack_exports__setSessionStorageItem as setSessionStorageItem, __webpack_exports__strEllipsis as strEllipsis };
+
+//# sourceMappingURL=utils.js.map