@exyconn/common 1.0.0 → 2.0.0

package/dist/index.js

@@ -5,6 +5,7 @@ var DailyRotateFile = require('winston-daily-rotate-file');
 var path = require('path');
 var mongoose = require('mongoose');
 var jwt = require('jsonwebtoken');
+var fs = require('fs');
 var axios = require('axios');
 var react = require('react');
 var dateFns = require('date-fns');
@@ -36,6 +37,7 @@ __export(server_exports, {
   buildFilter: () => buildFilter,
   buildPagination: () => buildPagination,
   buildPaginationMeta: () => buildPaginationMeta,
+  checkPackageServer: () => checkPackageServer,
   conflictResponse: () => conflictResponse,
   connectDB: () => connectDB,
   createLogger: () => createLogger,
@@ -46,13 +48,17 @@ __export(server_exports, {
   extractColumns: () => extractColumns,
   extractOrganization: () => extractOrganization,
   forbiddenResponse: () => forbiddenResponse,
+  formatPackageCheckResult: () => formatPackageCheckResult,
+  generateNcuCommand: () => generateNcuCommand,
   getConnectionStatus: () => getConnectionStatus,
   logger: () => logger,
   noContentResponse: () => noContentResponse,
   notFoundResponse: () => notFoundResponse,
   omitFields: () => omitFields,
   optionalAuthenticateJWT: () => optionalAuthenticateJWT,
+  packageCheckServer: () => packageCheckServer,
   pickFields: () => pickFields,
+  printPackageCheckSummary: () => printPackageCheckSummary,
   rateLimitResponse: () => rateLimitResponse,
   requireOrganization: () => requireOrganization,
   sanitizeDocument: () => sanitizeDocument,
@@ -580,6 +586,197 @@ var omitFields = (obj, fieldsToOmit) => {
   });
   return result;
 };
+function parseVersion(version) {
+  return version.replace(/[\^~>=<|*x\s]/g, "").split(" ")[0] || "0.0.0";
+}
+function compareVersions(current, latest) {
+  const currentClean = parseVersion(current);
+  const latestClean = parseVersion(latest);
+  if (currentClean === latestClean) return "none";
+  const [curMajor, curMinor, curPatch] = currentClean.split(".").map(Number);
+  const [latMajor, latMinor, latPatch] = latestClean.split(".").map(Number);
+  if (latest.includes("-")) return "prerelease";
+  if (latMajor > curMajor) return "major";
+  if (latMinor > curMinor) return "minor";
+  if (latPatch > curPatch) return "patch";
+  return "none";
+}
+async function fetchLatestVersion(packageName) {
+  try {
+    const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName);
+    const response = await fetch(`https://registry.npmjs.org/${encodedName}`);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data["dist-tags"]?.latest || null;
+  } catch {
+    return null;
+  }
+}
+async function loadPackageJson(source) {
+  if (typeof source === "object") {
+    return source;
+  }
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch: ${response.status}`);
+    }
+    return response.json();
+  }
+  const filePath = path.resolve(source);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function checkDeps(deps, type, errors) {
+  if (!deps) return [];
+  const results = [];
+  const entries = Object.entries(deps);
+  const concurrencyLimit = 10;
+  for (let i = 0; i < entries.length; i += concurrencyLimit) {
+    const batch = entries.slice(i, i + concurrencyLimit);
+    const batchResults = await Promise.all(
+      batch.map(async ([name, currentVersion]) => {
+        try {
+          const latest = await fetchLatestVersion(name);
+          if (!latest) {
+            errors.push(`Could not fetch: ${name}`);
+            return {
+              name,
+              current: currentVersion,
+              latest: "unknown",
+              hasUpdate: false,
+              updateType: "none",
+              dependencyType: type
+            };
+          }
+          const updateType = compareVersions(currentVersion, latest);
+          return {
+            name,
+            current: currentVersion,
+            latest,
+            hasUpdate: updateType !== "none",
+            updateType,
+            dependencyType: type
+          };
+        } catch (err) {
+          errors.push(`Error: ${name} - ${err}`);
+          return {
+            name,
+            current: currentVersion,
+            latest: "error",
+            hasUpdate: false,
+            updateType: "none",
+            dependencyType: type
+          };
+        }
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+async function checkPackageServer(source) {
+  const errors = [];
+  const pkg = await loadPackageJson(source);
+  const [dependencies, devDependencies, peerDependencies, optionalDependencies] = await Promise.all([
+    checkDeps(pkg.dependencies, "dependencies", errors),
+    checkDeps(pkg.devDependencies, "devDependencies", errors),
+    checkDeps(pkg.peerDependencies, "peerDependencies", errors),
+    checkDeps(pkg.optionalDependencies, "optionalDependencies", errors)
+  ]);
+  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
+  return {
+    packageName: pkg.name || "unknown",
+    packageVersion: pkg.version || "0.0.0",
+    totalDependencies: allDeps.length,
+    outdatedCount: allDeps.filter((d) => d.hasUpdate).length,
+    dependencies: allDeps,
+    byType: { dependencies, devDependencies, peerDependencies, optionalDependencies },
+    byUpdateType: {
+      major: allDeps.filter((d) => d.updateType === "major"),
+      minor: allDeps.filter((d) => d.updateType === "minor"),
+      patch: allDeps.filter((d) => d.updateType === "patch"),
+      prerelease: allDeps.filter((d) => d.updateType === "prerelease")
+    },
+    checkedAt: /* @__PURE__ */ new Date(),
+    errors
+  };
+}
+function formatPackageCheckResult(result) {
+  const lines = [];
+  lines.push(`
+\u{1F4E6} Package: ${result.packageName}@${result.packageVersion}`);
+  lines.push(`\u{1F4C5} Checked: ${result.checkedAt.toISOString()}`);
+  lines.push(`\u{1F4CA} Total: ${result.totalDependencies} | Outdated: ${result.outdatedCount}
+`);
+  const formatDep = (d) => `   ${d.name.padEnd(35)} ${d.current.padEnd(15)} \u2192 ${d.latest}`;
+  if (result.byUpdateType.major.length > 0) {
+    lines.push("\u{1F534} MAJOR Updates:");
+    result.byUpdateType.major.forEach((d) => lines.push(formatDep(d)));
+    lines.push("");
+  }
+  if (result.byUpdateType.minor.length > 0) {
+    lines.push("\u{1F7E1} MINOR Updates:");
+    result.byUpdateType.minor.forEach((d) => lines.push(formatDep(d)));
+    lines.push("");
+  }
+  if (result.byUpdateType.patch.length > 0) {
+    lines.push("\u{1F7E2} PATCH Updates:");
+    result.byUpdateType.patch.forEach((d) => lines.push(formatDep(d)));
+    lines.push("");
+  }
+  if (result.errors.length > 0) {
+    lines.push("\u26A0\uFE0F  Errors:");
+    result.errors.forEach((e) => lines.push(`   ${e}`));
+  }
+  return lines.join("\n");
+}
+function generateNcuCommand(result, options = {}) {
+  const { updateType = "all", interactive = false, upgrade = false } = options;
+  let packages = [];
+  switch (updateType) {
+    case "major":
+      packages = result.byUpdateType.major.map((d) => d.name);
+      break;
+    case "minor":
+      packages = result.byUpdateType.minor.map((d) => d.name);
+      break;
+    case "patch":
+      packages = result.byUpdateType.patch.map((d) => d.name);
+      break;
+    default:
+      packages = result.dependencies.filter((d) => d.hasUpdate).map((d) => d.name);
+  }
+  if (packages.length === 0) return "# No updates available";
+  let cmd = "npx npm-check-updates";
+  if (packages.length < result.dependencies.length) {
+    cmd += ` --filter "${packages.join(",")}"`;
+  }
+  if (interactive) cmd += " --interactive";
+  if (upgrade) cmd += " --upgrade";
+  return cmd;
+}
+function printPackageCheckSummary(result) {
+  console.log(formatPackageCheckResult(result));
+  if (result.outdatedCount > 0) {
+    console.log("\n\u{1F4DD} Quick Commands:");
+    console.log("   Check all:    npx npm-check-updates");
+    console.log("   Interactive:  npx npm-check-updates --interactive");
+    console.log("   Update all:   npx npm-check-updates --upgrade && npm install");
+    if (result.byUpdateType.patch.length > 0) {
+      console.log(`   Patch only:   ${generateNcuCommand(result, { updateType: "patch", upgrade: true })}`);
+    }
+  }
+}
+var packageCheckServer = {
+  check: checkPackageServer,
+  format: formatPackageCheckResult,
+  generateNcuCommand,
+  print: printPackageCheckSummary
+};
 
 // src/client/index.ts
 var client_exports = {};
@@ -592,6 +789,7 @@ __export(client_exports, {
   camelToKebab: () => camelToKebab,
   capitalize: () => capitalize,
   capitalizeWords: () => capitalizeWords,
+  checkPackage: () => checkPackage,
   clientLogger: () => clientLogger,
   copyToClipboard: () => copyToClipboard,
   createApiEndpoints: () => createApiEndpoints,
@@ -607,7 +805,9 @@ __export(client_exports, {
   formatDateForInput: () => formatDateForInput,
   formatDateTime: () => formatDateTime,
   formatDateTimeForInput: () => formatDateTimeForInput,
+  formatPackageCheckResult: () => formatPackageCheckResult2,
   formatRelativeTime: () => formatRelativeTime,
+  generateNcuCommand: () => generateNcuCommand2,
   getErrorMessage: () => getErrorMessage,
   getNextPage: () => getNextPage,
   getPrevPage: () => getPrevPage,
@@ -627,6 +827,7 @@ __export(client_exports, {
   isToday: () => isToday,
   isUnauthorized: () => isUnauthorized,
   kebabToCamel: () => kebabToCamel,
+  packageCheck: () => packageCheck,
   parseError: () => parseError,
   parseFullResponse: () => parseFullResponse,
   parseResponse: () => parseResponse,
@@ -637,19 +838,63 @@ __export(client_exports, {
   truncate: () => truncate,
   truncateWords: () => truncateWords,
   unslugify: () => unslugify,
+  useBattery: () => useBattery_default,
+  useClickAway: () => useClickAway_default,
+  useContinuousRetry: () => useContinuousRetry_default,
   useCopyToClipboard: () => useCopyToClipboard_default,
+  useCountdown: () => useCountdown_default,
+  useCounter: () => useCounter_default,
   useDebounce: () => useDebounce_default,
+  useDefault: () => useDefault_default,
+  useDocumentTitle: () => useDocumentTitle_default,
+  useEventListener: () => useEventListener_default,
+  useFavicon: () => useFavicon_default,
+  useFetch: () => useFetch_default,
+  useGeolocation: () => useGeolocation_default,
+  useHistoryState: () => useHistoryState_default,
+  useHover: () => useHover_default,
+  useIdle: () => useIdle_default,
+  useIntersectionObserver: () => useIntersectionObserver_default,
   useInterval: () => useInterval_default,
+  useIntervalWhen: () => useIntervalWhen_default,
+  useIsClient: () => useIsClient_default,
   useIsDesktop: () => useIsDesktop,
+  useIsFirstRender: () => useIsFirstRender_default,
   useIsMobile: () => useIsMobile,
   useIsMobileOrTablet: () => useIsMobileOrTablet,
   useIsTablet: () => useIsTablet,
+  useKeyPress: () => useKeyPress_default,
+  useList: () => useList_default,
   useLocalStorage: () => useLocalStorage_default,
+  useLockBodyScroll: () => useLockBodyScroll_default,
+  useLogger: () => useLogger_default,
+  useLongPress: () => useLongPress_default,
+  useMap: () => useMap_default,
+  useMeasure: () => useMeasure_default,
   useMediaQuery: () => useMediaQuery_default,
+  useMouse: () => useMouse_default,
+  useNetworkState: () => useNetworkState_default,
+  useObjectState: () => useObjectState_default,
   useOnClickOutside: () => useOnClickOutside_default,
+  useOrientation: () => useOrientation_default,
+  usePageLeave: () => usePageLeave_default,
   usePageTitle: () => usePageTitle_default,
+  usePreferredLanguage: () => usePreferredLanguage_default,
+  usePrevious: () => usePrevious_default,
+  useQueue: () => useQueue_default,
+  useRandomInterval: () => useRandomInterval_default,
+  useRenderCount: () => useRenderCount_default,
+  useRenderInfo: () => useRenderInfo_default,
+  useScript: () => useScript_default,
+  useSessionStorage: () => useSessionStorage_default,
+  useSet: () => useSet_default,
   useSnackbar: () => useSnackbar_default,
   useThemeDetector: () => useThemeDetector_default,
+  useThrottle: () => useThrottle_default,
+  useTimeout: () => useTimeout_default,
+  useToggle: () => useToggle_default,
+  useVisibilityChange: () => useVisibilityChange_default,
+  useWindowScroll: () => useWindowScroll_default,
   useWindowSize: () => useWindowSize_default,
   withAbortSignal: () => withAbortSignal,
   withFormData: () => withFormData,
@@ -1229,93 +1474,608 @@ var createErrorResponse = (message, statusCode2 = 400, error) => ({
   error,
   statusCode: statusCode2
 });
-function useLocalStorage(key, initialValue, options = {}) {
-  const {
-    serializer = JSON.stringify,
-    deserializer = JSON.parse,
-    syncTabs = true,
-    debug = false
-  } = options;
-  const log = react.useCallback(
-    (...args) => {
-      if (debug) console.log(`[useLocalStorage:${key}]`, ...args);
-    },
-    [debug, key]
-  );
-  const readValue = react.useCallback(() => {
-    if (typeof window === "undefined") {
-      return initialValue;
+
+// src/client/utils/packageCheck.ts
+function parseVersion2(version) {
+  return version.replace(/[\^~>=<|*x\s]/g, "").split(" ")[0] || "0.0.0";
+}
+function compareVersions2(current, latest) {
+  const currentClean = parseVersion2(current);
+  const latestClean = parseVersion2(latest);
+  if (currentClean === latestClean) return "none";
+  const [curMajor, curMinor, curPatch] = currentClean.split(".").map(Number);
+  const [latMajor, latMinor, latPatch] = latestClean.split(".").map(Number);
+  if (latest.includes("-")) return "prerelease";
+  if (latMajor > curMajor) return "major";
+  if (latMinor > curMinor) return "minor";
+  if (latPatch > curPatch) return "patch";
+  return "none";
+}
+async function fetchLatestVersion2(packageName) {
+  try {
+    const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : encodeURIComponent(packageName);
+    const response = await fetch(`https://registry.npmjs.org/${encodedName}`);
+    if (!response.ok) {
+      return null;
     }
-    try {
-      const item = window.localStorage.getItem(key);
-      if (item === null) {
-        return initialValue;
-      }
-      const parsed = deserializer(item);
-      log("Read value:", parsed);
-      return parsed;
-    } catch (error) {
-      console.warn(`Error reading localStorage key "${key}":`, error);
-      return initialValue;
+    const data = await response.json();
+    return data["dist-tags"]?.latest || null;
+  } catch {
+    return null;
+  }
+}
+async function fetchPackageJson(source) {
+  if (typeof source === "object") {
+    return source;
+  }
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch package.json from ${source}: ${response.status}`);
     }
-  }, [key, initialValue, deserializer, log]);
-  const [storedValue, setStoredValue] = react.useState(readValue);
-  const setValue = react.useCallback(
+    return response.json();
+  }
+  throw new Error(
+    "File path support requires Node.js environment. Use URL or pass package.json object directly."
+  );
+}
+async function checkDependencyType(deps, type, errors) {
+  if (!deps) return [];
+  const results = [];
+  const entries = Object.entries(deps);
+  const concurrencyLimit = 10;
+  for (let i = 0; i < entries.length; i += concurrencyLimit) {
+    const batch = entries.slice(i, i + concurrencyLimit);
+    const batchResults = await Promise.all(
+      batch.map(async ([name, currentVersion]) => {
+        try {
+          const latest = await fetchLatestVersion2(name);
+          if (!latest) {
+            errors.push(`Could not fetch latest version for ${name}`);
+            return {
+              name,
+              current: currentVersion,
+              latest: "unknown",
+              hasUpdate: false,
+              updateType: "none",
+              dependencyType: type
+            };
+          }
+          const updateType = compareVersions2(currentVersion, latest);
+          return {
+            name,
+            current: currentVersion,
+            latest,
+            hasUpdate: updateType !== "none",
+            updateType,
+            dependencyType: type
+          };
+        } catch (err) {
+          errors.push(`Error checking ${name}: ${err}`);
+          return {
+            name,
+            current: currentVersion,
+            latest: "error",
+            hasUpdate: false,
+            updateType: "none",
+            dependencyType: type
+          };
+        }
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+async function checkPackage(source) {
+  const errors = [];
+  let pkg;
+  try {
+    pkg = await fetchPackageJson(source);
+  } catch (err) {
+    throw new Error(`Failed to load package.json: ${err}`);
+  }
+  const [dependencies, devDependencies, peerDependencies, optionalDependencies] = await Promise.all([
+    checkDependencyType(pkg.dependencies, "dependencies", errors),
+    checkDependencyType(pkg.devDependencies, "devDependencies", errors),
+    checkDependencyType(pkg.peerDependencies, "peerDependencies", errors),
+    checkDependencyType(pkg.optionalDependencies, "optionalDependencies", errors)
+  ]);
+  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies, ...optionalDependencies];
+  return {
+    packageName: pkg.name || "unknown",
+    packageVersion: pkg.version || "0.0.0",
+    totalDependencies: allDeps.length,
+    outdatedCount: allDeps.filter((d) => d.hasUpdate).length,
+    dependencies: allDeps,
+    byType: {
+      dependencies,
+      devDependencies,
+      peerDependencies,
+      optionalDependencies
+    },
+    byUpdateType: {
+      major: allDeps.filter((d) => d.updateType === "major"),
+      minor: allDeps.filter((d) => d.updateType === "minor"),
+      patch: allDeps.filter((d) => d.updateType === "patch"),
+      prerelease: allDeps.filter((d) => d.updateType === "prerelease")
+    },
+    checkedAt: /* @__PURE__ */ new Date(),
+    errors
+  };
+}
+function formatPackageCheckResult2(result) {
+  const lines = [];
+  lines.push(`\u{1F4E6} Package: ${result.packageName}@${result.packageVersion}`);
+  lines.push(`\u{1F4C5} Checked: ${result.checkedAt.toISOString()}`);
+  lines.push(`\u{1F4CA} Total: ${result.totalDependencies} | Outdated: ${result.outdatedCount}`);
+  lines.push("");
+  if (result.byUpdateType.major.length > 0) {
+    lines.push("\u{1F534} MAJOR Updates:");
+    result.byUpdateType.major.forEach((d) => {
+      lines.push(`   ${d.name}: ${d.current} \u2192 ${d.latest}`);
+    });
+    lines.push("");
+  }
+  if (result.byUpdateType.minor.length > 0) {
+    lines.push("\u{1F7E1} MINOR Updates:");
+    result.byUpdateType.minor.forEach((d) => {
+      lines.push(`   ${d.name}: ${d.current} \u2192 ${d.latest}`);
+    });
+    lines.push("");
+  }
+  if (result.byUpdateType.patch.length > 0) {
+    lines.push("\u{1F7E2} PATCH Updates:");
+    result.byUpdateType.patch.forEach((d) => {
+      lines.push(`   ${d.name}: ${d.current} \u2192 ${d.latest}`);
+    });
+    lines.push("");
+  }
+  if (result.errors.length > 0) {
+    lines.push("\u26A0\uFE0F  Errors:");
+    result.errors.forEach((e) => {
+      lines.push(`   ${e}`);
+    });
+  }
+  return lines.join("\n");
+}
+function generateNcuCommand2(result, options = {}) {
+  const { updateType = "all", interactive = false, upgrade = false } = options;
+  let packages = [];
+  switch (updateType) {
+    case "major":
+      packages = result.byUpdateType.major.map((d) => d.name);
+      break;
+    case "minor":
+      packages = result.byUpdateType.minor.map((d) => d.name);
+      break;
+    case "patch":
+      packages = result.byUpdateType.patch.map((d) => d.name);
+      break;
+    default:
+      packages = result.dependencies.filter((d) => d.hasUpdate).map((d) => d.name);
+  }
+  if (packages.length === 0) {
+    return "# No updates available";
+  }
+  let cmd = "npx npm-check-updates";
+  if (packages.length > 0 && packages.length < result.dependencies.length) {
+    cmd += ` --filter "${packages.join(",")}"`;
+  }
+  if (interactive) {
+    cmd += " --interactive";
+  }
+  if (upgrade) {
+    cmd += " --upgrade";
+  }
+  return cmd;
+}
+var packageCheck = {
+  check: checkPackage,
+  format: formatPackageCheckResult2,
+  generateNcuCommand: generateNcuCommand2,
+  parseVersion: parseVersion2,
+  compareVersions: compareVersions2
+};
+function useToggle(initialValue = false) {
+  const [value, setValue] = react.useState(initialValue);
+  const toggle = react.useCallback(() => setValue((v) => !v), []);
+  const setTrue = react.useCallback(() => setValue(true), []);
+  const setFalse = react.useCallback(() => setValue(false), []);
+  return {
+    value,
+    toggle,
+    setTrue,
+    setFalse,
+    setValue
+  };
+}
+var useToggle_default = useToggle;
+function useCounter(initialValue = 0, options = {}) {
+  const { min = -Infinity, max = Infinity, step = 1 } = options;
+  const clamp = react.useCallback(
+    (value) => Math.min(Math.max(value, min), max),
+    [min, max]
+  );
+  const [count, setCount] = react.useState(clamp(initialValue));
+  const increment = react.useCallback(() => {
+    setCount((c) => clamp(c + step));
+  }, [clamp, step]);
+  const decrement = react.useCallback(() => {
+    setCount((c) => clamp(c - step));
+  }, [clamp, step]);
+  const set = react.useCallback(
     (value) => {
-      if (typeof window === "undefined") {
-        console.warn(`Cannot set localStorage key "${key}" in non-browser environment`);
-        return;
-      }
-      try {
-        const valueToStore = value instanceof Function ? value(storedValue) : value;
-        setStoredValue(valueToStore);
-        window.localStorage.setItem(key, serializer(valueToStore));
-        log("Set value:", valueToStore);
-        window.dispatchEvent(new StorageEvent("storage", { key, newValue: serializer(valueToStore) }));
-      } catch (error) {
-        console.warn(`Error setting localStorage key "${key}":`, error);
-      }
+      setCount(clamp(value));
     },
-    [key, storedValue, serializer, log]
+    [clamp]
   );
-  const removeValue = react.useCallback(() => {
-    if (typeof window === "undefined") {
-      return;
-    }
-    try {
-      window.localStorage.removeItem(key);
-      setStoredValue(initialValue);
-      log("Removed value");
-      window.dispatchEvent(new StorageEvent("storage", { key, newValue: null }));
-    } catch (error) {
-      console.warn(`Error removing localStorage key "${key}":`, error);
-    }
-  }, [key, initialValue, log]);
+  const reset = react.useCallback(() => {
+    setCount(clamp(initialValue));
+  }, [clamp, initialValue]);
+  return { count, increment, decrement, set, reset };
+}
+var useCounter_default = useCounter;
+function useDefault(initialValue, defaultValue) {
+  const [state, setState] = react.useState(initialValue);
+  const value = react.useMemo(() => {
+    return state === null || state === void 0 ? defaultValue : state;
+  }, [state, defaultValue]);
+  const setValue = react.useCallback((newValue) => {
+    setState(newValue);
+  }, []);
+  return [value, setValue];
+}
+var useDefault_default = useDefault;
+function usePrevious(value, initialValue) {
+  const ref = react.useRef(initialValue);
   react.useEffect(() => {
-    if (!syncTabs || typeof window === "undefined") {
-      return;
-    }
-    const handleStorageChange = (event) => {
-      if (event.key !== key) {
-        return;
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+var usePrevious_default = usePrevious;
+function useObjectState(initialState) {
+  const [state, setStateInternal] = react.useState(initialState);
+  const setState = react.useCallback((update) => {
+    setStateInternal((prev) => {
+      const newState = typeof update === "function" ? update(prev) : update;
+      return { ...prev, ...newState };
+    });
+  }, []);
+  const resetState = react.useCallback(() => {
+    setStateInternal(initialState);
+  }, [initialState]);
+  const setProperty = react.useCallback((key, value) => {
+    setStateInternal((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const removeProperty = react.useCallback((key) => {
+    setStateInternal((prev) => {
+      const newState = { ...prev };
+      delete newState[key];
+      return newState;
+    });
+  }, []);
+  return { state, setState, resetState, setProperty, removeProperty };
+}
+var useObjectState_default = useObjectState;
+function useHistoryState(initialValue, options = {}) {
+  const { maxLength = 100 } = options;
+  const [history, setHistory] = react.useState([initialValue]);
+  const [pointer, setPointer] = react.useState(0);
+  const state = react.useMemo(() => history[pointer], [history, pointer]);
+  const setState = react.useCallback(
+    (value) => {
+      setHistory((prev) => {
+        const currentValue = prev[pointer];
+        const newValue = typeof value === "function" ? value(currentValue) : value;
+        const newHistory = prev.slice(0, pointer + 1);
+        newHistory.push(newValue);
+        if (newHistory.length > maxLength) {
+          newHistory.shift();
+          return newHistory;
+        }
+        return newHistory;
+      });
+      setPointer((prev) => Math.min(prev + 1, maxLength - 1));
+    },
+    [pointer, maxLength]
+  );
+  const undo = react.useCallback(() => {
+    setPointer((prev) => Math.max(0, prev - 1));
+  }, []);
+  const redo = react.useCallback(() => {
+    setPointer((prev) => Math.min(history.length - 1, prev + 1));
+  }, [history.length]);
+  const go = react.useCallback(
+    (index) => {
+      const targetIndex = Math.max(0, Math.min(history.length - 1, index));
+      setPointer(targetIndex);
+    },
+    [history.length]
+  );
+  const clear = react.useCallback(
+    (value) => {
+      const resetValue = value ?? initialValue;
+      setHistory([resetValue]);
+      setPointer(0);
+    },
+    [initialValue]
+  );
+  const canUndo = pointer > 0;
+  const canRedo = pointer < history.length - 1;
+  return {
+    state,
+    setState,
+    undo,
+    redo,
+    clear,
+    canUndo,
+    canRedo,
+    history,
+    pointer,
+    go
+  };
+}
+var useHistoryState_default = useHistoryState;
+function useQueue(initialValue = []) {
+  const [queue, setQueue] = react.useState(initialValue);
+  const enqueue = react.useCallback((item) => {
+    setQueue((prev) => [...prev, item]);
+  }, []);
+  const enqueueAll = react.useCallback((items) => {
+    setQueue((prev) => [...prev, ...items]);
+  }, []);
+  const dequeue = react.useCallback(() => {
+    let dequeuedItem;
+    setQueue((prev) => {
+      if (prev.length === 0) return prev;
+      dequeuedItem = prev[0];
+      return prev.slice(1);
+    });
+    return dequeuedItem;
+  }, []);
+  const peek = react.useCallback(() => {
+    return queue[0];
+  }, [queue]);
+  const clear = react.useCallback(() => {
+    setQueue([]);
+  }, []);
+  const size = queue.length;
+  const isEmpty = size === 0;
+  const first = queue[0];
+  const last = queue[queue.length - 1];
+  return {
+    queue,
+    enqueue,
+    enqueueAll,
+    dequeue,
+    peek,
+    clear,
+    size,
+    isEmpty,
+    first,
+    last
+  };
+}
+var useQueue_default = useQueue;
+function useList(initialValue = []) {
+  const [list, setList] = react.useState(initialValue);
+  const set = react.useCallback((newList) => {
+    setList(newList);
+  }, []);
+  const push = react.useCallback((item) => {
+    setList((prev) => [...prev, item]);
+  }, []);
+  const unshift = react.useCallback((item) => {
+    setList((prev) => [item, ...prev]);
+  }, []);
+  const removeAt = react.useCallback((index) => {
+    setList((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const remove = react.useCallback((item) => {
+    setList((prev) => {
+      const index = prev.indexOf(item);
+      if (index === -1) return prev;
+      return prev.filter((_, i) => i !== index);
+    });
+  }, []);
+  const removeWhere = react.useCallback((predicate) => {
+    setList((prev) => prev.filter((item) => !predicate(item)));
+  }, []);
+  const updateAt = react.useCallback((index, item) => {
+    setList((prev) => prev.map((v, i) => i === index ? item : v));
+  }, []);
+  const updateWhere = react.useCallback(
+    (predicate, updater) => {
+      setList((prev) => prev.map((item) => predicate(item) ? updater(item) : item));
+    },
+    []
+  );
+  const insertAt = react.useCallback((index, item) => {
+    setList((prev) => [...prev.slice(0, index), item, ...prev.slice(index)]);
+  }, []);
+  const move = react.useCallback((fromIndex, toIndex) => {
+    setList((prev) => {
+      const newList = [...prev];
+      const [item] = newList.splice(fromIndex, 1);
+      newList.splice(toIndex, 0, item);
+      return newList;
+    });
+  }, []);
+  const clear = react.useCallback(() => {
+    setList([]);
+  }, []);
+  const reset = react.useCallback(() => {
+    setList(initialValue);
+  }, [initialValue]);
+  const filter = react.useCallback((predicate) => {
+    setList((prev) => prev.filter(predicate));
+  }, []);
+  const sort = react.useCallback((compareFn) => {
+    setList((prev) => [...prev].sort(compareFn));
+  }, []);
+  const reverse = react.useCallback(() => {
+    setList((prev) => [...prev].reverse());
+  }, []);
+  const size = list.length;
+  const isEmpty = size === 0;
+  const first = list[0];
+  const last = list[list.length - 1];
+  return {
+    list,
+    set,
+    push,
+    unshift,
+    removeAt,
+    remove,
+    removeWhere,
+    updateAt,
+    updateWhere,
+    insertAt,
+    move,
+    clear,
+    reset,
+    filter,
+    sort,
+    reverse,
+    size,
+    isEmpty,
+    first,
+    last
+  };
+}
+var useList_default = useList;
+function useMap(initialValue = []) {
+  const [map, setMap] = react.useState(() => new Map(initialValue));
+  const get = react.useCallback((key) => {
+    return map.get(key);
+  }, [map]);
+  const set = react.useCallback((key, value) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      newMap.set(key, value);
+      return newMap;
+    });
+  }, []);
+  const setAll = react.useCallback((entries2) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      for (const [key, value] of entries2) {
+        newMap.set(key, value);
       }
-      log("Storage event received:", event.newValue);
-      if (event.newValue === null) {
-        setStoredValue(initialValue);
+      return newMap;
+    });
+  }, []);
+  const has = react.useCallback((key) => {
+    return map.has(key);
+  }, [map]);
+  const remove = react.useCallback((key) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      newMap.delete(key);
+      return newMap;
+    });
+  }, []);
+  const removeAll = react.useCallback((keys2) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      keys2.forEach((key) => newMap.delete(key));
+      return newMap;
+    });
+  }, []);
+  const clear = react.useCallback(() => {
+    setMap(/* @__PURE__ */ new Map());
+  }, []);
+  const reset = react.useCallback(() => {
+    setMap(new Map(initialValue));
+  }, [initialValue]);
+  const size = map.size;
+  const keys = react.useMemo(() => Array.from(map.keys()), [map]);
+  const values = react.useMemo(() => Array.from(map.values()), [map]);
+  const entries = react.useMemo(() => Array.from(map.entries()), [map]);
+  const isEmpty = size === 0;
+  return {
+    map,
+    get,
+    set,
+    setAll,
+    has,
+    remove,
+    removeAll,
+    clear,
+    reset,
+    size,
+    keys,
+    values,
+    entries,
+    isEmpty
+  };
+}
+var useMap_default = useMap;
+function useSet(initialValue = []) {
+  const [set, setSet] = react.useState(() => new Set(initialValue));
+  const add = react.useCallback((item) => {
+    setSet((prev) => /* @__PURE__ */ new Set([...prev, item]));
+  }, []);
+  const addAll = react.useCallback((items) => {
+    setSet((prev) => /* @__PURE__ */ new Set([...prev, ...items]));
+  }, []);
+  const has = react.useCallback((item) => {
+    return set.has(item);
+  }, [set]);
+  const remove = react.useCallback((item) => {
+    setSet((prev) => {
+      const newSet = new Set(prev);
+      newSet.delete(item);
+      return newSet;
+    });
+  }, []);
+  const removeAll = react.useCallback((items) => {
+    setSet((prev) => {
+      const newSet = new Set(prev);
+      for (const item of items) {
+        newSet.delete(item);
+      }
+      return newSet;
+    });
+  }, []);
+  const toggle = react.useCallback((item) => {
+    setSet((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(item)) {
+        newSet.delete(item);
       } else {
-        try {
-          setStoredValue(deserializer(event.newValue));
-        } catch {
-          console.warn(`Error parsing localStorage change for key "${key}"`);
-        }
+        newSet.add(item);
       }
-    };
-    window.addEventListener("storage", handleStorageChange);
-    return () => window.removeEventListener("storage", handleStorageChange);
-  }, [key, initialValue, syncTabs, deserializer, log]);
-  return [storedValue, setValue, removeValue];
+      return newSet;
+    });
+  }, []);
+  const clear = react.useCallback(() => {
+    setSet(/* @__PURE__ */ new Set());
+  }, []);
+  const reset = react.useCallback(() => {
+    setSet(new Set(initialValue));
+  }, [initialValue]);
+  const size = set.size;
+  const values = react.useMemo(() => Array.from(set), [set]);
+  const isEmpty = size === 0;
+  return {
+    set,
+    add,
+    addAll,
+    has,
+    remove,
+    removeAll,
+    toggle,
+    clear,
+    reset,
+    size,
+    values,
+    isEmpty
+  };
 }
-var useLocalStorage_default = useLocalStorage;
+var useSet_default = useSet;
 function useDebounce(value, delay = 500) {
   const [debouncedValue, setDebouncedValue] = react.useState(value);
   react.useEffect(() => {
@@ -1329,60 +2089,383 @@ function useDebounce(value, delay = 500) {
   return debouncedValue;
 }
 var useDebounce_default = useDebounce;
-function useCopyToClipboard(resetDelay = 2e3) {
-  const [copied, setCopied] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const reset = react.useCallback(() => {
-    setCopied(false);
-    setError(null);
+function useThrottle(value, interval = 500) {
+  const [throttledValue, setThrottledValue] = react.useState(value);
+  const lastUpdated = react.useRef(Date.now());
+  react.useEffect(() => {
+    const now = Date.now();
+    const timeSinceLastUpdate = now - lastUpdated.current;
+    if (timeSinceLastUpdate >= interval) {
+      lastUpdated.current = now;
+      setThrottledValue(value);
+      return;
+    } else {
+      const timeoutId = setTimeout(() => {
+        lastUpdated.current = Date.now();
+        setThrottledValue(value);
+      }, interval - timeSinceLastUpdate);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [value, interval]);
+  return throttledValue;
+}
+var useThrottle_default = useThrottle;
+function useTimeout(callback, delay) {
+  const savedCallback = react.useRef(callback);
+  const timeoutId = react.useRef(null);
+  react.useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const clear = react.useCallback(() => {
+    if (timeoutId.current) {
+      clearTimeout(timeoutId.current);
+      timeoutId.current = null;
+    }
   }, []);
-  const copy = react.useCallback(
-    async (text) => {
-      if (!navigator?.clipboard) {
-        try {
-          const textarea = document.createElement("textarea");
-          textarea.value = text;
-          textarea.style.position = "fixed";
-          textarea.style.left = "-999999px";
-          textarea.style.top = "-999999px";
-          document.body.appendChild(textarea);
-          textarea.focus();
-          textarea.select();
-          const successful = document.execCommand("copy");
-          document.body.removeChild(textarea);
-          if (successful) {
-            setCopied(true);
-            setError(null);
-            setTimeout(reset, resetDelay);
-            return true;
-          } else {
-            throw new Error("execCommand failed");
-          }
-        } catch (err) {
-          const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
-          setError(message);
-          setCopied(false);
-          return false;
-        }
+  const reset = react.useCallback(() => {
+    clear();
+    if (delay !== null) {
+      timeoutId.current = setTimeout(() => {
+        savedCallback.current();
+      }, delay);
+    }
+  }, [delay, clear]);
+  react.useEffect(() => {
+    if (delay === null) {
+      return;
+    }
+    timeoutId.current = setTimeout(() => {
+      savedCallback.current();
+    }, delay);
+    return clear;
+  }, [delay, clear]);
+  return { reset, clear };
+}
+var useTimeout_default = useTimeout;
+function useInterval(callback, delay) {
+  const savedCallback = react.useRef(callback);
+  react.useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  react.useEffect(() => {
+    if (delay === null) {
+      return;
+    }
+    const tick = () => savedCallback.current();
+    const id = setInterval(tick, delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+var useInterval_default = useInterval;
+function useIntervalWhen(callback, delay, when, immediate = false) {
+  const savedCallback = react.useRef(callback);
+  const hasRunImmediate = react.useRef(false);
+  react.useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  react.useEffect(() => {
+    if (!when) {
+      hasRunImmediate.current = false;
+      return;
+    }
+    if (immediate && !hasRunImmediate.current) {
+      hasRunImmediate.current = true;
+      savedCallback.current();
+    }
+    const id = setInterval(() => {
+      savedCallback.current();
+    }, delay);
+    return () => clearInterval(id);
+  }, [delay, when, immediate]);
+}
+var useIntervalWhen_default = useIntervalWhen;
+function useRandomInterval(callback, minDelay, maxDelay, enabled = true) {
+  const savedCallback = react.useRef(callback);
+  const timeoutId = react.useRef(null);
+  react.useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const getRandomDelay = react.useCallback(() => {
+    return Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
+  }, [minDelay, maxDelay]);
+  react.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const tick = () => {
+      savedCallback.current();
+      timeoutId.current = setTimeout(tick, getRandomDelay());
+    };
+    timeoutId.current = setTimeout(tick, getRandomDelay());
+    return () => {
+      if (timeoutId.current) {
+        clearTimeout(timeoutId.current);
       }
+    };
+  }, [enabled, getRandomDelay]);
+}
+var useRandomInterval_default = useRandomInterval;
+function useCountdown(initialCount, options = {}) {
+  const { interval = 1e3, onComplete, autoStart = false } = options;
+  const [count, setCount] = react.useState(initialCount);
+  const [isRunning, setIsRunning] = react.useState(autoStart);
+  const intervalRef = react.useRef(null);
+  const onCompleteRef = react.useRef(onComplete);
+  react.useEffect(() => {
+    onCompleteRef.current = onComplete;
+  }, [onComplete]);
+  const isComplete = count <= 0;
+  const clear = react.useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+  const start = react.useCallback(() => {
+    if (count <= 0) return;
+    setIsRunning(true);
+  }, [count]);
+  const pause = react.useCallback(() => {
+    setIsRunning(false);
+    clear();
+  }, [clear]);
+  const resume = react.useCallback(() => {
+    if (count > 0) {
+      setIsRunning(true);
+    }
+  }, [count]);
+  const reset = react.useCallback(
+    (newCount) => {
+      clear();
+      setCount(newCount ?? initialCount);
+      setIsRunning(false);
+    },
+    [clear, initialCount]
+  );
+  react.useEffect(() => {
+    if (!isRunning || count <= 0) {
+      clear();
+      return;
+    }
+    intervalRef.current = setInterval(() => {
+      setCount((prev) => {
+        const newCount = prev - interval;
+        if (newCount <= 0) {
+          setIsRunning(false);
+          onCompleteRef.current?.();
+          return 0;
+        }
+        return newCount;
+      });
+    }, interval);
+    return clear;
+  }, [isRunning, interval, clear, count]);
+  const formatted = {
+    days: Math.floor(count / (1e3 * 60 * 60 * 24)),
+    hours: Math.floor(count % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60)),
+    minutes: Math.floor(count % (1e3 * 60 * 60) / (1e3 * 60)),
+    seconds: Math.floor(count % (1e3 * 60) / 1e3)
+  };
+  return {
+    count,
+    start,
+    pause,
+    resume,
+    reset,
+    isRunning,
+    isComplete,
+    formatted
+  };
+}
+var useCountdown_default = useCountdown;
+function useContinuousRetry(callback, options = {}) {
+  const {
+    maxAttempts = Infinity,
+    delay = 1e3,
+    exponentialBackoff = false,
+    maxDelay = 3e4,
+    autoStart = true
+  } = options;
+  const [attempts, setAttempts] = react.useState(0);
+  const [error, setError] = react.useState(null);
+  const [isRetrying, setIsRetrying] = react.useState(autoStart);
+  const [isSuccess2, setIsSuccess] = react.useState(false);
+  const callbackRef = react.useRef(callback);
+  const timeoutRef = react.useRef(null);
+  react.useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  const isMaxAttempts = attempts >= maxAttempts;
+  const calculateDelay = react.useCallback(
+    (attempt) => {
+      if (!exponentialBackoff) return delay;
+      const exponentialDelay = delay * Math.pow(2, attempt);
+      return Math.min(exponentialDelay, maxDelay);
+    },
+    [delay, exponentialBackoff, maxDelay]
+  );
+  const clear = react.useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const stop = react.useCallback(() => {
+    clear();
+    setIsRetrying(false);
+  }, [clear]);
+  const reset = react.useCallback(() => {
+    clear();
+    setAttempts(0);
+    setError(null);
+    setIsRetrying(false);
+    setIsSuccess(false);
+  }, [clear]);
+  const start = react.useCallback(() => {
+    reset();
+    setIsRetrying(true);
+  }, [reset]);
+  react.useEffect(() => {
+    if (!isRetrying || isSuccess2 || isMaxAttempts) {
+      return;
+    }
+    const attemptCallback = async () => {
       try {
-        await navigator.clipboard.writeText(text);
-        setCopied(true);
-        setError(null);
-        setTimeout(reset, resetDelay);
-        return true;
+        setAttempts((prev) => prev + 1);
+        const result = await callbackRef.current();
+        if (result) {
+          setIsSuccess(true);
+          setIsRetrying(false);
+        } else {
+          const currentDelay = calculateDelay(attempts);
+          timeoutRef.current = setTimeout(attemptCallback, currentDelay);
+        }
       } catch (err) {
-        const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
-        setError(message);
-        setCopied(false);
-        return false;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        const currentDelay = calculateDelay(attempts);
+        timeoutRef.current = setTimeout(attemptCallback, currentDelay);
       }
-    },
-    [resetDelay, reset]
-  );
-  return { copy, copied, error, reset };
+    };
+    if (attempts === 0) {
+      attemptCallback();
+    }
+    return clear;
+  }, [isRetrying, isSuccess2, isMaxAttempts, attempts, calculateDelay, clear]);
+  return {
+    attempts,
+    error,
+    isRetrying,
+    isSuccess: isSuccess2,
+    isMaxAttempts,
+    start,
+    stop,
+    reset
+  };
 }
-var useCopyToClipboard_default = useCopyToClipboard;
+var useContinuousRetry_default = useContinuousRetry;
+function useWindowSize(debounceMs = 100) {
+  const getSize = () => ({
+    width: typeof window !== "undefined" ? window.innerWidth : 0,
+    height: typeof window !== "undefined" ? window.innerHeight : 0
+  });
+  const [windowSize, setWindowSize] = react.useState(getSize);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    let timeoutId;
+    const handleResize = () => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        setWindowSize(getSize());
+      }, debounceMs);
+    };
+    setWindowSize(getSize());
+    window.addEventListener("resize", handleResize);
+    return () => {
+      clearTimeout(timeoutId);
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [debounceMs]);
+  return windowSize;
+}
+var useWindowSize_default = useWindowSize;
+function useWindowScroll() {
+  const [scroll, setScroll] = react.useState({
+    x: typeof window !== "undefined" ? window.scrollX : 0,
+    y: typeof window !== "undefined" ? window.scrollY : 0,
+    direction: null,
+    isScrolling: false
+  });
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    let prevX = window.scrollX;
+    let prevY = window.scrollY;
+    let scrollTimeout;
+    const handleScroll = () => {
+      const x = window.scrollX;
+      const y = window.scrollY;
+      let direction = null;
+      if (y > prevY) direction = "down";
+      else if (y < prevY) direction = "up";
+      else if (x > prevX) direction = "right";
+      else if (x < prevX) direction = "left";
+      prevX = x;
+      prevY = y;
+      setScroll({ x, y, direction, isScrolling: true });
+      clearTimeout(scrollTimeout);
+      scrollTimeout = setTimeout(() => {
+        setScroll((prev) => ({ ...prev, isScrolling: false }));
+      }, 150);
+    };
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+      clearTimeout(scrollTimeout);
+    };
+  }, []);
+  const scrollTo = react.useCallback((options) => {
+    if (typeof window !== "undefined") {
+      window.scrollTo(options);
+    }
+  }, []);
+  const scrollToTop = react.useCallback((behavior = "smooth") => {
+    if (typeof window !== "undefined") {
+      window.scrollTo({ top: 0, behavior });
+    }
+  }, []);
+  const scrollToBottom = react.useCallback((behavior = "smooth") => {
+    if (typeof window !== "undefined") {
+      window.scrollTo({
+        top: document.documentElement.scrollHeight,
+        behavior
+      });
+    }
+  }, []);
+  return {
+    ...scroll,
+    scrollTo,
+    scrollToTop,
+    scrollToBottom
+  };
+}
+var useWindowScroll_default = useWindowScroll;
+function useDocumentTitle(title, options = {}) {
+  const { restoreOnUnmount = true, template } = options;
+  const previousTitle = react.useRef(null);
+  react.useEffect(() => {
+    if (typeof document === "undefined") return;
+    if (previousTitle.current === null) {
+      previousTitle.current = document.title;
+    }
+    const finalTitle = template ? template.replace("%s", title) : title;
+    document.title = finalTitle;
+    return () => {
+      if (restoreOnUnmount && previousTitle.current !== null) {
+        document.title = previousTitle.current;
+      }
+    };
+  }, [title, template, restoreOnUnmount]);
+}
+var useDocumentTitle_default = useDocumentTitle;
 function usePageTitle(title, options = {}) {
   const { suffix, separator = " | ", restoreOnUnmount = true } = options;
   react.useEffect(() => {
@@ -1390,46 +2473,1379 @@ function usePageTitle(title, options = {}) {
     const newTitle = suffix ? `${title}${separator}${suffix}` : title;
     document.title = newTitle;
     return () => {
-      if (restoreOnUnmount) {
-        document.title = originalTitle;
+      if (restoreOnUnmount) {
+        document.title = originalTitle;
+      }
+    };
+  }, [title, suffix, separator, restoreOnUnmount]);
+}
+var usePageTitle_default = usePageTitle;
+function useFavicon(href, restoreOnUnmount = true) {
+  const originalHref = react.useRef(null);
+  react.useEffect(() => {
+    if (typeof document === "undefined") return;
+    const link = document.querySelector("link[rel*='icon']") || document.createElement("link");
+    if (originalHref.current === null) {
+      originalHref.current = link.href;
+    }
+    link.type = "image/x-icon";
+    link.rel = "shortcut icon";
+    link.href = href;
+    document.head.appendChild(link);
+    return () => {
+      if (restoreOnUnmount && originalHref.current) {
+        link.href = originalHref.current;
+      }
+    };
+  }, [href, restoreOnUnmount]);
+}
+var useFavicon_default = useFavicon;
+function useVisibilityChange(onVisibilityChange) {
+  const [state, setState] = react.useState(() => ({
+    isVisible: typeof document !== "undefined" ? !document.hidden : true,
+    visibilityState: typeof document !== "undefined" ? document.visibilityState : "visible",
+    lastChanged: null
+  }));
+  const handleVisibilityChange = react.useCallback(() => {
+    const isVisible = !document.hidden;
+    const visibilityState = document.visibilityState;
+    setState({
+      isVisible,
+      visibilityState,
+      lastChanged: /* @__PURE__ */ new Date()
+    });
+    onVisibilityChange?.(isVisible);
+  }, [onVisibilityChange]);
+  react.useEffect(() => {
+    if (typeof document === "undefined") return;
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [handleVisibilityChange]);
+  return state;
+}
+var useVisibilityChange_default = useVisibilityChange;
+function usePageLeave(onLeave, options = {}) {
+  const { showConfirmation = false, confirmationMessage = "" } = options;
+  const onLeaveRef = react.useRef(onLeave);
+  react.useEffect(() => {
+    onLeaveRef.current = onLeave;
+  }, [onLeave]);
+  const handleMouseLeave = react.useCallback((e) => {
+    if (e.clientY <= 0) {
+      onLeaveRef.current?.();
+    }
+  }, []);
+  const handleBeforeUnload = react.useCallback(
+    (e) => {
+      onLeaveRef.current?.();
+      if (showConfirmation) {
+        e.preventDefault();
+        e.returnValue = confirmationMessage;
+        return confirmationMessage;
+      }
+    },
+    [showConfirmation, confirmationMessage]
+  );
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    document.addEventListener("mouseleave", handleMouseLeave);
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      document.removeEventListener("mouseleave", handleMouseLeave);
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+    };
+  }, [handleMouseLeave, handleBeforeUnload]);
+}
+var usePageLeave_default = usePageLeave;
+function useLockBodyScroll(locked = true) {
+  react.useEffect(() => {
+    if (typeof document === "undefined" || !locked) return;
+    const originalStyle = window.getComputedStyle(document.body).overflow;
+    const originalPaddingRight = window.getComputedStyle(document.body).paddingRight;
+    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    document.body.style.overflow = "hidden";
+    if (scrollbarWidth > 0) {
+      document.body.style.paddingRight = `${scrollbarWidth}px`;
+    }
+    return () => {
+      document.body.style.overflow = originalStyle;
+      document.body.style.paddingRight = originalPaddingRight;
+    };
+  }, [locked]);
+}
+var useLockBodyScroll_default = useLockBodyScroll;
+function useIsClient() {
+  const [isClient, setIsClient] = react.useState(false);
+  react.useEffect(() => {
+    setIsClient(true);
+  }, []);
+  return isClient;
+}
+var useIsClient_default = useIsClient;
+function useIsFirstRender() {
+  const isFirst = react.useRef(true);
+  if (isFirst.current) {
+    isFirst.current = false;
+    return true;
+  }
+  return isFirst.current;
+}
+var useIsFirstRender_default = useIsFirstRender;
+function useEventListener(eventName, handler, element, options) {
+  const savedHandler = react.useRef(handler);
+  react.useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+  react.useEffect(() => {
+    const targetElement = element ?? (typeof window !== "undefined" ? window : null);
+    if (!targetElement?.addEventListener) {
+      return;
+    }
+    const eventListener = (event) => {
+      savedHandler.current(event);
+    };
+    targetElement.addEventListener(eventName, eventListener, options);
+    return () => {
+      targetElement.removeEventListener(eventName, eventListener, options);
+    };
+  }, [eventName, element, options]);
+}
+var useEventListener_default = useEventListener;
+function useKeyPress(targetKey, callback, options = {}) {
+  const {
+    target,
+    event: eventType = "keydown",
+    preventDefault = false,
+    stopPropagation = false
+  } = options;
+  const [pressed, setPressed] = react.useState(false);
+  const [event, setEvent] = react.useState(null);
+  const keys = Array.isArray(targetKey) ? targetKey : [targetKey];
+  const downHandler = react.useCallback(
+    (e) => {
+      if (keys.includes(e.key)) {
+        if (preventDefault) e.preventDefault();
+        if (stopPropagation) e.stopPropagation();
+        setPressed(true);
+        setEvent(e);
+        callback?.(e);
+      }
+    },
+    [keys, callback, preventDefault, stopPropagation]
+  );
+  const upHandler = react.useCallback(
+    (e) => {
+      if (keys.includes(e.key)) {
+        setPressed(false);
+      }
+    },
+    [keys]
+  );
+  react.useEffect(() => {
+    const targetElement = target ?? (typeof document !== "undefined" ? document : null);
+    if (!targetElement) return;
+    targetElement.addEventListener(eventType, downHandler);
+    targetElement.addEventListener("keyup", upHandler);
+    return () => {
+      targetElement.removeEventListener(eventType, downHandler);
+      targetElement.removeEventListener("keyup", upHandler);
+    };
+  }, [target, eventType, downHandler, upHandler]);
+  return { pressed, event };
+}
+var useKeyPress_default = useKeyPress;
+function useHover(onHoverChange) {
+  const [isHovered, setIsHovered] = react.useState(false);
+  const ref = react.useRef(null);
+  const onMouseEnter = react.useCallback(() => {
+    setIsHovered(true);
+    onHoverChange?.(true);
+  }, [onHoverChange]);
+  const onMouseLeave = react.useCallback(() => {
+    setIsHovered(false);
+    onHoverChange?.(false);
+  }, [onHoverChange]);
+  return {
+    ref,
+    isHovered,
+    bind: {
+      onMouseEnter,
+      onMouseLeave
+    }
+  };
+}
+var useHover_default = useHover;
+function useClickAway(callback, events = ["mousedown", "touchstart"]) {
+  const ref = react.useRef(null);
+  const savedCallback = react.useRef(callback);
+  react.useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const handleClickAway = react.useCallback((event) => {
+    const el = ref.current;
+    if (!el || el.contains(event.target)) {
+      return;
+    }
+    savedCallback.current(event);
+  }, []);
+  react.useEffect(() => {
+    if (typeof document === "undefined") return;
+    events.forEach((eventType) => {
+      document.addEventListener(eventType, handleClickAway);
+    });
+    return () => {
+      events.forEach((eventType) => {
+        document.removeEventListener(eventType, handleClickAway);
+      });
+    };
+  }, [events, handleClickAway]);
+  return ref;
+}
+var useClickAway_default = useClickAway;
+function useOnClickOutside(ref, handler, enabled = true) {
+  react.useEffect(() => {
+    if (!enabled) return;
+    const listener = (event) => {
+      const el = ref?.current;
+      if (!el || el.contains(event.target)) {
+        return;
+      }
+      handler(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [ref, handler, enabled]);
+}
+var useOnClickOutside_default = useOnClickOutside;
+function useLongPress(options = {}) {
+  const {
+    threshold = 400,
+    onLongPress,
+    onClick,
+    onStart,
+    onFinish,
+    onCancel
+  } = options;
+  const [isPressed, setIsPressed] = react.useState(false);
+  const [isLongPress, setIsLongPress] = react.useState(false);
+  const timerRef = react.useRef(null);
+  const isLongPressRef = react.useRef(false);
+  const start = react.useCallback(
+    (event) => {
+      setIsPressed(true);
+      setIsLongPress(false);
+      isLongPressRef.current = false;
+      onStart?.(event);
+      timerRef.current = setTimeout(() => {
+        isLongPressRef.current = true;
+        setIsLongPress(true);
+        onLongPress?.(event);
+      }, threshold);
+    },
+    [threshold, onLongPress, onStart]
+  );
+  const cancel = react.useCallback(
+    (event) => {
+      setIsPressed(false);
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      if (!isLongPressRef.current) {
+        onCancel?.(event);
+      }
+    },
+    [onCancel]
+  );
+  const end = react.useCallback(
+    (event) => {
+      setIsPressed(false);
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      if (isLongPressRef.current) {
+        onFinish?.(event);
+      } else {
+        onClick?.(event);
+      }
+    },
+    [onClick, onFinish]
+  );
+  return {
+    isPressed,
+    isLongPress,
+    bind: {
+      onMouseDown: start,
+      onMouseUp: end,
+      onMouseLeave: cancel,
+      onTouchStart: start,
+      onTouchEnd: end
+    }
+  };
+}
+var useLongPress_default = useLongPress;
+function useMouse(options = {}) {
+  const { enabled = true } = options;
+  const ref = react.useRef(null);
+  const [position, setPosition] = react.useState({
+    x: 0,
+    y: 0,
+    pageX: 0,
+    pageY: 0,
+    elementX: 0,
+    elementY: 0,
+    isInElement: false
+  });
+  const handleMouseMove = react.useCallback((event) => {
+    let elementX = 0;
+    let elementY = 0;
+    let isInElement = false;
+    if (ref.current) {
+      const rect = ref.current.getBoundingClientRect();
+      elementX = event.clientX - rect.left;
+      elementY = event.clientY - rect.top;
+      isInElement = elementX >= 0 && elementX <= rect.width && elementY >= 0 && elementY <= rect.height;
+    }
+    setPosition({
+      x: event.clientX,
+      y: event.clientY,
+      pageX: event.pageX,
+      pageY: event.pageY,
+      elementX,
+      elementY,
+      isInElement
+    });
+  }, []);
+  react.useEffect(() => {
+    if (!enabled || typeof window === "undefined") return;
+    window.addEventListener("mousemove", handleMouseMove);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+    };
+  }, [enabled, handleMouseMove]);
+  return {
+    ref,
+    ...position
+  };
+}
+var useMouse_default = useMouse;
+function useCopyToClipboard(resetDelay = 2e3) {
+  const [copied, setCopied] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const reset = react.useCallback(() => {
+    setCopied(false);
+    setError(null);
+  }, []);
+  const copy = react.useCallback(
+    async (text) => {
+      if (!navigator?.clipboard) {
+        try {
+          const textarea = document.createElement("textarea");
+          textarea.value = text;
+          textarea.style.position = "fixed";
+          textarea.style.left = "-999999px";
+          textarea.style.top = "-999999px";
+          document.body.appendChild(textarea);
+          textarea.focus();
+          textarea.select();
+          const successful = document.execCommand("copy");
+          document.body.removeChild(textarea);
+          if (successful) {
+            setCopied(true);
+            setError(null);
+            setTimeout(reset, resetDelay);
+            return true;
+          } else {
+            throw new Error("execCommand failed");
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
+          setError(message);
+          setCopied(false);
+          return false;
+        }
+      }
+      try {
+        await navigator.clipboard.writeText(text);
+        setCopied(true);
+        setError(null);
+        setTimeout(reset, resetDelay);
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
+        setError(message);
+        setCopied(false);
+        return false;
+      }
+    },
+    [resetDelay, reset]
+  );
+  return { copy, copied, error, reset };
+}
+var useCopyToClipboard_default = useCopyToClipboard;
+function useMediaQuery(query) {
+  const getMatches = (query2) => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query2).matches;
+  };
+  const [matches, setMatches] = react.useState(getMatches(query));
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia(query);
+    const handleChange = () => setMatches(mediaQuery.matches);
+    handleChange();
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [query]);
+  return matches;
+}
+var useIsMobile = () => useMediaQuery("(max-width: 767px)");
+var useIsTablet = () => useMediaQuery("(min-width: 768px) and (max-width: 1023px)");
+var useIsDesktop = () => useMediaQuery("(min-width: 1024px)");
+var useIsMobileOrTablet = () => useMediaQuery("(max-width: 1023px)");
+var useMediaQuery_default = useMediaQuery;
+function useOrientation() {
+  const getOrientation = () => {
+    if (typeof window === "undefined" || !window.screen?.orientation) {
+      return {
+        angle: 0,
+        type: "portrait-primary",
+        isPortrait: true,
+        isLandscape: false
+      };
+    }
+    const { angle, type } = window.screen.orientation;
+    const isPortrait = type.includes("portrait");
+    const isLandscape = type.includes("landscape");
+    return { angle, type, isPortrait, isLandscape };
+  };
+  const [orientation, setOrientation] = react.useState(getOrientation);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleOrientationChange = () => {
+      setOrientation(getOrientation());
+    };
+    if (window.screen?.orientation) {
+      window.screen.orientation.addEventListener("change", handleOrientationChange);
+    }
+    window.addEventListener("orientationchange", handleOrientationChange);
+    window.addEventListener("resize", handleOrientationChange);
+    return () => {
+      if (window.screen?.orientation) {
+        window.screen.orientation.removeEventListener("change", handleOrientationChange);
+      }
+      window.removeEventListener("orientationchange", handleOrientationChange);
+      window.removeEventListener("resize", handleOrientationChange);
+    };
+  }, []);
+  return orientation;
+}
+var useOrientation_default = useOrientation;
+function useBattery() {
+  const [battery, setBattery] = react.useState({
+    isSupported: false,
+    charging: false,
+    chargingTime: Infinity,
+    dischargingTime: Infinity,
+    level: 1,
+    percentage: 100
+  });
+  react.useEffect(() => {
+    if (typeof navigator === "undefined") return;
+    const nav = navigator;
+    if (!nav.getBattery) {
+      setBattery((prev) => ({ ...prev, isSupported: false }));
+      return;
+    }
+    let batteryManager = null;
+    const updateBattery = (battery2) => {
+      setBattery({
+        isSupported: true,
+        charging: battery2.charging,
+        chargingTime: battery2.chargingTime,
+        dischargingTime: battery2.dischargingTime,
+        level: battery2.level,
+        percentage: Math.round(battery2.level * 100)
+      });
+    };
+    const handleChange = () => {
+      if (batteryManager) {
+        updateBattery(batteryManager);
+      }
+    };
+    nav.getBattery().then((battery2) => {
+      batteryManager = battery2;
+      updateBattery(battery2);
+      battery2.addEventListener("chargingchange", handleChange);
+      battery2.addEventListener("chargingtimechange", handleChange);
+      battery2.addEventListener("dischargingtimechange", handleChange);
+      battery2.addEventListener("levelchange", handleChange);
+    });
+    return () => {
+      if (batteryManager) {
+        batteryManager.removeEventListener("chargingchange", handleChange);
+        batteryManager.removeEventListener("chargingtimechange", handleChange);
+        batteryManager.removeEventListener("dischargingtimechange", handleChange);
+        batteryManager.removeEventListener("levelchange", handleChange);
+      }
+    };
+  }, []);
+  return battery;
+}
+var useBattery_default = useBattery;
+function useNetworkState() {
+  const getConnection = () => {
+    if (typeof navigator === "undefined") return void 0;
+    const nav = navigator;
+    return nav.connection || nav.mozConnection || nav.webkitConnection;
+  };
+  const getNetworkState = () => {
+    const online = typeof navigator !== "undefined" ? navigator.onLine : true;
+    const connection = getConnection();
+    return {
+      online,
+      offline: !online,
+      downlink: connection?.downlink,
+      effectiveType: connection?.effectiveType,
+      rtt: connection?.rtt,
+      saveData: connection?.saveData,
+      type: connection?.type,
+      since: /* @__PURE__ */ new Date()
+    };
+  };
+  const [state, setState] = react.useState(getNetworkState);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleOnline = () => {
+      setState((prev) => ({ ...prev, online: true, offline: false, since: /* @__PURE__ */ new Date() }));
+    };
+    const handleOffline = () => {
+      setState((prev) => ({ ...prev, online: false, offline: true, since: /* @__PURE__ */ new Date() }));
+    };
+    const handleConnectionChange = () => {
+      setState(getNetworkState());
+    };
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    const connection = getConnection();
+    if (connection) {
+      connection.addEventListener("change", handleConnectionChange);
+    }
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+      if (connection) {
+        connection.removeEventListener("change", handleConnectionChange);
+      }
+    };
+  }, []);
+  return state;
+}
+var useNetworkState_default = useNetworkState;
+var DEFAULT_EVENTS = [
+  "mousemove",
+  "mousedown",
+  "keydown",
+  "touchstart",
+  "scroll",
+  "wheel"
+];
+function useIdle(options = {}) {
+  const {
+    timeout = 6e4,
+    events = DEFAULT_EVENTS,
+    initialState = false,
+    onIdle,
+    onActive
+  } = options;
+  const [isIdle, setIsIdle] = react.useState(initialState);
+  const [lastActive, setLastActive] = react.useState(/* @__PURE__ */ new Date());
+  const [isTracking, setIsTracking] = react.useState(true);
+  const timeoutRef = react.useRef(null);
+  const onIdleRef = react.useRef(onIdle);
+  const onActiveRef = react.useRef(onActive);
+  react.useEffect(() => {
+    onIdleRef.current = onIdle;
+    onActiveRef.current = onActive;
+  }, [onIdle, onActive]);
+  const handleActivity = react.useCallback(() => {
+    if (!isTracking) return;
+    setLastActive(/* @__PURE__ */ new Date());
+    if (isIdle) {
+      setIsIdle(false);
+      onActiveRef.current?.();
+    }
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(() => {
+      setIsIdle(true);
+      onIdleRef.current?.();
+    }, timeout);
+  }, [isIdle, isTracking, timeout]);
+  const reset = react.useCallback(() => {
+    handleActivity();
+  }, [handleActivity]);
+  const start = react.useCallback(() => {
+    setIsTracking(true);
+    handleActivity();
+  }, [handleActivity]);
+  const stop = react.useCallback(() => {
+    setIsTracking(false);
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  react.useEffect(() => {
+    if (typeof window === "undefined" || !isTracking) return;
+    timeoutRef.current = setTimeout(() => {
+      setIsIdle(true);
+      onIdleRef.current?.();
+    }, timeout);
+    events.forEach((event) => {
+      window.addEventListener(event, handleActivity, { passive: true });
+    });
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      events.forEach((event) => {
+        window.removeEventListener(event, handleActivity);
+      });
+    };
+  }, [events, handleActivity, isTracking, timeout]);
+  return {
+    isIdle,
+    lastActive,
+    reset,
+    start,
+    stop
+  };
+}
+var useIdle_default = useIdle;
+function useGeolocation(options = {}) {
+  const {
+    enableHighAccuracy = false,
+    maximumAge = 0,
+    timeout = Infinity,
+    watch = false
+  } = options;
+  const isSupported = typeof navigator !== "undefined" && "geolocation" in navigator;
+  const [state, setState] = react.useState({
+    loading: true,
+    error: null,
+    latitude: null,
+    longitude: null,
+    accuracy: null,
+    altitude: null,
+    altitudeAccuracy: null,
+    heading: null,
+    speed: null,
+    timestamp: null
+  });
+  const handleSuccess = react.useCallback((position) => {
+    setState({
+      loading: false,
+      error: null,
+      latitude: position.coords.latitude,
+      longitude: position.coords.longitude,
+      accuracy: position.coords.accuracy,
+      altitude: position.coords.altitude,
+      altitudeAccuracy: position.coords.altitudeAccuracy,
+      heading: position.coords.heading,
+      speed: position.coords.speed,
+      timestamp: position.timestamp
+    });
+  }, []);
+  const handleError = react.useCallback((error) => {
+    setState((prev) => ({
+      ...prev,
+      loading: false,
+      error: error.message
+    }));
+  }, []);
+  const refresh = react.useCallback(() => {
+    if (!isSupported) return;
+    setState((prev) => ({ ...prev, loading: true }));
+    navigator.geolocation.getCurrentPosition(handleSuccess, handleError, {
+      enableHighAccuracy,
+      maximumAge,
+      timeout
+    });
+  }, [isSupported, enableHighAccuracy, maximumAge, timeout, handleSuccess, handleError]);
+  react.useEffect(() => {
+    if (!isSupported) {
+      setState((prev) => ({
+        ...prev,
+        loading: false,
+        error: "Geolocation is not supported"
+      }));
+      return;
+    }
+    const positionOptions = {
+      enableHighAccuracy,
+      maximumAge,
+      timeout
+    };
+    navigator.geolocation.getCurrentPosition(
+      handleSuccess,
+      handleError,
+      positionOptions
+    );
+    let watchId = null;
+    if (watch) {
+      watchId = navigator.geolocation.watchPosition(
+        handleSuccess,
+        handleError,
+        positionOptions
+      );
+    }
+    return () => {
+      if (watchId !== null) {
+        navigator.geolocation.clearWatch(watchId);
+      }
+    };
+  }, [isSupported, enableHighAccuracy, maximumAge, timeout, watch, handleSuccess, handleError]);
+  return {
+    ...state,
+    refresh,
+    isSupported
+  };
+}
+var useGeolocation_default = useGeolocation;
+function usePreferredLanguage() {
+  const getLanguageState = () => {
+    if (typeof navigator === "undefined") {
+      return { language: "en", languages: ["en"] };
+    }
+    return {
+      language: navigator.language || "en",
+      languages: navigator.languages || [navigator.language || "en"]
+    };
+  };
+  const [state, setState] = react.useState(getLanguageState);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleLanguageChange = () => {
+      setState(getLanguageState());
+    };
+    window.addEventListener("languagechange", handleLanguageChange);
+    return () => {
+      window.removeEventListener("languagechange", handleLanguageChange);
+    };
+  }, []);
+  return state;
+}
+var usePreferredLanguage_default = usePreferredLanguage;
+function useThemeDetector() {
+  const getCurrentTheme = () => {
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  };
+  const [theme, setTheme] = react.useState(getCurrentTheme);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
+      setTheme(e.matches ? "dark" : "light");
+    };
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, []);
+  return theme;
+}
+var useThemeDetector_default = useThemeDetector;
+function useLocalStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    syncTabs = true,
+    debug = false
+  } = options;
+  const log = react.useCallback(
+    (...args) => {
+      if (debug) console.log(`[useLocalStorage:${key}]`, ...args);
+    },
+    [debug, key]
+  );
+  const readValue = react.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) {
+        return initialValue;
+      }
+      const parsed = deserializer(item);
+      log("Read value:", parsed);
+      return parsed;
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [key, initialValue, deserializer, log]);
+  const [storedValue, setStoredValue] = react.useState(readValue);
+  const setValue = react.useCallback(
+    (value) => {
+      if (typeof window === "undefined") {
+        console.warn(`Cannot set localStorage key "${key}" in non-browser environment`);
+        return;
+      }
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        window.localStorage.setItem(key, serializer(valueToStore));
+        log("Set value:", valueToStore);
+        window.dispatchEvent(new StorageEvent("storage", { key, newValue: serializer(valueToStore) }));
+      } catch (error) {
+        console.warn(`Error setting localStorage key "${key}":`, error);
+      }
+    },
+    [key, storedValue, serializer, log]
+  );
+  const removeValue = react.useCallback(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      window.localStorage.removeItem(key);
+      setStoredValue(initialValue);
+      log("Removed value");
+      window.dispatchEvent(new StorageEvent("storage", { key, newValue: null }));
+    } catch (error) {
+      console.warn(`Error removing localStorage key "${key}":`, error);
+    }
+  }, [key, initialValue, log]);
+  react.useEffect(() => {
+    if (!syncTabs || typeof window === "undefined") {
+      return;
+    }
+    const handleStorageChange = (event) => {
+      if (event.key !== key) {
+        return;
+      }
+      log("Storage event received:", event.newValue);
+      if (event.newValue === null) {
+        setStoredValue(initialValue);
+      } else {
+        try {
+          setStoredValue(deserializer(event.newValue));
+        } catch {
+          console.warn(`Error parsing localStorage change for key "${key}"`);
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [key, initialValue, syncTabs, deserializer, log]);
+  return [storedValue, setValue, removeValue];
+}
+var useLocalStorage_default = useLocalStorage;
+function useSessionStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    debug = false
+  } = options;
+  const log = react.useCallback(
+    (...args) => {
+      if (debug) console.log(`[useSessionStorage:${key}]`, ...args);
+    },
+    [debug, key]
+  );
+  const readValue = react.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      if (item === null) {
+        return initialValue;
+      }
+      const parsed = deserializer(item);
+      log("Read value:", parsed);
+      return parsed;
+    } catch (error) {
+      console.warn(`Error reading sessionStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [key, initialValue, deserializer, log]);
+  const [storedValue, setStoredValue] = react.useState(readValue);
+  const setValue = react.useCallback(
+    (value) => {
+      if (typeof window === "undefined") {
+        console.warn(`Cannot set sessionStorage key "${key}" in non-browser environment`);
+        return;
+      }
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        window.sessionStorage.setItem(key, serializer(valueToStore));
+        log("Set value:", valueToStore);
+      } catch (error) {
+        console.warn(`Error setting sessionStorage key "${key}":`, error);
+      }
+    },
+    [key, storedValue, serializer, log]
+  );
+  const removeValue = react.useCallback(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      window.sessionStorage.removeItem(key);
+      setStoredValue(initialValue);
+      log("Removed value");
+    } catch (error) {
+      console.warn(`Error removing sessionStorage key "${key}":`, error);
+    }
+  }, [key, initialValue, log]);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleStorageChange = (e) => {
+      if (e.storageArea !== sessionStorage || e.key !== key) {
+        return;
+      }
+      try {
+        if (e.newValue === null) {
+          setStoredValue(initialValue);
+        } else {
+          setStoredValue(deserializer(e.newValue));
+        }
+      } catch (error) {
+        console.warn(`Error handling storage event for key "${key}":`, error);
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [key, initialValue, deserializer]);
+  return [storedValue, setValue, removeValue];
+}
+var useSessionStorage_default = useSessionStorage;
+var cache = /* @__PURE__ */ new Map();
+function useFetch(url, options = {}) {
+  const {
+    skip = false,
+    transform,
+    retries = 0,
+    retryDelay = 1e3,
+    cacheKey,
+    cacheTime = 0,
+    onSuccess,
+    onError,
+    body,
+    ...fetchOptions
+  } = options;
+  const [data, setData] = react.useState(null);
+  const [loading, setLoading] = react.useState(!skip && !!url);
+  const [isFetching, setIsFetching] = react.useState(!skip && !!url);
+  const [error, setError] = react.useState(null);
+  const [status, setStatus] = react.useState(null);
+  const abortControllerRef = react.useRef(null);
+  const retriesRef = react.useRef(0);
+  const fetchData = react.useCallback(async () => {
+    if (!url) return null;
+    const key = cacheKey || url;
+    if (cacheTime > 0) {
+      const cached = cache.get(key);
+      if (cached && Date.now() - cached.timestamp < cacheTime) {
+        const cachedData = cached.data;
+        setData(cachedData);
+        setLoading(false);
+        setIsFetching(false);
+        return cachedData;
+      }
+    }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    abortControllerRef.current = new AbortController();
+    setIsFetching(true);
+    setError(null);
+    try {
+      let processedBody;
+      if (body !== null && body !== void 0) {
+        if (typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob)) {
+          processedBody = JSON.stringify(body);
+          fetchOptions.headers = {
+            "Content-Type": "application/json",
+            ...fetchOptions.headers
+          };
+        } else {
+          processedBody = body;
+        }
+      }
+      const response = await fetch(url, {
+        ...fetchOptions,
+        body: processedBody,
+        signal: abortControllerRef.current.signal
+      });
+      setStatus(response.status);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const responseData = await response.json();
+      const transformedData = transform ? transform(responseData) : responseData;
+      if (cacheTime > 0) {
+        cache.set(key, { data: transformedData, timestamp: Date.now() });
+      }
+      setData(transformedData);
+      setError(null);
+      setLoading(false);
+      setIsFetching(false);
+      retriesRef.current = 0;
+      onSuccess?.(transformedData);
+      return transformedData;
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return null;
+      }
+      const fetchError = err instanceof Error ? err : new Error(String(err));
+      if (retriesRef.current < retries) {
+        retriesRef.current++;
+        await new Promise((resolve2) => setTimeout(resolve2, retryDelay));
+        return fetchData();
+      }
+      setError(fetchError);
+      setLoading(false);
+      setIsFetching(false);
+      retriesRef.current = 0;
+      onError?.(fetchError);
+      return null;
+    }
+  }, [url, cacheKey, cacheTime, transform, retries, retryDelay, body, fetchOptions, onSuccess, onError]);
+  const abort = react.useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+  }, []);
+  const refetch = react.useCallback(async () => {
+    const key = cacheKey || url || "";
+    cache.delete(key);
+    setLoading(true);
+    return fetchData();
+  }, [fetchData, cacheKey, url]);
+  react.useEffect(() => {
+    if (skip || !url) {
+      setLoading(false);
+      setIsFetching(false);
+      return;
+    }
+    fetchData();
+    return () => {
+      abort();
+    };
+  }, [url, skip]);
+  return {
+    data,
+    loading,
+    error,
+    refetch,
+    abort,
+    isFetching,
+    status
+  };
+}
+var useFetch_default = useFetch;
+var scriptCache = /* @__PURE__ */ new Map();
+function useScript(src, options = {}) {
+  const { shouldLoad = true, removeOnUnmount = false, attributes = {} } = options;
+  const [status, setStatus] = react.useState(() => {
+    if (!src) return "idle";
+    if (typeof window === "undefined") return "idle";
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      return scriptCache.get(src) || "ready";
+    }
+    return "idle";
+  });
+  const load = react.useCallback(() => {
+    if (!src || typeof document === "undefined") return;
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      const cachedStatus = scriptCache.get(src);
+      if (cachedStatus) {
+        setStatus(cachedStatus);
+      }
+      return;
+    }
+    setStatus("loading");
+    scriptCache.set(src, "loading");
+    const script = document.createElement("script");
+    script.src = src;
+    script.async = true;
+    Object.entries(attributes).forEach(([key, value]) => {
+      script.setAttribute(key, value);
+    });
+    const handleLoad = () => {
+      setStatus("ready");
+      scriptCache.set(src, "ready");
+    };
+    const handleError = () => {
+      setStatus("error");
+      scriptCache.set(src, "error");
+    };
+    script.addEventListener("load", handleLoad);
+    script.addEventListener("error", handleError);
+    document.body.appendChild(script);
+  }, [src, attributes]);
+  const remove = react.useCallback(() => {
+    if (!src || typeof document === "undefined") return;
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      document.body.removeChild(existingScript);
+      scriptCache.delete(src);
+      setStatus("idle");
+    }
+  }, [src]);
+  react.useEffect(() => {
+    if (shouldLoad && status === "idle") {
+      load();
+    }
+  }, [shouldLoad, status, load]);
+  react.useEffect(() => {
+    return () => {
+      if (removeOnUnmount) {
+        remove();
       }
     };
-  }, [title, suffix, separator, restoreOnUnmount]);
+  }, [removeOnUnmount, remove]);
+  return {
+    status,
+    ready: status === "ready",
+    loading: status === "loading",
+    error: status === "error",
+    load,
+    remove
+  };
 }
