superjs-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1505 @@
+// src/core/index.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function getType(value) {
+  return Object.prototype.toString.call(value);
+}
+function clone(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  const tag = getType(value);
+  if (tag === "[object Date]") {
+    const cloned = new Date(value.getTime());
+    seen.set(value, cloned);
+    return cloned;
+  }
+  if (tag === "[object RegExp]") {
+    const regExp = value;
+    const cloned = new RegExp(regExp.source, regExp.flags);
+    cloned.lastIndex = regExp.lastIndex;
+    seen.set(value, cloned);
+    return cloned;
+  }
+  if (tag === "[object Map]") {
+    const cloned = /* @__PURE__ */ new Map();
+    seen.set(value, cloned);
+    value.forEach((v, k) => {
+      cloned.set(clone(k, seen), clone(v, seen));
+    });
+    return cloned;
+  }
+  if (tag === "[object Set]") {
+    const cloned = /* @__PURE__ */ new Set();
+    seen.set(value, cloned);
+    value.forEach((v) => {
+      cloned.add(clone(v, seen));
+    });
+    return cloned;
+  }
+  if (Array.isArray(value)) {
+    const cloned = [];
+    seen.set(value, cloned);
+    for (let i = 0; i < value.length; i++) {
+      cloned[i] = clone(value[i], seen);
+    }
+    return cloned;
+  }
+  if (tag === "[object Object]") {
+    const cloned = {};
+    seen.set(value, cloned);
+    const keys = Object.keys(value);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      cloned[key] = clone(value[key], seen);
+    }
+    return cloned;
+  }
+  return value;
+}
+function deepClone(value) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  return clone(value, seen);
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (let i = 0; i < objects.length; i++) {
+    const obj = objects[i];
+    if (obj === null || obj === void 0) continue;
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; j++) {
+      const key = keys[j];
+      const val = obj[key];
+      const existing = result[key];
+      if (val !== void 0 && isPlainObject(val) && isPlainObject(existing)) {
+        result[key] = deepMerge(
+          existing,
+          val
+        );
+      } else if (val !== void 0) {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+function debounce(fn, wait, options) {
+  const { leading = false, trailing = true, maxWait } = options ?? {};
+  let timer = null;
+  let maxTimer = null;
+  let lastArgs = null;
+  let lastCallTime = null;
+  let lastInvokeTime = 0;
+  function invoke(time) {
+    lastInvokeTime = time;
+    if (lastArgs) {
+      fn(...lastArgs);
+      lastArgs = null;
+    }
+  }
+  function startTimer(waitTime) {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const now = Date.now();
+      if (lastArgs && trailing) {
+        invoke(now);
+      }
+      timer = null;
+      lastCallTime = null;
+    }, waitTime);
+  }
+  function startMaxTimer() {
+    if (maxWait === void 0 || maxTimer) return;
+    maxTimer = setTimeout(() => {
+      if (lastArgs) {
+        invoke(Date.now());
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        lastCallTime = null;
+      }
+    }, maxWait);
+  }
+  function clearAllTimers() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (maxTimer) {
+      clearTimeout(maxTimer);
+      maxTimer = null;
+    }
+  }
+  function shouldInvoke(time) {
+    if (lastCallTime === null) return true;
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return timeSinceLastCall >= wait || maxWait !== void 0 && timeSinceLastInvoke >= maxWait;
+  }
+  const debounced = function(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastCallTime = time;
+    if (isInvoking && !timer && leading) {
+      invoke(time);
+    }
+    if (!timer) {
+      startTimer(wait);
+      if (maxWait !== void 0) {
+        startMaxTimer();
+      }
+    }
+  };
+  debounced.cancel = () => {
+    clearAllTimers();
+    lastArgs = null;
+    lastCallTime = null;
+    lastInvokeTime = 0;
+  };
+  debounced.flush = () => {
+    if (timer && lastArgs) {
+      invoke(Date.now());
+      clearAllTimers();
+      lastCallTime = null;
+    }
+  };
+  return debounced;
+}
+function throttle(fn, wait) {
+  let lastTime = 0;
+  let timer = null;
+  let lastArgs = null;
+  const throttled = function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastTime);
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastTime = now;
+      lastArgs = null;
+      fn.apply(this, args);
+    } else {
+      lastArgs = args;
+      if (!timer) {
+        timer = setTimeout(() => {
+          lastTime = Date.now();
+          timer = null;
+          if (lastArgs) {
+            fn.apply(this, lastArgs);
+            lastArgs = null;
+          }
+        }, remaining);
+      }
+    }
+  };
+  return throttled;
+}
+function memoize(fn, resolver) {
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = resolver ? resolver(...args) : String(args[0]);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  return memoized;
+}
+function retry(fn, options) {
+  const {
+    attempts = 3,
+    baseDelay = 1e3,
+    maxDelay = 3e4,
+    shouldRetry = () => true
+  } = options ?? {};
+  let attempt = 0;
+  const execute = () => {
+    attempt++;
+    return fn().catch((error) => {
+      if (attempt >= attempts || !shouldRetry(error)) {
+        throw error;
+      }
+      const delay = Math.min(
+        baseDelay * Math.pow(2, attempt - 1) + Math.random() * baseDelay,
+        maxDelay
+      );
+      return new Promise((resolve2) => {
+        setTimeout(() => {
+          resolve2(execute());
+        }, delay);
+      });
+    });
+  };
+  return execute();
+}
+function noop() {
+  return void 0;
+}
+function identity(value) {
+  return value;
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+
+// src/math/index.ts
+var DivisionByZeroError = class extends Error {
+  constructor() {
+    super("Division by zero");
+    this.name = "DivisionByZeroError";
+  }
+};
+function getPrecision(value) {
+  if (!isFinite(value)) return 0;
+  const eIndex = String(value).indexOf("e");
+  if (eIndex > -1) {
+    const exp = parseInt(String(value).slice(eIndex + 1), 10);
+    if (exp < 0) return Math.abs(exp);
+    return 0;
+  }
+  const str = String(value);
+  const dot = str.indexOf(".");
+  return dot === -1 ? 0 : str.length - dot - 1;
+}
+function toPrecisionFactor(a, b) {
+  return Math.pow(10, Math.max(getPrecision(a), getPrecision(b)));
+}
+function add(a, b) {
+  const factor = toPrecisionFactor(a, b);
+  return (Math.round(a * factor) + Math.round(b * factor)) / factor;
+}
+function sub(a, b) {
+  const factor = toPrecisionFactor(a, b);
+  return (Math.round(a * factor) - Math.round(b * factor)) / factor;
+}
+function mul(a, b) {
+  const factorA = toPrecisionFactor(a, 1);
+  const factorB = toPrecisionFactor(1, b);
+  const result = Math.round(a * factorA) * Math.round(b * factorB) / (factorA * factorB);
+  return result;
+}
+function div(a, b) {
+  if (b === 0) throw new DivisionByZeroError();
+  const factor = toPrecisionFactor(a, b);
+  return Math.round(a * factor) / Math.round(b * factor);
+}
+function round(value, precision = 0) {
+  const factor = Math.pow(10, precision);
+  return Math.round(value * factor) / factor;
+}
+function floor(value, precision = 0) {
+  const factor = Math.pow(10, precision);
+  return Math.floor(value * factor) / factor;
+}
+function ceil(value, precision = 0) {
+  const factor = Math.pow(10, precision);
+  return Math.ceil(value * factor) / factor;
+}
+function approxEqual(a, b, tolerance = Number.EPSILON) {
+  return Math.abs(a - b) <= tolerance;
+}
+function clamp(value, min, max) {
+  if (min > max) {
+    throw new RangeError("Minimum value cannot exceed maximum value");
+  }
+  return Math.min(Math.max(value, min), max);
+}
+function sum(values) {
+  let total = 0;
+  for (let i = 0; i < values.length; i++) {
+    total += values[i];
+  }
+  return total;
+}
+function average(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute average of an empty array");
+  }
+  return sum(values) / values.length;
+}
+function randomInt(min, max) {
+  if (!Number.isInteger(min) || !Number.isInteger(max)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (min > max) {
+    throw new RangeError("Minimum value cannot exceed maximum value");
+  }
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function inRange(value, min, max) {
+  return value >= min && value <= max;
+}
+
+// src/date/index.ts
+var InvalidDateError = class extends Error {
+  constructor(input) {
+    super(`Invalid date: ${String(input)}`);
+    this.name = "InvalidDateError";
+  }
+};
+var MONTH_NAMES_SHORT = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var MONTH_NAMES_FULL = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var MONTH_MAP = {
+  jan: 0,
+  january: 0,
+  feb: 1,
+  february: 1,
+  mar: 2,
+  march: 2,
+  apr: 3,
+  april: 3,
+  may: 4,
+  jun: 5,
+  june: 5,
+  jul: 6,
+  july: 6,
+  aug: 7,
+  august: 7,
+  sep: 8,
+  september: 8,
+  oct: 9,
+  october: 9,
+  nov: 10,
+  november: 10,
+  dec: 11,
+  december: 11
+};
+function formatDate(date, format2 = "YYYY-MM-DD") {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const ms = date.getMilliseconds();
+  const pad2 = (n, len = 2) => String(n).padStart(len, "0");
+  return format2.replace(/YYYY/g, String(year)).replace(/YY/g, String(year).slice(-2)).replace(/MMMM/g, MONTH_NAMES_FULL[month]).replace(/MMM/g, MONTH_NAMES_SHORT[month]).replace(/MM/g, pad2(month + 1)).replace(/DD/g, pad2(day)).replace(/HH/g, pad2(hours)).replace(/mm/g, pad2(minutes)).replace(/ss/g, pad2(seconds)).replace(/SSS/g, pad2(ms, 3));
+}
+function parseDate(input) {
+  if (input instanceof Date) {
+    if (isNaN(input.getTime())) throw new InvalidDateError(input);
+    return new Date(input.getTime());
+  }
+  if (typeof input === "number") {
+    const d = new Date(input);
+    if (isNaN(d.getTime())) throw new InvalidDateError(input);
+    return d;
+  }
+  const trimmed = input.trim();
+  const isoMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?(?:Z|[+-]\d{2}:?\d{2})?$/);
+  if (isoMatch) {
+    const d = new Date(
+      parseInt(isoMatch[1], 10),
+      parseInt(isoMatch[2], 10) - 1,
+      parseInt(isoMatch[3], 10),
+      isoMatch[4] ? parseInt(isoMatch[4], 10) : 0,
+      isoMatch[5] ? parseInt(isoMatch[5], 10) : 0,
+      isoMatch[6] ? parseInt(isoMatch[6], 10) : 0,
+      isoMatch[7] ? parseInt(isoMatch[7].padEnd(3, "0"), 10) : 0
+    );
+    if (!isNaN(d.getTime())) return d;
+  }
+  const dmyMatch = trimmed.match(/^(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})$/);
+  if (dmyMatch) {
+    const d = new Date(
+      parseInt(dmyMatch[3], 10),
+      parseInt(dmyMatch[2], 10) - 1,
+      parseInt(dmyMatch[1], 10)
+    );
+    if (!isNaN(d.getTime())) return d;
+  }
+  const textMatch = trimmed.match(/^(\d{1,2})\s+([a-zA-Z]+)\s+(\d{4})$/);
+  if (textMatch) {
+    const monthIndex = MONTH_MAP[textMatch[2].toLowerCase()];
+    if (monthIndex !== void 0) {
+      const d = new Date(
+        parseInt(textMatch[3], 10),
+        monthIndex,
+        parseInt(textMatch[1], 10)
+      );
+      if (!isNaN(d.getTime())) return d;
+    }
+  }
+  const numMatch = trimmed.match(/^-?\d+$/);
+  if (numMatch) {
+    const d = new Date(parseInt(numMatch[0], 10));
+    if (!isNaN(d.getTime())) return d;
+  }
+  const fallback = new Date(trimmed);
+  if (!isNaN(fallback.getTime())) return fallback;
+  throw new InvalidDateError(input);
+}
+function isValidDate(d) {
+  return d instanceof Date && !isNaN(d.getTime());
+}
+var MS_IN_SECOND = 1e3;
+var MS_IN_MINUTE = 60 * MS_IN_SECOND;
+var MS_IN_HOUR = 60 * MS_IN_MINUTE;
+var MS_IN_DAY = 24 * MS_IN_HOUR;
+function dateDiff(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to dateDiff");
+  }
+  let years = date2.getFullYear() - date1.getFullYear();
+  let months = date2.getMonth() - date1.getMonth();
+  let days = date2.getDate() - date1.getDate();
+  if (days < 0) {
+    months -= 1;
+    const prevMonth = new Date(date2.getFullYear(), date2.getMonth(), 0);
+    days += prevMonth.getDate();
+  }
+  if (months < 0) {
+    years -= 1;
+    months += 12;
+  }
+  const msDiff = Math.abs(date2.getTime() - date1.getTime());
+  const totalSeconds = Math.floor(msDiff / MS_IN_SECOND);
+  const hours = Math.floor(msDiff % MS_IN_DAY / MS_IN_HOUR);
+  const minutes = Math.floor(msDiff % MS_IN_HOUR / MS_IN_MINUTE);
+  const seconds = totalSeconds % 60;
+  return { years, months, days, hours, minutes, seconds };
+}
+function addDays(date, days) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function addMonths(date, months) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  const targetMonth = result.getMonth() + months;
+  result.setMonth(targetMonth);
+  if (result.getMonth() !== (targetMonth % 12 + 12) % 12) {
+    result.setDate(0);
+  }
+  return result;
+}
+function addYears(date, years) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  const targetYear = result.getFullYear() + years;
+  result.setFullYear(targetYear);
+  if (result.getFullYear() !== targetYear) {
+    result.setDate(0);
+  }
+  return result;
+}
+function startOfDay(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+}
+function endOfDay(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+}
+function startOfMonth(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
+}
+function endOfMonth(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
+}
+function startOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), 0, 1, 0, 0, 0, 0);
+}
+function endOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), 12, 0, 23, 59, 59, 999);
+}
+function isWeekend(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function isBefore(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to isBefore");
+  }
+  return date1.getTime() < date2.getTime();
+}
+function isAfter(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to isAfter");
+  }
+  return date1.getTime() > date2.getTime();
+}
+function isBetween(date, start, end) {
+  if (!isValidDate(date) || !isValidDate(start) || !isValidDate(end)) {
+    throw new InvalidDateError("Invalid date provided to isBetween");
+  }
+  return date.getTime() >= start.getTime() && date.getTime() <= end.getTime();
+}
+function isBusinessDay(date) {
+  return isValidDate(date) && !isWeekend(date);
+}
+function addBusinessDays(date, days) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  let remaining = Math.abs(days);
+  const step = days >= 0 ? 1 : -1;
+  while (remaining > 0) {
+    result.setDate(result.getDate() + step);
+    const day = result.getDay();
+    if (day !== 0 && day !== 6) {
+      remaining--;
+    }
+  }
+  return result;
+}
+function calculateAge(birthDate) {
+  if (!isValidDate(birthDate)) throw new InvalidDateError(birthDate);
+  const today = /* @__PURE__ */ new Date();
+  let age = today.getFullYear() - birthDate.getFullYear();
+  const monthDiff = today.getMonth() - birthDate.getMonth();
+  if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+    age--;
+  }
+  return age;
+}
+
+// src/crypto/index.ts
+function hash(str) {
+  let h = 5381;
+  for (let i = 0; i < str.length; i++) {
+    h = (h << 5) + h + str.charCodeAt(i) | 0;
+  }
+  return h >>> 0;
+}
+function simpleHash(str) {
+  let h1 = 1732584193;
+  let h2 = 4023233417;
+  let h3 = 2562383102;
+  let h4 = 271733878;
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    h1 = h1 + c | 0;
+    h2 = h2 + (c << 3) + i | 0;
+    h3 = h3 ^ c | 0;
+    h4 = h4 + (c << 5) + (c << 1) | 0;
+  }
+  const toHex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+  return toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4);
+}
+function getRandomBytes(size) {
+  const bytes = new Uint8Array(size);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < size; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return bytes;
+}
+function randomHex(size = 16) {
+  const bytes = getRandomBytes(size);
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    result += bytes[i].toString(16).padStart(2, "0");
+  }
+  return result;
+}
+function utf8ToBytes(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes;
+}
+function bytesToUtf8(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder().decode(bytes);
+  }
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    result += String.fromCharCode(bytes[i]);
+  }
+  return result;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  if (typeof btoa === "function") {
+    return btoa(binary);
+  }
+  return Buffer.from(binary, "latin1").toString("base64");
+}
+function base64ToBytes(str) {
+  let binary;
+  if (typeof atob === "function") {
+    binary = atob(str);
+  } else {
+    binary = Buffer.from(str, "base64").toString("latin1");
+  }
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function base64Encode(str) {
+  const bytes = utf8ToBytes(str);
+  return bytesToBase64(bytes);
+}
+function base64Decode(str) {
+  const bytes = base64ToBytes(str);
+  return bytesToUtf8(bytes);
+}
+function generateToken(bytes = 32) {
+  return randomHex(bytes);
+}
+function generateOTP(length = 6) {
+  const bytes = getRandomBytes(length);
+  let otp = "";
+  for (let i = 0; i < length; i++) {
+    otp += (bytes[i] % 10).toString();
+  }
+  return otp;
+}
+function xorCipher(str, key) {
+  let result = "";
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i) ^ key.charCodeAt(i % key.length);
+    result += String.fromCharCode(code);
+  }
+  return result;
+}
+function checksum(input) {
+  let crc = 4294967295;
+  for (let i = 0; i < input.length; i++) {
+    crc ^= input.charCodeAt(i);
+    for (let j = 0; j < 8; j++) {
+      if (crc & 1) {
+        crc = crc >>> 1 ^ 3988292384;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+  }
+  return ((crc ^ 4294967295) >>> 0).toString(16).padStart(8, "0");
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+
+// src/path/index.ts
+var SEP = "/";
+function join(...segments) {
+  const parts = [];
+  for (const seg of segments) {
+    if (seg === "") continue;
+    const split = seg.split(/[\\/]/);
+    for (const part of split) {
+      if (part === "" || part === ".") continue;
+      if (part === "..") {
+        if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+          parts.pop();
+        } else {
+          parts.push("..");
+        }
+      } else {
+        parts.push(part);
+      }
+    }
+  }
+  if (parts.length === 0) return ".";
+  const result = parts.join(SEP);
+  if (segments.length > 0 && segments[0].startsWith("/")) {
+    return SEP + result;
+  }
+  return result;
+}
+function resolve(...segments) {
+  let resolved = "";
+  let isAbs = false;
+  for (const seg of segments) {
+    if (seg.startsWith("/")) {
+      resolved = seg;
+      isAbs = true;
+    } else if (isAbs) {
+      resolved = join(resolved, seg);
+    } else {
+      resolved = resolved ? join(resolved, seg) : seg;
+    }
+  }
+  if (!isAbs) {
+    resolved = join(SEP, resolved);
+  }
+  return normalize(resolved);
+}
+function basename(p, ext) {
+  const normalized = p.replace(/[\\/]+$/, "");
+  const idx = normalized.lastIndexOf(SEP);
+  let base = idx === -1 ? normalized : normalized.slice(idx + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, -ext.length);
+  }
+  return base;
+}
+function dirname(p) {
+  if (p === SEP) return SEP;
+  const normalized = p.replace(/[\\/]+$/, "");
+  if (normalized === "") return ".";
+  const idx = normalized.lastIndexOf(SEP);
+  if (idx === -1) return ".";
+  if (idx === 0) return SEP;
+  return normalized.slice(0, idx);
+}
+function extname(p) {
+  const base = basename(p);
+  const idx = base.lastIndexOf(".");
+  if (idx === -1 || idx === 0) return "";
+  return base.slice(idx);
+}
+function normalize(p) {
+  const parts = p.split(/[\\/]+/);
+  const stack = [];
+  let isAbs = p.startsWith("/");
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+      } else if (!isAbs) {
+        stack.push("..");
+      }
+    } else {
+      stack.push(part);
+    }
+  }
+  const result = stack.join(SEP);
+  if (isAbs) return SEP + result;
+  if (result === "") return ".";
+  return result;
+}
+function isAbsolute(p) {
+  return p.startsWith("/");
+}
+function relative(from, to) {
+  const fromParts = normalize(from).split(SEP);
+  const toParts = normalize(to).split(SEP);
+  let i = 0;
+  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+    i++;
+  }
+  const up = fromParts.slice(i).map(() => "..");
+  const down = toParts.slice(i);
+  const result = [...up, ...down].join(SEP);
+  return result || ".";
+}
+function parse(p) {
+  const root = p.startsWith(SEP) ? SEP : "";
+  const base = basename(p);
+  const ext = extname(base);
+  const name = ext ? base.slice(0, -ext.length) : base;
+  const dir = root ? dirname(p) : dirname(p) === "." ? "" : dirname(p);
+  return { root, dir, base, name, ext };
+}
+function format(parsed) {
+  const { root = "", dir = "", base = "", name = "", ext = "" } = parsed;
+  const baseName = base || name + ext;
+  if (dir) {
+    return dir + SEP + baseName;
+  }
+  return root + baseName;
+}
+
+// src/collection/index.ts
+function groupBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!result[key]) result[key] = [];
+    result[key].push(item);
+  }
+  return result;
+}
+function keyBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    result[key] = item;
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function pluck(items, key) {
+  return items.map((item) => item[key]);
+}
+function shuffle(items) {
+  const result = [...items];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = result[i];
+    result[i] = result[j];
+    result[j] = temp;
+  }
+  return result;
+}
+function sample(items) {
+  return items.length > 0 ? items[Math.floor(Math.random() * items.length)] : void 0;
+}
+function sampleSize(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const pool = shuffle(items);
+  return pool.slice(0, Math.min(size, items.length));
+}
+function chunk(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const result = [];
+  for (let i = 0; i < items.length; i += size) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  return String(a) < String(b) ? -1 : 1;
+}
+function sortBy(items, ...criteria) {
+  return [...items].sort((a, b) => {
+    for (const criterion of criteria) {
+      const cmp = compareValues(criterion(a), criterion(b));
+      if (cmp !== 0) return cmp;
+    }
+    return 0;
+  });
+}
+function orderBy(items, key, direction = "asc") {
+  return [...items].sort((a, b) => {
+    const cmp = compareValues(key(a), key(b));
+    return direction === "asc" ? cmp : -cmp;
+  });
+}
+function uniqueBy(items, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function flatten(items) {
+  const result = [];
+  for (const sub2 of items) {
+    for (const item of sub2) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function first(items) {
+  return items[0];
+}
+function last(items) {
+  return items[items.length - 1];
+}
+function isEmpty(value) {
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "string") return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (value !== null && typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+
+// src/string/index.ts
+var WORD_SPLIT_RE = /[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\b)|\d+/g;
+function splitWords(str) {
+  return str.match(WORD_SPLIT_RE) ?? [];
+}
+function capitalize(str) {
+  if (str.length === 0) return str;
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+function camelCase(str) {
+  const words2 = splitWords(str);
+  if (words2.length === 0) return "";
+  const [firstWord, ...rest] = words2;
+  return firstWord.toLowerCase() + rest.map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function kebabCase(str) {
+  return splitWords(str).map((w) => w.toLowerCase()).join("-");
+}
+function snakeCase(str) {
+  return splitWords(str).map((w) => w.toLowerCase()).join("_");
+}
+function pascalCase(str) {
+  return splitWords(str).map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, Math.max(0, maxLength - suffix.length)) + suffix;
+}
+function template(str, data) {
+  return str.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = data[key];
+    return value !== void 0 ? String(value) : `{{${key}}}`;
+  });
+}
+function uuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const hex = "0123456789abcdef";
+  const chars = [];
+  for (let i = 0; i < 36; i++) {
+    if (i === 8 || i === 13 || i === 18 || i === 23) {
+      chars.push("-");
+    } else if (i === 14) {
+      chars.push("4");
+    } else if (i === 19) {
+      chars.push(hex[Math.floor(Math.random() * 4) + 8]);
+    } else {
+      chars.push(hex[Math.floor(Math.random() * 16)]);
+    }
+  }
+  return chars.join("");
+}
+function nanoid(size = 21, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-") {
+  const len = alphabet.length;
+  let result = "";
+  for (let i = 0; i < size; i++) {
+    result += alphabet[Math.floor(Math.random() * len)];
+  }
+  return result;
+}
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var HTML_UNESCAPE_MAP = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'"
+};
+function escapeHtml(str) {
+  return str.replace(/[&<>"']/g, (ch) => HTML_ESCAPE_MAP[ch] ?? ch);
+}
+function unescapeHtml(str) {
+  return str.replace(/&(?:amp|lt|gt|quot|#39|#x27);/g, (entity) => HTML_UNESCAPE_MAP[entity] ?? entity);
+}
+function trim(str) {
+  return str.trim();
+}
+function trimStart(str) {
+  return str.trimStart();
+}
+function trimEnd(str) {
+  return str.trimEnd();
+}
+function pad(str, length, char = " ") {
+  const totalPadding = Math.max(0, length - str.length);
+  const leftPad = Math.floor(totalPadding / 2);
+  const rightPad = totalPadding - leftPad;
+  return char.repeat(leftPad) + str + char.repeat(rightPad);
+}
+function padStart(str, length, char = " ") {
+  return str.padStart(length, char);
+}
+function padEnd(str, length, char = " ") {
+  return str.padEnd(length, char);
+}
+function reverse(str) {
+  return str.split("").reverse().join("");
+}
+function words(str) {
+  return splitWords(str);
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function countOccurrences(str, substring) {
+  if (substring.length === 0 || str.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = str.indexOf(substring, pos)) !== -1) {
+    count++;
+    pos += substring.length;
+  }
+  return count;
+}
+
+// src/async/index.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function timeout(promise, ms, errorMessage) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(errorMessage ?? `Promise timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function raceWithTimeout(promise, ms) {
+  let timer;
+  const timeoutPromise = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2("timeout"), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function allSettledMap(items, fn) {
+  return await Promise.allSettled(items.map(fn));
+}
+async function parallelMap(items, fn, concurrency = Number.POSITIVE_INFINITY) {
+  if (concurrency === Number.POSITIVE_INFINITY) {
+    return await Promise.all(items.map(fn));
+  }
+  const results = [];
+  const queue = [...items];
+  const worker = async () => {
+    while (queue.length > 0) {
+      const item = queue.shift();
+      results.push(await fn(item));
+    }
+  };
+  const workerCount = Math.min(concurrency, items.length);
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+async function retryAsync(fn, options) {
+  const { attempts = 3, baseDelay = 1e3, maxDelay = 3e4, shouldRetry = () => true } = options ?? {};
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!shouldRetry(error) || attempt >= attempts - 1) break;
+      const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * baseDelay, maxDelay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+async function pipeline(initial, ...fns) {
+  let result = initial;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+function deferred() {
+  let resolve2;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve2, reject };
+}
+
+// src/io/index.ts
+function parseCsv(input, options) {
+  const { delimiter = ",", header = true, skipEmptyLines = true } = options ?? {};
+  const lines = input.split(/\r?\n/);
+  const rows = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (skipEmptyLines && trimmed.length === 0) continue;
+    const values = parseCsvLine(trimmed, delimiter);
+    rows.push(values);
+  }
+  if (rows.length === 0) return [];
+  if (header) {
+    const [head, ...body] = rows;
+    if (head === void 0) return [];
+    return body.map((row) => {
+      const record = {};
+      for (let i = 0; i < head.length; i++) {
+        record[head[i]] = row[i] ?? "";
+      }
+      return record;
+    });
+  }
+  return rows.map((row) => {
+    const record = {};
+    for (let i = 0; i < row.length; i++) {
+      record[String(i)] = row[i];
+    }
+    return record;
+  });
+}
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === delimiter) {
+        result.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current);
+  return result;
+}
+function stringifyCsv(data, options) {
+  const { delimiter = "," } = options ?? {};
+  if (data.length === 0) return "";
+  const headers = Object.keys(data[0]);
+  const lines = [headers.map((v) => escapeCsvField(v, delimiter)).join(delimiter)];
+  for (const record of data) {
+    const row = headers.map((h) => escapeCsvField(String(record[h] ?? ""), delimiter));
+    lines.push(row.join(delimiter));
+  }
+  return lines.join("\n");
+}
+function escapeCsvField(value, delimiter) {
+  if (value.includes('"') || value.includes(delimiter) || value.includes("\n") || value.includes("\r")) {
+    return '"' + value.replace(/"/g, '""') + '"';
+  }
+  return value;
+}
+function safeJsonParse(input, default_) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return default_ ?? null;
+  }
+}
+function env(name, default_) {
+  const value = process.env[name];
+  return value ?? default_ ?? "";
+}
+function envInt(name, default_) {
+  const value = process.env[name];
+  if (value === void 0 || value === "") return default_ ?? 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? default_ ?? 0 : parsed;
+}
+function envBool(name, default_) {
+  const value = process.env[name];
+  if (value === void 0 || value === "") return default_ ?? false;
+  return value === "true" || value === "1" || value === "yes";
+}
+
+// src/type/index.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isDate(value) {
+  return value instanceof Date && !Number.isNaN(value.getTime());
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isNull(value) {
+  return value === null;
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isNil(value) {
+  return value === null || value === void 0;
+}
+function assertDefined(value, message) {
+  if (value === null || value === void 0) {
+    throw new Error(message ?? "Expected value to be defined");
+  }
+}
+function assertType(value, guard, message) {
+  if (!guard(value)) {
+    throw new Error(message ?? "Value does not match expected type");
+  }
+}
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function castArray(value) {
+  return ensureArray(value);
+}
+function getType2(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return "string";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "function") return "function";
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) return "nan";
+    if (!Number.isFinite(value)) return "infinity";
+    return "number";
+  }
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  if (value instanceof Promise) return "promise";
+  return "object";
+}
+export {
+  DivisionByZeroError,
+  InvalidDateError,
+  add,
+  addBusinessDays,
+  addDays,
+  addMonths,
+  addYears,
+  allSettledMap,
+  approxEqual,
+  assertDefined,
+  assertType,
+  average,
+  base64Decode,
+  base64Encode,
+  basename,
+  calculateAge,
+  camelCase,
+  capitalize,
+  castArray,
+  ceil,
+  checksum,
+  chunk,
+  clamp,
+  constantTimeEqual,
+  countOccurrences,
+  dateDiff,
+  debounce,
+  deepClone,
+  deepMerge,
+  deferred,
+  dirname,
+  div,
+  endOfDay,
+  endOfMonth,
+  endOfYear,
+  ensureArray,
+  env,
+  envBool,
+  envInt,
+  escapeHtml,
+  extname,
+  first,
+  flatten,
+  floor,
+  format,
+  formatDate,
+  generateOTP,
+  generateToken,
+  getType2 as getType,
+  groupBy,
+  hash,
+  identity,
+  inRange,
+  isAbsolute,
+  isAfter,
+  isArray,
+  isBefore,
+  isBetween,
+  isBoolean,
+  isBusinessDay,
+  isDate,
+  isEmpty,
+  isFunction,
+  isLeapYear,
+  isMap,
+  isNil,
+  isNull,
+  isNumber,
+  isObject,
+  isPromise,
+  isRegExp,
+  isSet,
+  isString,
+  isUndefined,
+  isWeekend,
+  join,
+  kebabCase,
+  keyBy,
+  last,
+  memoize,
+  mul,
+  nanoid,
+  noop,
+  normalize,
+  omit,
+  once,
+  orderBy,
+  pad,
+  padEnd,
+  padStart,
+  parallelMap,
+  parse,
+  parseCsv,
+  parseDate,
+  pascalCase,
+  pick,
+  pipeline,
+  pluck,
+  raceWithTimeout,
+  randomHex,
+  randomInt,
+  relative,
+  resolve,
+  retry,
+  retryAsync,
+  reverse,
+  round,
+  safeJsonParse,
+  sample,
+  sampleSize,
+  shuffle,
+  simpleHash,
+  sleep,
+  slugify,
+  snakeCase,
+  sortBy,
+  startOfDay,
+  startOfMonth,
+  startOfYear,
+  stringifyCsv,
+  sub,
+  sum,
+  template,
+  throttle,
+  timeout,
+  trim,
+  trimEnd,
+  trimStart,
+  truncate,
+  unescapeHtml,
+  uniq,
+  uniqueBy,
+  uuid,
+  words,
+  xorCipher
+};
+//# sourceMappingURL=index.js.map