@itshackers/utilix 0.0.0-stage → 0.3.0

package/dist/index.js

@@ -0,0 +1,853 @@
+// src/internal/validation.ts
+function assertFiniteNumber(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`${name} must be a finite number`);
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/string/index.ts
+var HTML_ESCAPE_MAP = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function splitWords(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  return trimmed.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/u).filter((word) => word.length > 0);
+}
+function toLowerWords(value) {
+  return splitWords(value).map((word) => word.toLowerCase());
+}
+function capitalizeWord(word) {
+  const [first = "", ...rest] = [...word];
+  return `${first.toUpperCase()}${rest.join("").toLowerCase()}`;
+}
+function toCamelCase(value) {
+  const words = toLowerWords(value);
+  if (words.length === 0) {
+    return "";
+  }
+  const [first = "", ...rest] = words;
+  return `${first}${rest.map(capitalizeWord).join("")}`;
+}
+function toPascalCase(value) {
+  return toLowerWords(value).map(capitalizeWord).join("");
+}
+function toSnakeCase(value) {
+  return toLowerWords(value).join("_");
+}
+function toKebabCase(value) {
+  return toLowerWords(value).join("-");
+}
+function capitalize(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  const [first = "", ...rest] = [...trimmed];
+  return `${first.toUpperCase()}${rest.join("")}`;
+}
+function normalizeWhitespace(value) {
+  return value.trim().replace(/\s+/gu, " ");
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (character) => HTML_ESCAPE_MAP[character] ?? character);
+}
+function escapeRegex(value) {
+  return escapeRegExp(value);
+}
+function toTitleCase(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  return trimmed.toLowerCase().replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function convertCase(value, casing = "title") {
+  switch (casing.toLowerCase()) {
+    case "title":
+    case "titlecase":
+      return toTitleCase(value);
+    case "lower":
+    case "lowercase":
+      return value.trim().toLowerCase();
+    case "upper":
+    case "uppercase":
+      return value.trim().toUpperCase();
+    case "camel":
+    case "camelcase":
+      return toCamelCase(value);
+    case "pascal":
+    case "pascalcase":
+      return toPascalCase(value);
+    case "snake":
+    case "snakecase":
+      return toSnakeCase(value);
+    case "kebab":
+    case "kebabcase":
+      return toKebabCase(value);
+    default:
+      throw new TypeError(`Unsupported case style: ${casing}`);
+  }
+}
+function replaceSeparatorsWithSpace(value) {
+  return toTitleCase(value.replace(/[-_]+/g, " ").replace(/\s+/g, " "));
+}
+function htmlToPlainText(value) {
+  if (value.trim().length === 0) {
+    return "";
+  }
+  return value.replace(/<(br|\/p|\/div|\/pre|\/li)\b[^>]*>/gi, " ").replace(/<[^>]*>/g, " ").replace(/[\n\t]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function nonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+
+// src/number/index.ts
+var DEFAULT_LOCALE = "en-IN";
+var DEFAULT_CURRENCY = "INR";
+var MAX_DECIMAL_PLACES = 15;
+var DECIMAL_NUMBER_PATTERN = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function toNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || /[,\s]/.test(trimmed)) {
+    return null;
+  }
+  if (!DECIMAL_NUMBER_PATTERN.test(trimmed)) {
+    return null;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function formatNumber(value, options) {
+  assertFiniteNumber(value, "value");
+  const { locale = DEFAULT_LOCALE, ...intlOptions } = options ?? {};
+  if (typeof locale !== "string" || locale.trim().length === 0) {
+    throw new TypeError("locale must be a non-empty BCP 47 locale tag");
+  }
+  return new Intl.NumberFormat(locale, intlOptions).format(value);
+}
+function formatCurrency(value, currency = DEFAULT_CURRENCY, locale = DEFAULT_LOCALE) {
+  assertFiniteNumber(value, "value");
+  if (typeof currency !== "string" || currency.trim().length === 0) {
+    throw new TypeError("currency must be a non-empty ISO 4217 currency code");
+  }
+  if (typeof locale !== "string" || locale.trim().length === 0) {
+    throw new TypeError("locale must be a non-empty BCP 47 locale tag");
+  }
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(value);
+}
+function clamp(value, min, max) {
+  assertFiniteNumber(value, "value");
+  assertFiniteNumber(min, "min");
+  assertFiniteNumber(max, "max");
+  if (min > max) {
+    throw new RangeError("min must be less than or equal to max");
+  }
+  return Math.min(max, Math.max(min, value));
+}
+function roundTo(value, decimalPlaces = 0) {
+  assertFiniteNumber(value, "value");
+  if (!Number.isInteger(decimalPlaces) || decimalPlaces < 0 || decimalPlaces > MAX_DECIMAL_PLACES) {
+    throw new RangeError(
+      `decimalPlaces must be an integer between 0 and ${MAX_DECIMAL_PLACES}`
+    );
+  }
+  if (Object.is(value, -0)) {
+    return 0;
+  }
+  const [significand = "0", exponent = "0"] = `${value}e`.split("e");
+  const shifted = Number(`${significand}e${Number(exponent) + decimalPlaces}`);
+  const rounded = Math.round(shifted);
+  const [roundedSignificand = "0", roundedExponent = "0"] = `${rounded}e`.split("e");
+  const result = Number(
+    `${roundedSignificand}e${Number(roundedExponent) - decimalPlaces}`
+  );
+  return Object.is(result, -0) ? 0 : result;
+}
+function parsePositiveInt(value, fallback) {
+  assertFiniteNumber(fallback, "fallback");
+  const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function toNumberIfValid(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (/^\d+$/.test(trimmed)) {
+      return Number(trimmed);
+    }
+  }
+  return value;
+}
+
+// src/slug/index.ts
+function slugify(value, options = {}) {
+  const separator = options.separator ?? "-";
+  const preserveUnicode = options.preserveUnicode ?? true;
+  const { maxLength } = options;
+  if (typeof separator !== "string" || separator.length === 0 || /\s/u.test(separator)) {
+    throw new TypeError("separator must be a non-empty string without whitespace");
+  }
+  if (options.preserveUnicode !== void 0 && typeof options.preserveUnicode !== "boolean") {
+    throw new TypeError("preserveUnicode must be a boolean");
+  }
+  if (maxLength !== void 0 && (!Number.isInteger(maxLength) || maxLength <= 0)) {
+    throw new RangeError("maxLength must be a positive integer");
+  }
+  const escapedSeparator = escapeRegExp(separator);
+  const disallowedPattern = preserveUnicode ? /[^\p{L}\p{N}]+/gu : /[^a-z0-9]+/g;
+  let slug = value.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().replace(disallowedPattern, separator).replace(new RegExp(`${escapedSeparator}+`, "g"), separator).replace(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, "g"), "");
+  if (maxLength !== void 0 && slug.length > maxLength) {
+    slug = slug.slice(0, maxLength).replace(new RegExp(`${escapedSeparator}+$`, "g"), "");
+  }
+  return slug;
+}
+
+// src/common/index.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function isNilOrEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  return false;
+}
+function coalesce(value, fallback) {
+  return value ?? fallback;
+}
+function toBoolean(value, fallback = false) {
+  if (value === true || value === 1 || value === "1") {
+    return true;
+  }
+  if (value === false || value === 0 || value === "0") {
+    return false;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+      return fallback;
+    }
+    if (normalized === "true") {
+      return true;
+    }
+    if (normalized === "false") {
+      return false;
+    }
+  }
+  if (value == null) {
+    return fallback;
+  }
+  return fallback;
+}
+function deepTrim(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepTrim(item));
+  }
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [key, deepTrim(nested)])
+    );
+  }
+  return value;
+}
+function omitEmpty(value) {
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const cleaned = { ...value };
+  for (const key of Object.keys(cleaned)) {
+    if (cleaned[key] === "" || cleaned[key] === null) {
+      delete cleaned[key];
+    }
+  }
+  return cleaned;
+}
+function pickAllowed(value, allowed, fallback) {
+  return allowed.includes(value) ? value : fallback;
+}
+function sleep(milliseconds) {
+  assertFiniteNumber(milliseconds, "milliseconds");
+  if (milliseconds < 0) {
+    throw new RangeError("milliseconds must be greater than or equal to 0");
+  }
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+
+// src/format/index.ts
+var DEFAULT_LOCALE2 = "en-IN";
+var DEFAULT_TIME_ZONE = "Asia/Kolkata";
+var FILE_SIZE_UNITS = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+function formatDateTime(value, options = {}) {
+  if (value == null || value === "") {
+    return null;
+  }
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  const { locale = DEFAULT_LOCALE2, ...intlOptions } = options;
+  if (typeof locale !== "string" || locale.trim().length === 0) {
+    throw new TypeError("locale must be a non-empty BCP 47 locale tag");
+  }
+  return new Intl.DateTimeFormat(locale, {
+    timeZone: DEFAULT_TIME_ZONE,
+    day: "2-digit",
+    month: "short",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: true,
+    ...intlOptions
+  }).format(date);
+}
+function formatFileSize(bytes, decimals = 2) {
+  assertFiniteNumber(bytes, "bytes");
+  if (bytes < 0) {
+    throw new RangeError("bytes must be greater than or equal to 0");
+  }
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 8) {
+    throw new RangeError("decimals must be an integer between 0 and 8");
+  }
+  if (bytes === 0) {
+    return "0 Bytes";
+  }
+  const unitIndex = Math.min(
+    Math.floor(Math.log(bytes) / Math.log(1024)),
+    FILE_SIZE_UNITS.length - 1
+  );
+  const value = bytes / 1024 ** unitIndex;
+  const unit = FILE_SIZE_UNITS[unitIndex] ?? "Bytes";
+  return `${Number(value.toFixed(decimals))} ${unit}`;
+}
+function formatDuration(seconds) {
+  assertFiniteNumber(seconds, "seconds");
+  if (seconds <= 0) {
+    return "0 sec";
+  }
+  const total = Math.floor(seconds);
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const remainingSeconds = total % 60;
+  const parts = [];
+  if (hours > 0) {
+    parts.push(`${hours} hr`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes} min`);
+  }
+  if (remainingSeconds > 0 || parts.length === 0) {
+    parts.push(`${remainingSeconds} sec`);
+  }
+  return parts.join(" ");
+}
+function formatDurationCompact(value, options = {}) {
+  assertFiniteNumber(value, "value");
+  const unit = options.unit ?? "seconds";
+  if (unit !== "seconds" && unit !== "milliseconds") {
+    throw new TypeError('unit must be "seconds" or "milliseconds"');
+  }
+  let remaining = Math.floor(unit === "milliseconds" ? value / 1e3 : value);
+  if (remaining <= 0) {
+    return "0s";
+  }
+  const years = Math.floor(remaining / 31536e3);
+  remaining %= 31536e3;
+  const months = Math.floor(remaining / 2592e3);
+  remaining %= 2592e3;
+  const days = Math.floor(remaining / 86400);
+  remaining %= 86400;
+  const hours = Math.floor(remaining / 3600);
+  remaining %= 3600;
+  const minutes = Math.floor(remaining / 60);
+  const seconds = remaining % 60;
+  const parts = [];
+  if (years > 0) {
+    parts.push(`${years}y`);
+  }
+  if (months > 0) {
+    parts.push(`${months}mo`);
+  }
+  if (days > 0) {
+    parts.push(`${days}d`);
+  }
+  if (hours > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes}m`);
+  }
+  if (seconds > 0 || parts.length === 0) {
+    parts.push(`${seconds}s`);
+  }
+  return parts.join(" ");
+}
+function formatPriceToLakh(price, decimals = 2) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 8) {
+    throw new RangeError("decimals must be an integer between 0 and 8");
+  }
+  const numeric = typeof price === "number" ? price : typeof price === "string" ? Number(price.trim()) : Number.NaN;
+  if (!Number.isFinite(numeric)) {
+    return "";
+  }
+  return `${(numeric / 1e5).toFixed(decimals)} Lakh`;
+}
+
+// src/phone/index.ts
+var INDIAN_MOBILE_PATTERN = /^[6-9]\d{9}$/;
+function normalizeMobile(value) {
+  if (value == null) {
+    return null;
+  }
+  const digits = String(value).replace(/\D/g, "");
+  if (digits.length === 0) {
+    return null;
+  }
+  const withoutCountryCode = digits.length > 10 && (digits.startsWith("91") || digits.startsWith("0")) ? digits.slice(-10) : digits.length >= 10 ? digits.slice(-10) : digits;
+  return INDIAN_MOBILE_PATTERN.test(withoutCountryCode) ? withoutCountryCode : null;
+}
+
+// src/internal/random.ts
+function getCrypto() {
+  const cryptoApi = globalThis.crypto;
+  if (!cryptoApi?.getRandomValues) {
+    throw new Error("Secure random number generation is not available in this runtime");
+  }
+  return cryptoApi;
+}
+function randomIndex(length) {
+  if (length <= 0) {
+    throw new RangeError("length must be greater than 0");
+  }
+  const cryptoApi = getCrypto();
+  const limit = 4294967296;
+  const unbiasedMax = Math.floor(limit / length) * length;
+  const bytes = new Uint32Array(1);
+  let value = 0;
+  do {
+    cryptoApi.getRandomValues(bytes);
+    value = bytes[0] ?? 0;
+  } while (value >= unbiasedMax);
+  return value % length;
+}
+function pickCharacter(charset) {
+  return charset[randomIndex(charset.length)] ?? charset[0] ?? "A";
+}
+function randomString(length, charset) {
+  return Array.from({ length }, () => pickCharacter(charset)).join("");
+}
+function shuffle(items) {
+  const result = [...items];
+  for (let index = result.length - 1; index > 0; index -= 1) {
+    const swapIndex = randomIndex(index + 1);
+    const current = result[index];
+    const other = result[swapIndex];
+    if (current === void 0 || other === void 0) {
+      continue;
+    }
+    result[index] = other;
+    result[swapIndex] = current;
+  }
+  return result;
+}
+
+// src/password/index.ts
+var UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+var NUMBERS = "0123456789";
+var SPECIAL = "!@#$%^&*()_+-=[]{}|;:,.<>?";
+var ALL_CHARACTERS = `${UPPERCASE}${LOWERCASE}${NUMBERS}${SPECIAL}`;
+var MIN_PASSWORD_LENGTH = 8;
+var DEFAULT_PASSWORD_LENGTH = 12;
+function generatePassword(length = DEFAULT_PASSWORD_LENGTH) {
+  if (!Number.isInteger(length) || length < MIN_PASSWORD_LENGTH) {
+    throw new RangeError(`length must be an integer greater than or equal to ${MIN_PASSWORD_LENGTH}`);
+  }
+  const required = [
+    pickCharacter(UPPERCASE),
+    pickCharacter(LOWERCASE),
+    pickCharacter(NUMBERS),
+    pickCharacter(SPECIAL)
+  ];
+  const remaining = Array.from(
+    { length: length - required.length },
+    () => pickCharacter(ALL_CHARACTERS)
+  );
+  return shuffle([...required, ...remaining]).join("");
+}
+
+// src/id/index.ts
+var DEFAULT_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function generatePrefixedCode(options) {
+  const prefix = options.prefix.trim();
+  if (prefix.length === 0) {
+    throw new TypeError("prefix must be a non-empty string");
+  }
+  const randomLength = options.randomLength ?? 5;
+  if (!Number.isInteger(randomLength) || randomLength < 0) {
+    throw new RangeError("randomLength must be an integer greater than or equal to 0");
+  }
+  const charset = options.charset ?? DEFAULT_CHARSET;
+  if (charset.length === 0) {
+    throw new TypeError("charset must be a non-empty string");
+  }
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const randomPart = randomLength > 0 ? randomString(randomLength, charset) : "";
+  if (!includeTimestamp) {
+    return `${prefix}${randomPart}`;
+  }
+  const day = pad(now.getDate());
+  const month = pad(now.getMonth() + 1);
+  const hour = pad(now.getHours());
+  const minute = pad(now.getMinutes());
+  return `${prefix}${day}${month}${randomPart}${hour}${minute}`;
+}
+
+// src/date/index.ts
+var IST_OFFSET_MS = 330 * 60 * 1e3;
+var IST_DATETIME_RE = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})(?::(\d{2}))?/;
+function pad2(value, length = 2) {
+  return String(value).padStart(length, "0");
+}
+function getIstDateParts(date = /* @__PURE__ */ new Date()) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Asia/Kolkata",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const read = (type) => {
+    const value = parts.find((part) => part.type === type)?.value;
+    return Number(value);
+  };
+  return {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour")
+  };
+}
+function addCalendarDays(year, month, day, days) {
+  const utc = new Date(Date.UTC(year, month - 1, day + days));
+  return {
+    year: utc.getUTCFullYear(),
+    month: utc.getUTCMonth() + 1,
+    day: utc.getUTCDate()
+  };
+}
+function istDateTime(year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0) {
+  return /* @__PURE__ */ new Date(
+    `${year}-${pad2(month)}-${pad2(day)}T${pad2(hour)}:${pad2(minute)}:${pad2(second)}.${pad2(millisecond, 3)}+05:30`
+  );
+}
+function parseIstDateTimeToUtc(value) {
+  if (value == null || value === "") {
+    return null;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === "number") {
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const raw = value.trim();
+  if (raw.length === 0) {
+    return null;
+  }
+  if (/[zZ]$/.test(raw) || /[+-]\d{2}:?\d{2}$/.test(raw)) {
+    const parsed = new Date(raw);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const match = raw.match(IST_DATETIME_RE);
+  if (!match) {
+    const parsed = new Date(raw);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const [, year = "0", month = "1", day = "1", hour = "0", minute = "0", second = "0"] = match;
+  const istAsUtcMs = Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second)
+  );
+  return new Date(istAsUtcMs - IST_OFFSET_MS);
+}
+function formatUtcToIstDateTime(value) {
+  if (value == null || value === "") {
+    return "";
+  }
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  const ist = new Date(date.getTime() + IST_OFFSET_MS);
+  return `${ist.getUTCFullYear()}-${pad2(ist.getUTCMonth() + 1)}-${pad2(ist.getUTCDate())} ${pad2(ist.getUTCHours())}:${pad2(ist.getUTCMinutes())}:${pad2(ist.getUTCSeconds())}`;
+}
+function getExpiryInfo(expiresAt, options = {}) {
+  if (!(expiresAt instanceof Date) || Number.isNaN(expiresAt.getTime())) {
+    return null;
+  }
+  const warningDays = options.warningDays ?? 7;
+  const compact = options.compact ?? false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  let remainingSeconds = Math.floor((expiresAt.getTime() - now.getTime()) / 1e3);
+  if (remainingSeconds < 0) {
+    remainingSeconds = 0;
+  }
+  const units = [
+    { label: "day", short: "d", value: 86400 },
+    { label: "hour", short: "h", value: 3600 },
+    { label: "minute", short: "m", value: 60 },
+    { label: "second", short: "s", value: 1 }
+  ];
+  const parts = [];
+  let remaining = remainingSeconds;
+  for (const unit of units) {
+    const count = Math.floor(remaining / unit.value);
+    if (count > 0) {
+      parts.push(compact ? `${count}${unit.short}` : `${count} ${unit.label}${count > 1 ? "s" : ""}`);
+      remaining -= count * unit.value;
+    }
+  }
+  const daysLeft = Math.ceil(remainingSeconds / 86400);
+  return {
+    expiresAt,
+    remainingSeconds,
+    remainingHuman: parts.join(" ") || "Expired",
+    daysLeft,
+    isExpired: remainingSeconds === 0,
+    needsRefresh: daysLeft <= warningDays
+  };
+}
+function getCalendarWindow(options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const cutoffHour = options.cutoffHour ?? 14;
+  const windowDays = options.windowDays ?? 36;
+  const startOffsetBeforeCutoff = options.startOffsetBeforeCutoff ?? 1;
+  const startOffsetAfterCutoff = options.startOffsetAfterCutoff ?? 2;
+  if (!Number.isInteger(cutoffHour) || cutoffHour < 0 || cutoffHour > 23) {
+    throw new RangeError("cutoffHour must be an integer between 0 and 23");
+  }
+  if (!Number.isInteger(windowDays) || windowDays < 0) {
+    throw new RangeError("windowDays must be an integer greater than or equal to 0");
+  }
+  const { year, month, day, hour } = getIstDateParts(now);
+  const startOffsetDays = hour < cutoffHour ? startOffsetBeforeCutoff : startOffsetAfterCutoff;
+  const minYmd = addCalendarDays(year, month, day, startOffsetDays);
+  const maxYmd = addCalendarDays(minYmd.year, minYmd.month, minYmd.day, windowDays);
+  return {
+    min: istDateTime(minYmd.year, minYmd.month, minYmd.day, 0, 0, 0, 0),
+    max: istDateTime(maxYmd.year, maxYmd.month, maxYmd.day, 23, 59, 59, 999)
+  };
+}
+
+// src/sanitize/index.ts
+var DEFAULT_SENSITIVE_KEYS = [
+  "authorization",
+  "password",
+  "client_secret",
+  "otp",
+  "otp_hash",
+  "api_key",
+  "x-api-key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "jwt",
+  "secret"
+];
+function resolveOptions(options = {}) {
+  return {
+    sensitiveKeys: new Set(
+      (options.sensitiveKeys ?? DEFAULT_SENSITIVE_KEYS).map((key) => key.toLowerCase())
+    ),
+    maxDepth: options.maxDepth ?? 6,
+    maxString: options.maxString ?? 2e3,
+    maxArray: options.maxArray ?? 50,
+    redactedValue: options.redactedValue ?? "[REDACTED]",
+    truncatedValue: options.truncatedValue ?? "[truncated]"
+  };
+}
+function sanitizeForLog(value, options = {}, depth = 0) {
+  const config = resolveOptions(options);
+  if (depth > config.maxDepth) {
+    return config.truncatedValue;
+  }
+  if (value == null || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.length > config.maxString ? `${value.slice(0, config.maxString)}\u2026` : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, config.maxArray).map((item) => sanitizeForLog(item, options, depth + 1));
+  }
+  if (isPlainObject(value)) {
+    const output = {};
+    for (const [key, nested] of Object.entries(value)) {
+      output[key] = config.sensitiveKeys.has(key.toLowerCase()) ? config.redactedValue : sanitizeForLog(nested, options, depth + 1);
+    }
+    return output;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return String(value);
+}
+function sanitizeHeaders(headers, options = {}) {
+  const config = resolveOptions(options);
+  const output = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (config.sensitiveKeys.has(key.toLowerCase())) {
+      output[key] = config.redactedValue;
+    } else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      output[key] = value;
+    } else if (Array.isArray(value)) {
+      output[key] = value.map(String);
+    }
+  }
+  return output;
+}
+
+// src/response/index.ts
+function createSuccessResponse(options = {}) {
+  const response = { success: true };
+  if (options.message) {
+    response.message = options.message;
+  }
+  if (options.data !== void 0) {
+    response.data = options.data;
+  }
+  if (options.meta !== void 0) {
+    response.meta = options.meta;
+  }
+  if (options.requestId) {
+    response.request_id = options.requestId;
+  }
+  return response;
+}
+function createErrorResponse(options = {}) {
+  const response = { success: false };
+  if (options.message) {
+    response.message = options.message;
+  }
+  if (options.code !== void 0) {
+    response.code = options.code;
+  }
+  if (options.errors !== void 0) {
+    response.errors = options.errors;
+  }
+  if (options.details !== void 0) {
+    response.details = options.details;
+  }
+  if (options.requestId) {
+    response.request_id = options.requestId;
+  }
+  return response;
+}
+
+// src/regex/index.ts
+var ValidationPatterns = {
+  YEAR: /^\d{4}$/,
+  OTP: /^\d{6}$/,
+  PINCODE: /^\d{6}$/,
+  POSTAL_CODE: /^\d{6}$/,
+  NUMERIC: /^[0-9]+$/,
+  MOBILE: /^[6-9]\d{9}$/,
+  NAME: /^[a-zA-Z\s\-']+$/,
+  ALPHABETIC: /^[a-zA-Z]+$/,
+  LOWERCASE_ONLY: /^[a-z_]+$/,
+  UPPERCASE_ONLY: /^[A-Z_]+$/,
+  USERNAME: /^[a-zA-Z0-9_-]+$/,
+  LOWER_NUMERIC: /^[a-z0-9_]+$/,
+  UPPER_NUMERIC: /^[A-Z0-9_]+$/,
+  LOWER_WITH_HYPHENS: /^[a-z-]+$/,
+  UPPER_WITH_HYPHENS: /^[A-Z-]+$/,
+  ALPHANUMERIC: /^[a-zA-Z0-9-\s]+$/,
+  PERMISSION_NAME: /^[a-z0-9._-]+$/,
+  AADHAR_CARD: /^[2-9][0-9]{11}$/,
+  LOWER_NUMERIC_WITH_HYPHENS: /^[a-z0-9-]+$/,
+  UPPER_NUMERIC_WITH_HYPHENS: /^[A-Z0-9-]+$/,
+  ALPHANUMERIC_WITH_SPACES: /^[a-zA-Z0-9\s]+$/,
+  ALPHANUMERIC_WITHOUT_SPACES: /^[a-zA-Z0-9]+$/,
+  PAN_CARD: /^[A-Za-z]{5}[0-9]{4}[A-Za-z]$/,
+  ALPHANUMERIC_WITH_UNDERSCORES: /^[a-zA-Z0-9-_]+$/,
+  MODEL_NAME: /^[a-zA-Z0-9_\s\-/\\*+()[\]:'",.%&]+$/,
+  NOTE: /^[a-zA-Z0-9\s/\\,.\-_+=<>()[\]{}@#$%^&*~`"',;:’]+$/,
+  EMAIL: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+  VEHICLE_NUMBER: /^[A-Za-z]{2}\d{1,2}[A-Za-z]{1,3}\d{1,4}$/,
+  PASSWORD: /^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[@$!%*?&])[a-zA-Z0-9@$!%*?&]{8,16}$/,
+  URL: /^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/,
+  DATE: /^\d{4}-\d{2}-\d{2}$/,
+  CURRENCY: /^\d+(?:\.\d{1,2})?$/,
+  TIME: /^(?:[01]?\d|2[0-3]):[0-5]\d$/,
+  MESSAGE: /^[a-zA-Z0-9\s.,!?_\-@#()&%$+=:;"'<>[\]{}|\\/]+$/,
+  DOMAIN_HOSTNAME: /^(?=.{1,253}$)(?:localhost|(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}|[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)$/i
+};
+function testPattern(value, pattern) {
+  if (typeof pattern === "string") {
+    const namedPattern = ValidationPatterns[pattern];
+    if (!namedPattern) {
+      throw new TypeError(`Unknown validation pattern: ${pattern}`);
+    }
+    return namedPattern.test(value);
+  }
+  return pattern.test(value);
+}
+function getPattern(name) {
+  const pattern = ValidationPatterns[name];
+  if (!pattern) {
+    throw new TypeError(`Unknown validation pattern: ${name}`);
+  }
+  return pattern;
+}
+
+export { ValidationPatterns, addCalendarDays, capitalize, clamp, coalesce, convertCase, createErrorResponse, createSuccessResponse, deepTrim, escapeHtml, escapeRegex as escapeRegExp, escapeRegex, formatCurrency, formatDateTime, formatDuration, formatDurationCompact, formatFileSize, formatNumber, formatPriceToLakh, formatUtcToIstDateTime, generatePassword, generatePrefixedCode, getCalendarWindow, getExpiryInfo, getIstDateParts, getPattern, htmlToPlainText, isNilOrEmpty, isPlainObject, istDateTime, nonEmptyString, normalizeMobile, normalizeWhitespace, omitEmpty, parseIstDateTimeToUtc, parsePositiveInt, pickAllowed, replaceSeparatorsWithSpace, roundTo, sanitizeForLog, sanitizeHeaders, sleep, slugify, testPattern, toBoolean, toCamelCase, toKebabCase, toNumber, toNumberIfValid, toPascalCase, toSnakeCase, toTitleCase };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map