-var usePageTitle_default = usePageTitle;
-function useInterval(callback, delay) {
-  const savedCallback = react.useRef(callback);
+var useScript_default = useScript;
+function useRenderInfo(componentName = "Component") {
+  const renderCount = react.useRef(0);
+  const lastRenderTime = react.useRef(Date.now());
+  const currentTime = Date.now();
+  const sinceLastRender = currentTime - lastRenderTime.current;
+  renderCount.current++;
+  const renders = renderCount.current;
   react.useEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
+    lastRenderTime.current = currentTime;
+  });
+  const info = {
+    name: componentName,
+    renders,
+    sinceLastRender,
+    timestamp: currentTime
+  };
+  if (process.env.NODE_ENV === "development") {
+    console.log(`[${componentName}] Render #${renders} (${sinceLastRender}ms since last)`);
+  }
+  return info;
+}
+var useRenderInfo_default = useRenderInfo;
+function useRenderCount() {
+  const renderCount = react.useRef(0);
+  renderCount.current++;
+  return renderCount.current;
+}
+var useRenderCount_default = useRenderCount;
+function useLogger(componentName, props, options = {}) {
+  const {
+    logProps = true,
+    logLifecycle = true,
+    logger: logger2 = console.log
+  } = options;
+  const previousProps = react.useRef(props);
+  const renderCount = react.useRef(0);
+  renderCount.current++;
   react.useEffect(() => {
-    if (delay === null) {
+    if (logLifecycle) {
+      logger2(`[${componentName}] Mounted`);
+    }
+    return () => {
+      if (logLifecycle) {
+        logger2(`[${componentName}] Unmounted (rendered ${renderCount.current} times)`);
+      }
+    };
+  }, []);
+  react.useEffect(() => {
+    if (!logProps || !props || !previousProps.current) {
+      previousProps.current = props;
       return;
     }
-    const tick = () => savedCallback.current();
-    const id = setInterval(tick, delay);
-    return () => clearInterval(id);
-  }, [delay]);
+    const changedProps = {};
+    let hasChanges = false;
+    Object.keys(props).forEach((key) => {
+      if (previousProps.current?.[key] !== props[key]) {
+        changedProps[key] = {
+          from: previousProps.current?.[key],
+          to: props[key]
+        };
+        hasChanges = true;
+      }
+    });
+    if (previousProps.current) {
+      Object.keys(previousProps.current).forEach((key) => {
+        if (!(key in props)) {
+          changedProps[key] = {
+            from: previousProps.current?.[key],
+            to: void 0
+          };
+          hasChanges = true;
+        }
+      });
+    }
+    if (hasChanges) {
+      logger2(`[${componentName}] Props changed:`, changedProps);
+    }
+    previousProps.current = props;
+  }, [componentName, props, logProps, logger2]);
+  if (process.env.NODE_ENV === "development") {
+    logger2(`[${componentName}] Render #${renderCount.current}`);
+  }
 }
