@exyconn/common 1.0.0

package/dist/index.js

@@ -0,0 +1,3806 @@
+'use strict';
+
+var winston = require('winston');
+var DailyRotateFile = require('winston-daily-rotate-file');
+var path = require('path');
+var mongoose = require('mongoose');
+var jwt = require('jsonwebtoken');
+var axios = require('axios');
+var react = require('react');
+var dateFns = require('date-fns');
+var dateFnsTz = require('date-fns-tz');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var winston__default = /*#__PURE__*/_interopDefault(winston);
+var DailyRotateFile__default = /*#__PURE__*/_interopDefault(DailyRotateFile);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var mongoose__default = /*#__PURE__*/_interopDefault(mongoose);
+var jwt__default = /*#__PURE__*/_interopDefault(jwt);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  StatusCode: () => StatusCode,
+  StatusMessage: () => StatusMessage,
+  authenticateApiKey: () => authenticateApiKey,
+  authenticateJWT: () => authenticateJWT,
+  badRequestResponse: () => badRequestResponse,
+  buildFilter: () => buildFilter,
+  buildPagination: () => buildPagination,
+  buildPaginationMeta: () => buildPaginationMeta,
+  conflictResponse: () => conflictResponse,
+  connectDB: () => connectDB,
+  createLogger: () => createLogger,
+  createMorganStream: () => createMorganStream,
+  createdResponse: () => createdResponse,
+  disconnectDB: () => disconnectDB,
+  errorResponse: () => errorResponse,
+  extractColumns: () => extractColumns,
+  extractOrganization: () => extractOrganization,
+  forbiddenResponse: () => forbiddenResponse,
+  getConnectionStatus: () => getConnectionStatus,
+  logger: () => logger,
+  noContentResponse: () => noContentResponse,
+  notFoundResponse: () => notFoundResponse,
+  omitFields: () => omitFields,
+  optionalAuthenticateJWT: () => optionalAuthenticateJWT,
+  pickFields: () => pickFields,
+  rateLimitResponse: () => rateLimitResponse,
+  requireOrganization: () => requireOrganization,
+  sanitizeDocument: () => sanitizeDocument,
+  sanitizeUser: () => sanitizeUser,
+  simpleLogger: () => simpleLogger,
+  statusCode: () => statusCode,
+  statusMessage: () => statusMessage,
+  stream: () => stream,
+  successResponse: () => successResponse,
+  successResponseArr: () => successResponseArr,
+  unauthorizedResponse: () => unauthorizedResponse,
+  validationErrorResponse: () => validationErrorResponse
+});
+
+// src/server/enums/status.ts
+var StatusCode = /* @__PURE__ */ ((StatusCode2) => {
+  StatusCode2[StatusCode2["SUCCESS"] = 200] = "SUCCESS";
+  StatusCode2[StatusCode2["CREATED"] = 201] = "CREATED";
+  StatusCode2[StatusCode2["ACCEPTED"] = 202] = "ACCEPTED";
+  StatusCode2[StatusCode2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  StatusCode2[StatusCode2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  StatusCode2[StatusCode2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  StatusCode2[StatusCode2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  StatusCode2[StatusCode2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  StatusCode2[StatusCode2["CONFLICT"] = 409] = "CONFLICT";
+  StatusCode2[StatusCode2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  StatusCode2[StatusCode2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  StatusCode2[StatusCode2["INTERNAL_ERROR"] = 500] = "INTERNAL_ERROR";
+  StatusCode2[StatusCode2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  StatusCode2[StatusCode2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  StatusCode2[StatusCode2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  return StatusCode2;
+})(StatusCode || {});
+var StatusMessage = /* @__PURE__ */ ((StatusMessage2) => {
+  StatusMessage2["SUCCESS"] = "success";
+  StatusMessage2["CREATED"] = "created";
+  StatusMessage2["ACCEPTED"] = "accepted";
+  StatusMessage2["NO_CONTENT"] = "no-data-found";
+  StatusMessage2["BAD_REQUEST"] = "bad-request";
+  StatusMessage2["UNAUTHORIZED"] = "unauthorized";
+  StatusMessage2["FORBIDDEN"] = "forbidden";
+  StatusMessage2["NOT_FOUND"] = "not-found";
+  StatusMessage2["CONFLICT"] = "conflict";
+  StatusMessage2["UNPROCESSABLE_ENTITY"] = "validation-error";
+  StatusMessage2["TOO_MANY_REQUESTS"] = "rate-limit-exceeded";
+  StatusMessage2["INTERNAL_ERROR"] = "error";
+  StatusMessage2["NOT_IMPLEMENTED"] = "not-implemented";
+  StatusMessage2["BAD_GATEWAY"] = "bad-gateway";
+  StatusMessage2["SERVICE_UNAVAILABLE"] = "service-unavailable";
+  return StatusMessage2;
+})(StatusMessage || {});
+var statusCode = StatusCode;
+var statusMessage = StatusMessage;
+
+// src/server/response/response-object.ts
+var extractColumns = (data) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    return [];
+  }
+  const sample = data[0];
+  return Object.entries(sample).map(([key, value]) => {
+    let datatype = typeof value;
+    if (value === null) {
+      datatype = "null";
+    } else if (Array.isArray(value)) {
+      datatype = "array";
+    } else if (value instanceof Date) {
+      datatype = "date";
+    } else if (typeof value === "object") {
+      datatype = "object";
+    }
+    return {
+      name: key,
+      datatype,
+      required: value !== null && value !== void 0
+    };
+  });
+};
+var successResponse = (res, data, message = "Operation successful") => {
+  return res.status(200 /* SUCCESS */).json({
+    message,
+    data,
+    status: "success" /* SUCCESS */,
+    statusCode: 200 /* SUCCESS */
+  });
+};
+var successResponseArr = (res, data, paginationData = {}, message = "Operation successful") => {
+  return res.status(200 /* SUCCESS */).json({
+    message,
+    data,
+    columns: extractColumns(data),
+    paginationData,
+    status: "success" /* SUCCESS */,
+    statusCode: 200 /* SUCCESS */
+  });
+};
+var createdResponse = (res, data, message = "Resource created successfully") => {
+  return res.status(201 /* CREATED */).json({
+    message,
+    data,
+    status: "created" /* CREATED */,
+    statusCode: 201 /* CREATED */
+  });
+};
+var noContentResponse = (res, data = null, message = "No data found") => {
+  return res.status(200 /* SUCCESS */).json({
+    message,
+    data,
+    status: "no-data-found" /* NO_CONTENT */,
+    statusCode: 204 /* NO_CONTENT */
+  });
+};
+var badRequestResponse = (res, message = "Bad request", errors = null) => {
+  return res.status(400 /* BAD_REQUEST */).json({
+    message,
+    data: errors,
+    status: "bad-request" /* BAD_REQUEST */,
+    statusCode: 400 /* BAD_REQUEST */
+  });
+};
+var unauthorizedResponse = (res, message = "Unauthorized access") => {
+  return res.status(401 /* UNAUTHORIZED */).json({
+    message,
+    data: null,
+    status: "unauthorized" /* UNAUTHORIZED */,
+    statusCode: 401 /* UNAUTHORIZED */
+  });
+};
+var forbiddenResponse = (res, message = "Access forbidden") => {
+  return res.status(403 /* FORBIDDEN */).json({
+    message,
+    data: null,
+    status: "forbidden" /* FORBIDDEN */,
+    statusCode: 403 /* FORBIDDEN */
+  });
+};
+var notFoundResponse = (res, message = "Resource not found") => {
+  return res.status(404 /* NOT_FOUND */).json({
+    message,
+    data: null,
+    status: "not-found" /* NOT_FOUND */,
+    statusCode: 404 /* NOT_FOUND */
+  });
+};
+var conflictResponse = (res, message = "Resource conflict") => {
+  return res.status(409 /* CONFLICT */).json({
+    message,
+    data: null,
+    status: "conflict" /* CONFLICT */,
+    statusCode: 409 /* CONFLICT */
+  });
+};
+var validationErrorResponse = (res, errors, message = "Validation failed") => {
+  return res.status(422 /* UNPROCESSABLE_ENTITY */).json({
+    message,
+    data: errors,
+    status: "validation-error" /* UNPROCESSABLE_ENTITY */,
+    statusCode: 422 /* UNPROCESSABLE_ENTITY */
+  });
+};
+var errorResponse = (res, error = null, message = "Something went wrong") => {
+  return res.status(500 /* INTERNAL_ERROR */).json({
+    message,
+    data: error,
+    status: "error" /* INTERNAL_ERROR */,
+    statusCode: 500 /* INTERNAL_ERROR */
+  });
+};
+var rateLimitResponse = (res, message = "Too many requests, please try again later") => {
+  return res.status(429 /* TOO_MANY_REQUESTS */).json({
+    message,
+    data: null,
+    status: "rate-limit-exceeded" /* TOO_MANY_REQUESTS */,
+    statusCode: 429 /* TOO_MANY_REQUESTS */
+  });
+};
+var defaultConfig = {
+  level: process.env.LOG_LEVEL || "info",
+  logsDir: "logs",
+  maxSize: "20m",
+  maxFiles: "14d",
+  errorMaxFiles: "30d"
+};
+var levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4
+};
+var colors = {
+  error: "red",
+  warn: "yellow",
+  info: "green",
+  http: "magenta",
+  debug: "blue"
+};
+winston__default.default.addColors(colors);
+var fileFormat = winston__default.default.format.combine(
+  winston__default.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+  winston__default.default.format.errors({ stack: true }),
+  winston__default.default.format.splat(),
+  winston__default.default.format.json()
+);
+var consoleFormat = winston__default.default.format.combine(
+  winston__default.default.format.colorize({ all: true }),
+  winston__default.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+  winston__default.default.format.printf((info) => {
+    const timestamp = info.timestamp;
+    const level = info.level;
+    const message = info.message;
+    const stack = info.stack;
+    return `${timestamp} [${level}]: ${message}${stack ? "\n" + stack : ""}`;
+  })
+);
+var createLogger = (config = {}) => {
+  const finalConfig = { ...defaultConfig, ...config };
+  const transports = [
+    // Console transport
+    new winston__default.default.transports.Console({
+      format: consoleFormat
+    }),
+    // Combined logs (all levels)
+    new DailyRotateFile__default.default({
+      filename: path__default.default.join(finalConfig.logsDir, "combined-%DATE%.log"),
+      datePattern: "YYYY-MM-DD",
+      maxSize: finalConfig.maxSize,
+      maxFiles: finalConfig.maxFiles,
+      format: fileFormat
+    }),
+    // Error logs only
+    new DailyRotateFile__default.default({
+      filename: path__default.default.join(finalConfig.logsDir, "error-%DATE%.log"),
+      datePattern: "YYYY-MM-DD",
+      level: "error",
+      maxSize: finalConfig.maxSize,
+      maxFiles: finalConfig.errorMaxFiles,
+      format: fileFormat
+    })
+  ];
+  return winston__default.default.createLogger({
+    level: finalConfig.level,
+    levels,
+    format: fileFormat,
+    transports,
+    exitOnError: false
+  });
+};
+var logger = createLogger();
+var createMorganStream = (loggerInstance) => ({
+  write: (message) => {
+    loggerInstance.http(message.trim());
+  }
+});
+var stream = createMorganStream(logger);
+var serializeMeta = (meta) => {
+  if (meta === void 0 || meta === null) return "";
+  if (meta instanceof Error) {
+    return JSON.stringify({ message: meta.message, stack: meta.stack }, null, 2);
+  }
+  try {
+    return JSON.stringify(meta, null, 2);
+  } catch {
+    return String(meta);
+  }
+};
+var simpleLogger = {
+  info: (message, meta) => {
+    console.log(`[INFO] ${message}`, serializeMeta(meta));
+  },
+  error: (message, meta) => {
+    console.error(`[ERROR] ${message}`, serializeMeta(meta));
+  },
+  warn: (message, meta) => {
+    console.warn(`[WARN] ${message}`, serializeMeta(meta));
+  },
+  debug: (message, meta) => {
+    console.debug(`[DEBUG] ${message}`, serializeMeta(meta));
+  }
+};
+var defaultOptions = {
+  maxPoolSize: process.env.NODE_ENV === "production" ? 50 : 10,
+  minPoolSize: process.env.NODE_ENV === "production" ? 10 : 5,
+  socketTimeoutMS: 45e3,
+  serverSelectionTimeoutMS: 1e4,
+  maxIdleTimeMS: 1e4,
+  retryWrites: true,
+  retryReads: true,
+  w: "majority"
+};
+var connectDB = async (mongoUri, options = {}, logger2) => {
+  if (mongoose__default.default.connection.readyState === 1) {
+    logger2?.info("Database already connected, reusing connection");
+    return mongoose__default.default;
+  }
+  const finalOptions = { ...defaultOptions, ...options };
+  try {
+    await mongoose__default.default.connect(mongoUri, finalOptions);
+    logger2?.info("MongoDB connected successfully");
+    mongoose__default.default.connection.on("error", (err) => {
+      logger2?.error("MongoDB connection error", err);
+    });
+    mongoose__default.default.connection.on("disconnected", () => {
+      logger2?.info("MongoDB disconnected");
+    });
+    mongoose__default.default.connection.on("reconnected", () => {
+      logger2?.info("MongoDB reconnected");
+    });
+    return mongoose__default.default;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger2?.error("MongoDB connection failed", { error: errorMessage });
+    throw error;
+  }
+};
+var disconnectDB = async (logger2) => {
+  try {
+    await mongoose__default.default.disconnect();
+    logger2?.info("MongoDB disconnected successfully");
+  } catch (error) {
+    logger2?.error("Error disconnecting from MongoDB", error);
+    throw error;
+  }
+};
+var getConnectionStatus = () => {
+  const states = {
+    0: "disconnected",
+    1: "connected",
+    2: "connecting",
+    3: "disconnecting"
+  };
+  return states[mongoose__default.default.connection.readyState] || "unknown";
+};
+var authenticateJWT = (secretKey) => {
+  return (req, res, next) => {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      unauthorizedResponse(res, "Authorization header missing or malformed");
+      return;
+    }
+    const token = authHeader.split(" ")[1];
+    try {
+      const decoded = jwt__default.default.verify(token, secretKey);
+      req.userId = decoded.userId;
+      req.organizationId = decoded.organizationId;
+      req.user = decoded;
+      if (!decoded.userId) {
+        unauthorizedResponse(res, "User ID not found in token");
+        return;
+      }
+      next();
+    } catch (err) {
+      if (err instanceof jwt__default.default.TokenExpiredError) {
+        unauthorizedResponse(res, "Token has expired");
+        return;
+      }
+      if (err instanceof jwt__default.default.JsonWebTokenError) {
+        forbiddenResponse(res, "Invalid token");
+        return;
+      }
+      unauthorizedResponse(res, "Token validation failed");
+    }
+  };
+};
+var optionalAuthenticateJWT = (secretKey) => {
+  return (req, _res, next) => {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      next();
+      return;
+    }
+    const token = authHeader.split(" ")[1];
+    try {
+      const decoded = jwt__default.default.verify(token, secretKey);
+      req.userId = decoded.userId;
+      req.organizationId = decoded.organizationId;
+      req.user = decoded;
+    } catch {
+    }
+    next();
+  };
+};
+var authenticateApiKey = (validateKeyFn) => {
+  return async (req, res, next) => {
+    try {
+      const apiKey = req.headers["x-api-key"];
+      if (!apiKey) {
+        unauthorizedResponse(res, "API key is required. Please provide x-api-key header");
+        return;
+      }
+      const validation = await validateKeyFn(apiKey);
+      if (!validation.valid) {
+        unauthorizedResponse(res, "Invalid or inactive API key");
+        return;
+      }
+      if (validation.organizationId) {
+        req.organizationId = validation.organizationId;
+      }
+      if (validation.keyId && validation.keyName) {
+        req.apiKey = {
+          _id: validation.keyId,
+          name: validation.keyName
+        };
+      }
+      next();
+    } catch {
+      unauthorizedResponse(res, "API key validation failed");
+    }
+  };
+};
+var extractOrganization = (req, _res, next) => {
+  const orgId = req.headers["x-organization-id"];
+  if (orgId) {
+    req.organizationId = orgId;
+  }
+  next();
+};
+var requireOrganization = (req, res, next) => {
+  if (!req.organizationId) {
+    unauthorizedResponse(res, "Organization ID is required");
+    return;
+  }
+  next();
+};
+
+// src/server/utils/filter-builder.ts
+var buildFilter = (options) => {
+  const {
+    organizationId,
+    search,
+    searchFields = [],
+    dateField = "createdAt",
+    startDate,
+    endDate,
+    status,
+    isActive,
+    ...additionalFilters
+  } = options;
+  const filter = {};
+  if (organizationId) {
+    filter.organizationId = organizationId;
+  }
+  if (search && search.trim().length >= 2 && searchFields.length > 0) {
+    const searchRegex = new RegExp(search.trim(), "i");
+    filter.$or = searchFields.map((field) => ({ [field]: searchRegex }));
+  }
+  if (startDate || endDate) {
+    filter[dateField] = {};
+    if (startDate) {
+      filter[dateField].$gte = new Date(startDate);
+    }
+    if (endDate) {
+      filter[dateField].$lte = new Date(endDate);
+    }
+  }
+  if (status !== void 0) {
+    filter.status = status;
+  }
+  if (isActive !== void 0) {
+    filter.isActive = isActive;
+  }
+  Object.entries(additionalFilters).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null && value !== "") {
+      filter[key] = value;
+    }
+  });
+  return filter;
+};
+var buildPagination = (options) => {
+  const { page = 1, limit, defaultLimit = 10, maxLimit = 100 } = options;
+  const finalPage = Math.max(1, page);
+  const finalLimit = Math.min(maxLimit, Math.max(1, limit || defaultLimit));
+  const skip = (finalPage - 1) * finalLimit;
+  return {
+    skip,
+    limit: finalLimit,
+    page: finalPage
+  };
+};
+var buildPaginationMeta = (total, page, limit) => {
+  const totalPages = Math.ceil(total / limit);
+  return {
+    total,
+    page,
+    limit,
+    totalPages,
+    hasNextPage: page < totalPages,
+    hasPrevPage: page > 1
+  };
+};
+
+// src/server/utils/sanitize.ts
+var sanitizeUser = (user, additionalFieldsToRemove = []) => {
+  if (!user) return null;
+  const fieldsToRemove = ["password", "__v", "_id", ...additionalFieldsToRemove];
+  const obj = typeof user.toObject === "function" ? user.toObject() : { ...user };
+  fieldsToRemove.forEach((field) => {
+    delete obj[field];
+  });
+  return obj;
+};
+var sanitizeDocument = (doc, fieldsToRemove) => {
+  if (!doc) return null;
+  const obj = typeof doc.toObject === "function" ? doc.toObject() : { ...doc };
+  fieldsToRemove.forEach((field) => {
+    delete obj[field];
+  });
+  return obj;
+};
+var pickFields = (obj, fieldsToPick) => {
+  if (!obj) return null;
+  const result = {};
+  fieldsToPick.forEach((field) => {
+    if (field in obj) {
+      result[field] = obj[field];
+    }
+  });
+  return result;
+};
+var omitFields = (obj, fieldsToOmit) => {
+  if (!obj) return null;
+  const result = { ...obj };
+  fieldsToOmit.forEach((field) => {
+    delete result[field];
+  });
+  return result;
+};
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  ApiUrlBuilder: () => ApiUrlBuilder,
+  ClientLogger: () => ClientLogger,
+  EventEmitter: () => EventEmitter,
+  addDays: () => addDays,
+  appEvents: () => appEvents,
+  camelToKebab: () => camelToKebab,
+  capitalize: () => capitalize,
+  capitalizeWords: () => capitalizeWords,
+  clientLogger: () => clientLogger,
+  copyToClipboard: () => copyToClipboard,
+  createApiEndpoints: () => createApiEndpoints,
+  createApiUrlBuilder: () => createApiUrlBuilder,
+  createClientLogger: () => createClientLogger,
+  createEmptyPaginationMeta: () => createEmptyPaginationMeta,
+  createErrorResponse: () => createErrorResponse,
+  createEventEmitter: () => createEventEmitter,
+  createHttpClient: () => createHttpClient,
+  createSuccessResponse: () => createSuccessResponse,
+  endOfDay: () => endOfDay,
+  formatDate: () => formatDate,
+  formatDateForInput: () => formatDateForInput,
+  formatDateTime: () => formatDateTime,
+  formatDateTimeForInput: () => formatDateTimeForInput,
+  formatRelativeTime: () => formatRelativeTime,
+  getErrorMessage: () => getErrorMessage,
+  getNextPage: () => getNextPage,
+  getPrevPage: () => getPrevPage,
+  getResponseData: () => getResponseData,
+  hasData: () => hasData,
+  hasMorePages: () => hasMorePages,
+  isClipboardAvailable: () => isClipboardAvailable,
+  isErrorResponse: () => isErrorResponse,
+  isForbidden: () => isForbidden,
+  isFuture: () => isFuture,
+  isNotFound: () => isNotFound,
+  isPast: () => isPast,
+  isServerError: () => isServerError,
+  isStatusError: () => isStatusError,
+  isSuccess: () => isSuccess,
+  isSuccessResponse: () => isSuccessResponse,
+  isToday: () => isToday,
+  isUnauthorized: () => isUnauthorized,
+  kebabToCamel: () => kebabToCamel,
+  parseError: () => parseError,
+  parseFullResponse: () => parseFullResponse,
+  parseResponse: () => parseResponse,
+  readFromClipboard: () => readFromClipboard,
+  slugify: () => slugify,
+  slugifyUnique: () => slugifyUnique,
+  startOfDay: () => startOfDay,
+  truncate: () => truncate,
+  truncateWords: () => truncateWords,
+  unslugify: () => unslugify,
+  useCopyToClipboard: () => useCopyToClipboard_default,
+  useDebounce: () => useDebounce_default,
+  useInterval: () => useInterval_default,
+  useIsDesktop: () => useIsDesktop,
+  useIsMobile: () => useIsMobile,
+  useIsMobileOrTablet: () => useIsMobileOrTablet,
+  useIsTablet: () => useIsTablet,
+  useLocalStorage: () => useLocalStorage_default,
+  useMediaQuery: () => useMediaQuery_default,
+  useOnClickOutside: () => useOnClickOutside_default,
+  usePageTitle: () => usePageTitle_default,
+  useSnackbar: () => useSnackbar_default,
+  useThemeDetector: () => useThemeDetector_default,
+  useWindowSize: () => useWindowSize_default,
+  withAbortSignal: () => withAbortSignal,
+  withFormData: () => withFormData,
+  withTimeout: () => withTimeout
+});
+var createHttpClient = (options) => {
+  const {
+    baseURL,
+    timeout = 3e4,
+    withCredentials = true,
+    getAuthToken,
+    onUnauthorized,
+    onServerError
+  } = options;
+  const instance = axios__default.default.create({
+    baseURL,
+    timeout,
+    withCredentials,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  instance.interceptors.request.use(
+    (config) => {
+      if (getAuthToken) {
+        const token = getAuthToken();
+        if (token && config.headers) {
+          config.headers.Authorization = `Bearer ${token}`;
+        }
+      }
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (error.response) {
+        const status = error.response.status;
+        if (status === 401 && onUnauthorized) {
+          onUnauthorized();
+        }
+        if (status >= 500 && onServerError) {
+          onServerError(error);
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return instance;
+};
+var withFormData = () => ({
+  headers: {
+    "Content-Type": "multipart/form-data"
+  }
+});
+var withTimeout = (ms) => ({
+  timeout: ms
+});
+var withAbortSignal = (signal) => ({
+  signal
+});
+
+// src/client/http/response-parser.ts
+var parseResponse = (response) => {
+  if (response.data?.success && response.data?.data !== void 0) {
+    return response.data.data;
+  }
+  return null;
+};
+var parseFullResponse = (response) => {
+  return response.data;
+};
+var parseError = (error) => {
+  if (error.response?.data?.message) {
+    return error.response.data.message;
+  }
+  if (error.response?.data?.error) {
+    return error.response.data.error;
+  }
+  if (error.code === "ERR_NETWORK") {
+    return "Network error. Please check your connection.";
+  }
+  if (error.code === "ECONNABORTED") {
+    return "Request timed out. Please try again.";
+  }
+  return error.message || "An unexpected error occurred.";
+};
+var isSuccess = (response) => {
+  return response.data?.success === true;
+};
+var isStatusError = (error, statusCode2) => {
+  return error.response?.status === statusCode2;
+};
+var isUnauthorized = (error) => {
+  return isStatusError(error, 401);
+};
+var isForbidden = (error) => {
+  return isStatusError(error, 403);
+};
+var isNotFound = (error) => {
+  return isStatusError(error, 404);
+};
+var isServerError = (error) => {
+  const status = error.response?.status;
+  return status !== void 0 && status >= 500;
+};
+
+// src/client/logger/client-logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var ClientLogger = class {
+  constructor(config = {}) {
+    this.buffer = [];
+    this.config = {
+      enabled: config.enabled ?? process.env.NODE_ENV !== "production",
+      minLevel: config.minLevel ?? "debug",
+      prefix: config.prefix ?? "[App]",
+      includeTimestamp: config.includeTimestamp ?? true,
+      remoteLogging: config.remoteLogging
+    };
+    if (this.config.remoteLogging?.enabled) {
+      const interval = this.config.remoteLogging.flushInterval ?? 3e4;
+      this.flushTimer = setInterval(() => this.flush(), interval);
+    }
+  }
+  shouldLog(level) {
+    if (!this.config.enabled) return false;
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.config.minLevel];
+  }
+  formatMessage(level, message) {
+    const parts = [];
+    if (this.config.includeTimestamp) {
+      parts.push(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
+    }
+    parts.push(this.config.prefix);
+    parts.push(`[${level.toUpperCase()}]`);
+    parts.push(message);
+    return parts.join(" ");
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level)) return;
+    const formattedMessage = this.formatMessage(level, message);
+    const entry = {
+      level,
+      message,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      prefix: this.config.prefix
+    };
+    switch (level) {
+      case "debug":
+        console.debug(formattedMessage, data ?? "");
+        break;
+      case "info":
+        console.info(formattedMessage, data ?? "");
+        break;
+      case "warn":
+        console.warn(formattedMessage, data ?? "");
+        break;
+      case "error":
+        console.error(formattedMessage, data ?? "");
+        break;
+    }
+    if (this.config.remoteLogging?.enabled) {
+      this.buffer.push(entry);
+      const batchSize = this.config.remoteLogging.batchSize ?? 10;
+      if (this.buffer.length >= batchSize) {
+        this.flush();
+      }
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  /**
+   * Flush buffered logs to remote endpoint
+   */
+  async flush() {
+    if (!this.config.remoteLogging?.enabled || this.buffer.length === 0) return;
+    const logs = [...this.buffer];
+    this.buffer = [];
+    try {
+      await fetch(this.config.remoteLogging.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ logs })
+      });
+    } catch (error) {
+      this.buffer = [...logs, ...this.buffer].slice(0, 100);
+      console.error("Failed to send logs to remote endpoint", error);
+    }
+  }
+  /**
+   * Cleanup logger (clear intervals)
+   */
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flush();
+  }
+};
+var createClientLogger = (config) => {
+  return new ClientLogger(config);
+};
+var clientLogger = new ClientLogger();
+
+// src/client/utils/date.ts
+var formatDate = (date, locale = "en-US") => {
+  const dateObj = new Date(date);
+  return dateObj.toLocaleDateString(locale, {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+};
+var formatDateTime = (date, locale = "en-US") => {
+  const dateObj = new Date(date);
+  return dateObj.toLocaleDateString(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+};
+var formatRelativeTime = (date) => {
+  const dateObj = new Date(date);
+  const now = /* @__PURE__ */ new Date();
+  const diffInSeconds = Math.floor((now.getTime() - dateObj.getTime()) / 1e3);
+  const intervals = [
+    { label: "year", seconds: 31536e3 },
+    { label: "month", seconds: 2592e3 },
+    { label: "week", seconds: 604800 },
+    { label: "day", seconds: 86400 },
+    { label: "hour", seconds: 3600 },
+    { label: "minute", seconds: 60 },
+    { label: "second", seconds: 1 }
+  ];
+  for (const interval of intervals) {
+    const count = Math.floor(diffInSeconds / interval.seconds);
+    if (count >= 1) {
+      return `${count} ${interval.label}${count !== 1 ? "s" : ""} ago`;
+    }
+  }
+  return "just now";
+};
+var formatDateForInput = (date) => {
+  const dateObj = new Date(date);
+  return dateObj.toISOString().split("T")[0];
+};
+var formatDateTimeForInput = (date) => {
+  const dateObj = new Date(date);
+  return dateObj.toISOString().slice(0, 16);
+};
+var isToday = (date) => {
+  const dateObj = new Date(date);
+  const today = /* @__PURE__ */ new Date();
+  return dateObj.getDate() === today.getDate() && dateObj.getMonth() === today.getMonth() && dateObj.getFullYear() === today.getFullYear();
+};
+var isPast = (date) => {
+  return new Date(date).getTime() < Date.now();
+};
+var isFuture = (date) => {
+  return new Date(date).getTime() > Date.now();
+};
+var addDays = (date, days) => {
+  const dateObj = new Date(date);
+  dateObj.setDate(dateObj.getDate() + days);
+  return dateObj;
+};
+var startOfDay = (date) => {
+  const dateObj = new Date(date);
+  dateObj.setHours(0, 0, 0, 0);
+  return dateObj;
+};
+var endOfDay = (date) => {
+  const dateObj = new Date(date);
+  dateObj.setHours(23, 59, 59, 999);
+  return dateObj;
+};
+
+// src/client/utils/clipboard.ts
+var copyToClipboard = async (text) => {
+  try {
+    if (navigator.clipboard && window.isSecureContext) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+    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 success = document.execCommand("copy");
+    document.body.removeChild(textArea);
+    return success;
+  } catch (error) {
+    console.error("Failed to copy to clipboard:", error);
+    return false;
+  }
+};
+var readFromClipboard = async () => {
+  try {
+    if (navigator.clipboard && window.isSecureContext) {
+      return await navigator.clipboard.readText();
+    }
+    return null;
+  } catch (error) {
+    console.error("Failed to read from clipboard:", error);
+    return null;
+  }
+};
+var isClipboardAvailable = () => {
+  return !!(navigator.clipboard && window.isSecureContext);
+};
+
+// src/client/utils/slug.ts
+var slugify = (text) => {
+  return text.toString().toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w\-]+/g, "").replace(/\-\-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+};
+var slugifyUnique = (text) => {
+  const baseSlug = slugify(text);
+  const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 5);
+  return `${baseSlug}-${uniqueSuffix}`;
+};
+var unslugify = (slug) => {
+  return slug.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+};
+var truncate = (text, maxLength, suffix = "...") => {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - suffix.length).trim() + suffix;
+};
+var truncateWords = (text, maxWords, suffix = "...") => {
+  const words = text.split(/\s+/);
+  if (words.length <= maxWords) return text;
+  return words.slice(0, maxWords).join(" ") + suffix;
+};
+var capitalizeWords = (text) => {
+  return text.replace(/\b\w/g, (char) => char.toUpperCase());
+};
+var capitalize = (text) => {
+  if (!text) return "";
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+var camelToKebab = (text) => {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+};
+var kebabToCamel = (text) => {
+  return text.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+};
+
+// src/client/utils/events.ts
+var EventEmitter = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to an event
+   * @returns Unsubscribe function
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(event, handler) {
+    const wrappedHandler = (data) => {
+      this.off(event, wrappedHandler);
+      handler(data);
+    };
+    return this.on(event, wrappedHandler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, data) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`Error in event handler for "${String(event)}":`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Remove all handlers for an event (or all events)
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+  /**
+   * Get count of listeners for an event
+   */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+};
+var createEventEmitter = () => {
+  return new EventEmitter();
+};
+var appEvents = new EventEmitter();
+
+// src/client/utils/api-urls.ts
+var ApiUrlBuilder = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.version = config.version || "";
+  }
+  /**
+   * Build full URL from path
+   */
+  build(path2) {
+    const normalizedPath = path2.startsWith("/") ? path2 : `/${path2}`;
+    const versionPath = this.version ? `/${this.version}` : "";
+    return `${this.baseUrl}${versionPath}${normalizedPath}`;
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildWithParams(path2, params) {
+    const url = this.build(path2);
+    const filteredParams = Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+    return filteredParams ? `${url}?${filteredParams}` : url;
+  }
+  /**
+   * Build URL with path parameters
+   */
+  buildWithPathParams(template, params) {
+    let path2 = template;
+    Object.entries(params).forEach(([key, value]) => {
+      path2 = path2.replace(`:${key}`, String(value));
+      path2 = path2.replace(`{${key}}`, String(value));
+    });
+    return this.build(path2);
+  }
+  /**
+   * Get base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Set new base URL
+   */
+  setBaseUrl(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+};
+var createApiUrlBuilder = (config) => {
+  return new ApiUrlBuilder(config);
+};
+var createApiEndpoints = (builder) => ({
+  // Auth endpoints
+  auth: {
+    login: () => builder.build("/auth/login"),
+    register: () => builder.build("/auth/register"),
+    logout: () => builder.build("/auth/logout"),
+    refresh: () => builder.build("/auth/refresh"),
+    me: () => builder.build("/auth/me"),
+    forgotPassword: () => builder.build("/auth/forgot-password"),
+    resetPassword: () => builder.build("/auth/reset-password")
+  },
+  // User endpoints
+  users: {
+    list: () => builder.build("/users"),
+    get: (id) => builder.buildWithPathParams("/users/:id", { id }),
+    create: () => builder.build("/users"),
+    update: (id) => builder.buildWithPathParams("/users/:id", { id }),
+    delete: (id) => builder.buildWithPathParams("/users/:id", { id })
+  },
+  // Generic CRUD factory
+  crud: (resource) => ({
+    list: () => builder.build(`/${resource}`),
+    get: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id }),
+    create: () => builder.build(`/${resource}`),
+    update: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id }),
+    delete: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id })
+  })
+});
+
+// src/client/utils/response-parser.ts
+var isSuccessResponse = (response) => {
+  return response.success === true;
+};
+var isErrorResponse = (response) => {
+  return response.success === false;
+};
+var getResponseData = (response, defaultValue) => {
+  if (isSuccessResponse(response) && response.data !== void 0) {
+    return response.data;
+  }
+  return defaultValue;
+};
+var getErrorMessage = (response, defaultMessage = "An error occurred") => {
+  if (response.error) {
+    return response.error;
+  }
+  if (response.message) {
+    return response.message;
+  }
+  return defaultMessage;
+};
+var hasData = (response) => {
+  return response.data !== null && response.data !== void 0;
+};
+var hasMorePages = (response) => {
+  return response.pagination.hasNextPage;
+};
+var getNextPage = (response) => {
+  if (response.pagination.hasNextPage) {
+    return response.pagination.page + 1;
+  }
+  return null;
+};
+var getPrevPage = (response) => {
+  if (response.pagination.hasPrevPage) {
+    return response.pagination.page - 1;
+  }
+  return null;
+};
+var createEmptyPaginationMeta = () => ({
+  total: 0,
+  page: 1,
+  limit: 10,
+  totalPages: 0,
+  hasNextPage: false,
+  hasPrevPage: false
+});
+var createSuccessResponse = (data, message = "Success") => ({
+  success: true,
+  message,
+  data,
+  statusCode: 200
+});
+var createErrorResponse = (message, statusCode2 = 400, error) => ({
+  success: false,
+  message,
+  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;
+    }
+    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 useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = react.useState(value);
+  react.useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  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);
+  }, []);
+  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 usePageTitle(title, options = {}) {
+  const { suffix, separator = " | ", restoreOnUnmount = true } = options;
+  react.useEffect(() => {
+    const originalTitle = document.title;
+    const newTitle = suffix ? `${title}${separator}${suffix}` : title;
+    document.title = newTitle;
+    return () => {
+      if (restoreOnUnmount) {
+        document.title = originalTitle;
+      }
+    };
+  }, [title, suffix, separator, restoreOnUnmount]);
+}
+var usePageTitle_default = usePageTitle;
+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 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;
+var DEFAULT_DURATION = 4e3;
+function useSnackbar(defaultDuration = DEFAULT_DURATION) {
+  const [state, setState] = react.useState({
+    open: false,
+    message: "",
+    severity: "info",
+    autoHideDuration: defaultDuration
+  });
+  const show = react.useCallback(
+    (message, severity = "info", duration) => {
+      setState({
+        open: true,
+        message,
+        severity,
+        autoHideDuration: duration ?? defaultDuration
+      });
+    },
+    [defaultDuration]
+  );
+  const success = react.useCallback(
+    (message, duration) => show(message, "success", duration),
+    [show]
+  );
+  const error = react.useCallback(
+    (message, duration) => show(message, "error", duration),
+    [show]
+  );
+  const warning = react.useCallback(
+    (message, duration) => show(message, "warning", duration),
+    [show]
+  );
+  const info = react.useCallback(
+    (message, duration) => show(message, "info", duration),
+    [show]
+  );
+  const close = react.useCallback(() => {
+    setState((prev) => ({ ...prev, open: false }));
+  }, []);
+  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, {
+  DATE_FORMATS: () => DATE_FORMATS,
+  HTTP_STATUS: () => HTTP_STATUS,
+  HTTP_STATUS_MESSAGES: () => HTTP_STATUS_MESSAGES,
+  PAGINATION: () => PAGINATION,
+  ROLES: () => ROLES,
+  STATUS: () => STATUS,
+  TOKEN_TYPES: () => TOKEN_TYPES,
+  USER_STATUS: () => USER_STATUS,
+  VALIDATION_MESSAGES: () => VALIDATION_MESSAGES,
+  VALIDATION_PATTERNS: () => VALIDATION_PATTERNS,
+  VALIDATION_RULES: () => VALIDATION_RULES,
+  addDays: () => dateFns.addDays,
+  addHours: () => dateFns.addHours,
+  addMinutes: () => dateFns.addMinutes,
+  addMonths: () => dateFns.addMonths,
+  addTime: () => addTime,
+  addWeeks: () => dateFns.addWeeks,
+  addYears: () => dateFns.addYears,
+  combineDateAndTime: () => combineDateAndTime,
+  dateTime: () => date_time_default,
+  daysSince: () => daysSince,
+  daysUntil: () => daysUntil,
+  differenceInDays: () => dateFns.differenceInDays,
+  differenceInHours: () => dateFns.differenceInHours,
+  differenceInMinutes: () => dateFns.differenceInMinutes,
+  differenceInMonths: () => dateFns.differenceInMonths,
+  differenceInSeconds: () => dateFns.differenceInSeconds,
+  differenceInWeeks: () => dateFns.differenceInWeeks,
+  differenceInYears: () => dateFns.differenceInYears,
+  doDateRangesOverlap: () => doDateRangesOverlap,
+  eachDayOfInterval: () => dateFns.eachDayOfInterval,
+  eachMonthOfInterval: () => dateFns.eachMonthOfInterval,
+  eachWeekOfInterval: () => dateFns.eachWeekOfInterval,
+  endOfDay: () => dateFns.endOfDay,
+  endOfMonth: () => dateFns.endOfMonth,
+  endOfWeek: () => dateFns.endOfWeek,
+  endOfYear: () => dateFns.endOfYear,
+  format: () => dateFns.format,
+  formatDate: () => formatDate2,
+  formatDateInTimezone: () => formatDateInTimezone,
+  formatDateRange: () => formatDateRange,
+  formatDateTime: () => formatDateTime2,
+  formatDistance: () => dateFns.formatDistance,
+  formatDistanceToNow: () => dateFns.formatDistanceToNow,
+  formatDuration: () => dateFns.formatDuration,
+  formatInTimeZone: () => dateFnsTz.formatInTimeZone,
+  formatRelative: () => dateFns.formatRelative,
+  formatRelativeTime: () => formatRelativeTime2,
+  formatSmartDate: () => formatSmartDate,
+  fromTimezone: () => fromTimezone,
+  fromZonedTime: () => dateFnsTz.fromZonedTime,
+  getAge: () => getAge,
+  getDate: () => dateFns.getDate,
+  getDateDifference: () => getDateDifference,
+  getDay: () => dateFns.getDay,
+  getDayBoundaries: () => getDayBoundaries,
+  getDaysInRange: () => getDaysInRange,
+  getEnv: () => getEnv,
+  getEnvOptional: () => getEnvOptional,
+  getHours: () => dateFns.getHours,
+  getMinutes: () => dateFns.getMinutes,
+  getMonth: () => dateFns.getMonth,
+  getMonthBoundaries: () => getMonthBoundaries,
+  getMonthsInRange: () => getMonthsInRange,
+  getSeconds: () => dateFns.getSeconds,
+  getTimezoneDifference: () => getTimezoneDifference,
+  getWeekBoundaries: () => getWeekBoundaries,
+  getWeeksInRange: () => getWeeksInRange,
+  getYear: () => dateFns.getYear,
+  getYearBoundaries: () => getYearBoundaries,
+  intervalToDuration: () => dateFns.intervalToDuration,
+  isAfter: () => dateFns.isAfter,
+  isBefore: () => dateFns.isBefore,
+  isDateBetween: () => isDateBetween,
+  isDev: () => isDev,
+  isEqual: () => dateFns.isEqual,
+  isFuture: () => dateFns.isFuture,
+  isPast: () => dateFns.isPast,
+  isProd: () => isProd,
+  isSameDay: () => dateFns.isSameDay,
+  isSameMonth: () => dateFns.isSameMonth,
+  isSameWeek: () => dateFns.isSameWeek,
+  isSameYear: () => dateFns.isSameYear,
+  isTest: () => isTest,
+  isThisMonth: () => dateFns.isThisMonth,
+  isThisWeek: () => dateFns.isThisWeek,
+  isThisYear: () => dateFns.isThisYear,
+  isToday: () => dateFns.isToday,
+  isTomorrow: () => dateFns.isTomorrow,
+  isValid: () => dateFns.isValid,
+  isValidDate: () => isValidDate,
+  isValidEmail: () => isValidEmail,
+  isValidPassword: () => isValidPassword,
+  isValidPhone: () => isValidPhone,
+  isValidSlug: () => isValidSlug,
+  isValidUrl: () => isValidUrl,
+  isValidUsername: () => isValidUsername,
+  isWeekday: () => isWeekday,
+  isWeekend: () => isWeekend,
+  isYesterday: () => dateFns.isYesterday,
+  nowInTimezone: () => nowInTimezone,
+  parseDate: () => parseDate,
+  parseISO: () => dateFns.parseISO,
+  setHours: () => dateFns.setHours,
+  setMinutes: () => dateFns.setMinutes,
+  setSeconds: () => dateFns.setSeconds,
+  setTime: () => setTime,
+  startOfDay: () => dateFns.startOfDay,
+  startOfMonth: () => dateFns.startOfMonth,
+  startOfWeek: () => dateFns.startOfWeek,
+  startOfYear: () => dateFns.startOfYear,
+  subDays: () => dateFns.subDays,
+  subHours: () => dateFns.subHours,
+  subMinutes: () => dateFns.subMinutes,
+  subMonths: () => dateFns.subMonths,
+  subWeeks: () => dateFns.subWeeks,
+  subYears: () => dateFns.subYears,
+  subtractTime: () => subtractTime,
+  toDateInputValue: () => toDateInputValue,
+  toDateTimeInputValue: () => toDateTimeInputValue,
+  toTimeInputValue: () => toTimeInputValue,
+  toTimezone: () => toTimezone,
+  toZonedTime: () => dateFnsTz.toZonedTime,
+  validateEnv: () => validateEnv
+});
+
+// src/shared/config/env.ts
+var getEnv = (key, defaultValue) => {
+  const value = process.env[key];
+  if (value === void 0) {
+    if (defaultValue !== void 0) {
+      return defaultValue;
+    }
+    throw new Error(`Environment variable ${key} is required but not defined`);
+  }
+  if (typeof defaultValue === "number") {
+    return Number(value);
+  }
+  if (typeof defaultValue === "boolean") {
+    return value === "true" || value === "1";
+  }
+  return value;
+};
+var getEnvOptional = (key, defaultValue) => {
+  const value = process.env[key];
+  if (value === void 0) {
+    return defaultValue;
+  }
+  if (typeof defaultValue === "number") {
+    return Number(value);
+  }
+  if (typeof defaultValue === "boolean") {
+    return value === "true" || value === "1";
+  }
+  return value;
+};
+var isProd = () => {
+  return process.env.NODE_ENV === "production";
+};
+var isDev = () => {
+  return process.env.NODE_ENV === "development";
+};
+var isTest = () => {
+  return process.env.NODE_ENV === "test";
+};
+var validateEnv = (requiredVars) => {
+  const missing = requiredVars.filter((key) => !process.env[key]);
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required environment variables: ${missing.join(", ")}`
+    );
+  }
+};
+
+// src/shared/constants/status-codes.ts
+var HTTP_STATUS = {
+  // Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  // Redirection
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  // Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  GONE: 410,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  // Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+var HTTP_STATUS_MESSAGES = {
+  [HTTP_STATUS.OK]: "OK",
+  [HTTP_STATUS.CREATED]: "Created",
+  [HTTP_STATUS.ACCEPTED]: "Accepted",
+  [HTTP_STATUS.NO_CONTENT]: "No Content",
+  [HTTP_STATUS.BAD_REQUEST]: "Bad Request",
+  [HTTP_STATUS.UNAUTHORIZED]: "Unauthorized",
+  [HTTP_STATUS.FORBIDDEN]: "Forbidden",
+  [HTTP_STATUS.NOT_FOUND]: "Not Found",
+  [HTTP_STATUS.METHOD_NOT_ALLOWED]: "Method Not Allowed",
+  [HTTP_STATUS.CONFLICT]: "Conflict",
+  [HTTP_STATUS.UNPROCESSABLE_ENTITY]: "Unprocessable Entity",
+  [HTTP_STATUS.TOO_MANY_REQUESTS]: "Too Many Requests",
+  [HTTP_STATUS.INTERNAL_SERVER_ERROR]: "Internal Server Error",
+  [HTTP_STATUS.SERVICE_UNAVAILABLE]: "Service Unavailable"
+};
+var STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  APPROVED: "approved",
+  REJECTED: "rejected",
+  DELETED: "deleted",
+  ARCHIVED: "archived",
+  DRAFT: "draft",
+  PUBLISHED: "published",
+  SUSPENDED: "suspended"
+};
+var USER_STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  SUSPENDED: "suspended",
+  BANNED: "banned"
+};
+var ROLES = {
+  ADMIN: "admin",
+  USER: "user",
+  MODERATOR: "moderator",
+  GUEST: "guest",
+  SUPER_ADMIN: "super_admin"
+};
+var PAGINATION = {
+  DEFAULT_PAGE: 1,
+  DEFAULT_LIMIT: 10,
+  MAX_LIMIT: 100
+};
+var TOKEN_TYPES = {
+  ACCESS: "access",
+  REFRESH: "refresh",
+  RESET_PASSWORD: "reset_password",
+  EMAIL_VERIFICATION: "email_verification"
+};
+var parseDate = (date) => {
+  if (date instanceof Date) return date;
+  if (typeof date === "string") return dateFns.parseISO(date);
+  return new Date(date);
+};
+var isValidDate = (date) => {
+  const parsed = parseDate(date);
+  return dateFns.isValid(parsed);
+};
+var DATE_FORMATS = {
+  // Date only
+  DATE_SHORT: "MM/dd/yyyy",
+  // 01/15/2026
+  DATE_MEDIUM: "MMM d, yyyy",
+  // Jan 15, 2026
+  DATE_LONG: "MMMM d, yyyy",
+  // January 15, 2026
+  DATE_FULL: "EEEE, MMMM d, yyyy",
+  // Friday, January 15, 2026
+  DATE_ISO: "yyyy-MM-dd",
+  // 2026-01-15
+  // Time only
+  TIME_SHORT: "h:mm a",
+  // 3:30 PM
+  TIME_MEDIUM: "h:mm:ss a",
+  // 3:30:45 PM
+  TIME_24H: "HH:mm",
+  // 15:30
+  TIME_24H_FULL: "HH:mm:ss",
+  // 15:30:45
+  // Date and time
+  DATETIME_SHORT: "MM/dd/yyyy h:mm a",
+  // 01/15/2026 3:30 PM
+  DATETIME_MEDIUM: "MMM d, yyyy h:mm a",
+  // Jan 15, 2026 3:30 PM
+  DATETIME_LONG: "MMMM d, yyyy h:mm a",
+  // January 15, 2026 3:30 PM
+  DATETIME_FULL: "EEEE, MMMM d, yyyy h:mm a",
+  // Friday, January 15, 2026 3:30 PM
+  DATETIME_ISO: "yyyy-MM-dd'T'HH:mm:ss",
+  // 2026-01-15T15:30:45
+  // Special formats
+  MONTH_YEAR: "MMMM yyyy",
+  // January 2026
+  MONTH_DAY: "MMM d",
+  // Jan 15
+  DAY_MONTH: "d MMM",
+  // 15 Jan
+  WEEKDAY: "EEEE",
+  // Friday
+  WEEKDAY_SHORT: "EEE"
+  // Fri
+};
+var formatDate2 = (date, formatStr = DATE_FORMATS.DATE_MEDIUM) => {
+  return dateFns.format(parseDate(date), formatStr);
+};
+var formatDateTime2 = (date, formatStr = DATE_FORMATS.DATETIME_MEDIUM) => {
+  return dateFns.format(parseDate(date), formatStr);
+};
+var formatDateInTimezone = (date, timezone, formatStr = DATE_FORMATS.DATETIME_MEDIUM) => {
+  return dateFnsTz.formatInTimeZone(parseDate(date), timezone, formatStr);
+};
+var formatRelativeTime2 = (date, baseDate) => {
+  const parsed = parseDate(date);
+  if (baseDate) {
+    return dateFns.formatDistance(parsed, parseDate(baseDate), { addSuffix: true });
+  }
+  return dateFns.formatDistanceToNow(parsed, { addSuffix: true });
+};
+var formatSmartDate = (date) => {
+  const parsed = parseDate(date);
+  if (dateFns.isToday(parsed)) {
+    return `Today at ${dateFns.format(parsed, DATE_FORMATS.TIME_SHORT)}`;
+  }
+  if (dateFns.isYesterday(parsed)) {
+    return `Yesterday at ${dateFns.format(parsed, DATE_FORMATS.TIME_SHORT)}`;
+  }
+  if (dateFns.isTomorrow(parsed)) {
+    return `Tomorrow at ${dateFns.format(parsed, DATE_FORMATS.TIME_SHORT)}`;
+  }
+  if (dateFns.isThisWeek(parsed)) {
+    return dateFns.format(parsed, "EEEE 'at' h:mm a");
+  }
+  if (dateFns.isThisYear(parsed)) {
+    return dateFns.format(parsed, "MMM d 'at' h:mm a");
+  }
+  return dateFns.format(parsed, DATE_FORMATS.DATETIME_MEDIUM);
+};
+var formatDateRange = (start, end) => {
+  const duration = dateFns.intervalToDuration({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+  return dateFns.formatDuration(duration, {
+    format: ["years", "months", "days", "hours", "minutes"]
+  });
+};
+var toTimezone = (date, timezone) => {
+  return dateFnsTz.toZonedTime(parseDate(date), timezone);
+};
+var fromTimezone = (date, timezone) => {
+  return dateFnsTz.fromZonedTime(parseDate(date), timezone);
+};
+var nowInTimezone = (timezone) => {
+  return dateFnsTz.toZonedTime(/* @__PURE__ */ new Date(), timezone);
+};
+var getTimezoneDifference = (timezone1, timezone2) => {
+  const now = /* @__PURE__ */ new Date();
+  const time1 = dateFnsTz.toZonedTime(now, timezone1);
+  const time2 = dateFnsTz.toZonedTime(now, timezone2);
+  const diffMinutes = dateFns.differenceInMinutes(time1, time2);
+  const hours = Math.floor(Math.abs(diffMinutes) / 60);
+  const minutes = Math.abs(diffMinutes) % 60;
+  const sign = diffMinutes >= 0 ? "+" : "-";
+  if (minutes === 0) {
+    return `${sign}${hours}h`;
+  }
+  return `${sign}${hours}h ${minutes}m`;
+};
+var addTime = (date, amount, unit) => {
+  const parsed = parseDate(date);
+  switch (unit) {
+    case "minutes":
+      return dateFns.addMinutes(parsed, amount);
+    case "hours":
+      return dateFns.addHours(parsed, amount);
+    case "days":
+      return dateFns.addDays(parsed, amount);
+    case "weeks":
+      return dateFns.addWeeks(parsed, amount);
+    case "months":
+      return dateFns.addMonths(parsed, amount);
+    case "years":
+      return dateFns.addYears(parsed, amount);
+  }
+};
+var subtractTime = (date, amount, unit) => {
+  const parsed = parseDate(date);
+  switch (unit) {
+    case "minutes":
+      return dateFns.subMinutes(parsed, amount);
+    case "hours":
+      return dateFns.subHours(parsed, amount);
+    case "days":
+      return dateFns.subDays(parsed, amount);
+    case "weeks":
+      return dateFns.subWeeks(parsed, amount);
+    case "months":
+      return dateFns.subMonths(parsed, amount);
+    case "years":
+      return dateFns.subYears(parsed, amount);
+  }
+};
+var getDateDifference = (date1, date2, unit) => {
+  const d1 = parseDate(date1);
+  const d2 = parseDate(date2);
+  switch (unit) {
+    case "seconds":
+      return dateFns.differenceInSeconds(d1, d2);
+    case "minutes":
+      return dateFns.differenceInMinutes(d1, d2);
+    case "hours":
+      return dateFns.differenceInHours(d1, d2);
+    case "days":
+      return dateFns.differenceInDays(d1, d2);
+    case "weeks":
+      return dateFns.differenceInWeeks(d1, d2);
+    case "months":
+      return dateFns.differenceInMonths(d1, d2);
+    case "years":
+      return dateFns.differenceInYears(d1, d2);
+  }
+};
+var getDaysInRange = (start, end) => {
+  return dateFns.eachDayOfInterval({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+};
+var getWeeksInRange = (start, end) => {
+  return dateFns.eachWeekOfInterval({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+};
+var getMonthsInRange = (start, end) => {
+  return dateFns.eachMonthOfInterval({
+    start: parseDate(start),
+    end: parseDate(end)
+  });
+};
+var getDayBoundaries = (date) => {
+  const parsed = parseDate(date);
+  return {
+    start: dateFns.startOfDay(parsed),
+    end: dateFns.endOfDay(parsed)
+  };
+};
+var getWeekBoundaries = (date, weekStartsOn = 0) => {
+  const parsed = parseDate(date);
+  return {
+    start: dateFns.startOfWeek(parsed, { weekStartsOn }),
+    end: dateFns.endOfWeek(parsed, { weekStartsOn })
+  };
+};
+var getMonthBoundaries = (date) => {
+  const parsed = parseDate(date);
+  return {
+    start: dateFns.startOfMonth(parsed),
+    end: dateFns.endOfMonth(parsed)
+  };
+};
+var getYearBoundaries = (date) => {
+  const parsed = parseDate(date);
+  return {
+    start: dateFns.startOfYear(parsed),
+    end: dateFns.endOfYear(parsed)
+  };
+};
+var isDateBetween = (date, start, end) => {
+  const d = parseDate(date);
+  const s = parseDate(start);
+  const e = parseDate(end);
+  return (dateFns.isAfter(d, s) || dateFns.isEqual(d, s)) && (dateFns.isBefore(d, e) || dateFns.isEqual(d, e));
+};
+var doDateRangesOverlap = (range1Start, range1End, range2Start, range2End) => {
+  const r1s = parseDate(range1Start);
+  const r1e = parseDate(range1End);
+  const r2s = parseDate(range2Start);
+  const r2e = parseDate(range2End);
+  return dateFns.isBefore(r1s, r2e) && dateFns.isAfter(r1e, r2s);
+};
+var getAge = (birthDate) => {
+  return dateFns.differenceInYears(/* @__PURE__ */ new Date(), parseDate(birthDate));
+};
+var isWeekend = (date) => {
+  const day = dateFns.getDay(parseDate(date));
+  return day === 0 || day === 6;
+};
+var isWeekday = (date) => {
+  return !isWeekend(date);
+};
+var daysUntil = (date) => {
+  return dateFns.differenceInDays(parseDate(date), /* @__PURE__ */ new Date());
+};
+var daysSince = (date) => {
+  return dateFns.differenceInDays(/* @__PURE__ */ new Date(), parseDate(date));
+};
+var toDateInputValue = (date) => {
+  return dateFns.format(parseDate(date), DATE_FORMATS.DATE_ISO);
+};
+var toDateTimeInputValue = (date) => {
+  return dateFns.format(parseDate(date), "yyyy-MM-dd'T'HH:mm");
+};
+var toTimeInputValue = (date) => {
+  return dateFns.format(parseDate(date), DATE_FORMATS.TIME_24H);
+};
+var setTime = (date, hours, minutes, seconds = 0) => {
+  let result = parseDate(date);
+  result = dateFns.setHours(result, hours);
+  result = dateFns.setMinutes(result, minutes);
+  result = dateFns.setSeconds(result, seconds);
+  return result;
+};
+var combineDateAndTime = (dateInput, timeInput) => {
+  const date = parseDate(dateInput);
+  const time = parseDate(timeInput);
+  return setTime(date, dateFns.getHours(time), dateFns.getMinutes(time), dateFns.getSeconds(time));
+};
+var date_time_default = {
+  // Core
+  parseDate,
+  isValidDate,
+  DATE_FORMATS,
+  // Format
+  formatDate: formatDate2,
+  formatDateTime: formatDateTime2,
+  formatDateInTimezone,
+  formatRelativeTime: formatRelativeTime2,
+  formatSmartDate,
+  formatDateRange,
+  // Timezone
+  toTimezone,
+  fromTimezone,
+  nowInTimezone,
+  getTimezoneDifference,
+  // Arithmetic
+  addTime,
+  subtractTime,
+  getDateDifference,
+  // Ranges
+  getDaysInRange,
+  getWeeksInRange,
+  getMonthsInRange,
+  // Boundaries
+  getDayBoundaries,
+  getWeekBoundaries,
+  getMonthBoundaries,
+  getYearBoundaries,
+  // Comparison
+  isDateBetween,
+  doDateRangesOverlap,
+  // Utilities
+  getAge,
+  isWeekend,
+  isWeekday,
+  daysUntil,
+  daysSince,
+  toDateInputValue,
+  toDateTimeInputValue,
+  toTimeInputValue,
+  setTime,
+  combineDateAndTime
+};
+
+// src/shared/validation/index.ts
+var VALIDATION_PATTERNS = {
+  /** Email pattern (RFC 5322 simplified) */
+  EMAIL: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  /** Strong password: min 8 chars, uppercase, lowercase, number, special char */
+  PASSWORD_STRONG: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
+  /** Medium password: min 8 chars, uppercase, lowercase, number */
+  PASSWORD_MEDIUM: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d@$!%*?&]{8,}$/,
+  /** Basic password: min 8 chars */
+  PASSWORD_BASIC: /^.{8,}$/,
+  /** Phone number (international) */
+  PHONE_INTERNATIONAL: /^\+?[\d\s\-().]{10,}$/,
+  /** Phone number (US) */
+  PHONE_US: /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/,
+  /** Phone number (India) */
+  PHONE_INDIA: /^[6-9]\d{9}$/,
+  /** URL pattern */
+  URL: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/,
+  /** URL with required protocol */
+  URL_STRICT: /^https?:\/\/([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/,
+  /** Alphanumeric only */
+  ALPHANUMERIC: /^[a-zA-Z0-9]+$/,
+  /** Letters only */
+  LETTERS_ONLY: /^[a-zA-Z]+$/,
+  /** Numbers only */
+  NUMBERS_ONLY: /^\d+$/,
+  /** Slug pattern (kebab-case) */
+  SLUG: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+  /** Username pattern (alphanumeric, underscore, hyphen) */
+  USERNAME: /^[a-zA-Z0-9_-]{3,30}$/,
+  /** Credit card (basic validation) */
+  CREDIT_CARD: /^\d{13,19}$/,
+  /** CVV (3 or 4 digits) */
+  CVV: /^\d{3,4}$/,
+  /** ZIP code (US) */
+  ZIP_US: /^\d{5}(-\d{4})?$/,
+  /** Postal code (India) */
+  POSTAL_INDIA: /^\d{6}$/,
+  /** IP Address (IPv4) */
+  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]?)$/,
+  /** Hex color */
+  HEX_COLOR: /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/,
+  /** Date (YYYY-MM-DD) */
+  DATE_ISO: /^\d{4}-\d{2}-\d{2}$/,
+  /** Time (HH:MM or HH:MM:SS) */
+  TIME: /^([01]\d|2[0-3]):([0-5]\d)(:[0-5]\d)?$/
+};
+var isValidEmail = (email) => {
+  return VALIDATION_PATTERNS.EMAIL.test(email.trim());
+};
+var isValidPassword = (password, strength = "medium") => {
+  switch (strength) {
+    case "strong":
+      return VALIDATION_PATTERNS.PASSWORD_STRONG.test(password);
+    case "medium":
+      return VALIDATION_PATTERNS.PASSWORD_MEDIUM.test(password);
+    case "basic":
+    default:
+      return VALIDATION_PATTERNS.PASSWORD_BASIC.test(password);
+  }
+};
+var isValidPhone = (phone, format2 = "international") => {
+  const cleaned = phone.replace(/\s/g, "");
+  switch (format2) {
+    case "us":
+      return VALIDATION_PATTERNS.PHONE_US.test(cleaned);
+    case "india":
+      return VALIDATION_PATTERNS.PHONE_INDIA.test(cleaned);
+    case "international":
+    default:
+      return VALIDATION_PATTERNS.PHONE_INTERNATIONAL.test(cleaned);
+  }
+};
+var isValidUrl = (url, requireProtocol = false) => {
+  if (requireProtocol) {
+    return VALIDATION_PATTERNS.URL_STRICT.test(url);
+  }
+  return VALIDATION_PATTERNS.URL.test(url);
+};
+var isValidUsername = (username) => {
+  return VALIDATION_PATTERNS.USERNAME.test(username);
+};
+var isValidSlug = (slug) => {
+  return VALIDATION_PATTERNS.SLUG.test(slug);
+};
+var VALIDATION_MESSAGES = {
+  // Required fields
+  REQUIRED: "This field is required",
+  REQUIRED_FIELD: (field) => `${field} is required`,
+  // Email
+  EMAIL_INVALID: "Please enter a valid email address",
+  EMAIL_REQUIRED: "Email is required",
+  // Password
+  PASSWORD_REQUIRED: "Password is required",
+  PASSWORD_MIN_LENGTH: (length) => `Password must be at least ${length} characters`,
+  PASSWORD_WEAK: "Password is too weak",
+  PASSWORD_MEDIUM: "Password must contain uppercase, lowercase, and number",
+  PASSWORD_STRONG: "Password must contain uppercase, lowercase, number, and special character",
+  PASSWORD_MISMATCH: "Passwords do not match",
+  // Name
+  NAME_REQUIRED: "Name is required",
+  FIRST_NAME_REQUIRED: "First name is required",
+  LAST_NAME_REQUIRED: "Last name is required",
+  NAME_MIN_LENGTH: (length) => `Name must be at least ${length} characters`,
+  NAME_MAX_LENGTH: (length) => `Name must be at most ${length} characters`,
+  // Phone
+  PHONE_INVALID: "Please enter a valid phone number",
+  PHONE_REQUIRED: "Phone number is required",
+  // URL
+  URL_INVALID: "Please enter a valid URL",
+  // Username
+  USERNAME_INVALID: "Username can only contain letters, numbers, underscores, and hyphens",
+  USERNAME_MIN_LENGTH: "Username must be at least 3 characters",
+  USERNAME_MAX_LENGTH: "Username must be at most 30 characters",
+  USERNAME_TAKEN: "This username is already taken",
+  // General
+  MIN_LENGTH: (field, length) => `${field} must be at least ${length} characters`,
+  MAX_LENGTH: (field, length) => `${field} must be at most ${length} characters`,
+  MIN_VALUE: (field, value) => `${field} must be at least ${value}`,
+  MAX_VALUE: (field, value) => `${field} must be at most ${value}`,
+  INVALID_FORMAT: "Invalid format",
+  TERMS_REQUIRED: "You must accept the terms and conditions"
+};
+var VALIDATION_RULES = {
+  email: {
+    pattern: VALIDATION_PATTERNS.EMAIL,
+    message: VALIDATION_MESSAGES.EMAIL_INVALID
+  },
+  password: {
+    minLength: 8,
+    pattern: VALIDATION_PATTERNS.PASSWORD_MEDIUM,
+    message: VALIDATION_MESSAGES.PASSWORD_MEDIUM
+  },
+  passwordStrong: {
+    minLength: 8,
+    pattern: VALIDATION_PATTERNS.PASSWORD_STRONG,
+    message: VALIDATION_MESSAGES.PASSWORD_STRONG
+  },
+  name: {
+    minLength: 2,
+    maxLength: 50
+  },
+  username: {
+    minLength: 3,
+    maxLength: 30,
+    pattern: VALIDATION_PATTERNS.USERNAME,
+    message: VALIDATION_MESSAGES.USERNAME_INVALID
+  },
+  phone: {
+    pattern: VALIDATION_PATTERNS.PHONE_INTERNATIONAL,
+    message: VALIDATION_MESSAGES.PHONE_INVALID
+  },
+  url: {
+    pattern: VALIDATION_PATTERNS.URL,
+    message: VALIDATION_MESSAGES.URL_INVALID
+  }
+};
+
+// src/data/index.ts
+var data_exports = {};
+__export(data_exports, {
+  brands: () => logos_default,
+  countries: () => countries_default,
+  currencies: () => currencies_default,
+  formatCurrency: () => formatCurrency,
+  formatCurrencyNative: () => formatCurrencyNative,
+  getAllBrandKeys: () => getAllBrandKeys,
+  getAllBrands: () => getAllBrands,
+  getAllCities: () => getAllCities,
+  getBrand: () => getBrand,
+  getBrandByDomain: () => getBrandByDomain,
+  getCitiesByState: () => getCitiesByState,
+  getCountriesByContinent: () => getCountriesByContinent,
+  getCountryByCode: () => getCountryByCode,
+  getCountryByName: () => getCountryByName,
+  getCurrencyByCode: () => getCurrencyByCode,
+  getLogo: () => getLogo,
+  getPhoneCodeByCountry: () => getPhoneCodeByCountry,
+  getPhoneCodesByPrefix: () => getPhoneCodesByPrefix,
+  getStatesByCountry: () => getStatesByCountry,
+  getTimezoneByName: () => getTimezoneByName,
+  getTimezonesByOffset: () => getTimezonesByOffset,
+  phoneCodes: () => phone_codes_default,
+  searchCountries: () => searchCountries,
+  searchCurrencies: () => searchCurrencies,
+  searchPhoneCodes: () => searchPhoneCodes,
+  searchTimezones: () => searchTimezones,
+  sortTimezonesByOffset: () => sortTimezonesByOffset,
+  timezones: () => timezones_default
+});
+
+// src/data/countries.ts
+var countries = [
+  {
+    name: "Afghanistan",
+    code: "AF",
+    code3: "AFG",
+    phoneCode: "+93",
+    currency: "AFN",
+    currencySymbol: "\u060B",
+    continent: "Asia",
+    capital: "Kabul",
+    timezone: "Asia/Kabul",
+    states: [
+      { name: "Kabul", code: "KBL", cities: [{ name: "Kabul" }] },
+      { name: "Kandahar", code: "KDH", cities: [{ name: "Kandahar" }] },
+      { name: "Herat", code: "HER", cities: [{ name: "Herat" }] }
+    ]
+  },
+  {
+    name: "Albania",
+    code: "AL",
+    code3: "ALB",
+    phoneCode: "+355",
+    currency: "ALL",
+    currencySymbol: "L",
+    continent: "Europe",
+    capital: "Tirana",
+    timezone: "Europe/Tirane",
+    states: [
+      { name: "Tirana", code: "TR", cities: [{ name: "Tirana" }] },
+      { name: "Durr\xEBs", code: "DR", cities: [{ name: "Durr\xEBs" }] }
+    ]
+  },
+  {
+    name: "Algeria",
+    code: "DZ",
+    code3: "DZA",
+    phoneCode: "+213",
+    currency: "DZD",
+    currencySymbol: "\u062F.\u062C",
+    continent: "Africa",
+    capital: "Algiers",
+    timezone: "Africa/Algiers",
+    states: [
+      { name: "Algiers", code: "ALG", cities: [{ name: "Algiers" }] },
+      { name: "Oran", code: "ORA", cities: [{ name: "Oran" }] }
+    ]
+  },
+  {
+    name: "Argentina",
+    code: "AR",
+    code3: "ARG",
+    phoneCode: "+54",
+    currency: "ARS",
+    currencySymbol: "$",
+    continent: "South America",
+    capital: "Buenos Aires",
+    timezone: "America/Argentina/Buenos_Aires",
+    states: [
+      { name: "Buenos Aires", code: "BA", cities: [{ name: "Buenos Aires" }, { name: "La Plata" }] },
+      { name: "C\xF3rdoba", code: "CO", cities: [{ name: "C\xF3rdoba" }] },
+      { name: "Santa Fe", code: "SF", cities: [{ name: "Rosario" }, { name: "Santa Fe" }] }
+    ]
+  },
+  {
+    name: "Australia",
+    code: "AU",
+    code3: "AUS",
+    phoneCode: "+61",
+    currency: "AUD",
+    currencySymbol: "$",
+    continent: "Oceania",
+    capital: "Canberra",
+    timezone: "Australia/Sydney",
+    states: [
+      { name: "New South Wales", code: "NSW", cities: [{ name: "Sydney" }, { name: "Newcastle" }, { name: "Wollongong" }] },
+      { name: "Victoria", code: "VIC", cities: [{ name: "Melbourne" }, { name: "Geelong" }] },
+      { name: "Queensland", code: "QLD", cities: [{ name: "Brisbane" }, { name: "Gold Coast" }, { name: "Cairns" }] },
+      { name: "Western Australia", code: "WA", cities: [{ name: "Perth" }, { name: "Fremantle" }] },
+      { name: "South Australia", code: "SA", cities: [{ name: "Adelaide" }] },
+      { name: "Tasmania", code: "TAS", cities: [{ name: "Hobart" }, { name: "Launceston" }] },
+      { name: "Australian Capital Territory", code: "ACT", cities: [{ name: "Canberra" }] },
+      { name: "Northern Territory", code: "NT", cities: [{ name: "Darwin" }] }
+    ]
+  },
+  {
+    name: "Austria",
+    code: "AT",
+    code3: "AUT",
+    phoneCode: "+43",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Vienna",
+    timezone: "Europe/Vienna",
+    states: [
+      { name: "Vienna", code: "VIE", cities: [{ name: "Vienna" }] },
+      { name: "Salzburg", code: "SBG", cities: [{ name: "Salzburg" }] },
+      { name: "Tyrol", code: "TYR", cities: [{ name: "Innsbruck" }] }
+    ]
+  },
+  {
+    name: "Bangladesh",
+    code: "BD",
+    code3: "BGD",
+    phoneCode: "+880",
+    currency: "BDT",
+    currencySymbol: "\u09F3",
+    continent: "Asia",
+    capital: "Dhaka",
+    timezone: "Asia/Dhaka",
+    states: [
+      { name: "Dhaka", code: "DHA", cities: [{ name: "Dhaka" }, { name: "Gazipur" }, { name: "Narayanganj" }] },
+      { name: "Chittagong", code: "CTG", cities: [{ name: "Chittagong" }, { name: "Cox's Bazar" }] },
+      { name: "Khulna", code: "KHL", cities: [{ name: "Khulna" }] },
+      { name: "Rajshahi", code: "RAJ", cities: [{ name: "Rajshahi" }] },
+      { name: "Sylhet", code: "SYL", cities: [{ name: "Sylhet" }] }
+    ]
+  },
+  {
+    name: "Belgium",
+    code: "BE",
+    code3: "BEL",
+    phoneCode: "+32",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Brussels",
+    timezone: "Europe/Brussels",
+    states: [
+      { name: "Brussels", code: "BRU", cities: [{ name: "Brussels" }] },
+      { name: "Flanders", code: "FLA", cities: [{ name: "Antwerp" }, { name: "Ghent" }, { name: "Bruges" }] },
+      { name: "Wallonia", code: "WAL", cities: [{ name: "Li\xE8ge" }, { name: "Charleroi" }] }
+    ]
+  },
+  {
+    name: "Brazil",
+    code: "BR",
+    code3: "BRA",
+    phoneCode: "+55",
+    currency: "BRL",
+    currencySymbol: "R$",
+    continent: "South America",
+    capital: "Bras\xEDlia",
+    timezone: "America/Sao_Paulo",
+    states: [
+      { name: "S\xE3o Paulo", code: "SP", cities: [{ name: "S\xE3o Paulo" }, { name: "Campinas" }, { name: "Santos" }] },
+      { name: "Rio de Janeiro", code: "RJ", cities: [{ name: "Rio de Janeiro" }, { name: "Niter\xF3i" }] },
+      { name: "Minas Gerais", code: "MG", cities: [{ name: "Belo Horizonte" }, { name: "Uberl\xE2ndia" }] },
+      { name: "Bahia", code: "BA", cities: [{ name: "Salvador" }] },
+      { name: "Paran\xE1", code: "PR", cities: [{ name: "Curitiba" }] },
+      { name: "Rio Grande do Sul", code: "RS", cities: [{ name: "Porto Alegre" }] },
+      { name: "Federal District", code: "DF", cities: [{ name: "Bras\xEDlia" }] }
+    ]
+  },
+  {
+    name: "Canada",
+    code: "CA",
+    code3: "CAN",
+    phoneCode: "+1",
+    currency: "CAD",
+    currencySymbol: "$",
+    continent: "North America",
+    capital: "Ottawa",
+    timezone: "America/Toronto",
+    states: [
+      { name: "Ontario", code: "ON", cities: [{ name: "Toronto" }, { name: "Ottawa" }, { name: "Mississauga" }, { name: "Hamilton" }] },
+      { name: "Quebec", code: "QC", cities: [{ name: "Montreal" }, { name: "Quebec City" }, { name: "Laval" }] },
+      { name: "British Columbia", code: "BC", cities: [{ name: "Vancouver" }, { name: "Victoria" }, { name: "Surrey" }] },
+      { name: "Alberta", code: "AB", cities: [{ name: "Calgary" }, { name: "Edmonton" }] },
+      { name: "Manitoba", code: "MB", cities: [{ name: "Winnipeg" }] },
+      { name: "Saskatchewan", code: "SK", cities: [{ name: "Saskatoon" }, { name: "Regina" }] },
+      { name: "Nova Scotia", code: "NS", cities: [{ name: "Halifax" }] },
+      { name: "New Brunswick", code: "NB", cities: [{ name: "Moncton" }, { name: "Saint John" }] }
+    ]
+  },
+  {
+    name: "China",
+    code: "CN",
+    code3: "CHN",
+    phoneCode: "+86",
+    currency: "CNY",
+    currencySymbol: "\xA5",
+    continent: "Asia",
+    capital: "Beijing",
+    timezone: "Asia/Shanghai",
+    states: [
+      { name: "Beijing", code: "BJ", cities: [{ name: "Beijing" }] },
+      { name: "Shanghai", code: "SH", cities: [{ name: "Shanghai" }] },
+      { name: "Guangdong", code: "GD", cities: [{ name: "Guangzhou" }, { name: "Shenzhen" }, { name: "Dongguan" }] },
+      { name: "Jiangsu", code: "JS", cities: [{ name: "Nanjing" }, { name: "Suzhou" }, { name: "Wuxi" }] },
+      { name: "Zhejiang", code: "ZJ", cities: [{ name: "Hangzhou" }, { name: "Ningbo" }] },
+      { name: "Sichuan", code: "SC", cities: [{ name: "Chengdu" }, { name: "Chongqing" }] },
+      { name: "Hubei", code: "HB", cities: [{ name: "Wuhan" }] }
+    ]
+  },
+  {
+    name: "Denmark",
+    code: "DK",
+    code3: "DNK",
+    phoneCode: "+45",
+    currency: "DKK",
+    currencySymbol: "kr",
+    continent: "Europe",
+    capital: "Copenhagen",
+    timezone: "Europe/Copenhagen",
+    states: [
+      { name: "Capital Region", code: "HO", cities: [{ name: "Copenhagen" }] },
+      { name: "Central Denmark", code: "MJ", cities: [{ name: "Aarhus" }] },
+      { name: "Southern Denmark", code: "SD", cities: [{ name: "Odense" }] }
+    ]
+  },
+  {
+    name: "Egypt",
+    code: "EG",
+    code3: "EGY",
+    phoneCode: "+20",
+    currency: "EGP",
+    currencySymbol: "\xA3",
+    continent: "Africa",
+    capital: "Cairo",
+    timezone: "Africa/Cairo",
+    states: [
+      { name: "Cairo", code: "CAI", cities: [{ name: "Cairo" }, { name: "Giza" }] },
+      { name: "Alexandria", code: "ALX", cities: [{ name: "Alexandria" }] },
+      { name: "Luxor", code: "LXR", cities: [{ name: "Luxor" }] }
+    ]
+  },
+  {
+    name: "Finland",
+    code: "FI",
+    code3: "FIN",
+    phoneCode: "+358",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Helsinki",
+    timezone: "Europe/Helsinki",
+    states: [
+      { name: "Uusimaa", code: "UUS", cities: [{ name: "Helsinki" }, { name: "Espoo" }, { name: "Vantaa" }] },
+      { name: "Pirkanmaa", code: "PIR", cities: [{ name: "Tampere" }] },
+      { name: "Southwest Finland", code: "VAR", cities: [{ name: "Turku" }] }
+    ]
+  },
+  {
+    name: "France",
+    code: "FR",
+    code3: "FRA",
+    phoneCode: "+33",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Paris",
+    timezone: "Europe/Paris",
+    states: [
+      { name: "\xCEle-de-France", code: "IDF", cities: [{ name: "Paris" }, { name: "Versailles" }, { name: "Boulogne-Billancourt" }] },
+      { name: "Provence-Alpes-C\xF4te d'Azur", code: "PAC", cities: [{ name: "Marseille" }, { name: "Nice" }, { name: "Cannes" }] },
+      { name: "Auvergne-Rh\xF4ne-Alpes", code: "ARA", cities: [{ name: "Lyon" }, { name: "Grenoble" }] },
+      { name: "Nouvelle-Aquitaine", code: "NAQ", cities: [{ name: "Bordeaux" }] },
+      { name: "Occitanie", code: "OCC", cities: [{ name: "Toulouse" }, { name: "Montpellier" }] }
+    ]
+  },
+  {
+    name: "Germany",
+    code: "DE",
+    code3: "DEU",
+    phoneCode: "+49",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Berlin",
+    timezone: "Europe/Berlin",
+    states: [
+      { name: "Berlin", code: "BE", cities: [{ name: "Berlin" }] },
+      { name: "Bavaria", code: "BY", cities: [{ name: "Munich" }, { name: "Nuremberg" }, { name: "Augsburg" }] },
+      { name: "North Rhine-Westphalia", code: "NW", cities: [{ name: "Cologne" }, { name: "D\xFCsseldorf" }, { name: "Dortmund" }, { name: "Essen" }] },
+      { name: "Baden-W\xFCrttemberg", code: "BW", cities: [{ name: "Stuttgart" }, { name: "Mannheim" }, { name: "Karlsruhe" }] },
+      { name: "Hesse", code: "HE", cities: [{ name: "Frankfurt" }, { name: "Wiesbaden" }] },
+      { name: "Hamburg", code: "HH", cities: [{ name: "Hamburg" }] },
+      { name: "Saxony", code: "SN", cities: [{ name: "Dresden" }, { name: "Leipzig" }] }
+    ]
+  },
+  {
+    name: "Greece",
+    code: "GR",
+    code3: "GRC",
+    phoneCode: "+30",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Athens",
+    timezone: "Europe/Athens",
+    states: [
+      { name: "Attica", code: "AT", cities: [{ name: "Athens" }, { name: "Piraeus" }] },
+      { name: "Central Macedonia", code: "CM", cities: [{ name: "Thessaloniki" }] },
+      { name: "Crete", code: "CR", cities: [{ name: "Heraklion" }, { name: "Chania" }] }
+    ]
+  },
+  {
+    name: "Hong Kong",
+    code: "HK",
+    code3: "HKG",
+    phoneCode: "+852",
+    currency: "HKD",
+    currencySymbol: "$",
+    continent: "Asia",
+    capital: "Hong Kong",
+    timezone: "Asia/Hong_Kong",
+    states: [
+      { name: "Hong Kong Island", code: "HKI", cities: [{ name: "Central" }, { name: "Wan Chai" }] },
+      { name: "Kowloon", code: "KLN", cities: [{ name: "Tsim Sha Tsui" }, { name: "Mong Kok" }] },
+      { name: "New Territories", code: "NT", cities: [{ name: "Sha Tin" }, { name: "Tsuen Wan" }] }
+    ]
+  },
+  {
+    name: "India",
+    code: "IN",
+    code3: "IND",
+    phoneCode: "+91",
+    currency: "INR",
+    currencySymbol: "\u20B9",
+    continent: "Asia",
+    capital: "New Delhi",
+    timezone: "Asia/Kolkata",
+    states: [
+      { name: "Delhi", code: "DL", cities: [{ name: "New Delhi" }, { name: "Delhi" }] },
+      { name: "Maharashtra", code: "MH", cities: [{ name: "Mumbai" }, { name: "Pune" }, { name: "Nagpur" }, { name: "Nashik" }] },
+      { name: "Karnataka", code: "KA", cities: [{ name: "Bangalore" }, { name: "Mysore" }, { name: "Mangalore" }] },
+      { name: "Tamil Nadu", code: "TN", cities: [{ name: "Chennai" }, { name: "Coimbatore" }, { name: "Madurai" }] },
+      { name: "Telangana", code: "TG", cities: [{ name: "Hyderabad" }, { name: "Warangal" }] },
+      { name: "West Bengal", code: "WB", cities: [{ name: "Kolkata" }, { name: "Howrah" }] },
+      { name: "Gujarat", code: "GJ", cities: [{ name: "Ahmedabad" }, { name: "Surat" }, { name: "Vadodara" }] },
+      { name: "Rajasthan", code: "RJ", cities: [{ name: "Jaipur" }, { name: "Jodhpur" }, { name: "Udaipur" }] },
+      { name: "Uttar Pradesh", code: "UP", cities: [{ name: "Lucknow" }, { name: "Kanpur" }, { name: "Varanasi" }, { name: "Agra" }, { name: "Noida" }] },
+      { name: "Kerala", code: "KL", cities: [{ name: "Thiruvananthapuram" }, { name: "Kochi" }, { name: "Kozhikode" }] },
+      { name: "Punjab", code: "PB", cities: [{ name: "Chandigarh" }, { name: "Ludhiana" }, { name: "Amritsar" }] },
+      { name: "Haryana", code: "HR", cities: [{ name: "Gurugram" }, { name: "Faridabad" }] },
+      { name: "Madhya Pradesh", code: "MP", cities: [{ name: "Bhopal" }, { name: "Indore" }] },
+      { name: "Bihar", code: "BR", cities: [{ name: "Patna" }] },
+      { name: "Odisha", code: "OR", cities: [{ name: "Bhubaneswar" }] },
+      { name: "Goa", code: "GA", cities: [{ name: "Panaji" }, { name: "Margao" }] }
+    ]
+  },
+  {
+    name: "Indonesia",
+    code: "ID",
+    code3: "IDN",
+    phoneCode: "+62",
+    currency: "IDR",
+    currencySymbol: "Rp",
+    continent: "Asia",
+    capital: "Jakarta",
+    timezone: "Asia/Jakarta",
+    states: [
+      { name: "Jakarta", code: "JK", cities: [{ name: "Jakarta" }] },
+      { name: "West Java", code: "JB", cities: [{ name: "Bandung" }, { name: "Bekasi" }] },
+      { name: "East Java", code: "JI", cities: [{ name: "Surabaya" }, { name: "Malang" }] },
+      { name: "Bali", code: "BA", cities: [{ name: "Denpasar" }, { name: "Ubud" }] }
+    ]
+  },
+  {
+    name: "Ireland",
+    code: "IE",
+    code3: "IRL",
+    phoneCode: "+353",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Dublin",
+    timezone: "Europe/Dublin",
+    states: [
+      { name: "Leinster", code: "L", cities: [{ name: "Dublin" }] },
+      { name: "Munster", code: "M", cities: [{ name: "Cork" }, { name: "Limerick" }] },
+      { name: "Connacht", code: "C", cities: [{ name: "Galway" }] }
+    ]
+  },
+  {
+    name: "Israel",
+    code: "IL",
+    code3: "ISR",
+    phoneCode: "+972",
+    currency: "ILS",
+    currencySymbol: "\u20AA",
+    continent: "Asia",
+    capital: "Jerusalem",
+    timezone: "Asia/Jerusalem",
+    states: [
+      { name: "Tel Aviv", code: "TA", cities: [{ name: "Tel Aviv" }] },
+      { name: "Jerusalem", code: "JM", cities: [{ name: "Jerusalem" }] },
+      { name: "Haifa", code: "HA", cities: [{ name: "Haifa" }] }
+    ]
+  },
+  {
+    name: "Italy",
+    code: "IT",
+    code3: "ITA",
+    phoneCode: "+39",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Rome",
+    timezone: "Europe/Rome",
+    states: [
+      { name: "Lazio", code: "LAZ", cities: [{ name: "Rome" }] },
+      { name: "Lombardy", code: "LOM", cities: [{ name: "Milan" }, { name: "Bergamo" }] },
+      { name: "Veneto", code: "VEN", cities: [{ name: "Venice" }, { name: "Verona" }, { name: "Padua" }] },
+      { name: "Tuscany", code: "TOS", cities: [{ name: "Florence" }, { name: "Pisa" }, { name: "Siena" }] },
+      { name: "Campania", code: "CAM", cities: [{ name: "Naples" }] },
+      { name: "Sicily", code: "SIC", cities: [{ name: "Palermo" }, { name: "Catania" }] }
+    ]
+  },
+  {
+    name: "Japan",
+    code: "JP",
+    code3: "JPN",
+    phoneCode: "+81",
+    currency: "JPY",
+    currencySymbol: "\xA5",
+    continent: "Asia",
+    capital: "Tokyo",
+    timezone: "Asia/Tokyo",
+    states: [
+      { name: "Tokyo", code: "TK", cities: [{ name: "Tokyo" }, { name: "Shibuya" }, { name: "Shinjuku" }] },
+      { name: "Osaka", code: "OS", cities: [{ name: "Osaka" }] },
+      { name: "Kyoto", code: "KY", cities: [{ name: "Kyoto" }] },
+      { name: "Kanagawa", code: "KN", cities: [{ name: "Yokohama" }, { name: "Kawasaki" }] },
+      { name: "Aichi", code: "AI", cities: [{ name: "Nagoya" }] },
+      { name: "Hokkaido", code: "HK", cities: [{ name: "Sapporo" }] },
+      { name: "Fukuoka", code: "FK", cities: [{ name: "Fukuoka" }] },
+      { name: "Hiroshima", code: "HS", cities: [{ name: "Hiroshima" }] }
+    ]
+  },
+  {
+    name: "Malaysia",
+    code: "MY",
+    code3: "MYS",
+    phoneCode: "+60",
+    currency: "MYR",
+    currencySymbol: "RM",
+    continent: "Asia",
+    capital: "Kuala Lumpur",
+    timezone: "Asia/Kuala_Lumpur",
+    states: [
+      { name: "Kuala Lumpur", code: "KL", cities: [{ name: "Kuala Lumpur" }] },
+      { name: "Selangor", code: "SL", cities: [{ name: "Shah Alam" }, { name: "Petaling Jaya" }] },
+      { name: "Penang", code: "PG", cities: [{ name: "George Town" }] },
+      { name: "Johor", code: "JH", cities: [{ name: "Johor Bahru" }] }
+    ]
+  },
+  {
+    name: "Mexico",
+    code: "MX",
+    code3: "MEX",
+    phoneCode: "+52",
+    currency: "MXN",
+    currencySymbol: "$",
+    continent: "North America",
+    capital: "Mexico City",
+    timezone: "America/Mexico_City",
+    states: [
+      { name: "Mexico City", code: "CMX", cities: [{ name: "Mexico City" }] },
+      { name: "Jalisco", code: "JAL", cities: [{ name: "Guadalajara" }] },
+      { name: "Nuevo Le\xF3n", code: "NLE", cities: [{ name: "Monterrey" }] },
+      { name: "Quintana Roo", code: "ROO", cities: [{ name: "Canc\xFAn" }, { name: "Playa del Carmen" }] }
+    ]
+  },
+  {
+    name: "Netherlands",
+    code: "NL",
+    code3: "NLD",
+    phoneCode: "+31",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Amsterdam",
+    timezone: "Europe/Amsterdam",
+    states: [
+      { name: "North Holland", code: "NH", cities: [{ name: "Amsterdam" }, { name: "Haarlem" }] },
+      { name: "South Holland", code: "ZH", cities: [{ name: "Rotterdam" }, { name: "The Hague" }, { name: "Leiden" }] },
+      { name: "Utrecht", code: "UT", cities: [{ name: "Utrecht" }] },
+      { name: "North Brabant", code: "NB", cities: [{ name: "Eindhoven" }, { name: "Tilburg" }] }
+    ]
+  },
+  {
+    name: "New Zealand",
+    code: "NZ",
+    code3: "NZL",
+    phoneCode: "+64",
+    currency: "NZD",
+    currencySymbol: "$",
+    continent: "Oceania",
+    capital: "Wellington",
+    timezone: "Pacific/Auckland",
+    states: [
+      { name: "Auckland", code: "AUK", cities: [{ name: "Auckland" }] },
+      { name: "Wellington", code: "WGN", cities: [{ name: "Wellington" }] },
+      { name: "Canterbury", code: "CAN", cities: [{ name: "Christchurch" }] },
+      { name: "Otago", code: "OTA", cities: [{ name: "Dunedin" }, { name: "Queenstown" }] }
+    ]
+  },
+  {
+    name: "Nigeria",
+    code: "NG",
+    code3: "NGA",
+    phoneCode: "+234",
+    currency: "NGN",
+    currencySymbol: "\u20A6",
+    continent: "Africa",
+    capital: "Abuja",
+    timezone: "Africa/Lagos",
+    states: [
+      { name: "Lagos", code: "LA", cities: [{ name: "Lagos" }, { name: "Ikeja" }] },
+      { name: "FCT", code: "FC", cities: [{ name: "Abuja" }] },
+      { name: "Kano", code: "KN", cities: [{ name: "Kano" }] },
+      { name: "Rivers", code: "RI", cities: [{ name: "Port Harcourt" }] }
+    ]
+  },
+  {
+    name: "Norway",
+    code: "NO",
+    code3: "NOR",
+    phoneCode: "+47",
+    currency: "NOK",
+    currencySymbol: "kr",
+    continent: "Europe",
+    capital: "Oslo",
+    timezone: "Europe/Oslo",
+    states: [
+      { name: "Oslo", code: "OSL", cities: [{ name: "Oslo" }] },
+      { name: "Vestland", code: "VES", cities: [{ name: "Bergen" }] },
+      { name: "Tr\xF8ndelag", code: "TRO", cities: [{ name: "Trondheim" }] }
+    ]
+  },
+  {
+    name: "Pakistan",
+    code: "PK",
+    code3: "PAK",
+    phoneCode: "+92",
+    currency: "PKR",
+    currencySymbol: "\u20A8",
+    continent: "Asia",
+    capital: "Islamabad",
+    timezone: "Asia/Karachi",
+    states: [
+      { name: "Punjab", code: "PB", cities: [{ name: "Lahore" }, { name: "Faisalabad" }, { name: "Rawalpindi" }] },
+      { name: "Sindh", code: "SD", cities: [{ name: "Karachi" }, { name: "Hyderabad" }] },
+      { name: "Islamabad", code: "IS", cities: [{ name: "Islamabad" }] },
+      { name: "Khyber Pakhtunkhwa", code: "KP", cities: [{ name: "Peshawar" }] }
+    ]
+  },
+  {
+    name: "Philippines",
+    code: "PH",
+    code3: "PHL",
+    phoneCode: "+63",
+    currency: "PHP",
+    currencySymbol: "\u20B1",
+    continent: "Asia",
+    capital: "Manila",
+    timezone: "Asia/Manila",
+    states: [
+      { name: "Metro Manila", code: "NCR", cities: [{ name: "Manila" }, { name: "Quezon City" }, { name: "Makati" }] },
+      { name: "Cebu", code: "CEB", cities: [{ name: "Cebu City" }] },
+      { name: "Davao", code: "DAV", cities: [{ name: "Davao City" }] }
+    ]
+  },
+  {
+    name: "Poland",
+    code: "PL",
+    code3: "POL",
+    phoneCode: "+48",
+    currency: "PLN",
+    currencySymbol: "z\u0142",
+    continent: "Europe",
+    capital: "Warsaw",
+    timezone: "Europe/Warsaw",
+    states: [
+      { name: "Masovian", code: "MZ", cities: [{ name: "Warsaw" }] },
+      { name: "Lesser Poland", code: "MA", cities: [{ name: "Krakow" }] },
+      { name: "Greater Poland", code: "WP", cities: [{ name: "Pozna\u0144" }] },
+      { name: "Lower Silesian", code: "DS", cities: [{ name: "Wroc\u0142aw" }] }
+    ]
+  },
+  {
+    name: "Portugal",
+    code: "PT",
+    code3: "PRT",
+    phoneCode: "+351",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Lisbon",
+    timezone: "Europe/Lisbon",
+    states: [
+      { name: "Lisbon", code: "LIS", cities: [{ name: "Lisbon" }] },
+      { name: "Porto", code: "POR", cities: [{ name: "Porto" }] },
+      { name: "Faro", code: "FAR", cities: [{ name: "Faro" }] }
+    ]
+  },
+  {
+    name: "Qatar",
+    code: "QA",
+    code3: "QAT",
+    phoneCode: "+974",
+    currency: "QAR",
+    currencySymbol: "\u0631.\u0642",
+    continent: "Asia",
+    capital: "Doha",
+    timezone: "Asia/Qatar",
+    states: [
+      { name: "Doha", code: "DA", cities: [{ name: "Doha" }] },
+      { name: "Al Wakrah", code: "WA", cities: [{ name: "Al Wakrah" }] }
+    ]
+  },
+  {
+    name: "Russia",
+    code: "RU",
+    code3: "RUS",
+    phoneCode: "+7",
+    currency: "RUB",
+    currencySymbol: "\u20BD",
+    continent: "Europe",
+    capital: "Moscow",
+    timezone: "Europe/Moscow",
+    states: [
+      { name: "Moscow", code: "MOW", cities: [{ name: "Moscow" }] },
+      { name: "Saint Petersburg", code: "SPE", cities: [{ name: "Saint Petersburg" }] },
+      { name: "Novosibirsk Oblast", code: "NVS", cities: [{ name: "Novosibirsk" }] },
+      { name: "Sverdlovsk Oblast", code: "SVE", cities: [{ name: "Yekaterinburg" }] }
+    ]
+  },
+  {
+    name: "Saudi Arabia",
+    code: "SA",
+    code3: "SAU",
+    phoneCode: "+966",
+    currency: "SAR",
+    currencySymbol: "\u0631.\u0633",
+    continent: "Asia",
+    capital: "Riyadh",
+    timezone: "Asia/Riyadh",
+    states: [
+      { name: "Riyadh", code: "RIY", cities: [{ name: "Riyadh" }] },
+      { name: "Makkah", code: "MKK", cities: [{ name: "Jeddah" }, { name: "Mecca" }] },
+      { name: "Eastern Province", code: "ASH", cities: [{ name: "Dammam" }, { name: "Dhahran" }] }
+    ]
+  },
+  {
+    name: "Singapore",
+    code: "SG",
+    code3: "SGP",
+    phoneCode: "+65",
+    currency: "SGD",
+    currencySymbol: "$",
+    continent: "Asia",
+    capital: "Singapore",
+    timezone: "Asia/Singapore",
+    states: [
+      { name: "Central Region", code: "CEN", cities: [{ name: "Singapore" }] }
+    ]
+  },
+  {
+    name: "South Africa",
+    code: "ZA",
+    code3: "ZAF",
+    phoneCode: "+27",
+    currency: "ZAR",
+    currencySymbol: "R",
+    continent: "Africa",
+    capital: "Pretoria",
+    timezone: "Africa/Johannesburg",
+    states: [
+      { name: "Gauteng", code: "GP", cities: [{ name: "Johannesburg" }, { name: "Pretoria" }] },
+      { name: "Western Cape", code: "WC", cities: [{ name: "Cape Town" }] },
+      { name: "KwaZulu-Natal", code: "KZN", cities: [{ name: "Durban" }] }
+    ]
+  },
+  {
+    name: "South Korea",
+    code: "KR",
+    code3: "KOR",
+    phoneCode: "+82",
+    currency: "KRW",
+    currencySymbol: "\u20A9",
+    continent: "Asia",
+    capital: "Seoul",
+    timezone: "Asia/Seoul",
+    states: [
+      { name: "Seoul", code: "SEO", cities: [{ name: "Seoul" }] },
+      { name: "Busan", code: "BUS", cities: [{ name: "Busan" }] },
+      { name: "Incheon", code: "INC", cities: [{ name: "Incheon" }] },
+      { name: "Gyeonggi", code: "GGI", cities: [{ name: "Suwon" }, { name: "Seongnam" }] }
+    ]
+  },
+  {
+    name: "Spain",
+    code: "ES",
+    code3: "ESP",
+    phoneCode: "+34",
+    currency: "EUR",
+    currencySymbol: "\u20AC",
+    continent: "Europe",
+    capital: "Madrid",
+    timezone: "Europe/Madrid",
+    states: [
+      { name: "Madrid", code: "MD", cities: [{ name: "Madrid" }] },
+      { name: "Catalonia", code: "CT", cities: [{ name: "Barcelona" }] },
+      { name: "Andalusia", code: "AN", cities: [{ name: "Seville" }, { name: "Malaga" }, { name: "Granada" }] },
+      { name: "Valencia", code: "VC", cities: [{ name: "Valencia" }] },
+      { name: "Basque Country", code: "PV", cities: [{ name: "Bilbao" }, { name: "San Sebasti\xE1n" }] }
+    ]
+  },
+  {
+    name: "Sri Lanka",
+    code: "LK",
+    code3: "LKA",
+    phoneCode: "+94",
+    currency: "LKR",
+    currencySymbol: "\u20A8",
+    continent: "Asia",
+    capital: "Colombo",
+    timezone: "Asia/Colombo",
+    states: [
+      { name: "Western", code: "WP", cities: [{ name: "Colombo" }] },
+      { name: "Central", code: "CP", cities: [{ name: "Kandy" }] },
+      { name: "Southern", code: "SP", cities: [{ name: "Galle" }] }
+    ]
+  },
+  {
+    name: "Sweden",
+    code: "SE",
+    code3: "SWE",
+    phoneCode: "+46",
+    currency: "SEK",
+    currencySymbol: "kr",
+    continent: "Europe",
+    capital: "Stockholm",
+    timezone: "Europe/Stockholm",
+    states: [
+      { name: "Stockholm", code: "AB", cities: [{ name: "Stockholm" }] },
+      { name: "V\xE4stra G\xF6taland", code: "VG", cities: [{ name: "Gothenburg" }] },
+      { name: "Sk\xE5ne", code: "SK", cities: [{ name: "Malm\xF6" }] }
+    ]
+  },
+  {
+    name: "Switzerland",
+    code: "CH",
+    code3: "CHE",
+    phoneCode: "+41",
+    currency: "CHF",
+    currencySymbol: "CHF",
+    continent: "Europe",
+    capital: "Bern",
+    timezone: "Europe/Zurich",
+    states: [
+      { name: "Z\xFCrich", code: "ZH", cities: [{ name: "Z\xFCrich" }] },
+      { name: "Geneva", code: "GE", cities: [{ name: "Geneva" }] },
+      { name: "Bern", code: "BE", cities: [{ name: "Bern" }] },
+      { name: "Basel-Stadt", code: "BS", cities: [{ name: "Basel" }] }
+    ]
+  },
+  {
+    name: "Taiwan",
+    code: "TW",
+    code3: "TWN",
+    phoneCode: "+886",
+    currency: "TWD",
+    currencySymbol: "NT$",
+    continent: "Asia",
+    capital: "Taipei",
+    timezone: "Asia/Taipei",
+    states: [
+      { name: "Taipei", code: "TPE", cities: [{ name: "Taipei" }, { name: "New Taipei" }] },
+      { name: "Taichung", code: "TXG", cities: [{ name: "Taichung" }] },
+      { name: "Kaohsiung", code: "KHH", cities: [{ name: "Kaohsiung" }] }
+    ]
+  },
+  {
+    name: "Thailand",
+    code: "TH",
+    code3: "THA",
+    phoneCode: "+66",
+    currency: "THB",
+    currencySymbol: "\u0E3F",
+    continent: "Asia",
+    capital: "Bangkok",
+    timezone: "Asia/Bangkok",
+    states: [
+      { name: "Bangkok", code: "BKK", cities: [{ name: "Bangkok" }] },
+      { name: "Chiang Mai", code: "CNX", cities: [{ name: "Chiang Mai" }] },
+      { name: "Phuket", code: "PKT", cities: [{ name: "Phuket" }] },
+      { name: "Chonburi", code: "CBI", cities: [{ name: "Pattaya" }] }
+    ]
+  },
+  {
+    name: "Turkey",
+    code: "TR",
+    code3: "TUR",
+    phoneCode: "+90",
+    currency: "TRY",
+    currencySymbol: "\u20BA",
+    continent: "Asia",
+    capital: "Ankara",
+    timezone: "Europe/Istanbul",
+    states: [
+      { name: "Istanbul", code: "IST", cities: [{ name: "Istanbul" }] },
+      { name: "Ankara", code: "ANK", cities: [{ name: "Ankara" }] },
+      { name: "Izmir", code: "IZM", cities: [{ name: "Izmir" }] },
+      { name: "Antalya", code: "ANT", cities: [{ name: "Antalya" }] }
+    ]
+  },
+  {
+    name: "Ukraine",
+    code: "UA",
+    code3: "UKR",
+    phoneCode: "+380",
+    currency: "UAH",
+    currencySymbol: "\u20B4",
+    continent: "Europe",
+    capital: "Kyiv",
+    timezone: "Europe/Kyiv",
+    states: [
+      { name: "Kyiv", code: "KY", cities: [{ name: "Kyiv" }] },
+      { name: "Kharkiv", code: "KH", cities: [{ name: "Kharkiv" }] },
+      { name: "Odessa", code: "OD", cities: [{ name: "Odessa" }] },
+      { name: "Lviv", code: "LV", cities: [{ name: "Lviv" }] }
+    ]
+  },
+  {
+    name: "United Arab Emirates",
+    code: "AE",
+    code3: "ARE",
+    phoneCode: "+971",
+    currency: "AED",
+    currencySymbol: "\u062F.\u0625",
+    continent: "Asia",
+    capital: "Abu Dhabi",
+    timezone: "Asia/Dubai",
+    states: [
+      { name: "Dubai", code: "DU", cities: [{ name: "Dubai" }] },
+      { name: "Abu Dhabi", code: "AZ", cities: [{ name: "Abu Dhabi" }] },
+      { name: "Sharjah", code: "SH", cities: [{ name: "Sharjah" }] },
+      { name: "Ajman", code: "AJ", cities: [{ name: "Ajman" }] }
+    ]
+  },
+  {
+    name: "United Kingdom",
+    code: "GB",
+    code3: "GBR",
+    phoneCode: "+44",
+    currency: "GBP",
+    currencySymbol: "\xA3",
+    continent: "Europe",
+    capital: "London",
+    timezone: "Europe/London",
+    states: [
+      { name: "England", code: "ENG", cities: [{ name: "London" }, { name: "Manchester" }, { name: "Birmingham" }, { name: "Liverpool" }, { name: "Leeds" }, { name: "Bristol" }] },
+      { name: "Scotland", code: "SCT", cities: [{ name: "Edinburgh" }, { name: "Glasgow" }] },
+      { name: "Wales", code: "WLS", cities: [{ name: "Cardiff" }, { name: "Swansea" }] },
+      { name: "Northern Ireland", code: "NIR", cities: [{ name: "Belfast" }] }
+    ]
+  },
+  {
+    name: "United States",
+    code: "US",
+    code3: "USA",
+    phoneCode: "+1",
+    currency: "USD",
+    currencySymbol: "$",
+    continent: "North America",
+    capital: "Washington, D.C.",
+    timezone: "America/New_York",
+    states: [
+      { name: "California", code: "CA", cities: [{ name: "Los Angeles" }, { name: "San Francisco" }, { name: "San Diego" }, { name: "San Jose" }, { name: "Sacramento" }] },
+      { name: "New York", code: "NY", cities: [{ name: "New York City" }, { name: "Buffalo" }, { name: "Albany" }] },
+      { name: "Texas", code: "TX", cities: [{ name: "Houston" }, { name: "Dallas" }, { name: "Austin" }, { name: "San Antonio" }] },
+      { name: "Florida", code: "FL", cities: [{ name: "Miami" }, { name: "Orlando" }, { name: "Tampa" }, { name: "Jacksonville" }] },
+      { name: "Illinois", code: "IL", cities: [{ name: "Chicago" }] },
+      { name: "Pennsylvania", code: "PA", cities: [{ name: "Philadelphia" }, { name: "Pittsburgh" }] },
+      { name: "Ohio", code: "OH", cities: [{ name: "Columbus" }, { name: "Cleveland" }, { name: "Cincinnati" }] },
+      { name: "Georgia", code: "GA", cities: [{ name: "Atlanta" }] },
+      { name: "North Carolina", code: "NC", cities: [{ name: "Charlotte" }, { name: "Raleigh" }] },
+      { name: "Michigan", code: "MI", cities: [{ name: "Detroit" }] },
+      { name: "Washington", code: "WA", cities: [{ name: "Seattle" }] },
+      { name: "Arizona", code: "AZ", cities: [{ name: "Phoenix" }, { name: "Tucson" }] },
+      { name: "Massachusetts", code: "MA", cities: [{ name: "Boston" }, { name: "Cambridge" }] },
+      { name: "Colorado", code: "CO", cities: [{ name: "Denver" }, { name: "Colorado Springs" }] },
+      { name: "Nevada", code: "NV", cities: [{ name: "Las Vegas" }, { name: "Reno" }] },
+      { name: "Oregon", code: "OR", cities: [{ name: "Portland" }] },
+      { name: "District of Columbia", code: "DC", cities: [{ name: "Washington" }] }
+    ]
+  },
+  {
+    name: "Vietnam",
+    code: "VN",
+    code3: "VNM",
+    phoneCode: "+84",
+    currency: "VND",
+    currencySymbol: "\u20AB",
+    continent: "Asia",
+    capital: "Hanoi",
+    timezone: "Asia/Ho_Chi_Minh",
+    states: [
+      { name: "Ho Chi Minh City", code: "HCM", cities: [{ name: "Ho Chi Minh City" }] },
+      { name: "Hanoi", code: "HAN", cities: [{ name: "Hanoi" }] },
+      { name: "Da Nang", code: "DAN", cities: [{ name: "Da Nang" }] }
+    ]
+  }
+];
+var getCountryByCode = (code) => {
+  return countries.find((c) => c.code === code || c.code3 === code);
+};
+var getCountryByName = (name) => {
+  return countries.find((c) => c.name.toLowerCase() === name.toLowerCase());
+};
+var getStatesByCountry = (countryCode) => {
+  const country = getCountryByCode(countryCode);
+  return country?.states || [];
+};
+var getCitiesByState = (countryCode, stateCode) => {
+  const states = getStatesByCountry(countryCode);
+  const state = states.find((s) => s.code === stateCode);
+  return state?.cities || [];
+};
+var getAllCities = (countryCode) => {
+  const states = getStatesByCountry(countryCode);
+  return states.flatMap((s) => s.cities);
+};
+var getCountriesByContinent = (continent) => {
+  return countries.filter((c) => c.continent.toLowerCase() === continent.toLowerCase());
+};
+var searchCountries = (query) => {
+  const lowerQuery = query.toLowerCase();
+  return countries.filter(
+    (c) => c.name.toLowerCase().includes(lowerQuery) || c.code.toLowerCase() === lowerQuery || c.code3.toLowerCase() === lowerQuery
+  );
+};
+var countries_default = countries;
+
+// src/data/phone-codes.ts
+var phoneCodes = [
+  { country: "Afghanistan", code: "AF", phoneCode: "+93", flag: "\u{1F1E6}\u{1F1EB}" },
+  { country: "Albania", code: "AL", phoneCode: "+355", flag: "\u{1F1E6}\u{1F1F1}" },
+  { country: "Algeria", code: "DZ", phoneCode: "+213", flag: "\u{1F1E9}\u{1F1FF}" },
+  { country: "American Samoa", code: "AS", phoneCode: "+1684", flag: "\u{1F1E6}\u{1F1F8}" },
+  { country: "Andorra", code: "AD", phoneCode: "+376", flag: "\u{1F1E6}\u{1F1E9}" },
+  { country: "Angola", code: "AO", phoneCode: "+244", flag: "\u{1F1E6}\u{1F1F4}" },
+  { country: "Anguilla", code: "AI", phoneCode: "+1264", flag: "\u{1F1E6}\u{1F1EE}" },
+  { country: "Argentina", code: "AR", phoneCode: "+54", flag: "\u{1F1E6}\u{1F1F7}" },
+  { country: "Armenia", code: "AM", phoneCode: "+374", flag: "\u{1F1E6}\u{1F1F2}" },
+  { country: "Australia", code: "AU", phoneCode: "+61", flag: "\u{1F1E6}\u{1F1FA}" },
+  { country: "Austria", code: "AT", phoneCode: "+43", flag: "\u{1F1E6}\u{1F1F9}" },
+  { country: "Azerbaijan", code: "AZ", phoneCode: "+994", flag: "\u{1F1E6}\u{1F1FF}" },
+  { country: "Bahamas", code: "BS", phoneCode: "+1242", flag: "\u{1F1E7}\u{1F1F8}" },
+  { country: "Bahrain", code: "BH", phoneCode: "+973", flag: "\u{1F1E7}\u{1F1ED}" },
+  { country: "Bangladesh", code: "BD", phoneCode: "+880", flag: "\u{1F1E7}\u{1F1E9}" },
+  { country: "Barbados", code: "BB", phoneCode: "+1246", flag: "\u{1F1E7}\u{1F1E7}" },
+  { country: "Belarus", code: "BY", phoneCode: "+375", flag: "\u{1F1E7}\u{1F1FE}" },
+  { country: "Belgium", code: "BE", phoneCode: "+32", flag: "\u{1F1E7}\u{1F1EA}" },
+  { country: "Belize", code: "BZ", phoneCode: "+501", flag: "\u{1F1E7}\u{1F1FF}" },
+  { country: "Benin", code: "BJ", phoneCode: "+229", flag: "\u{1F1E7}\u{1F1EF}" },
+  { country: "Bermuda", code: "BM", phoneCode: "+1441", flag: "\u{1F1E7}\u{1F1F2}" },
+  { country: "Bhutan", code: "BT", phoneCode: "+975", flag: "\u{1F1E7}\u{1F1F9}" },
+  { country: "Bolivia", code: "BO", phoneCode: "+591", flag: "\u{1F1E7}\u{1F1F4}" },
+  { country: "Bosnia and Herzegovina", code: "BA", phoneCode: "+387", flag: "\u{1F1E7}\u{1F1E6}" },
+  { country: "Botswana", code: "BW", phoneCode: "+267", flag: "\u{1F1E7}\u{1F1FC}" },
+  { country: "Brazil", code: "BR", phoneCode: "+55", flag: "\u{1F1E7}\u{1F1F7}" },
+  { country: "Brunei", code: "BN", phoneCode: "+673", flag: "\u{1F1E7}\u{1F1F3}" },
+  { country: "Bulgaria", code: "BG", phoneCode: "+359", flag: "\u{1F1E7}\u{1F1EC}" },
+  { country: "Burkina Faso", code: "BF", phoneCode: "+226", flag: "\u{1F1E7}\u{1F1EB}" },
+  { country: "Burundi", code: "BI", phoneCode: "+257", flag: "\u{1F1E7}\u{1F1EE}" },
+  { country: "Cambodia", code: "KH", phoneCode: "+855", flag: "\u{1F1F0}\u{1F1ED}" },
+  { country: "Cameroon", code: "CM", phoneCode: "+237", flag: "\u{1F1E8}\u{1F1F2}" },
+  { country: "Canada", code: "CA", phoneCode: "+1", flag: "\u{1F1E8}\u{1F1E6}" },
+  { country: "Cape Verde", code: "CV", phoneCode: "+238", flag: "\u{1F1E8}\u{1F1FB}" },
+  { country: "Cayman Islands", code: "KY", phoneCode: "+1345", flag: "\u{1F1F0}\u{1F1FE}" },
+  { country: "Central African Republic", code: "CF", phoneCode: "+236", flag: "\u{1F1E8}\u{1F1EB}" },
+  { country: "Chad", code: "TD", phoneCode: "+235", flag: "\u{1F1F9}\u{1F1E9}" },
+  { country: "Chile", code: "CL", phoneCode: "+56", flag: "\u{1F1E8}\u{1F1F1}" },
+  { country: "China", code: "CN", phoneCode: "+86", flag: "\u{1F1E8}\u{1F1F3}" },
+  { country: "Colombia", code: "CO", phoneCode: "+57", flag: "\u{1F1E8}\u{1F1F4}" },
+  { country: "Comoros", code: "KM", phoneCode: "+269", flag: "\u{1F1F0}\u{1F1F2}" },
+  { country: "Congo", code: "CG", phoneCode: "+242", flag: "\u{1F1E8}\u{1F1EC}" },
+  { country: "Costa Rica", code: "CR", phoneCode: "+506", flag: "\u{1F1E8}\u{1F1F7}" },
+  { country: "Croatia", code: "HR", phoneCode: "+385", flag: "\u{1F1ED}\u{1F1F7}" },
+  { country: "Cuba", code: "CU", phoneCode: "+53", flag: "\u{1F1E8}\u{1F1FA}" },
+  { country: "Cyprus", code: "CY", phoneCode: "+357", flag: "\u{1F1E8}\u{1F1FE}" },
+  { country: "Czech Republic", code: "CZ", phoneCode: "+420", flag: "\u{1F1E8}\u{1F1FF}" },
+  { country: "Denmark", code: "DK", phoneCode: "+45", flag: "\u{1F1E9}\u{1F1F0}" },
+  { country: "Djibouti", code: "DJ", phoneCode: "+253", flag: "\u{1F1E9}\u{1F1EF}" },
+  { country: "Dominica", code: "DM", phoneCode: "+1767", flag: "\u{1F1E9}\u{1F1F2}" },
+  { country: "Dominican Republic", code: "DO", phoneCode: "+1809", flag: "\u{1F1E9}\u{1F1F4}" },
+  { country: "Ecuador", code: "EC", phoneCode: "+593", flag: "\u{1F1EA}\u{1F1E8}" },
+  { country: "Egypt", code: "EG", phoneCode: "+20", flag: "\u{1F1EA}\u{1F1EC}" },
+  { country: "El Salvador", code: "SV", phoneCode: "+503", flag: "\u{1F1F8}\u{1F1FB}" },
+  { country: "Equatorial Guinea", code: "GQ", phoneCode: "+240", flag: "\u{1F1EC}\u{1F1F6}" },
+  { country: "Eritrea", code: "ER", phoneCode: "+291", flag: "\u{1F1EA}\u{1F1F7}" },
+  { country: "Estonia", code: "EE", phoneCode: "+372", flag: "\u{1F1EA}\u{1F1EA}" },
+  { country: "Ethiopia", code: "ET", phoneCode: "+251", flag: "\u{1F1EA}\u{1F1F9}" },
+  { country: "Fiji", code: "FJ", phoneCode: "+679", flag: "\u{1F1EB}\u{1F1EF}" },
+  { country: "Finland", code: "FI", phoneCode: "+358", flag: "\u{1F1EB}\u{1F1EE}" },
+  { country: "France", code: "FR", phoneCode: "+33", flag: "\u{1F1EB}\u{1F1F7}" },
+  { country: "Gabon", code: "GA", phoneCode: "+241", flag: "\u{1F1EC}\u{1F1E6}" },
+  { country: "Gambia", code: "GM", phoneCode: "+220", flag: "\u{1F1EC}\u{1F1F2}" },
+  { country: "Georgia", code: "GE", phoneCode: "+995", flag: "\u{1F1EC}\u{1F1EA}" },
+  { country: "Germany", code: "DE", phoneCode: "+49", flag: "\u{1F1E9}\u{1F1EA}" },
+  { country: "Ghana", code: "GH", phoneCode: "+233", flag: "\u{1F1EC}\u{1F1ED}" },
+  { country: "Greece", code: "GR", phoneCode: "+30", flag: "\u{1F1EC}\u{1F1F7}" },
+  { country: "Greenland", code: "GL", phoneCode: "+299", flag: "\u{1F1EC}\u{1F1F1}" },
+  { country: "Grenada", code: "GD", phoneCode: "+1473", flag: "\u{1F1EC}\u{1F1E9}" },
+  { country: "Guam", code: "GU", phoneCode: "+1671", flag: "\u{1F1EC}\u{1F1FA}" },
+  { country: "Guatemala", code: "GT", phoneCode: "+502", flag: "\u{1F1EC}\u{1F1F9}" },
+  { country: "Guinea", code: "GN", phoneCode: "+224", flag: "\u{1F1EC}\u{1F1F3}" },
+  { country: "Guyana", code: "GY", phoneCode: "+592", flag: "\u{1F1EC}\u{1F1FE}" },
+  { country: "Haiti", code: "HT", phoneCode: "+509", flag: "\u{1F1ED}\u{1F1F9}" },
+  { country: "Honduras", code: "HN", phoneCode: "+504", flag: "\u{1F1ED}\u{1F1F3}" },
+  { country: "Hong Kong", code: "HK", phoneCode: "+852", flag: "\u{1F1ED}\u{1F1F0}" },
+  { country: "Hungary", code: "HU", phoneCode: "+36", flag: "\u{1F1ED}\u{1F1FA}" },
+  { country: "Iceland", code: "IS", phoneCode: "+354", flag: "\u{1F1EE}\u{1F1F8}" },
+  { country: "India", code: "IN", phoneCode: "+91", flag: "\u{1F1EE}\u{1F1F3}" },
+  { country: "Indonesia", code: "ID", phoneCode: "+62", flag: "\u{1F1EE}\u{1F1E9}" },
+  { country: "Iran", code: "IR", phoneCode: "+98", flag: "\u{1F1EE}\u{1F1F7}" },
+  { country: "Iraq", code: "IQ", phoneCode: "+964", flag: "\u{1F1EE}\u{1F1F6}" },
+  { country: "Ireland", code: "IE", phoneCode: "+353", flag: "\u{1F1EE}\u{1F1EA}" },
+  { country: "Israel", code: "IL", phoneCode: "+972", flag: "\u{1F1EE}\u{1F1F1}" },
+  { country: "Italy", code: "IT", phoneCode: "+39", flag: "\u{1F1EE}\u{1F1F9}" },
+  { country: "Jamaica", code: "JM", phoneCode: "+1876", flag: "\u{1F1EF}\u{1F1F2}" },
+  { country: "Japan", code: "JP", phoneCode: "+81", flag: "\u{1F1EF}\u{1F1F5}" },
+  { country: "Jordan", code: "JO", phoneCode: "+962", flag: "\u{1F1EF}\u{1F1F4}" },
+  { country: "Kazakhstan", code: "KZ", phoneCode: "+7", flag: "\u{1F1F0}\u{1F1FF}" },
+  { country: "Kenya", code: "KE", phoneCode: "+254", flag: "\u{1F1F0}\u{1F1EA}" },
+  { country: "Kiribati", code: "KI", phoneCode: "+686", flag: "\u{1F1F0}\u{1F1EE}" },
+  { country: "Kuwait", code: "KW", phoneCode: "+965", flag: "\u{1F1F0}\u{1F1FC}" },
+  { country: "Kyrgyzstan", code: "KG", phoneCode: "+996", flag: "\u{1F1F0}\u{1F1EC}" },
+  { country: "Laos", code: "LA", phoneCode: "+856", flag: "\u{1F1F1}\u{1F1E6}" },
+  { country: "Latvia", code: "LV", phoneCode: "+371", flag: "\u{1F1F1}\u{1F1FB}" },
+  { country: "Lebanon", code: "LB", phoneCode: "+961", flag: "\u{1F1F1}\u{1F1E7}" },
+  { country: "Lesotho", code: "LS", phoneCode: "+266", flag: "\u{1F1F1}\u{1F1F8}" },
+  { country: "Liberia", code: "LR", phoneCode: "+231", flag: "\u{1F1F1}\u{1F1F7}" },
+  { country: "Libya", code: "LY", phoneCode: "+218", flag: "\u{1F1F1}\u{1F1FE}" },
+  { country: "Liechtenstein", code: "LI", phoneCode: "+423", flag: "\u{1F1F1}\u{1F1EE}" },
+  { country: "Lithuania", code: "LT", phoneCode: "+370", flag: "\u{1F1F1}\u{1F1F9}" },
+  { country: "Luxembourg", code: "LU", phoneCode: "+352", flag: "\u{1F1F1}\u{1F1FA}" },
+  { country: "Macau", code: "MO", phoneCode: "+853", flag: "\u{1F1F2}\u{1F1F4}" },
+  { country: "Madagascar", code: "MG", phoneCode: "+261", flag: "\u{1F1F2}\u{1F1EC}" },
+  { country: "Malawi", code: "MW", phoneCode: "+265", flag: "\u{1F1F2}\u{1F1FC}" },
+  { country: "Malaysia", code: "MY", phoneCode: "+60", flag: "\u{1F1F2}\u{1F1FE}" },
+  { country: "Maldives", code: "MV", phoneCode: "+960", flag: "\u{1F1F2}\u{1F1FB}" },
+  { country: "Mali", code: "ML", phoneCode: "+223", flag: "\u{1F1F2}\u{1F1F1}" },
+  { country: "Malta", code: "MT", phoneCode: "+356", flag: "\u{1F1F2}\u{1F1F9}" },
+  { country: "Mauritania", code: "MR", phoneCode: "+222", flag: "\u{1F1F2}\u{1F1F7}" },
+  { country: "Mauritius", code: "MU", phoneCode: "+230", flag: "\u{1F1F2}\u{1F1FA}" },
+  { country: "Mexico", code: "MX", phoneCode: "+52", flag: "\u{1F1F2}\u{1F1FD}" },
+  { country: "Moldova", code: "MD", phoneCode: "+373", flag: "\u{1F1F2}\u{1F1E9}" },
+  { country: "Monaco", code: "MC", phoneCode: "+377", flag: "\u{1F1F2}\u{1F1E8}" },
+  { country: "Mongolia", code: "MN", phoneCode: "+976", flag: "\u{1F1F2}\u{1F1F3}" },
+  { country: "Montenegro", code: "ME", phoneCode: "+382", flag: "\u{1F1F2}\u{1F1EA}" },
+  { country: "Morocco", code: "MA", phoneCode: "+212", flag: "\u{1F1F2}\u{1F1E6}" },
+  { country: "Mozambique", code: "MZ", phoneCode: "+258", flag: "\u{1F1F2}\u{1F1FF}" },
+  { country: "Myanmar", code: "MM", phoneCode: "+95", flag: "\u{1F1F2}\u{1F1F2}" },
+  { country: "Namibia", code: "NA", phoneCode: "+264", flag: "\u{1F1F3}\u{1F1E6}" },
+  { country: "Nauru", code: "NR", phoneCode: "+674", flag: "\u{1F1F3}\u{1F1F7}" },
+  { country: "Nepal", code: "NP", phoneCode: "+977", flag: "\u{1F1F3}\u{1F1F5}" },
+  { country: "Netherlands", code: "NL", phoneCode: "+31", flag: "\u{1F1F3}\u{1F1F1}" },
+  { country: "New Zealand", code: "NZ", phoneCode: "+64", flag: "\u{1F1F3}\u{1F1FF}" },
+  { country: "Nicaragua", code: "NI", phoneCode: "+505", flag: "\u{1F1F3}\u{1F1EE}" },
+  { country: "Niger", code: "NE", phoneCode: "+227", flag: "\u{1F1F3}\u{1F1EA}" },
+  { country: "Nigeria", code: "NG", phoneCode: "+234", flag: "\u{1F1F3}\u{1F1EC}" },
+  { country: "North Korea", code: "KP", phoneCode: "+850", flag: "\u{1F1F0}\u{1F1F5}" },
+  { country: "North Macedonia", code: "MK", phoneCode: "+389", flag: "\u{1F1F2}\u{1F1F0}" },
+  { country: "Norway", code: "NO", phoneCode: "+47", flag: "\u{1F1F3}\u{1F1F4}" },
+  { country: "Oman", code: "OM", phoneCode: "+968", flag: "\u{1F1F4}\u{1F1F2}" },
+  { country: "Pakistan", code: "PK", phoneCode: "+92", flag: "\u{1F1F5}\u{1F1F0}" },
+  { country: "Palau", code: "PW", phoneCode: "+680", flag: "\u{1F1F5}\u{1F1FC}" },
+  { country: "Palestine", code: "PS", phoneCode: "+970", flag: "\u{1F1F5}\u{1F1F8}" },
+  { country: "Panama", code: "PA", phoneCode: "+507", flag: "\u{1F1F5}\u{1F1E6}" },
+  { country: "Papua New Guinea", code: "PG", phoneCode: "+675", flag: "\u{1F1F5}\u{1F1EC}" },
+  { country: "Paraguay", code: "PY", phoneCode: "+595", flag: "\u{1F1F5}\u{1F1FE}" },
+  { country: "Peru", code: "PE", phoneCode: "+51", flag: "\u{1F1F5}\u{1F1EA}" },
+  { country: "Philippines", code: "PH", phoneCode: "+63", flag: "\u{1F1F5}\u{1F1ED}" },
+  { country: "Poland", code: "PL", phoneCode: "+48", flag: "\u{1F1F5}\u{1F1F1}" },
+  { country: "Portugal", code: "PT", phoneCode: "+351", flag: "\u{1F1F5}\u{1F1F9}" },
+  { country: "Puerto Rico", code: "PR", phoneCode: "+1787", flag: "\u{1F1F5}\u{1F1F7}" },
+  { country: "Qatar", code: "QA", phoneCode: "+974", flag: "\u{1F1F6}\u{1F1E6}" },
+  { country: "Romania", code: "RO", phoneCode: "+40", flag: "\u{1F1F7}\u{1F1F4}" },
+  { country: "Russia", code: "RU", phoneCode: "+7", flag: "\u{1F1F7}\u{1F1FA}" },
+  { country: "Rwanda", code: "RW", phoneCode: "+250", flag: "\u{1F1F7}\u{1F1FC}" },
+  { country: "Saudi Arabia", code: "SA", phoneCode: "+966", flag: "\u{1F1F8}\u{1F1E6}" },
+  { country: "Senegal", code: "SN", phoneCode: "+221", flag: "\u{1F1F8}\u{1F1F3}" },
+  { country: "Serbia", code: "RS", phoneCode: "+381", flag: "\u{1F1F7}\u{1F1F8}" },
+  { country: "Seychelles", code: "SC", phoneCode: "+248", flag: "\u{1F1F8}\u{1F1E8}" },
+  { country: "Sierra Leone", code: "SL", phoneCode: "+232", flag: "\u{1F1F8}\u{1F1F1}" },
+  { country: "Singapore", code: "SG", phoneCode: "+65", flag: "\u{1F1F8}\u{1F1EC}" },
+  { country: "Slovakia", code: "SK", phoneCode: "+421", flag: "\u{1F1F8}\u{1F1F0}" },
+  { country: "Slovenia", code: "SI", phoneCode: "+386", flag: "\u{1F1F8}\u{1F1EE}" },
+  { country: "Solomon Islands", code: "SB", phoneCode: "+677", flag: "\u{1F1F8}\u{1F1E7}" },
+  { country: "Somalia", code: "SO", phoneCode: "+252", flag: "\u{1F1F8}\u{1F1F4}" },
+  { country: "South Africa", code: "ZA", phoneCode: "+27", flag: "\u{1F1FF}\u{1F1E6}" },
+  { country: "South Korea", code: "KR", phoneCode: "+82", flag: "\u{1F1F0}\u{1F1F7}" },
+  { country: "South Sudan", code: "SS", phoneCode: "+211", flag: "\u{1F1F8}\u{1F1F8}" },
+  { country: "Spain", code: "ES", phoneCode: "+34", flag: "\u{1F1EA}\u{1F1F8}" },
+  { country: "Sri Lanka", code: "LK", phoneCode: "+94", flag: "\u{1F1F1}\u{1F1F0}" },
+  { country: "Sudan", code: "SD", phoneCode: "+249", flag: "\u{1F1F8}\u{1F1E9}" },
+  { country: "Suriname", code: "SR", phoneCode: "+597", flag: "\u{1F1F8}\u{1F1F7}" },
+  { country: "Sweden", code: "SE", phoneCode: "+46", flag: "\u{1F1F8}\u{1F1EA}" },
+  { country: "Switzerland", code: "CH", phoneCode: "+41", flag: "\u{1F1E8}\u{1F1ED}" },
+  { country: "Syria", code: "SY", phoneCode: "+963", flag: "\u{1F1F8}\u{1F1FE}" },
+  { country: "Taiwan", code: "TW", phoneCode: "+886", flag: "\u{1F1F9}\u{1F1FC}" },
+  { country: "Tajikistan", code: "TJ", phoneCode: "+992", flag: "\u{1F1F9}\u{1F1EF}" },
+  { country: "Tanzania", code: "TZ", phoneCode: "+255", flag: "\u{1F1F9}\u{1F1FF}" },
+  { country: "Thailand", code: "TH", phoneCode: "+66", flag: "\u{1F1F9}\u{1F1ED}" },
+  { country: "Togo", code: "TG", phoneCode: "+228", flag: "\u{1F1F9}\u{1F1EC}" },
+  { country: "Tonga", code: "TO", phoneCode: "+676", flag: "\u{1F1F9}\u{1F1F4}" },
+  { country: "Trinidad and Tobago", code: "TT", phoneCode: "+1868", flag: "\u{1F1F9}\u{1F1F9}" },
+  { country: "Tunisia", code: "TN", phoneCode: "+216", flag: "\u{1F1F9}\u{1F1F3}" },
+  { country: "Turkey", code: "TR", phoneCode: "+90", flag: "\u{1F1F9}\u{1F1F7}" },
+  { country: "Turkmenistan", code: "TM", phoneCode: "+993", flag: "\u{1F1F9}\u{1F1F2}" },
+  { country: "Tuvalu", code: "TV", phoneCode: "+688", flag: "\u{1F1F9}\u{1F1FB}" },
+  { country: "Uganda", code: "UG", phoneCode: "+256", flag: "\u{1F1FA}\u{1F1EC}" },
+  { country: "Ukraine", code: "UA", phoneCode: "+380", flag: "\u{1F1FA}\u{1F1E6}" },
+  { country: "United Arab Emirates", code: "AE", phoneCode: "+971", flag: "\u{1F1E6}\u{1F1EA}" },
+  { country: "United Kingdom", code: "GB", phoneCode: "+44", flag: "\u{1F1EC}\u{1F1E7}" },
+  { country: "United States", code: "US", phoneCode: "+1", flag: "\u{1F1FA}\u{1F1F8}" },
+  { country: "Uruguay", code: "UY", phoneCode: "+598", flag: "\u{1F1FA}\u{1F1FE}" },
+  { country: "Uzbekistan", code: "UZ", phoneCode: "+998", flag: "\u{1F1FA}\u{1F1FF}" },
+  { country: "Vanuatu", code: "VU", phoneCode: "+678", flag: "\u{1F1FB}\u{1F1FA}" },
+  { country: "Vatican City", code: "VA", phoneCode: "+379", flag: "\u{1F1FB}\u{1F1E6}" },
+  { country: "Venezuela", code: "VE", phoneCode: "+58", flag: "\u{1F1FB}\u{1F1EA}" },
+  { country: "Vietnam", code: "VN", phoneCode: "+84", flag: "\u{1F1FB}\u{1F1F3}" },
+  { country: "Yemen", code: "YE", phoneCode: "+967", flag: "\u{1F1FE}\u{1F1EA}" },
+  { country: "Zambia", code: "ZM", phoneCode: "+260", flag: "\u{1F1FF}\u{1F1F2}" },
+  { country: "Zimbabwe", code: "ZW", phoneCode: "+263", flag: "\u{1F1FF}\u{1F1FC}" }
+];
+var getPhoneCodeByCountry = (countryCode) => {
+  return phoneCodes.find((p) => p.code === countryCode);
+};
+var searchPhoneCodes = (query) => {
+  const lowerQuery = query.toLowerCase();
+  return phoneCodes.filter(
+    (p) => p.country.toLowerCase().includes(lowerQuery) || p.code.toLowerCase() === lowerQuery || p.phoneCode.includes(query)
+  );
+};
+var getPhoneCodesByPrefix = (prefix) => {
+  return phoneCodes.filter((p) => p.phoneCode.startsWith(prefix));
+};
+var phone_codes_default = phoneCodes;
+
+// src/data/currencies.ts
+var currencies = [
+  { code: "AED", name: "UAE Dirham", symbol: "AED", symbolNative: "\u062F.\u0625", decimalDigits: 2, rounding: 0, namePlural: "UAE dirhams" },
+  { code: "AFN", name: "Afghan Afghani", symbol: "Af", symbolNative: "\u060B", decimalDigits: 0, rounding: 0, namePlural: "Afghan Afghanis" },
+  { code: "ALL", name: "Albanian Lek", symbol: "ALL", symbolNative: "Lek", decimalDigits: 0, rounding: 0, namePlural: "Albanian lek\xEB" },
+  { code: "AMD", name: "Armenian Dram", symbol: "AMD", symbolNative: "\u0564\u0580.", decimalDigits: 0, rounding: 0, namePlural: "Armenian drams" },
+  { code: "ARS", name: "Argentine Peso", symbol: "AR$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Argentine pesos" },
+  { code: "AUD", name: "Australian Dollar", symbol: "AU$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Australian dollars" },
+  { code: "AZN", name: "Azerbaijani Manat", symbol: "man.", symbolNative: "\u043C\u0430\u043D.", decimalDigits: 2, rounding: 0, namePlural: "Azerbaijani manats" },
+  { code: "BAM", name: "Bosnia-Herzegovina Convertible Mark", symbol: "KM", symbolNative: "KM", decimalDigits: 2, rounding: 0, namePlural: "Bosnia-Herzegovina convertible marks" },
+  { code: "BDT", name: "Bangladeshi Taka", symbol: "Tk", symbolNative: "\u09F3", decimalDigits: 2, rounding: 0, namePlural: "Bangladeshi takas" },
+  { code: "BGN", name: "Bulgarian Lev", symbol: "BGN", symbolNative: "\u043B\u0432.", decimalDigits: 2, rounding: 0, namePlural: "Bulgarian leva" },
+  { code: "BHD", name: "Bahraini Dinar", symbol: "BD", symbolNative: "\u062F.\u0628.", decimalDigits: 3, rounding: 0, namePlural: "Bahraini dinars" },
+  { code: "BIF", name: "Burundian Franc", symbol: "FBu", symbolNative: "FBu", decimalDigits: 0, rounding: 0, namePlural: "Burundian francs" },
+  { code: "BND", name: "Brunei Dollar", symbol: "BN$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Brunei dollars" },
+  { code: "BOB", name: "Bolivian Boliviano", symbol: "Bs", symbolNative: "Bs", decimalDigits: 2, rounding: 0, namePlural: "Bolivian bolivianos" },
+  { code: "BRL", name: "Brazilian Real", symbol: "R$", symbolNative: "R$", decimalDigits: 2, rounding: 0, namePlural: "Brazilian reals" },
+  { code: "BWP", name: "Botswanan Pula", symbol: "BWP", symbolNative: "P", decimalDigits: 2, rounding: 0, namePlural: "Botswanan pulas" },
+  { code: "BYN", name: "Belarusian Ruble", symbol: "Br", symbolNative: "\u0440\u0443\u0431.", decimalDigits: 2, rounding: 0, namePlural: "Belarusian rubles" },
+  { code: "BZD", name: "Belize Dollar", symbol: "BZ$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Belize dollars" },
+  { code: "CAD", name: "Canadian Dollar", symbol: "CA$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Canadian dollars" },
+  { code: "CDF", name: "Congolese Franc", symbol: "CDF", symbolNative: "FrCD", decimalDigits: 2, rounding: 0, namePlural: "Congolese francs" },
+  { code: "CHF", name: "Swiss Franc", symbol: "CHF", symbolNative: "CHF", decimalDigits: 2, rounding: 0.05, namePlural: "Swiss francs" },
+  { code: "CLP", name: "Chilean Peso", symbol: "CL$", symbolNative: "$", decimalDigits: 0, rounding: 0, namePlural: "Chilean pesos" },
+  { code: "CNY", name: "Chinese Yuan", symbol: "CN\xA5", symbolNative: "\xA5", decimalDigits: 2, rounding: 0, namePlural: "Chinese yuan" },
+  { code: "COP", name: "Colombian Peso", symbol: "CO$", symbolNative: "$", decimalDigits: 0, rounding: 0, namePlural: "Colombian pesos" },
+  { code: "CRC", name: "Costa Rican Col\xF3n", symbol: "\u20A1", symbolNative: "\u20A1", decimalDigits: 0, rounding: 0, namePlural: "Costa Rican col\xF3ns" },
+  { code: "CZK", name: "Czech Koruna", symbol: "K\u010D", symbolNative: "K\u010D", decimalDigits: 2, rounding: 0, namePlural: "Czech korunas" },
+  { code: "DKK", name: "Danish Krone", symbol: "Dkr", symbolNative: "kr", decimalDigits: 2, rounding: 0, namePlural: "Danish kroner" },
+  { code: "DOP", name: "Dominican Peso", symbol: "RD$", symbolNative: "RD$", decimalDigits: 2, rounding: 0, namePlural: "Dominican pesos" },
+  { code: "DZD", name: "Algerian Dinar", symbol: "DA", symbolNative: "\u062F.\u062C.", decimalDigits: 2, rounding: 0, namePlural: "Algerian dinars" },
+  { code: "EGP", name: "Egyptian Pound", symbol: "EGP", symbolNative: "\u062C.\u0645.", decimalDigits: 2, rounding: 0, namePlural: "Egyptian pounds" },
+  { code: "ETB", name: "Ethiopian Birr", symbol: "Br", symbolNative: "Br", decimalDigits: 2, rounding: 0, namePlural: "Ethiopian birrs" },
+  { code: "EUR", name: "Euro", symbol: "\u20AC", symbolNative: "\u20AC", decimalDigits: 2, rounding: 0, namePlural: "euros" },
+  { code: "GBP", name: "British Pound", symbol: "\xA3", symbolNative: "\xA3", decimalDigits: 2, rounding: 0, namePlural: "British pounds" },
+  { code: "GEL", name: "Georgian Lari", symbol: "GEL", symbolNative: "GEL", decimalDigits: 2, rounding: 0, namePlural: "Georgian laris" },
+  { code: "GHS", name: "Ghanaian Cedi", symbol: "GH\u20B5", symbolNative: "GH\u20B5", decimalDigits: 2, rounding: 0, namePlural: "Ghanaian cedis" },
+  { code: "GNF", name: "Guinean Franc", symbol: "FG", symbolNative: "FG", decimalDigits: 0, rounding: 0, namePlural: "Guinean francs" },
+  { code: "GTQ", name: "Guatemalan Quetzal", symbol: "GTQ", symbolNative: "Q", decimalDigits: 2, rounding: 0, namePlural: "Guatemalan quetzals" },
+  { code: "HKD", name: "Hong Kong Dollar", symbol: "HK$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Hong Kong dollars" },
+  { code: "HNL", name: "Honduran Lempira", symbol: "HNL", symbolNative: "L", decimalDigits: 2, rounding: 0, namePlural: "Honduran lempiras" },
+  { code: "HRK", name: "Croatian Kuna", symbol: "kn", symbolNative: "kn", decimalDigits: 2, rounding: 0, namePlural: "Croatian kunas" },
+  { code: "HUF", name: "Hungarian Forint", symbol: "Ft", symbolNative: "Ft", decimalDigits: 0, rounding: 0, namePlural: "Hungarian forints" },
+  { code: "IDR", name: "Indonesian Rupiah", symbol: "Rp", symbolNative: "Rp", decimalDigits: 0, rounding: 0, namePlural: "Indonesian rupiahs" },
+  { code: "ILS", name: "Israeli New Shekel", symbol: "\u20AA", symbolNative: "\u20AA", decimalDigits: 2, rounding: 0, namePlural: "Israeli new shekels" },
+  { code: "INR", name: "Indian Rupee", symbol: "\u20B9", symbolNative: "\u20B9", decimalDigits: 2, rounding: 0, namePlural: "Indian rupees" },
+  { code: "IQD", name: "Iraqi Dinar", symbol: "IQD", symbolNative: "\u062F.\u0639.", decimalDigits: 0, rounding: 0, namePlural: "Iraqi dinars" },
+  { code: "IRR", name: "Iranian Rial", symbol: "IRR", symbolNative: "\uFDFC", decimalDigits: 0, rounding: 0, namePlural: "Iranian rials" },
+  { code: "ISK", name: "Icelandic Kr\xF3na", symbol: "Ikr", symbolNative: "kr", decimalDigits: 0, rounding: 0, namePlural: "Icelandic kr\xF3nur" },
+  { code: "JMD", name: "Jamaican Dollar", symbol: "J$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Jamaican dollars" },
+  { code: "JOD", name: "Jordanian Dinar", symbol: "JD", symbolNative: "\u062F.\u0623.", decimalDigits: 3, rounding: 0, namePlural: "Jordanian dinars" },
+  { code: "JPY", name: "Japanese Yen", symbol: "\xA5", symbolNative: "\uFFE5", decimalDigits: 0, rounding: 0, namePlural: "Japanese yen" },
+  { code: "KES", name: "Kenyan Shilling", symbol: "Ksh", symbolNative: "Ksh", decimalDigits: 2, rounding: 0, namePlural: "Kenyan shillings" },
+  { code: "KHR", name: "Cambodian Riel", symbol: "KHR", symbolNative: "\u17DB", decimalDigits: 2, rounding: 0, namePlural: "Cambodian riels" },
+  { code: "KRW", name: "South Korean Won", symbol: "\u20A9", symbolNative: "\u20A9", decimalDigits: 0, rounding: 0, namePlural: "South Korean won" },
+  { code: "KWD", name: "Kuwaiti Dinar", symbol: "KD", symbolNative: "\u062F.\u0643.", decimalDigits: 3, rounding: 0, namePlural: "Kuwaiti dinars" },
+  { code: "KZT", name: "Kazakhstani Tenge", symbol: "KZT", symbolNative: "\u0442\u04A3\u0433.", decimalDigits: 2, rounding: 0, namePlural: "Kazakhstani tenges" },
+  { code: "LAK", name: "Lao Kip", symbol: "\u20AD", symbolNative: "\u20AD", decimalDigits: 0, rounding: 0, namePlural: "Lao kip" },
+  { code: "LBP", name: "Lebanese Pound", symbol: "LB\xA3", symbolNative: "\u0644.\u0644.", decimalDigits: 0, rounding: 0, namePlural: "Lebanese pounds" },
+  { code: "LKR", name: "Sri Lankan Rupee", symbol: "SLRs", symbolNative: "\u0DBB\u0DD4", decimalDigits: 2, rounding: 0, namePlural: "Sri Lankan rupees" },
+  { code: "LYD", name: "Libyan Dinar", symbol: "LD", symbolNative: "\u062F.\u0644.", decimalDigits: 3, rounding: 0, namePlural: "Libyan dinars" },
+  { code: "MAD", name: "Moroccan Dirham", symbol: "MAD", symbolNative: "\u062F.\u0645.", decimalDigits: 2, rounding: 0, namePlural: "Moroccan dirhams" },
+  { code: "MDL", name: "Moldovan Leu", symbol: "MDL", symbolNative: "MDL", decimalDigits: 2, rounding: 0, namePlural: "Moldovan lei" },
+  { code: "MGA", name: "Malagasy Ariary", symbol: "MGA", symbolNative: "MGA", decimalDigits: 0, rounding: 0, namePlural: "Malagasy ariaries" },
+  { code: "MKD", name: "Macedonian Denar", symbol: "MKD", symbolNative: "MKD", decimalDigits: 2, rounding: 0, namePlural: "Macedonian denari" },
+  { code: "MMK", name: "Myanmar Kyat", symbol: "MMK", symbolNative: "K", decimalDigits: 0, rounding: 0, namePlural: "Myanmar kyats" },
+  { code: "MNT", name: "Mongolian Tugrik", symbol: "\u20AE", symbolNative: "\u20AE", decimalDigits: 0, rounding: 0, namePlural: "Mongolian tugriks" },
+  { code: "MOP", name: "Macanese Pataca", symbol: "MOP$", symbolNative: "MOP$", decimalDigits: 2, rounding: 0, namePlural: "Macanese patacas" },
+  { code: "MUR", name: "Mauritian Rupee", symbol: "MURs", symbolNative: "MURs", decimalDigits: 0, rounding: 0, namePlural: "Mauritian rupees" },
+  { code: "MXN", name: "Mexican Peso", symbol: "MX$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Mexican pesos" },
+  { code: "MYR", name: "Malaysian Ringgit", symbol: "RM", symbolNative: "RM", decimalDigits: 2, rounding: 0, namePlural: "Malaysian ringgits" },
+  { code: "MZN", name: "Mozambican Metical", symbol: "MTn", symbolNative: "MTn", decimalDigits: 2, rounding: 0, namePlural: "Mozambican meticals" },
+  { code: "NAD", name: "Namibian Dollar", symbol: "N$", symbolNative: "N$", decimalDigits: 2, rounding: 0, namePlural: "Namibian dollars" },
+  { code: "NGN", name: "Nigerian Naira", symbol: "\u20A6", symbolNative: "\u20A6", decimalDigits: 2, rounding: 0, namePlural: "Nigerian nairas" },
+  { code: "NIO", name: "Nicaraguan C\xF3rdoba", symbol: "C$", symbolNative: "C$", decimalDigits: 2, rounding: 0, namePlural: "Nicaraguan c\xF3rdobas" },
+  { code: "NOK", name: "Norwegian Krone", symbol: "Nkr", symbolNative: "kr", decimalDigits: 2, rounding: 0, namePlural: "Norwegian kroner" },
+  { code: "NPR", name: "Nepalese Rupee", symbol: "NPRs", symbolNative: "\u0928\u0947\u0930\u0942", decimalDigits: 2, rounding: 0, namePlural: "Nepalese rupees" },
+  { code: "NZD", name: "New Zealand Dollar", symbol: "NZ$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "New Zealand dollars" },
+  { code: "OMR", name: "Omani Rial", symbol: "OMR", symbolNative: "\u0631.\u0639.", decimalDigits: 3, rounding: 0, namePlural: "Omani rials" },
+  { code: "PAB", name: "Panamanian Balboa", symbol: "B/.", symbolNative: "B/.", decimalDigits: 2, rounding: 0, namePlural: "Panamanian balboas" },
+  { code: "PEN", name: "Peruvian Sol", symbol: "S/", symbolNative: "S/", decimalDigits: 2, rounding: 0, namePlural: "Peruvian soles" },
+  { code: "PHP", name: "Philippine Peso", symbol: "\u20B1", symbolNative: "\u20B1", decimalDigits: 2, rounding: 0, namePlural: "Philippine pesos" },
+  { code: "PKR", name: "Pakistani Rupee", symbol: "PKRs", symbolNative: "\u20A8", decimalDigits: 0, rounding: 0, namePlural: "Pakistani rupees" },
+  { code: "PLN", name: "Polish Zloty", symbol: "z\u0142", symbolNative: "z\u0142", decimalDigits: 2, rounding: 0, namePlural: "Polish zlotys" },
+  { code: "PYG", name: "Paraguayan Guarani", symbol: "\u20B2", symbolNative: "\u20B2", decimalDigits: 0, rounding: 0, namePlural: "Paraguayan guaranis" },
+  { code: "QAR", name: "Qatari Rial", symbol: "QR", symbolNative: "\u0631.\u0642.", decimalDigits: 2, rounding: 0, namePlural: "Qatari rials" },
+  { code: "RON", name: "Romanian Leu", symbol: "RON", symbolNative: "RON", decimalDigits: 2, rounding: 0, namePlural: "Romanian lei" },
+  { code: "RSD", name: "Serbian Dinar", symbol: "din.", symbolNative: "\u0434\u0438\u043D.", decimalDigits: 0, rounding: 0, namePlural: "Serbian dinars" },
+  { code: "RUB", name: "Russian Ruble", symbol: "RUB", symbolNative: "\u20BD", decimalDigits: 2, rounding: 0, namePlural: "Russian rubles" },
+  { code: "RWF", name: "Rwandan Franc", symbol: "RWF", symbolNative: "FR", decimalDigits: 0, rounding: 0, namePlural: "Rwandan francs" },
+  { code: "SAR", name: "Saudi Riyal", symbol: "SR", symbolNative: "\u0631.\u0633.", decimalDigits: 2, rounding: 0, namePlural: "Saudi riyals" },
+  { code: "SEK", name: "Swedish Krona", symbol: "Skr", symbolNative: "kr", decimalDigits: 2, rounding: 0, namePlural: "Swedish kronor" },
+  { code: "SGD", name: "Singapore Dollar", symbol: "S$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Singapore dollars" },
+  { code: "SOS", name: "Somali Shilling", symbol: "Ssh", symbolNative: "Ssh", decimalDigits: 0, rounding: 0, namePlural: "Somali shillings" },
+  { code: "SYP", name: "Syrian Pound", symbol: "SY\xA3", symbolNative: "\u0644.\u0633.", decimalDigits: 0, rounding: 0, namePlural: "Syrian pounds" },
+  { code: "THB", name: "Thai Baht", symbol: "\u0E3F", symbolNative: "\u0E3F", decimalDigits: 2, rounding: 0, namePlural: "Thai baht" },
+  { code: "TND", name: "Tunisian Dinar", symbol: "DT", symbolNative: "\u062F.\u062A.", decimalDigits: 3, rounding: 0, namePlural: "Tunisian dinars" },
+  { code: "TOP", name: "Tongan Pa'anga", symbol: "T$", symbolNative: "T$", decimalDigits: 2, rounding: 0, namePlural: "Tongan pa'anga" },
+  { code: "TRY", name: "Turkish Lira", symbol: "TL", symbolNative: "\u20BA", decimalDigits: 2, rounding: 0, namePlural: "Turkish liras" },
+  { code: "TTD", name: "Trinidad & Tobago Dollar", symbol: "TT$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Trinidad & Tobago dollars" },
+  { code: "TWD", name: "New Taiwan Dollar", symbol: "NT$", symbolNative: "NT$", decimalDigits: 2, rounding: 0, namePlural: "New Taiwan dollars" },
+  { code: "TZS", name: "Tanzanian Shilling", symbol: "TSh", symbolNative: "TSh", decimalDigits: 0, rounding: 0, namePlural: "Tanzanian shillings" },
+  { code: "UAH", name: "Ukrainian Hryvnia", symbol: "\u20B4", symbolNative: "\u20B4", decimalDigits: 2, rounding: 0, namePlural: "Ukrainian hryvnias" },
+  { code: "UGX", name: "Ugandan Shilling", symbol: "USh", symbolNative: "USh", decimalDigits: 0, rounding: 0, namePlural: "Ugandan shillings" },
+  { code: "USD", name: "US Dollar", symbol: "$", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "US dollars" },
+  { code: "UYU", name: "Uruguayan Peso", symbol: "$U", symbolNative: "$", decimalDigits: 2, rounding: 0, namePlural: "Uruguayan pesos" },
+  { code: "UZS", name: "Uzbekistani Som", symbol: "UZS", symbolNative: "UZS", decimalDigits: 0, rounding: 0, namePlural: "Uzbekistani som" },
+  { code: "VES", name: "Venezuelan Bol\xEDvar", symbol: "Bs", symbolNative: "Bs", decimalDigits: 2, rounding: 0, namePlural: "Venezuelan bol\xEDvars" },
+  { code: "VND", name: "Vietnamese Dong", symbol: "\u20AB", symbolNative: "\u20AB", decimalDigits: 0, rounding: 0, namePlural: "Vietnamese dong" },
+  { code: "XAF", name: "Central African CFA Franc", symbol: "FCFA", symbolNative: "FCFA", decimalDigits: 0, rounding: 0, namePlural: "Central African CFA francs" },
+  { code: "XOF", name: "West African CFA Franc", symbol: "CFA", symbolNative: "CFA", decimalDigits: 0, rounding: 0, namePlural: "West African CFA francs" },
+  { code: "YER", name: "Yemeni Rial", symbol: "YR", symbolNative: "\u0631.\u064A.", decimalDigits: 0, rounding: 0, namePlural: "Yemeni rials" },
+  { code: "ZAR", name: "South African Rand", symbol: "R", symbolNative: "R", decimalDigits: 2, rounding: 0, namePlural: "South African rand" },
+  { code: "ZMW", name: "Zambian Kwacha", symbol: "ZK", symbolNative: "ZK", decimalDigits: 0, rounding: 0, namePlural: "Zambian kwachas" },
+  { code: "ZWL", name: "Zimbabwean Dollar", symbol: "ZWL$", symbolNative: "ZWL$", decimalDigits: 0, rounding: 0, namePlural: "Zimbabwean dollars" }
+];
+var getCurrencyByCode = (code) => {
+  return currencies.find((c) => c.code === code.toUpperCase());
+};
+var searchCurrencies = (query) => {
+  const lowerQuery = query.toLowerCase();
+  return currencies.filter(
+    (c) => c.code.toLowerCase().includes(lowerQuery) || c.name.toLowerCase().includes(lowerQuery)
+  );
+};
+var formatCurrency = (amount, currencyCode, locale = "en-US") => {
+  const currency = getCurrencyByCode(currencyCode);
+  if (!currency) {
+    return amount.toFixed(2);
+  }
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currency.code,
+      minimumFractionDigits: currency.decimalDigits,
+      maximumFractionDigits: currency.decimalDigits
+    }).format(amount);
+  } catch {
+    return `${currency.symbol}${amount.toFixed(currency.decimalDigits)}`;
+  }
+};
+var formatCurrencyNative = (amount, currencyCode) => {
+  const currency = getCurrencyByCode(currencyCode);
+  if (!currency) {
+    return amount.toFixed(2);
+  }
+  return `${currency.symbolNative}${amount.toFixed(currency.decimalDigits)}`;
+};
+var currencies_default = currencies;
+
+// src/data/timezones.ts
+var timezones = [
+  { name: "Pacific/Midway", label: "(UTC-11:00) Midway Island", offset: "-11:00", offsetMinutes: -660 },
+  { name: "Pacific/Honolulu", label: "(UTC-10:00) Hawaii", offset: "-10:00", offsetMinutes: -600 },
+  { name: "America/Anchorage", label: "(UTC-09:00) Alaska", offset: "-09:00", offsetMinutes: -540 },
+  { name: "America/Los_Angeles", label: "(UTC-08:00) Pacific Time (US & Canada)", offset: "-08:00", offsetMinutes: -480 },
+  { name: "America/Phoenix", label: "(UTC-07:00) Arizona", offset: "-07:00", offsetMinutes: -420 },
+  { name: "America/Denver", label: "(UTC-07:00) Mountain Time (US & Canada)", offset: "-07:00", offsetMinutes: -420 },
+  { name: "America/Chicago", label: "(UTC-06:00) Central Time (US & Canada)", offset: "-06:00", offsetMinutes: -360 },
+  { name: "America/Mexico_City", label: "(UTC-06:00) Mexico City", offset: "-06:00", offsetMinutes: -360 },
+  { name: "America/New_York", label: "(UTC-05:00) Eastern Time (US & Canada)", offset: "-05:00", offsetMinutes: -300 },
+  { name: "America/Bogota", label: "(UTC-05:00) Bogota", offset: "-05:00", offsetMinutes: -300 },
+  { name: "America/Lima", label: "(UTC-05:00) Lima", offset: "-05:00", offsetMinutes: -300 },
+  { name: "America/Caracas", label: "(UTC-04:00) Caracas", offset: "-04:00", offsetMinutes: -240 },
+  { name: "America/Halifax", label: "(UTC-04:00) Atlantic Time (Canada)", offset: "-04:00", offsetMinutes: -240 },
+  { name: "America/Santiago", label: "(UTC-04:00) Santiago", offset: "-04:00", offsetMinutes: -240 },
+  { name: "America/Sao_Paulo", label: "(UTC-03:00) Brasilia", offset: "-03:00", offsetMinutes: -180 },
+  { name: "America/Buenos_Aires", label: "(UTC-03:00) Buenos Aires", offset: "-03:00", offsetMinutes: -180 },
+  { name: "Atlantic/South_Georgia", label: "(UTC-02:00) Mid-Atlantic", offset: "-02:00", offsetMinutes: -120 },
+  { name: "Atlantic/Azores", label: "(UTC-01:00) Azores", offset: "-01:00", offsetMinutes: -60 },
+  { name: "Europe/London", label: "(UTC+00:00) London, Dublin", offset: "+00:00", offsetMinutes: 0 },
+  { name: "UTC", label: "(UTC+00:00) UTC", offset: "+00:00", offsetMinutes: 0 },
+  { name: "Africa/Casablanca", label: "(UTC+00:00) Casablanca", offset: "+00:00", offsetMinutes: 0 },
+  { name: "Europe/Paris", label: "(UTC+01:00) Paris, Berlin, Rome", offset: "+01:00", offsetMinutes: 60 },
+  { name: "Europe/Amsterdam", label: "(UTC+01:00) Amsterdam, Brussels", offset: "+01:00", offsetMinutes: 60 },
+  { name: "Africa/Lagos", label: "(UTC+01:00) West Central Africa", offset: "+01:00", offsetMinutes: 60 },
+  { name: "Europe/Athens", label: "(UTC+02:00) Athens, Istanbul", offset: "+02:00", offsetMinutes: 120 },
+  { name: "Europe/Kiev", label: "(UTC+02:00) Kyiv", offset: "+02:00", offsetMinutes: 120 },
+  { name: "Africa/Cairo", label: "(UTC+02:00) Cairo", offset: "+02:00", offsetMinutes: 120 },
+  { name: "Africa/Johannesburg", label: "(UTC+02:00) Johannesburg", offset: "+02:00", offsetMinutes: 120 },
+  { name: "Asia/Jerusalem", label: "(UTC+02:00) Jerusalem", offset: "+02:00", offsetMinutes: 120 },
+  { name: "Europe/Moscow", label: "(UTC+03:00) Moscow", offset: "+03:00", offsetMinutes: 180 },
+  { name: "Asia/Kuwait", label: "(UTC+03:00) Kuwait, Riyadh", offset: "+03:00", offsetMinutes: 180 },
+  { name: "Africa/Nairobi", label: "(UTC+03:00) Nairobi", offset: "+03:00", offsetMinutes: 180 },
+  { name: "Asia/Tehran", label: "(UTC+03:30) Tehran", offset: "+03:30", offsetMinutes: 210 },
+  { name: "Asia/Dubai", label: "(UTC+04:00) Dubai, Abu Dhabi", offset: "+04:00", offsetMinutes: 240 },
+  { name: "Asia/Baku", label: "(UTC+04:00) Baku", offset: "+04:00", offsetMinutes: 240 },
+  { name: "Asia/Kabul", label: "(UTC+04:30) Kabul", offset: "+04:30", offsetMinutes: 270 },
+  { name: "Asia/Karachi", label: "(UTC+05:00) Karachi", offset: "+05:00", offsetMinutes: 300 },
+  { name: "Asia/Tashkent", label: "(UTC+05:00) Tashkent", offset: "+05:00", offsetMinutes: 300 },
+  { name: "Asia/Kolkata", label: "(UTC+05:30) Mumbai, New Delhi", offset: "+05:30", offsetMinutes: 330 },
+  { name: "Asia/Colombo", label: "(UTC+05:30) Sri Lanka", offset: "+05:30", offsetMinutes: 330 },
+  { name: "Asia/Kathmandu", label: "(UTC+05:45) Kathmandu", offset: "+05:45", offsetMinutes: 345 },
+  { name: "Asia/Dhaka", label: "(UTC+06:00) Dhaka", offset: "+06:00", offsetMinutes: 360 },
+  { name: "Asia/Almaty", label: "(UTC+06:00) Almaty", offset: "+06:00", offsetMinutes: 360 },
+  { name: "Asia/Yangon", label: "(UTC+06:30) Yangon", offset: "+06:30", offsetMinutes: 390 },
+  { name: "Asia/Bangkok", label: "(UTC+07:00) Bangkok", offset: "+07:00", offsetMinutes: 420 },
+  { name: "Asia/Jakarta", label: "(UTC+07:00) Jakarta", offset: "+07:00", offsetMinutes: 420 },
+  { name: "Asia/Ho_Chi_Minh", label: "(UTC+07:00) Ho Chi Minh City", offset: "+07:00", offsetMinutes: 420 },
+  { name: "Asia/Singapore", label: "(UTC+08:00) Singapore", offset: "+08:00", offsetMinutes: 480 },
+  { name: "Asia/Hong_Kong", label: "(UTC+08:00) Hong Kong", offset: "+08:00", offsetMinutes: 480 },
+  { name: "Asia/Shanghai", label: "(UTC+08:00) Beijing, Shanghai", offset: "+08:00", offsetMinutes: 480 },
+  { name: "Asia/Taipei", label: "(UTC+08:00) Taipei", offset: "+08:00", offsetMinutes: 480 },
+  { name: "Asia/Kuala_Lumpur", label: "(UTC+08:00) Kuala Lumpur", offset: "+08:00", offsetMinutes: 480 },
+  { name: "Australia/Perth", label: "(UTC+08:00) Perth", offset: "+08:00", offsetMinutes: 480 },
+  { name: "Asia/Seoul", label: "(UTC+09:00) Seoul", offset: "+09:00", offsetMinutes: 540 },
+  { name: "Asia/Tokyo", label: "(UTC+09:00) Tokyo", offset: "+09:00", offsetMinutes: 540 },
+  { name: "Australia/Darwin", label: "(UTC+09:30) Darwin", offset: "+09:30", offsetMinutes: 570 },
+  { name: "Australia/Adelaide", label: "(UTC+09:30) Adelaide", offset: "+09:30", offsetMinutes: 570 },
+  { name: "Australia/Sydney", label: "(UTC+10:00) Sydney, Melbourne", offset: "+10:00", offsetMinutes: 600 },
+  { name: "Australia/Brisbane", label: "(UTC+10:00) Brisbane", offset: "+10:00", offsetMinutes: 600 },
+  { name: "Pacific/Guam", label: "(UTC+10:00) Guam", offset: "+10:00", offsetMinutes: 600 },
+  { name: "Pacific/Noumea", label: "(UTC+11:00) New Caledonia", offset: "+11:00", offsetMinutes: 660 },
+  { name: "Pacific/Fiji", label: "(UTC+12:00) Fiji", offset: "+12:00", offsetMinutes: 720 },
+  { name: "Pacific/Auckland", label: "(UTC+12:00) Auckland, Wellington", offset: "+12:00", offsetMinutes: 720 },
+  { name: "Pacific/Tongatapu", label: "(UTC+13:00) Nuku'alofa", offset: "+13:00", offsetMinutes: 780 }
+];
+var getTimezoneByName = (name) => {
+  return timezones.find((tz) => tz.name === name);
+};
+var searchTimezones = (query) => {
+  const lowerQuery = query.toLowerCase();
+  return timezones.filter(
+    (tz) => tz.name.toLowerCase().includes(lowerQuery) || tz.label.toLowerCase().includes(lowerQuery)
+  );
+};
+var getTimezonesByOffset = (offsetMinutes) => {
+  return timezones.filter((tz) => tz.offsetMinutes === offsetMinutes);
+};
+var sortTimezonesByOffset = (ascending = true) => {
+  return [...timezones].sort(
+    (a, b) => ascending ? a.offsetMinutes - b.offsetMinutes : b.offsetMinutes - a.offsetMinutes
+  );
+};
+var timezones_default = timezones;
+
+// src/data/logos.ts
+var brands = {
+  botify: {
+    name: "Botify",
+    domain: "botify.life",
+    tagline: "AI-Powered Chatbots",
+    primaryColor: "#6366F1",
+    secondaryColor: "#8B5CF6",
+    logo: {
+      full: {
+        light: "https://botify.life/logos/botify-full-dark.svg",
+        dark: "https://botify.life/logos/botify-full-light.svg"
+      },
+      icon: {
+        light: "https://botify.life/logos/botify-icon-dark.svg",
+        dark: "https://botify.life/logos/botify-icon-light.svg"
+      },
+      favicon: "https://botify.life/favicon.ico"
+    }
+  },
+  exyconn: {
+    name: "Exyconn",
+    domain: "exyconn.com",
+    tagline: "Connect. Create. Collaborate.",
+    primaryColor: "#0EA5E9",
+    secondaryColor: "#06B6D4",
+    logo: {
+      full: {
+        light: "https://exyconn.com/logos/exyconn-full-dark.svg",
+        dark: "https://exyconn.com/logos/exyconn-full-light.svg"
+      },
+      icon: {
+        light: "https://exyconn.com/logos/exyconn-icon-dark.svg",
+        dark: "https://exyconn.com/logos/exyconn-icon-light.svg"
+      },
+      favicon: "https://exyconn.com/favicon.ico"
+    }
+  },
+  partywings: {
+    name: "PartyWings",
+    domain: "partywings.fun",
+    tagline: "Your Party, Your Rules",
+    primaryColor: "#EC4899",
+    secondaryColor: "#F472B6",
+    logo: {
+      full: {
+        light: "https://partywings.fun/logos/partywings-full-dark.svg",
+        dark: "https://partywings.fun/logos/partywings-full-light.svg"
+      },
+      icon: {
+        light: "https://partywings.fun/logos/partywings-icon-dark.svg",
+        dark: "https://partywings.fun/logos/partywings-icon-light.svg"
+      },
+      favicon: "https://partywings.fun/favicon.ico"
+    }
+  },
+  sibera: {
+    name: "Sibera",
+    domain: "sibera.work",
+    tagline: "Work Smarter, Together",
+    primaryColor: "#10B981",
+    secondaryColor: "#34D399",
+    logo: {
+      full: {
+        light: "https://sibera.work/logos/sibera-full-dark.svg",
+        dark: "https://sibera.work/logos/sibera-full-light.svg"
+      },
+      icon: {
+        light: "https://sibera.work/logos/sibera-icon-dark.svg",
+        dark: "https://sibera.work/logos/sibera-icon-light.svg"
+      },
+      favicon: "https://sibera.work/favicon.ico"
+    }
+  },
+  spentiva: {
+    name: "Spentiva",
+    domain: "spentiva.com",
+    tagline: "Smart Spending, Smart Living",
+    primaryColor: "#F59E0B",
+    secondaryColor: "#FBBF24",
+    logo: {
+      full: {
+        light: "https://spentiva.com/logos/spentiva-full-dark.svg",
+        dark: "https://spentiva.com/logos/spentiva-full-light.svg"
+      },
+      icon: {
+        light: "https://spentiva.com/logos/spentiva-icon-dark.svg",
+        dark: "https://spentiva.com/logos/spentiva-icon-light.svg"
+      },
+      favicon: "https://spentiva.com/favicon.ico"
+    }
+  }
+};
+var getBrand = (key) => {
+  return brands[key.toLowerCase()];
+};
+var getBrandByDomain = (domain) => {
+  return Object.values(brands).find((b) => b.domain === domain);
+};
+var getLogo = (brandKey, mode, type = "full") => {
+  const brand = getBrand(brandKey);
+  if (!brand) return void 0;
+  return brand.logo[type][mode];
+};
+var getAllBrands = () => {
+  return Object.values(brands);
+};
+var getAllBrandKeys = () => {
+  return Object.keys(brands);
+};
+var logos_default = brands;
+
+exports.client = client_exports;
+exports.data = data_exports;
+exports.server = server_exports;
+exports.shared = shared_exports;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map