-var useInterval_default = useInterval;
-function useThemeDetector() {
-  const getCurrentTheme = () => {
-    if (typeof window === "undefined") return "light";
-    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-  };
-  const [theme, setTheme] = react.useState(getCurrentTheme);
+var useLogger_default = useLogger;
+var defaultDimensions = {
+  width: 0,
+  height: 0,
+  top: 0,
+  left: 0,
+  bottom: 0,
+  right: 0,
+  x: 0,
+  y: 0
+};
+function useMeasure() {
+  const [dimensions, setDimensions] = react.useState(defaultDimensions);
+  const elementRef = react.useRef(null);
+  const observerRef = react.useRef(null);
+  const measure = react.useCallback(() => {
+    if (!elementRef.current) return;
+    const rect = elementRef.current.getBoundingClientRect();
+    setDimensions({
+      width: rect.width,
+      height: rect.height,
+      top: rect.top,
+      left: rect.left,
+      bottom: rect.bottom,
+      right: rect.right,
+      x: rect.x,
+      y: rect.y
+    });
+  }, []);
+  const ref = react.useCallback((node) => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+      observerRef.current = null;
+    }
+    if (node) {
+      elementRef.current = node;
+      if (typeof ResizeObserver !== "undefined") {
+        observerRef.current = new ResizeObserver((entries) => {
+          if (entries[0]) {
+            const rect2 = entries[0].target.getBoundingClientRect();
+            setDimensions({
+              width: rect2.width,
+              height: rect2.height,
+              top: rect2.top,
+              left: rect2.left,
+              bottom: rect2.bottom,
+              right: rect2.right,
+              x: rect2.x,
+              y: rect2.y
+            });
+          }
+        });
+        observerRef.current.observe(node);
+      }
+      const rect = node.getBoundingClientRect();
+      setDimensions({
+        width: rect.width,
+        height: rect.height,
+        top: rect.top,
+        left: rect.left,
+        bottom: rect.bottom,
+        right: rect.right,
+        x: rect.x,
+        y: rect.y
+      });
+    } else {
+      elementRef.current = null;
+    }
+  }, []);
   react.useEffect(() => {
-    if (typeof window === "undefined") return;
-    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
-    const handleChange = (e) => {
-      setTheme(e.matches ? "dark" : "light");
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
     };
-    mediaQuery.addEventListener("change", handleChange);
-    return () => mediaQuery.removeEventListener("change", handleChange);
   }, []);
-  return theme;
+  return { ref, dimensions, measure };
 }
-var useThemeDetector_default = useThemeDetector;
+var useMeasure_default = useMeasure;
+function useIntersectionObserver(options = {}) {
+  const {
+    root = null,
+    rootMargin = "0px",
+    threshold = 0,
+    freezeOnceVisible = false,
+    initialIsIntersecting = false,
+    onChange
+  } = options;
+  const [entry, setEntry] = react.useState(null);
+  const [isIntersecting, setIsIntersecting] = react.useState(initialIsIntersecting);
+  const elementRef = react.useRef(null);
+  const observerRef = react.useRef(null);
+  const frozen = react.useRef(false);
+  const ref = react.useCallback(
+    (node) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+      if (frozen.current) return;
+      if (node && typeof IntersectionObserver !== "undefined") {
+        elementRef.current = node;
+        observerRef.current = new IntersectionObserver(
+          ([observerEntry]) => {
+            const newIsIntersecting = observerEntry.isIntersecting;
+            setEntry(observerEntry);
+            setIsIntersecting(newIsIntersecting);
+            onChange?.(newIsIntersecting, observerEntry);
+            if (freezeOnceVisible && newIsIntersecting) {
+              frozen.current = true;
+              observerRef.current?.disconnect();
+            }
+          },
+          { root, rootMargin, threshold }
+        );
+        observerRef.current.observe(node);
+      } else {
+        elementRef.current = null;
+      }
+    },
+    [root, rootMargin, threshold, freezeOnceVisible, onChange]
+  );
+  react.useEffect(() => {
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, []);
+  return { ref, isIntersecting, entry };
+}
+var useIntersectionObserver_default = useIntersectionObserver;
 var DEFAULT_DURATION = 4e3;
 function useSnackbar(defaultDuration = DEFAULT_DURATION) {
   const [state, setState] = react.useState({
@@ -1471,86 +3887,44 @@ function useSnackbar(defaultDuration = DEFAULT_DURATION) {
   return { state, show, success, error, warning, info, close };
 }
 var useSnackbar_default = useSnackbar;
-function useMediaQuery(query) {
-  const getMatches = (query2) => {
-    if (typeof window === "undefined") return false;
-    return window.matchMedia(query2).matches;
-  };
-  const [matches, setMatches] = react.useState(getMatches(query));
-  react.useEffect(() => {
-    if (typeof window === "undefined") return;
-    const mediaQuery = window.matchMedia(query);
-    const handleChange = () => setMatches(mediaQuery.matches);
-    handleChange();
-    mediaQuery.addEventListener("change", handleChange);
-    return () => mediaQuery.removeEventListener("change", handleChange);
-  }, [query]);
-  return matches;
-}
-var useIsMobile = () => useMediaQuery("(max-width: 767px)");
-var useIsTablet = () => useMediaQuery("(min-width: 768px) and (max-width: 1023px)");
-var useIsDesktop = () => useMediaQuery("(min-width: 1024px)");
-var useIsMobileOrTablet = () => useMediaQuery("(max-width: 1023px)");
-var useMediaQuery_default = useMediaQuery;
-function useOnClickOutside(ref, handler, enabled = true) {
-  react.useEffect(() => {
-    if (!enabled) return;
-    const listener = (event) => {
-      const el = ref?.current;
-      if (!el || el.contains(event.target)) {
-        return;
-      }
-      handler(event);
-    };
-    document.addEventListener("mousedown", listener);
-    document.addEventListener("touchstart", listener);
-    return () => {
-      document.removeEventListener("mousedown", listener);
-      document.removeEventListener("touchstart", listener);
-    };
-  }, [ref, handler, enabled]);
-}
-var useOnClickOutside_default = useOnClickOutside;
-function useWindowSize(debounceMs = 100) {
-  const getSize = () => ({
-    width: typeof window !== "undefined" ? window.innerWidth : 0,
-    height: typeof window !== "undefined" ? window.innerHeight : 0
-  });
-  const [windowSize, setWindowSize] = react.useState(getSize);
-  react.useEffect(() => {
-    if (typeof window === "undefined") return;
-    let timeoutId;
-    const handleResize = () => {
-      clearTimeout(timeoutId);
-      timeoutId = setTimeout(() => {
-        setWindowSize(getSize());
-      }, debounceMs);
-    };
-    setWindowSize(getSize());
-    window.addEventListener("resize", handleResize);
-    return () => {
-      clearTimeout(timeoutId);
-      window.removeEventListener("resize", handleResize);
-    };
-  }, [debounceMs]);
-  return windowSize;
-}
-var useWindowSize_default = useWindowSize;
 
 // src/shared/index.ts
 var shared_exports = {};
 __export(shared_exports, {
+  BREAKPOINTS: () => BREAKPOINTS,
+  CONTAINER_WIDTHS: () => CONTAINER_WIDTHS,
+  DATE_FORMAT: () => DATE_FORMAT,
   DATE_FORMATS: () => DATE_FORMATS,
+  ENUMS: () => ENUMS,
+  ENUMS_DEFAULT: () => enums_default,
+  FILE_TYPE: () => FILE_TYPE,
+  GENDER: () => GENDER,
   HTTP_STATUS: () => HTTP_STATUS,
   HTTP_STATUS_MESSAGES: () => HTTP_STATUS_MESSAGES,
+  INTERVAL: () => INTERVAL,
+  LOCALE: () => LOCALE,
+  MEDIA_QUERIES: () => MEDIA_QUERIES,
+  MEDIA_QUERIES_MAX: () => MEDIA_QUERIES_MAX,
+  NOTIFICATION_TYPE: () => NOTIFICATION_TYPE,
+  ORDER_STATUS: () => ORDER_STATUS,
   PAGINATION: () => PAGINATION,
+  PAYMENT_STATUS: () => PAYMENT_STATUS,
+  PERMISSION_LEVEL: () => PERMISSION_LEVEL,
+  PRIORITY: () => PRIORITY,
+  ROLE: () => ROLE,
   ROLES: () => ROLES,
+  SORT: () => SORT,
+  SORT_DIRECTION: () => SORT_DIRECTION,
   STATUS: () => STATUS,
+  SUBSCRIPTION_STATUS: () => SUBSCRIPTION_STATUS,
+  TASK_STATUS: () => TASK_STATUS,
+  THEME: () => THEME,
   TOKEN_TYPES: () => TOKEN_TYPES,
   USER_STATUS: () => USER_STATUS,
   VALIDATION_MESSAGES: () => VALIDATION_MESSAGES,
   VALIDATION_PATTERNS: () => VALIDATION_PATTERNS,
   VALIDATION_RULES: () => VALIDATION_RULES,
+  VISIBILITY: () => VISIBILITY,
   addDays: () => dateFns.addDays,
   addHours: () => dateFns.addHours,
   addMinutes: () => dateFns.addMinutes,
@@ -1797,6 +4171,279 @@ var TOKEN_TYPES = {
   RESET_PASSWORD: "reset_password",
   EMAIL_VERIFICATION: "email_verification"
 };
+
+// src/shared/constants/enums.ts
+var STATUS2 = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  APPROVED: "approved",
+  REJECTED: "rejected",
+  ARCHIVED: "archived",
+  DELETED: "deleted",
+  DRAFT: "draft",
+  PUBLISHED: "published",
+  SUSPENDED: "suspended",
+  EXPIRED: "expired",
+  CANCELLED: "cancelled"
+};
+var USER_STATUS2 = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  SUSPENDED: "suspended",
+  BANNED: "banned",
+  DELETED: "deleted",
+  UNVERIFIED: "unverified",
+  VERIFIED: "verified"
+};
+var ORDER_STATUS = {
+  PENDING: "pending",
+  CONFIRMED: "confirmed",
+  PROCESSING: "processing",
+  SHIPPED: "shipped",
+  DELIVERED: "delivered",
+  CANCELLED: "cancelled",
+  REFUNDED: "refunded",
+  FAILED: "failed",
+  ON_HOLD: "on_hold"
+};
+var PAYMENT_STATUS = {
+  PENDING: "pending",
+  PROCESSING: "processing",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+  REFUNDED: "refunded",
+  PARTIALLY_REFUNDED: "partially_refunded",
+  DISPUTED: "disputed"
+};
+var TASK_STATUS = {
+  TODO: "todo",
+  IN_PROGRESS: "in_progress",
+  IN_REVIEW: "in_review",
+  DONE: "done",
+  BLOCKED: "blocked",
+  CANCELLED: "cancelled",
+  ON_HOLD: "on_hold"
+};
+var SUBSCRIPTION_STATUS = {
+  ACTIVE: "active",
+  TRIAL: "trial",
+  PAST_DUE: "past_due",
+  CANCELLED: "cancelled",
+  EXPIRED: "expired",
+  PAUSED: "paused",
+  PENDING: "pending"
+};
+var SORT_DIRECTION = {
+  ASC: "asc",
+  DESC: "desc"
+};
+var SORT = {
+  // Date sorting
+  NEWEST: "newest",
+  OLDEST: "oldest",
+  CREATED_AT_ASC: "created_at_asc",
+  CREATED_AT_DESC: "created_at_desc",
+  UPDATED_AT_ASC: "updated_at_asc",
+  UPDATED_AT_DESC: "updated_at_desc",
+  // Alphabetical
+  NAME_ASC: "name_asc",
+  NAME_DESC: "name_desc",
+  TITLE_ASC: "title_asc",
+  TITLE_DESC: "title_desc",
+  ALPHABETICAL: "alphabetical",
+  REVERSE_ALPHABETICAL: "reverse_alphabetical",
+  // Numeric
+  PRICE_ASC: "price_asc",
+  PRICE_DESC: "price_desc",
+  AMOUNT_ASC: "amount_asc",
+  AMOUNT_DESC: "amount_desc",
+  // Popularity/Engagement
+  POPULAR: "popular",
+  TRENDING: "trending",
+  MOST_VIEWED: "most_viewed",
+  MOST_LIKED: "most_liked",
+  MOST_COMMENTED: "most_commented",
+  TOP_RATED: "top_rated",
+  // Relevance
+  RELEVANCE: "relevance",
+  BEST_MATCH: "best_match",
+  // Custom
+  CUSTOM: "custom",
+  MANUAL: "manual",
+  RANDOM: "random"
+};
+var ROLE = {
+  // System roles
+  SUPER_ADMIN: "super_admin",
+  ADMIN: "admin",
+  MODERATOR: "moderator",
+  SUPPORT: "support",
+  // User roles
+  USER: "user",
+  MEMBER: "member",
+  GUEST: "guest",
+  // Business roles
+  OWNER: "owner",
+  MANAGER: "manager",
+  EDITOR: "editor",
+  VIEWER: "viewer",
+  CONTRIBUTOR: "contributor",
+  // Team roles
+  TEAM_LEAD: "team_lead",
+  TEAM_MEMBER: "team_member",
+  // API roles
+  API_USER: "api_user",
+  SERVICE: "service",
+  BOT: "bot"
+};
+var PERMISSION_LEVEL = {
+  NONE: 0,
+  READ: 1,
+  WRITE: 2,
+  DELETE: 3,
+  ADMIN: 4,
+  SUPER_ADMIN: 5
+};
+var PRIORITY = {
+  LOWEST: "lowest",
+  LOW: "low",
+  MEDIUM: "medium",
+  HIGH: "high",
+  HIGHEST: "highest",
+  URGENT: "urgent",
+  CRITICAL: "critical"
+};
+var VISIBILITY = {
+  PUBLIC: "public",
+  PRIVATE: "private",
+  INTERNAL: "internal",
+  RESTRICTED: "restricted",
+  HIDDEN: "hidden",
+  UNLISTED: "unlisted"
+};
+var BREAKPOINTS = {
+  xs: 0,
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536
+};
+var MEDIA_QUERIES = {
+  xs: "(min-width: 0px)",
+  sm: "(min-width: 640px)",
+  md: "(min-width: 768px)",
+  lg: "(min-width: 1024px)",
+  xl: "(min-width: 1280px)",
+  "2xl": "(min-width: 1536px)"
+};
+var MEDIA_QUERIES_MAX = {
+  xs: "(max-width: 639px)",
+  sm: "(max-width: 767px)",
+  md: "(max-width: 1023px)",
+  lg: "(max-width: 1279px)",
+  xl: "(max-width: 1535px)",
+  "2xl": "(max-width: 9999px)"
+};
+var CONTAINER_WIDTHS = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536
+};
+var FILE_TYPE = {
+  IMAGE: "image",
+  VIDEO: "video",
+  AUDIO: "audio",
+  DOCUMENT: "document",
+  SPREADSHEET: "spreadsheet",
+  PRESENTATION: "presentation",
+  ARCHIVE: "archive",
+  CODE: "code",
+  OTHER: "other"
+};
+var NOTIFICATION_TYPE = {
+  INFO: "info",
+  SUCCESS: "success",
+  WARNING: "warning",
+  ERROR: "error",
+  ALERT: "alert"
+};
+var THEME = {
+  LIGHT: "light",
+  DARK: "dark",
+  SYSTEM: "system"
+};
+var LOCALE = {
+  EN_US: "en-US",
+  EN_GB: "en-GB",
+  ES_ES: "es-ES",
+  FR_FR: "fr-FR",
+  DE_DE: "de-DE",
+  IT_IT: "it-IT",
+  PT_BR: "pt-BR",
+  JA_JP: "ja-JP",
+  ZH_CN: "zh-CN",
+  ZH_TW: "zh-TW",
+  KO_KR: "ko-KR",
+  HI_IN: "hi-IN",
+  AR_SA: "ar-SA",
+  RU_RU: "ru-RU"
+};
+var DATE_FORMAT = {
+  ISO: "yyyy-MM-dd",
+  US: "MM/dd/yyyy",
+  EU: "dd/MM/yyyy",
+  LONG: "MMMM d, yyyy",
+  SHORT: "MMM d, yyyy",
+  WITH_TIME: "yyyy-MM-dd HH:mm:ss",
+  RELATIVE: "relative"
+};
+var INTERVAL = {
+  DAILY: "daily",
+  WEEKLY: "weekly",
+  BIWEEKLY: "biweekly",
+  MONTHLY: "monthly",
+  QUARTERLY: "quarterly",
+  YEARLY: "yearly",
+  ONCE: "once"
+};
+var GENDER = {
+  MALE: "male",
+  FEMALE: "female",
+  OTHER: "other",
+  PREFER_NOT_TO_SAY: "prefer_not_to_say"
+};
+var ENUMS = {
+  STATUS: STATUS2,
+  USER_STATUS: USER_STATUS2,
+  ORDER_STATUS,
+  PAYMENT_STATUS,
+  TASK_STATUS,
+  SUBSCRIPTION_STATUS,
+  SORT_DIRECTION,
+  SORT,
+  ROLE,
+  PERMISSION_LEVEL,
+  PRIORITY,
+  VISIBILITY,
+  BREAKPOINTS,
+  MEDIA_QUERIES,
+  MEDIA_QUERIES_MAX,
+  CONTAINER_WIDTHS,
+  FILE_TYPE,
+  NOTIFICATION_TYPE,
+  THEME,
+  LOCALE,
+  DATE_FORMAT,
+  INTERVAL,
+  GENDER
+};
+var enums_default = ENUMS;
 var parseDate = (date) => {
   if (date instanceof Date) return date;
   if (typeof date === "string") return dateFns.parseISO(date);
@@ -2273,27 +4920,137 @@ var VALIDATION_RULES = {
 // src/data/index.ts
 var data_exports = {};
 __export(data_exports, {
+  AADHAAR_INDIA: () => AADHAAR_INDIA,
+  ALPHANUMERIC: () => ALPHANUMERIC,
+  AMEX: () => AMEX,
+  APPS: () => APPS,
+  ARCHIVE_EXT: () => ARCHIVE_EXT,
+  AUDIO_EXT: () => AUDIO_EXT,
+  BASE64: () => BASE64,
+  BRANDS: () => BRANDS,
+  CARD_EXPIRY: () => CARD_EXPIRY,
+  CREDIT_CARD: () => CREDIT_CARD,
+  CUID: () => CUID,
+  CUID2: () => CUID2,
+  CVV: () => CVV,
+  DATETIME_ISO: () => DATETIME_ISO,
+  DATE_DMY: () => DATE_DMY,
+  DATE_ISO: () => DATE_ISO,
+  DATE_MDY: () => DATE_MDY,
+  DECIMAL: () => DECIMAL,
+  DISCOVER: () => DISCOVER,
+  DL_INDIA: () => DL_INDIA,
+  DOCUMENT_EXT: () => DOCUMENT_EXT,
+  DOMAIN: () => DOMAIN,
+  EMAIL: () => EMAIL,
+  EMAIL_COMMON_DOMAINS: () => EMAIL_COMMON_DOMAINS,
+  EMAIL_RFC5322: () => EMAIL_RFC5322,
+  EMOJI: () => EMOJI,
+  GST_INDIA: () => GST_INDIA,
+  HANDLE: () => HANDLE,
+  HASHTAG: () => HASHTAG,
+  HAS_DIGIT: () => HAS_DIGIT,
+  HAS_LOWERCASE: () => HAS_LOWERCASE,
+  HAS_SPECIAL: () => HAS_SPECIAL,
+  HAS_UPPERCASE: () => HAS_UPPERCASE,
+  HEX_COLOR: () => HEX_COLOR,
+  HEX_COLOR_ALPHA: () => HEX_COLOR_ALPHA,
+  HSL_COLOR: () => HSL_COLOR,
+  HTML_TAG: () => HTML_TAG,
+  IFSC_INDIA: () => IFSC_INDIA,
+  IMAGE_EXT: () => IMAGE_EXT,
+  IPV4: () => IPV4,
+  IPV6: () => IPV6,
+  JSON_STRING: () => JSON_STRING,
+  JWT: () => JWT,
+  LATITUDE: () => LATITUDE,
+  LETTERS_ONLY: () => LETTERS_ONLY,
+  LOCALHOST: () => LOCALHOST,
+  LONGITUDE: () => LONGITUDE,
+  MAC_ADDRESS: () => MAC_ADDRESS,
+  MASTERCARD: () => MASTERCARD,
+  MENTION: () => MENTION,
+  MONGO_OBJECT_ID: () => MONGO_OBJECT_ID,
+  NANOID: () => NANOID,
+  NON_NEGATIVE_INTEGER: () => NON_NEGATIVE_INTEGER,
+  NO_SPECIAL_CHARS: () => NO_SPECIAL_CHARS,
+  NO_WHITESPACE: () => NO_WHITESPACE,
+  NUMBERS_ONLY: () => NUMBERS_ONLY,
+  PAN_INDIA: () => PAN_INDIA,
+  PASSWORD_ALPHANUMERIC: () => PASSWORD_ALPHANUMERIC,
+  PASSWORD_MEDIUM: () => PASSWORD_MEDIUM,
+  PASSWORD_MIN_8: () => PASSWORD_MIN_8,
+  PASSWORD_STRONG: () => PASSWORD_STRONG,
+  PASSWORD_VERY_STRONG: () => PASSWORD_VERY_STRONG,
+  PHONE_10_DIGIT: () => PHONE_10_DIGIT,
+  PHONE_INDIA: () => PHONE_INDIA,
+  PHONE_INTERNATIONAL: () => PHONE_INTERNATIONAL,
+  PHONE_UK: () => PHONE_UK,
+  PHONE_US: () => PHONE_US,
+  PHONE_WITH_CODE: () => PHONE_WITH_CODE,
+  PIN_INDIA: () => PIN_INDIA,
+  PLZ_GERMANY: () => PLZ_GERMANY,
+  POSITIVE_INTEGER: () => POSITIVE_INTEGER,
+  POSTAL_CANADA: () => POSTAL_CANADA,
+  POSTAL_GENERIC: () => POSTAL_GENERIC,
+  POSTAL_UK: () => POSTAL_UK,
+  REGEX: () => regex_default,
+  RGBA_COLOR: () => RGBA_COLOR,
+  RGB_COLOR: () => RGB_COLOR,
+  SAFE_FILENAME: () => SAFE_FILENAME,
+  SEMVER: () => SEMVER,
+  SLUG: () => SLUG,
+  SSN_US: () => SSN_US,
+  SUBDOMAIN: () => SUBDOMAIN,
+  TIME_12H: () => TIME_12H,
+  TIME_24H: () => TIME_24H,
+  TIME_24H_SECONDS: () => TIME_24H_SECONDS,
+  URL_BASIC: () => URL_BASIC,
+  URL_OPTIONAL_PROTOCOL: () => URL_OPTIONAL_PROTOCOL,
+  URL_STRICT: () => URL_STRICT,
+  USERNAME: () => USERNAME,
+  USERNAME_ALPHA_START: () => USERNAME_ALPHA_START,
+  UUID: () => UUID,
+  UUID_V4: () => UUID_V4,
+  VEHICLE_INDIA: () => VEHICLE_INDIA,
+  VIDEO_EXT: () => VIDEO_EXT,
+  VISA: () => VISA,
+  ZIP_US: () => ZIP_US,
   brands: () => logos_default,
+  codeToFlag: () => codeToFlag,
   countries: () => countries_default,
+  createAppConfig: () => createAppConfig,
   currencies: () => currencies_default,
+  detectCurrentBrand: () => detectCurrentBrand,
   formatCurrency: () => formatCurrency,
   formatCurrencyNative: () => formatCurrencyNative,
+  getAllBrandIds: () => getAllBrandIds,
   getAllBrandKeys: () => getAllBrandKeys,
-  getAllBrands: () => getAllBrands,
+  getAllBrands: () => getAllBrands2,
   getAllCities: () => getAllCities,
+  getAllCountriesWithFlags: () => getAllCountriesWithFlags,
+  getAppConfigByDomain: () => getAppConfigByDomain,
   getBrand: () => getBrand,
-  getBrandByDomain: () => getBrandByDomain,
+  getBrandByDomain: () => getBrandByDomain2,
+  getBrandById: () => getBrandById,
   getCitiesByState: () => getCitiesByState,
   getCountriesByContinent: () => getCountriesByContinent,
   getCountryByCode: () => getCountryByCode,
   getCountryByName: () => getCountryByName,
+  getCountryWithFlag: () => getCountryWithFlag,
   getCurrencyByCode: () => getCurrencyByCode,
-  getLogo: () => getLogo,
+  getFlag: () => getFlag,
+  getLegacyAllBrands: () => getAllBrands,
+  getLegacyBrandByDomain: () => getBrandByDomain,
+  getLegacyLogo: () => getLogo,
+  getLogo: () => getLogo2,
   getPhoneCodeByCountry: () => getPhoneCodeByCountry,
   getPhoneCodesByPrefix: () => getPhoneCodesByPrefix,
   getStatesByCountry: () => getStatesByCountry,
+  getThemedLogo: () => getThemedLogo,
   getTimezoneByName: () => getTimezoneByName,
   getTimezonesByOffset: () => getTimezonesByOffset,
+  legacyBrands: () => brands,
   phoneCodes: () => phone_codes_default,
   searchCountries: () => searchCountries,
   searchCurrencies: () => searchCurrencies,
@@ -2304,11 +5061,16 @@ __export(data_exports, {
 });
 
 // src/data/countries.ts
+var codeToFlag = (countryCode) => {
+  const codePoints = countryCode.toUpperCase().split("").map((char) => 127397 + char.charCodeAt(0));
+  return String.fromCodePoint(...codePoints);
+};
 var countries = [
   {
     name: "Afghanistan",
     code: "AF",
     code3: "AFG",
+    flag: "\u{1F1E6}\u{1F1EB}",
     phoneCode: "+93",
     currency: "AFN",
     currencySymbol: "\u060B",
@@ -2325,6 +5087,7 @@ var countries = [
     name: "Albania",
     code: "AL",
     code3: "ALB",
+    flag: "\u{1F1E6}\u{1F1F1}",
     phoneCode: "+355",
     currency: "ALL",
     currencySymbol: "L",
@@ -2340,6 +5103,7 @@ var countries = [
     name: "Algeria",
     code: "DZ",
     code3: "DZA",
+    flag: "\u{1F1E9}\u{1F1FF}",
     phoneCode: "+213",
     currency: "DZD",
     currencySymbol: "\u062F.\u062C",
@@ -2355,6 +5119,7 @@ var countries = [
     name: "Argentina",
     code: "AR",
     code3: "ARG",
+    flag: "\u{1F1E6}\u{1F1F7}",
     phoneCode: "+54",
     currency: "ARS",
     currencySymbol: "$",
@@ -2371,6 +5136,7 @@ var countries = [
     name: "Australia",
     code: "AU",
     code3: "AUS",
+    flag: "\u{1F1E6}\u{1F1FA}",
     phoneCode: "+61",
     currency: "AUD",
     currencySymbol: "$",
@@ -2392,6 +5158,7 @@ var countries = [
     name: "Austria",
     code: "AT",
     code3: "AUT",
+    flag: "\u{1F1E6}\u{1F1F9}",
     phoneCode: "+43",
     currency: "EUR",
     currencySymbol: "\u20AC",
@@ -2408,6 +5175,7 @@ var countries = [
     name: "Bangladesh",
     code: "BD",
     code3: "BGD",
+    flag: "\u{1F1E7}\u{1F1E9}",
     phoneCode: "+880",
     currency: "BDT",
     currencySymbol: "\u09F3",
@@ -2426,6 +5194,7 @@ var countries = [
     name: "Belgium",
     code: "BE",
     code3: "BEL",
+    flag: "\u{1F1E7}\u{1F1EA}",
     phoneCode: "+32",
     currency: "EUR",
     currencySymbol: "\u20AC",
@@ -2442,6 +5211,7 @@ var countries = [
     name: "Brazil",
     code: "BR",
     code3: "BRA",
+    flag: "\u{1F1E7}\u{1F1F7}",
     phoneCode: "+55",
     currency: "BRL",
     currencySymbol: "R$",
@@ -2462,6 +5232,7 @@ var countries = [
     name: "Canada",
     code: "CA",
     code3: "CAN",
+    flag: "\u{1F1E8}\u{1F1E6}",
     phoneCode: "+1",
     currency: "CAD",
     currencySymbol: "$",
@@ -3240,6 +6011,21 @@ var searchCountries = (query) => {
     (c) => c.name.toLowerCase().includes(lowerQuery) || c.code.toLowerCase() === lowerQuery || c.code3.toLowerCase() === lowerQuery
   );
 };
+var getFlag = (countryCode) => {
+  const country = getCountryByCode(countryCode);
+  return country?.flag || codeToFlag(countryCode);
+};
+var getCountryWithFlag = (code) => {
+  const country = getCountryByCode(code);
+  if (!country) return void 0;
+  return { ...country, flag: country.flag || codeToFlag(country.code) };
+};
+var getAllCountriesWithFlags = () => {
+  return countries.map((c) => ({
+    ...c,
+    flag: c.flag || codeToFlag(c.code)
+  }));
+};
 var countries_default = countries;
 
 // src/data/phone-codes.ts
@@ -3686,6 +6472,211 @@ var sortTimezonesByOffset = (ascending = true) => {
 };
 var timezones_default = timezones;
 
+// src/data/regex.ts
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var EMAIL_RFC5322 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+var EMAIL_COMMON_DOMAINS = /^[^\s@]+@(gmail|yahoo|outlook|hotmail|icloud|proton|aol|mail)\.[a-z]{2,}$/i;
+var PASSWORD_MIN_8 = /^.{8,}$/;
+var PASSWORD_ALPHANUMERIC = /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/;
+var PASSWORD_MEDIUM = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d@$!%*?&]{8,}$/;
+var PASSWORD_STRONG = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+var PASSWORD_VERY_STRONG = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&^()_+=[\]{}|;:'"<>,.\/\\-])[A-Za-z\d@$!%*#?&^()_+=[\]{}|;:'"<>,.\/\\-]{12,}$/;
+var PHONE_INTERNATIONAL = /^\+?[1-9]\d{1,14}$/;
+var PHONE_US = /^(\+1)?[-.\s]?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}$/;
+var PHONE_INDIA = /^(\+91)?[-.\s]?[6-9]\d{9}$/;
+var PHONE_UK = /^(\+44)?[-.\s]?[0-9]{10,11}$/;
+var PHONE_10_DIGIT = /^\d{10}$/;
+var PHONE_WITH_CODE = /^\+?[\d\s\-().]{10,20}$/;
+var ZIP_US = /^\d{5}(-\d{4})?$/;
+var PIN_INDIA = /^[1-9][0-9]{5}$/;
+var POSTAL_UK = /^[A-Z]{1,2}\d[A-Z\d]?\s*\d[A-Z]{2}$/i;
+var POSTAL_CANADA = /^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i;
+var PLZ_GERMANY = /^\d{5}$/;
+var POSTAL_GENERIC = /^[A-Z0-9]{4,10}$/i;
+var UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var MONGO_OBJECT_ID = /^[0-9a-f]{24}$/i;
+var CUID = /^c[a-z0-9]{24}$/i;
+var CUID2 = /^[a-z][a-z0-9]{23}$/;
+var NANOID = /^[A-Za-z0-9_-]{21}$/;
+var AADHAAR_INDIA = /^[2-9]\d{11}$/;
+var PAN_INDIA = /^[A-Z]{5}[0-9]{4}[A-Z]$/;
+var GST_INDIA = /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z][1-9A-Z]Z[0-9A-Z]$/;
+var SSN_US = /^\d{3}-?\d{2}-?\d{4}$/;
+var DL_INDIA = /^[A-Z]{2}[0-9]{2}[0-9]{4}[0-9]{7}$/;
+var VEHICLE_INDIA = /^[A-Z]{2}[0-9]{2}[A-Z]{1,2}[0-9]{4}$/;
+var IFSC_INDIA = /^[A-Z]{4}0[A-Z0-9]{6}$/;
+var URL_BASIC = /^https?:\/\/[^\s$.?#].[^\s]*$/i;
+var URL_OPTIONAL_PROTOCOL = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([\/\w .-]*)*\/?$/i;
+var URL_STRICT = /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/;
+var DOMAIN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i;
+var SUBDOMAIN = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i;
+var LOCALHOST = /^(localhost|127\.0\.0\.1)(:\d{1,5})?$/;
+var SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var USERNAME = /^[a-zA-Z0-9_-]{3,30}$/;
+var USERNAME_ALPHA_START = /^[a-zA-Z][a-zA-Z0-9_-]{2,29}$/;
+var HANDLE = /^@?[a-zA-Z0-9_]{1,15}$/;
+var CREDIT_CARD = /^\d{13,19}$/;
+var VISA = /^4[0-9]{12}(?:[0-9]{3})?$/;
+var MASTERCARD = /^5[1-5][0-9]{14}$/;
+var AMEX = /^3[47][0-9]{13}$/;
+var DISCOVER = /^6(?:011|5[0-9]{2})[0-9]{12}$/;
+var CVV = /^\d{3,4}$/;
+var CARD_EXPIRY = /^(0[1-9]|1[0-2])\/(\d{2}|\d{4})$/;
+var DATE_ISO = /^\d{4}-\d{2}-\d{2}$/;
+var DATE_DMY = /^(0[1-9]|[12]\d|3[01])\/(0[1-9]|1[0-2])\/\d{4}$/;
+var DATE_MDY = /^(0[1-9]|1[0-2])\/(0[1-9]|[12]\d|3[01])\/\d{4}$/;
+var TIME_24H = /^([01]\d|2[0-3]):([0-5]\d)$/;
+var TIME_24H_SECONDS = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/;
+var TIME_12H = /^(0?[1-9]|1[0-2]):[0-5]\d\s?(AM|PM|am|pm)$/;
+var DATETIME_ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?$/;
+var IPV4 = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var IPV6 = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+var MAC_ADDRESS = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;
+var IMAGE_EXT = /\.(jpg|jpeg|png|gif|bmp|webp|svg|ico|tiff?)$/i;
+var VIDEO_EXT = /\.(mp4|webm|ogg|avi|mov|wmv|flv|mkv)$/i;
+var AUDIO_EXT = /\.(mp3|wav|ogg|aac|flac|wma|m4a)$/i;
+var DOCUMENT_EXT = /\.(pdf|doc|docx|xls|xlsx|ppt|pptx|txt|rtf|odt|ods|odp)$/i;
+var ARCHIVE_EXT = /\.(zip|rar|7z|tar|gz|bz2)$/i;
+var SAFE_FILENAME = /^[a-zA-Z0-9._-]+$/;
+var HEX_COLOR = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+var HEX_COLOR_ALPHA = /^#([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{4}|[A-Fa-f0-9]{3})$/;
+var RGB_COLOR = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;
+var RGBA_COLOR = /^rgba\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(0|1|0?\.\d+)\s*\)$/;
+var HSL_COLOR = /^hsl\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*\)$/;
+var ALPHANUMERIC = /^[a-zA-Z0-9]+$/;
+var LETTERS_ONLY = /^[a-zA-Z]+$/;
+var NUMBERS_ONLY = /^\d+$/;
+var DECIMAL = /^-?\d+(\.\d+)?$/;
+var POSITIVE_INTEGER = /^[1-9]\d*$/;
+var NON_NEGATIVE_INTEGER = /^\d+$/;
+var NO_WHITESPACE = /^\S+$/;
+var NO_SPECIAL_CHARS = /^[a-zA-Z0-9\s]+$/;
+var HAS_UPPERCASE = /[A-Z]/;
+var HAS_LOWERCASE = /[a-z]/;
+var HAS_DIGIT = /\d/;
+var HAS_SPECIAL = /[!@#$%^&*(),.?":{}|<>]/;
+var HTML_TAG = /<[^>]*>/g;
+var EMOJI = /[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F1E0}-\u{1F1FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]/u;
+var HASHTAG = /#[a-zA-Z0-9_]+/g;
+var MENTION = /@[a-zA-Z0-9_]+/g;
+var JSON_STRING = /^[\],:{}\s]*$/;
+var BASE64 = /^[A-Za-z0-9+/]+=*$/;
+var JWT = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var LATITUDE = /^-?([0-8]?[0-9]|90)(\.[0-9]{1,10})?$/;
+var LONGITUDE = /^-?([0-9]{1,2}|1[0-7][0-9]|180)(\.[0-9]{1,10})?$/;
+var REGEX = {
+  // Email
+  EMAIL,
+  EMAIL_RFC5322,
+  EMAIL_COMMON_DOMAINS,
+  // Password
+  PASSWORD_MIN_8,
+  PASSWORD_ALPHANUMERIC,
+  PASSWORD_MEDIUM,
+  PASSWORD_STRONG,
+  PASSWORD_VERY_STRONG,
+  // Phone
+  PHONE_INTERNATIONAL,
+  PHONE_US,
+  PHONE_INDIA,
+  PHONE_UK,
+  PHONE_10_DIGIT,
+  PHONE_WITH_CODE,
+  // Postal
+  ZIP_US,
+  PIN_INDIA,
+  POSTAL_UK,
+  POSTAL_CANADA,
+  PLZ_GERMANY,
+  POSTAL_GENERIC,
+  // IDs
+  UUID_V4,
+  UUID,
+  MONGO_OBJECT_ID,
+  CUID,
+  CUID2,
+  NANOID,
+  // Government IDs
+  AADHAAR_INDIA,
+  PAN_INDIA,
+  GST_INDIA,
+  SSN_US,
+  DL_INDIA,
+  VEHICLE_INDIA,
+  IFSC_INDIA,
+  // URL
+  URL_BASIC,
+  URL_OPTIONAL_PROTOCOL,
+  URL_STRICT,
+  DOMAIN,
+  SUBDOMAIN,
+  LOCALHOST,
+  // Slug & Username
+  SLUG,
+  USERNAME,
+  USERNAME_ALPHA_START,
+  HANDLE,
+  // Credit Card
+  CREDIT_CARD,
+  VISA,
+  MASTERCARD,
+  AMEX,
+  DISCOVER,
+  CVV,
+  CARD_EXPIRY,
+  // Date & Time
+  DATE_ISO,
+  DATE_DMY,
+  DATE_MDY,
+  TIME_24H,
+  TIME_24H_SECONDS,
+  TIME_12H,
+  DATETIME_ISO,
+  // IP
+  IPV4,
+  IPV6,
+  MAC_ADDRESS,
+  // File
+  IMAGE_EXT,
+  VIDEO_EXT,
+  AUDIO_EXT,
+  DOCUMENT_EXT,
+  ARCHIVE_EXT,
+  SAFE_FILENAME,
+  // Color
+  HEX_COLOR,
+  HEX_COLOR_ALPHA,
+  RGB_COLOR,
+  RGBA_COLOR,
+  HSL_COLOR,
+  // Misc
+  ALPHANUMERIC,
+  LETTERS_ONLY,
+  NUMBERS_ONLY,
+  DECIMAL,
+  POSITIVE_INTEGER,
+  NON_NEGATIVE_INTEGER,
+  NO_WHITESPACE,
+  NO_SPECIAL_CHARS,
+  HAS_UPPERCASE,
+  HAS_LOWERCASE,
+  HAS_DIGIT,
+  HAS_SPECIAL,
+  HTML_TAG,
+  EMOJI,
+  HASHTAG,
+  MENTION,
+  JSON_STRING,
+  BASE64,
+  JWT,
+  SEMVER,
+  LATITUDE,
+  LONGITUDE
+};
+var regex_default = REGEX;
+
 // src/data/logos.ts
 var brands = {
   botify: {
@@ -3798,6 +6789,222 @@ var getAllBrandKeys = () => {
 };
 var logos_default = brands;
 
+// src/data/brand-identity.ts
+var BRANDS = {
+  botify: {
+    id: "botify",
+    name: "Botify",
+    tagline: "AI-Powered Chatbots",
+    domain: "botify.life",
+    logo: {
+      light: "https://botify.life/logos/botify-full-light.svg",
+      dark: "https://botify.life/logos/botify-full-dark.svg",
+      logoOnly: "https://botify.life/logos/botify-icon-light.svg",
+      darkLogoOnly: "https://botify.life/logos/botify-icon-dark.svg",
+      favicon: "https://botify.life/favicon.ico"
+    },
+    colors: {
+      primary: "#6366F1",
+      secondary: "#8B5CF6",
+      accent: "#A78BFA"
+    },
+    contact: {
+      supportEmail: "support@botify.life",
+      salesEmail: "sales@botify.life"
+    },
+    social: {
+      twitter: "https://twitter.com/botifylife",
+      github: "https://github.com/botifylife"
+    },
+    seo: {
+      title: "Botify - AI-Powered Chatbots",
+      description: "Create intelligent chatbots with Botify. AI-powered conversations for your business.",
+      keywords: ["chatbot", "AI", "conversational AI", "customer support", "automation"]
+    }
+  },
+  exyconn: {
+    id: "exyconn",
+    name: "Exyconn",
+    tagline: "Connect. Create. Collaborate.",
+    domain: "exyconn.com",
+    logo: {
+      light: "https://exyconn.com/logos/exyconn-full-light.svg",
+      dark: "https://exyconn.com/logos/exyconn-full-dark.svg",
+      logoOnly: "https://exyconn.com/logos/exyconn-icon-light.svg",
+      darkLogoOnly: "https://exyconn.com/logos/exyconn-icon-dark.svg",
+      favicon: "https://exyconn.com/favicon.ico"
+    },
+    colors: {
+      primary: "#0EA5E9",
+      secondary: "#06B6D4",
+      accent: "#22D3EE"
+    },
+    contact: {
+      supportEmail: "support@exyconn.com",
+      salesEmail: "sales@exyconn.com"
+    },
+    social: {
+      twitter: "https://twitter.com/exyconn",
+      linkedin: "https://linkedin.com/company/exyconn",
+      github: "https://github.com/exyconn"
+    },
+    seo: {
+      title: "Exyconn - Connect. Create. Collaborate.",
+      description: "The platform that brings teams together. Connect, create, and collaborate seamlessly.",
+      keywords: ["collaboration", "team", "productivity", "communication", "workspace"]
+    }
+  },
+  partywings: {
+    id: "partywings",
+    name: "PartyWings",
+    tagline: "Your Party, Your Rules",
+    domain: "partywings.fun",
+    logo: {
+      light: "https://partywings.fun/logos/partywings-full-light.svg",
+      dark: "https://partywings.fun/logos/partywings-full-dark.svg",
+      logoOnly: "https://partywings.fun/logos/partywings-icon-light.svg",
+      darkLogoOnly: "https://partywings.fun/logos/partywings-icon-dark.svg",
+      favicon: "https://partywings.fun/favicon.ico"
+    },
+    colors: {
+      primary: "#EC4899",
+      secondary: "#F472B6",
+      accent: "#F9A8D4"
+    },
+    contact: {
+      supportEmail: "support@partywings.fun"
+    },
+    social: {
+      instagram: "https://instagram.com/partywingsfun",
+      tiktok: "https://tiktok.com/@partywingsfun"
+    },
+    seo: {
+      title: "PartyWings - Your Party, Your Rules",
+      description: "Plan unforgettable parties and events. Your party, your rules with PartyWings.",
+      keywords: ["party", "events", "celebration", "planning", "entertainment"]
+    }
+  },
+  sibera: {
+    id: "sibera",
+    name: "Sibera",
+    tagline: "Work Smarter, Together",
+    domain: "sibera.work",
+    logo: {
+      light: "https://sibera.work/logos/sibera-full-light.svg",
+      dark: "https://sibera.work/logos/sibera-full-dark.svg",
+      logoOnly: "https://sibera.work/logos/sibera-icon-light.svg",
+      darkLogoOnly: "https://sibera.work/logos/sibera-icon-dark.svg",
+      favicon: "https://sibera.work/favicon.ico"
+    },
+    colors: {
+      primary: "#10B981",
+      secondary: "#34D399",
+      accent: "#6EE7B7"
+    },
+    contact: {
+      supportEmail: "support@sibera.work",
+      salesEmail: "sales@sibera.work"
+    },
+    social: {
+      twitter: "https://twitter.com/siberawork",
+      linkedin: "https://linkedin.com/company/sibera"
+    },
+    seo: {
+      title: "Sibera - Work Smarter, Together",
+      description: "Streamline your workflow and collaborate efficiently with Sibera.",
+      keywords: ["work management", "productivity", "team collaboration", "project management"]
+    }
+  },
+  spentiva: {
+    id: "spentiva",
+    name: "Spentiva",
+    tagline: "Smart Spending, Smart Living",
+    domain: "spentiva.com",
+    logo: {
+      light: "https://spentiva.com/logos/spentiva-full-light.svg",
+      dark: "https://spentiva.com/logos/spentiva-full-dark.svg",
+      logoOnly: "https://spentiva.com/logos/spentiva-icon-light.svg",
+      darkLogoOnly: "https://spentiva.com/logos/spentiva-icon-dark.svg",
+      favicon: "https://spentiva.com/favicon.ico"
+    },
+    colors: {
+      primary: "#F59E0B",
+      secondary: "#FBBF24",
+      accent: "#FCD34D"
+    },
+    contact: {
+      supportEmail: "support@spentiva.com",
+      salesEmail: "hello@spentiva.com"
+    },
+    social: {
+      twitter: "https://twitter.com/spentiva",
+      instagram: "https://instagram.com/spentiva"
+    },
+    seo: {
+      title: "Spentiva - Smart Spending, Smart Living",
+      description: "Take control of your finances with Spentiva. Smart spending for smart living.",
+      keywords: ["finance", "budgeting", "expense tracking", "money management", "personal finance"]
+    }
+  }
+};
+var APPS = {
+  BOTIFY: createAppConfig("botify"),
+  EXYCONN: createAppConfig("exyconn"),
+  PARTYWINGS: createAppConfig("partywings"),
+  SIBERA: createAppConfig("sibera"),
+  SPENTIVA: createAppConfig("spentiva")
+};
+function createAppConfig(brandId) {
+  const brand = BRANDS[brandId.toLowerCase()];
+  if (!brand) {
+    throw new Error(`Brand "${brandId}" not found`);
+  }
+  return {
+    name: brand.name,
+    tagline: brand.tagline,
+    domain: brand.domain,
+    supportEmail: brand.contact.supportEmail,
+    logo: brand.logo,
+    colors: brand.colors
+  };
+}
+function getBrandById(id) {
+  return BRANDS[id.toLowerCase()];
+}
+function getBrandByDomain2(domain) {
+  return Object.values(BRANDS).find((b) => b.domain === domain);
+}
+function getAllBrands2() {
+  return Object.values(BRANDS);
+}
+function getAllBrandIds() {
+  return Object.keys(BRANDS);
+}
+function getLogo2(brandId, variant) {
+  const brand = getBrandById(brandId);
+  return brand?.logo[variant];
+}
+function getThemedLogo(brandId, theme, iconOnly = false) {
+  const brand = getBrandById(brandId);
+  if (!brand) return void 0;
+  if (iconOnly) {
+    return theme === "light" ? brand.logo.logoOnly : brand.logo.darkLogoOnly;
+  }
+  return brand.logo[theme];
+}
+function getAppConfigByDomain(domain) {
+  const brand = getBrandByDomain2(domain);
+  if (!brand) return void 0;
+  return createAppConfig(brand.id);
+}
+function detectCurrentBrand() {
+  if (typeof window === "undefined") return void 0;
+  const hostname = window.location.hostname;
+  return Object.values(BRANDS).find(
+    (b) => hostname === b.domain || hostname.endsWith(`.${b.domain}`)
+  );
+}
+
 exports.client = client_exports;
 exports.data = data_exports;
 exports.server = server_exports;