superjs-core 0.6.0 → 0.7.0

package/dist/index.js

@@ -78,6 +78,7 @@ function deepMerge(...objects) {
     const keys = Object.keys(obj);
     for (let j = 0; j < keys.length; j++) {
       const key = keys[j];
+      if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
       const val = obj[key];
       const existing = result[key];
       if (val !== void 0 && isPlainObject(val) && isPlainObject(existing)) {
@@ -265,6 +266,54 @@ function once(fn) {
     return result;
   };
 }
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEqual(v, b.get(k))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const v of a) {
+      if (!b.has(v)) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(aObj);
+  const keysB = Object.keys(bObj);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+    if (!deepEqual(aObj[key], bObj[key])) return false;
+  }
+  return true;
+}
+function pipe(initial, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), initial);
+}
+function compose(...fns) {
+  return (initial) => fns.reduceRight((acc, fn) => fn(acc), initial);
+}
 
 // src/math/index.ts
 var DivisionByZeroError = class extends Error {
@@ -354,6 +403,250 @@ function randomInt(min, max) {
 function inRange(value, min, max) {
   return value >= min && value <= max;
 }
+function median(values) {
+  if (values.length === 0) throw new RangeError("Cannot compute median of an empty array");
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function stddev(values) {
+  if (values.length < 2) throw new RangeError("Need at least 2 values for stddev");
+  const mean = sum(values) / values.length;
+  const sqDiffs = values.map((v) => (v - mean) ** 2);
+  return Math.sqrt(sqDiffs.reduce((a, b) => a + b, 0) / values.length);
+}
+function sampleStddev(values) {
+  if (values.length < 2) throw new RangeError("Need at least 2 values for sample stddev");
+  const mean = sum(values) / values.length;
+  const sqDiffs = values.map((v) => (v - mean) ** 2);
+  return Math.sqrt(sqDiffs.reduce((a, b) => a + b, 0) / (values.length - 1));
+}
+function percentile(values, p) {
+  if (values.length === 0) throw new RangeError("Cannot compute percentile of empty array");
+  if (p < 0 || p > 100) throw new RangeError("Percentile must be between 0 and 100");
+  const sorted = [...values].sort((a, b) => a - b);
+  const rank = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(rank);
+  const upper = Math.ceil(rank);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (rank - lower);
+}
+function correlation(x, y) {
+  if (x.length !== y.length) throw new RangeError("Arrays must have the same length");
+  if (x.length < 2) throw new RangeError("Need at least 2 pairs for correlation");
+  const n = x.length;
+  const meanX = sum(x) / n;
+  const meanY = sum(y) / n;
+  let num = 0;
+  let denX = 0;
+  let denY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - meanX;
+    const dy = y[i] - meanY;
+    num += dx * dy;
+    denX += dx * dx;
+    denY += dy * dy;
+  }
+  if (denX === 0 || denY === 0) return 0;
+  return num / Math.sqrt(denX * denY);
+}
+function formatCurrency(value, options) {
+  const locale = options?.locale ?? "id-ID";
+  const currency = options?.currency ?? "IDR";
+  const notation = options?.notation ?? "standard";
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      notation,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    }).format(value);
+  } catch {
+    return `${currency} ${value.toLocaleString(locale)}`;
+  }
+}
+function isEven(n) {
+  return n % 2 === 0;
+}
+function isOdd(n) {
+  return n % 2 !== 0;
+}
+function gcd(a, b) {
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+function lcm(a, b) {
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (a === 0 || b === 0) {
+    throw new RangeError("Arguments must be non-zero");
+  }
+  return Math.abs(a * b) / gcd(a, b);
+}
+function factorial(n) {
+  if (!Number.isInteger(n)) {
+    throw new RangeError("Argument must be an integer");
+  }
+  if (n < 0) {
+    throw new RangeError("Factorial is not defined for negative numbers");
+  }
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function isPrime(n) {
+  if (!Number.isInteger(n)) {
+    throw new RangeError("Argument must be an integer");
+  }
+  if (n < 2) return false;
+  if (n === 2 || n === 3) return true;
+  if (n % 2 === 0 || n % 3 === 0) return false;
+  const limit = Math.sqrt(n);
+  for (let i = 5; i <= limit; i += 6) {
+    if (n % i === 0 || n % (i + 2) === 0) return false;
+  }
+  return true;
+}
+function toRadians(degrees) {
+  return degrees * Math.PI / 180;
+}
+function toDegrees(radians) {
+  return radians * 180 / Math.PI;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function percentageOf(value, total) {
+  if (total === 0) {
+    throw new RangeError("Total must be non-zero");
+  }
+  return value / total * 100;
+}
+function mapRange(value, inMin, inMax, outMin, outMax) {
+  if (inMin === inMax) {
+    throw new RangeError("Input range must not be zero");
+  }
+  return (value - inMin) / (inMax - inMin) * (outMax - outMin) + outMin;
+}
+function mode(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute mode of an empty array");
+  }
+  const freq = /* @__PURE__ */ new Map();
+  let maxFreq = 0;
+  for (const v of values) {
+    const count = (freq.get(v) ?? 0) + 1;
+    freq.set(v, count);
+    if (count > maxFreq) maxFreq = count;
+  }
+  const result = [];
+  for (const [v, count] of freq) {
+    if (count === maxFreq) result.push(v);
+  }
+  return result;
+}
+function range(start, end, step) {
+  const dir = end >= start ? 1 : -1;
+  const s = step ?? dir;
+  if (s === 0) {
+    throw new RangeError("Step must not be zero");
+  }
+  if ((end - start) * s < 0) {
+    return [];
+  }
+  const result = [];
+  let i = start;
+  if (s > 0) {
+    while (i <= end) {
+      result.push(i);
+      i += s;
+    }
+  } else {
+    while (i >= end) {
+      result.push(i);
+      i += s;
+    }
+  }
+  return result;
+}
+function weightedAverage(values, weights) {
+  if (values.length === 0 || weights.length === 0) {
+    throw new RangeError("Arrays must not be empty");
+  }
+  if (values.length !== weights.length) {
+    throw new RangeError("Values and weights must have the same length");
+  }
+  let weightedSum = 0;
+  let weightSum = 0;
+  for (let i = 0; i < values.length; i++) {
+    weightedSum += values[i] * weights[i];
+    weightSum += weights[i];
+  }
+  if (weightSum === 0) {
+    throw new RangeError("Sum of weights must be non-zero");
+  }
+  return weightedSum / weightSum;
+}
+function geometricMean(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute geometric mean of an empty array");
+  }
+  for (const v of values) {
+    if (v < 0) {
+      throw new RangeError("Values must be non-negative for geometric mean");
+    }
+  }
+  const logSum = values.reduce((acc, v) => v === 0 ? acc : acc + Math.log(v), 0);
+  if (logSum === -Infinity) return 0;
+  return Math.exp(logSum / values.length);
+}
+function combinations(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (n < 0 || k < 0) {
+    throw new RangeError("Arguments must be non-negative");
+  }
+  if (k > n) {
+    throw new RangeError("k must not exceed n");
+  }
+  if (k === 0 || k === n) return 1;
+  const r = Math.min(k, n - k);
+  let result = 1;
+  for (let i = 1; i <= r; i++) {
+    result = result * (n - r + i) / i;
+  }
+  return result;
+}
+function permutations(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (n < 0 || k < 0) {
+    throw new RangeError("Arguments must be non-negative");
+  }
+  if (k > n) {
+    throw new RangeError("k must not exceed n");
+  }
+  let result = 1;
+  for (let i = n; i > n - k; i--) {
+    result *= i;
+  }
+  return result;
+}
 
 // src/date/index.ts
 var InvalidDateError = class extends Error {
@@ -610,6 +903,427 @@ function calculateAge(birthDate) {
   }
   return age;
 }
+var LOCALE_LABELS = {
+  id: {
+    years: { single: "tahun", plural: "tahun" },
+    months: { single: "bulan", plural: "bulan" },
+    weeks: { single: "minggu", plural: "minggu" },
+    days: { single: "hari", plural: "hari" },
+    hours: { single: "jam", plural: "jam" },
+    minutes: { single: "menit", plural: "menit" },
+    seconds: { single: "detik", plural: "detik" }
+  },
+  en: {
+    years: { single: "year", plural: "years" },
+    months: { single: "month", plural: "months" },
+    weeks: { single: "week", plural: "weeks" },
+    days: { single: "day", plural: "days" },
+    hours: { single: "hour", plural: "hours" },
+    minutes: { single: "minute", plural: "minutes" },
+    seconds: { single: "second", plural: "seconds" }
+  }
+};
+function getSuffix(diffMs, kind, locale) {
+  if (diffMs < 0) {
+    return locale === "en" ? "ago" : "yang lalu";
+  }
+  if (kind === "remaining") {
+    return locale === "en" ? "remaining" : "lagi";
+  }
+  return locale === "en" ? "ago" : "yang lalu";
+}
+function formatRelativeTime(absDiffMs, suffix, locale) {
+  const labels = LOCALE_LABELS[locale] ?? LOCALE_LABELS.id;
+  const seconds = Math.floor(absDiffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30.4375);
+  const years = Math.floor(days / 365.25);
+  let count;
+  let unit;
+  if (years >= 1) {
+    count = years;
+    unit = "years";
+  } else if (months >= 1) {
+    count = months;
+    unit = "months";
+  } else if (weeks >= 1) {
+    count = weeks;
+    unit = "weeks";
+  } else if (days >= 1) {
+    count = days;
+    unit = "days";
+  } else if (hours >= 1) {
+    count = hours;
+    unit = "hours";
+  } else if (minutes >= 1) {
+    count = minutes;
+    unit = "minutes";
+  } else {
+    count = Math.max(1, seconds);
+    unit = "seconds";
+  }
+  const label = count === 1 ? labels[unit].single : labels[unit].plural;
+  return `${count} ${label} ${suffix}`;
+}
+function timeAgo(date, options) {
+  const diff = Date.now() - date.getTime();
+  const locale = options?.locale ?? "id";
+  const suffix = getSuffix(diff, "ago", locale);
+  return formatRelativeTime(Math.abs(diff), suffix, locale);
+}
+function timeRemaining(target, options) {
+  const diff = target.getTime() - Date.now();
+  const locale = options?.locale ?? "id";
+  const suffix = getSuffix(diff, "remaining", locale);
+  return formatRelativeTime(Math.abs(diff), suffix, locale);
+}
+function formatDuration(duration, options) {
+  const locale = options?.locale ?? "id";
+  const labels = LOCALE_LABELS[locale] ?? LOCALE_LABELS.id;
+  const parts = [];
+  const entries = [
+    ["years", duration.years],
+    ["months", duration.months],
+    ["days", duration.days],
+    ["hours", duration.hours],
+    ["minutes", duration.minutes],
+    ["seconds", duration.seconds]
+  ];
+  for (const [key, value] of entries) {
+    if (value > 0) {
+      const label = value === 1 ? labels[key].single : labels[key].plural;
+      parts.push(`${value} ${label}`);
+    }
+  }
+  if (parts.length === 0) {
+    const label = labels.seconds.plural;
+    return `0 ${label}`;
+  }
+  return parts.join(" ");
+}
+var TIMEZONE_WIB = 7;
+var TIMEZONE_WITA = 8;
+var TIMEZONE_WIT = 9;
+function toTimezone(date, offsetHours) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const utcMs = date.getTime() + date.getTimezoneOffset() * 6e4;
+  return new Date(utcMs + offsetHours * 36e5);
+}
+function formatInTimezone(date, format2, offsetHours) {
+  return formatDate(toTimezone(date, offsetHours), format2);
+}
+function isToday(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const now = /* @__PURE__ */ new Date();
+  return date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+}
+function isYesterday(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return date.getFullYear() === yesterday.getFullYear() && date.getMonth() === yesterday.getMonth() && date.getDate() === yesterday.getDate();
+}
+function isTomorrow(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const tomorrow = /* @__PURE__ */ new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  return date.getFullYear() === tomorrow.getFullYear() && date.getMonth() === tomorrow.getMonth() && date.getDate() === tomorrow.getDate();
+}
+function isPast(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return date.getTime() < Date.now();
+}
+function isFuture(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return date.getTime() > Date.now();
+}
+function isSameDay(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to isSameDay");
+  }
+  return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
+}
+function daysInMonth(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+}
+function dayOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const start = new Date(date.getFullYear(), 0, 0);
+  return Math.floor((date.getTime() - start.getTime()) / MS_IN_DAY);
+}
+function weekOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNum = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return weekNum;
+}
+function quarter(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return Math.floor(date.getMonth() / 3) + 1;
+}
+function maxDate(dates) {
+  if (dates.length === 0) throw new Error("maxDate requires at least one date");
+  const ms = Math.max(...dates.map((d) => {
+    if (!isValidDate(d)) throw new InvalidDateError(d);
+    return d.getTime();
+  }));
+  return new Date(ms);
+}
+function minDate(dates) {
+  if (dates.length === 0) throw new Error("minDate requires at least one date");
+  const ms = Math.min(...dates.map((d) => {
+    if (!isValidDate(d)) throw new InvalidDateError(d);
+    return d.getTime();
+  }));
+  return new Date(ms);
+}
+function getNextWeekday(date, targetDay) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date);
+  const currentDay = result.getDay();
+  let diff = targetDay - currentDay;
+  if (diff <= 0) diff += 7;
+  result.setDate(result.getDate() + diff);
+  return result;
+}
+function getLastWeekday(date, targetDay) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date);
+  const currentDay = result.getDay();
+  let diff = currentDay - targetDay;
+  if (diff <= 0) diff += 7;
+  result.setDate(result.getDate() - diff);
+  return result;
+}
+function nextMonday(date) {
+  return getNextWeekday(date, 1);
+}
+function nextTuesday(date) {
+  return getNextWeekday(date, 2);
+}
+function nextWednesday(date) {
+  return getNextWeekday(date, 3);
+}
+function nextThursday(date) {
+  return getNextWeekday(date, 4);
+}
+function nextFriday(date) {
+  return getNextWeekday(date, 5);
+}
+function nextSaturday(date) {
+  return getNextWeekday(date, 6);
+}
+function nextSunday(date) {
+  return getNextWeekday(date, 0);
+}
+function lastMonday(date) {
+  return getLastWeekday(date, 1);
+}
+function lastTuesday(date) {
+  return getLastWeekday(date, 2);
+}
+function lastWednesday(date) {
+  return getLastWeekday(date, 3);
+}
+function lastThursday(date) {
+  return getLastWeekday(date, 4);
+}
+function lastFriday(date) {
+  return getLastWeekday(date, 5);
+}
+function lastSaturday(date) {
+  return getLastWeekday(date, 6);
+}
+function lastSunday(date) {
+  return getLastWeekday(date, 0);
+}
+function parseDuration(input) {
+  const regex = /(\d+)\s*([wdhms])/g;
+  let ms = 0;
+  let match;
+  while ((match = regex.exec(input)) !== null) {
+    const val = parseInt(match[1], 10);
+    switch (match[2]) {
+      case "w":
+        ms += val * 7 * MS_IN_DAY;
+        break;
+      case "d":
+        ms += val * MS_IN_DAY;
+        break;
+      case "h":
+        ms += val * MS_IN_HOUR;
+        break;
+      case "m":
+        ms += val * MS_IN_MINUTE;
+        break;
+      case "s":
+        ms += val * MS_IN_SECOND;
+        break;
+    }
+  }
+  return ms;
+}
+var INDONESIAN_FIXED_HOLIDAYS = [
+  { name: "New Year", month: 0, day: 1 },
+  { name: "Labor Day", month: 4, day: 1 },
+  { name: "Pancasila Day", month: 5, day: 1 },
+  { name: "Independence Day", month: 7, day: 17 },
+  { name: "National Awakening Day", month: 4, day: 20 },
+  { name: "National Heroes Day", month: 10, day: 10 },
+  { name: "Christmas", month: 11, day: 25 }
+];
+function computeEaster(year) {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * m + 114) / 31);
+  const day = (h + l - 7 * m + 114) % 31 + 1;
+  return new Date(year, month - 1, day);
+}
+var CHINESE_NEW_YEAR = {
+  2024: { month: 1, day: 10 },
+  2025: { month: 0, day: 29 },
+  2026: { month: 1, day: 17 },
+  2027: { month: 1, day: 6 },
+  2028: { month: 0, day: 26 },
+  2029: { month: 1, day: 13 },
+  2030: { month: 2, day: 3 }
+};
+var NYEPI = {
+  2024: { month: 2, day: 11 },
+  2025: { month: 2, day: 29 },
+  2026: { month: 2, day: 19 },
+  2027: { month: 2, day: 7 },
+  2028: { month: 2, day: 26 },
+  2029: { month: 2, day: 15 },
+  2030: { month: 2, day: 5 }
+};
+var VESAK = {
+  2024: { month: 4, day: 23 },
+  2025: { month: 4, day: 12 },
+  2026: { month: 4, day: 31 },
+  2027: { month: 4, day: 20 },
+  2028: { month: 4, day: 9 },
+  2029: { month: 4, day: 28 },
+  2030: { month: 4, day: 18 }
+};
+var EID_AL_FITR = {
+  2024: [{ month: 3, day: 10 }, { month: 3, day: 11 }],
+  2025: [{ month: 2, day: 31 }, { month: 3, day: 1 }],
+  2026: [{ month: 2, day: 21 }, { month: 2, day: 22 }],
+  2027: [{ month: 2, day: 10 }, { month: 2, day: 11 }],
+  2028: [{ month: 2, day: 28 }, { month: 2, day: 29 }],
+  2029: [{ month: 2, day: 17 }, { month: 2, day: 18 }],
+  2030: [{ month: 2, day: 7 }, { month: 2, day: 8 }]
+};
+var EID_AL_ADHA = {
+  2024: { month: 5, day: 17 },
+  2025: { month: 5, day: 7 },
+  2026: { month: 4, day: 27 },
+  2027: { month: 4, day: 17 },
+  2028: { month: 5, day: 5 },
+  2029: { month: 4, day: 25 },
+  2030: { month: 4, day: 15 }
+};
+var ISLAMIC_NEW_YEAR = {
+  2024: { month: 6, day: 7 },
+  2025: { month: 5, day: 27 },
+  2026: { month: 5, day: 16 },
+  2027: { month: 5, day: 6 },
+  2028: { month: 6, day: 24 },
+  2029: { month: 6, day: 13 },
+  2030: { month: 6, day: 3 }
+};
+var PROPHETS_BIRTHDAY = {
+  2024: { month: 8, day: 16 },
+  2025: { month: 8, day: 5 },
+  2026: { month: 7, day: 26 },
+  2027: { month: 7, day: 16 },
+  2028: { month: 8, day: 3 },
+  2029: { month: 7, day: 23 },
+  2030: { month: 7, day: 13 }
+};
+var ISRA_MIRAJ = {
+  2024: { month: 1, day: 8 },
+  2025: { month: 0, day: 28 },
+  2026: { month: 0, day: 17 },
+  2027: { month: 0, day: 6 },
+  2028: { month: 0, day: 26 },
+  2029: { month: 1, day: 14 },
+  2030: { month: 1, day: 3 }
+};
+function addHolidayEntry(entries, name, month, day) {
+  entries.push({ name, month, day });
+}
+function getIndonesianHolidaysForYear(year) {
+  const holidays = [...INDONESIAN_FIXED_HOLIDAYS];
+  const easter = computeEaster(year);
+  addHolidayEntry(holidays, "Good Friday", easter.getMonth(), easter.getDate() - 2);
+  addHolidayEntry(holidays, "Easter", easter.getMonth(), easter.getDate());
+  const ascension = new Date(easter);
+  ascension.setDate(ascension.getDate() + 39);
+  addHolidayEntry(holidays, "Ascension of Jesus Christ", ascension.getMonth(), ascension.getDate());
+  const cny = CHINESE_NEW_YEAR[year];
+  if (cny) addHolidayEntry(holidays, "Chinese New Year", cny.month, cny.day);
+  const nyepi = NYEPI[year];
+  if (nyepi) addHolidayEntry(holidays, "Nyepi (Day of Silence)", nyepi.month, nyepi.day);
+  const vesak = VESAK[year];
+  if (vesak) addHolidayEntry(holidays, "Vesak (Buddha's Birthday)", vesak.month, vesak.day);
+  const eidDays = EID_AL_FITR[year];
+  if (eidDays) {
+    eidDays.forEach((entry, idx) => {
+      addHolidayEntry(holidays, idx === 0 ? "Eid al-Fitr" : "Eid al-Fitr (Day 2)", entry.month, entry.day);
+    });
+  }
+  const eidAdha = EID_AL_ADHA[year];
+  if (eidAdha) addHolidayEntry(holidays, "Eid al-Adha", eidAdha.month, eidAdha.day);
+  const islNewYear = ISLAMIC_NEW_YEAR[year];
+  if (islNewYear) addHolidayEntry(holidays, "Islamic New Year", islNewYear.month, islNewYear.day);
+  const prophetBday = PROPHETS_BIRTHDAY[year];
+  if (prophetBday) addHolidayEntry(holidays, "Prophet Muhammad's Birthday", prophetBday.month, prophetBday.day);
+  const isra = ISRA_MIRAJ[year];
+  if (isra) addHolidayEntry(holidays, "Isra' Mi'raj (Ascension of Prophet Muhammad)", isra.month, isra.day);
+  return holidays;
+}
+function isHolidayIndonesia(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const year = date.getFullYear();
+  const holidays = getIndonesianHolidaysForYear(year);
+  for (const h of holidays) {
+    if (h.month === date.getMonth() && h.day === date.getDate()) {
+      return true;
+    }
+  }
+  return false;
+}
+function getIndonesianHolidayNames(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const year = date.getFullYear();
+  const holidays = getIndonesianHolidaysForYear(year);
+  const names = [];
+  for (const h of holidays) {
+    if (h.month === date.getMonth() && h.day === date.getDate()) {
+      names.push(h.name);
+    }
+  }
+  return names;
+}
 
 // src/crypto/index.ts
 function hash(str) {
@@ -635,15 +1349,12 @@ function simpleHash(str) {
   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") {
+    const bytes = new Uint8Array(size);
     crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < size; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
+    return bytes;
   }
-  return bytes;
+  throw new Error("Crypto API unavailable. Cannot generate secure random bytes.");
 }
 function randomHex(size = 16) {
   const bytes = getRandomBytes(size);
@@ -988,6 +1699,217 @@ function isEmpty(value) {
   if (value !== null && typeof value === "object") return Object.keys(value).length === 0;
   return false;
 }
+function topoSort(items) {
+  const adj = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    itemMap.set(item.id, item);
+    if (!adj.has(item.id)) adj.set(item.id, []);
+    if (!inDegree.has(item.id)) inDegree.set(item.id, 0);
+  }
+  for (const item of items) {
+    if (item.dependencies) {
+      for (const depId of item.dependencies) {
+        adj.get(depId)?.push(item.id);
+        inDegree.set(item.id, (inDegree.get(item.id) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(id);
+    for (const neighbor of adj.get(id) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  if (sorted.length !== items.length) {
+    throw new Error("Circular dependency detected");
+  }
+  return sorted.map((id) => itemMap.get(id));
+}
+function slidingWindows(items, size, step = 1) {
+  if (size <= 0 || items.length === 0 || step <= 0) return [];
+  const result = [];
+  for (let i = 0; i + size <= items.length; i += step) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+function tumblingWindows(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 deepGet(obj, path, default_) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) return default_;
+    if (typeof current !== "object") return default_;
+    const curObj = current;
+    if (!(key in curObj)) return default_;
+    current = curObj[key];
+  }
+  return current ?? default_;
+}
+function deepSet(obj, path, value) {
+  const keys = path.split(".");
+  const PROTO_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  for (const key of keys) {
+    if (PROTO_KEYS.has(key)) {
+      return { ...obj };
+    }
+  }
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (next === null || next === void 0 || typeof next !== "object") {
+      const isArray2 = /^\d+$/.test(keys[i + 1]);
+      current[key] = isArray2 ? [] : {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return result;
+}
+function partition(items, predicate) {
+  const pass = [];
+  const fail = [];
+  for (const item of items) {
+    if (predicate(item)) pass.push(item);
+    else fail.push(item);
+  }
+  return [pass, fail];
+}
+function compact(items) {
+  return items.filter(Boolean);
+}
+function difference(a, b) {
+  const setB = new Set(b);
+  return a.filter((item) => !setB.has(item));
+}
+function intersection(a, b) {
+  const setB = new Set(b);
+  return a.filter((item) => setB.has(item));
+}
+function union(...arrays) {
+  const set = /* @__PURE__ */ new Set();
+  for (const arr of arrays) {
+    for (const item of arr) {
+      set.add(item);
+    }
+  }
+  return [...set];
+}
+function zip(...arrays) {
+  if (arrays.length === 0) return [];
+  const minLen = Math.min(...arrays.map((a) => a.length));
+  const result = [];
+  for (let i = 0; i < minLen; i++) {
+    const tuple = [];
+    for (const arr of arrays) {
+      tuple.push(arr[i]);
+    }
+    result.push(tuple);
+  }
+  return result;
+}
+function unzip(paired) {
+  if (paired.length === 0) return [];
+  const tupleLen = paired.reduce((max, t) => Math.max(max, t.length), 0);
+  const result = Array.from({ length: tupleLen }, () => []);
+  for (const tuple of paired) {
+    for (let i = 0; i < tupleLen; i++) {
+      result[i].push(tuple[i]);
+    }
+  }
+  return result;
+}
+function countBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+function maxBy(items, keyFn) {
+  if (items.length === 0) return void 0;
+  let maxItem = items[0];
+  let maxVal = keyFn(maxItem);
+  for (let i = 1; i < items.length; i++) {
+    const val = keyFn(items[i]);
+    if (val > maxVal) {
+      maxVal = val;
+      maxItem = items[i];
+    }
+  }
+  return maxItem;
+}
+function minBy(items, keyFn) {
+  if (items.length === 0) return void 0;
+  let minItem = items[0];
+  let minVal = keyFn(minItem);
+  for (let i = 1; i < items.length; i++) {
+    const val = keyFn(items[i]);
+    if (val < minVal) {
+      minVal = val;
+      minItem = items[i];
+    }
+  }
+  return minItem;
+}
+function sumBy(items, keyFn) {
+  let total = 0;
+  for (const item of items) {
+    total += keyFn(item);
+  }
+  return total;
+}
+function findIndex(items, predicate, fromIndex = 0) {
+  for (let i = fromIndex; i < items.length; i++) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+function findLast(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return items[i];
+  }
+  return void 0;
+}
+function drop(items, n = 1) {
+  return items.slice(Math.max(0, n));
+}
+function dropRight(items, n = 1) {
+  return items.slice(0, Math.max(0, items.length - n));
+}
+function take(items, n = 1) {
+  return items.slice(0, Math.max(0, n));
+}
+function takeRight(items, n = 1) {
+  return items.slice(Math.max(0, items.length - n));
+}
+function without(items, ...values) {
+  const exclude = new Set(values);
+  return items.filter((item) => !exclude.has(item));
+}
+function nth(items, index) {
+  return index < 0 ? items[items.length + index] : items[index];
+}
 
 // src/string/index.ts
 var WORD_SPLIT_RE = /[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\b)|\d+/g;
@@ -1019,6 +1941,7 @@ function truncate(str, maxLength, suffix = "...") {
 }
 function template(str, data) {
   return str.replace(/\{\{(\w+)\}\}/g, (_2, key) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return `{{${key}}}`;
     const value = data[key];
     return value !== void 0 ? String(value) : `{{${key}}}`;
   });
@@ -1044,9 +1967,15 @@ function uuid() {
 }
 function nanoid(size = 21, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-") {
   const len = alphabet.length;
+  const bytes = new Uint8Array(size);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    throw new Error("Crypto API unavailable. Cannot generate secure random ID.");
+  }
   let result = "";
   for (let i = 0; i < size; i++) {
-    result += alphabet[Math.floor(Math.random() * len)];
+    result += alphabet[bytes[i] % len];
   }
   return result;
 }
@@ -1055,7 +1984,9 @@ var HTML_ESCAPE_MAP = {
   "<": "&lt;",
   ">": "&gt;",
   '"': "&quot;",
-  "'": "&#39;"
+  "'": "&#39;",
+  "`": "&#96;",
+  "/": "&#x2F;"
 };
 var HTML_UNESCAPE_MAP = {
   "&amp;": "&",
@@ -1063,13 +1994,15 @@ var HTML_UNESCAPE_MAP = {
   "&gt;": ">",
   "&quot;": '"',
   "&#39;": "'",
-  "&#x27;": "'"
+  "&#x27;": "'",
+  "&#96;": "`",
+  "&#x2F;": "/"
 };
 function escapeHtml(str) {
-  return str.replace(/[&<>"']/g, (ch) => HTML_ESCAPE_MAP[ch] ?? ch);
+  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);
+  return str.replace(/&(?:amp|lt|gt|quot|#39|#x27|#96|#x2F);/g, (entity) => HTML_UNESCAPE_MAP[entity] ?? entity);
 }
 function trim(str) {
   return str.trim();
@@ -1111,6 +2044,494 @@ function countOccurrences(str, substring) {
   }
   return count;
 }
+function levenshtein(a, b) {
+  const an = a.length;
+  const bn = b.length;
+  if (an === 0) return bn;
+  if (bn === 0) return an;
+  if (an < bn) return levenshtein(b, a);
+  let prev = new Uint32Array(bn + 1);
+  let curr = new Uint32Array(bn + 1);
+  for (let j = 0; j <= bn; j++) prev[j] = j;
+  for (let i = 1; i <= an; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= bn; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(
+        prev[j] + 1,
+        curr[j - 1] + 1,
+        prev[j - 1] + cost
+      );
+    }
+    ;
+    [prev, curr] = [curr, prev];
+  }
+  return prev[bn];
+}
+function fuzzyMatch(str, query) {
+  if (query.length === 0) return true;
+  if (str.length === 0) return false;
+  const sl = str.toLowerCase();
+  const ql = query.toLowerCase();
+  let si = 0;
+  for (let qi = 0; qi < ql.length; qi++) {
+    si = sl.indexOf(ql[qi], si);
+    if (si === -1) return false;
+    si++;
+  }
+  return true;
+}
+function maskString(str, options) {
+  if (str.length === 0) return str;
+  const maskChar = options?.char ?? "*";
+  const start = options?.start ?? Math.ceil(str.length * 0.25);
+  const end = options?.end ?? Math.floor(str.length * 0.75);
+  if (start >= end || start < 0) return str;
+  const clampedStart = Math.max(0, start);
+  const clampedEnd = Math.min(str.length, end);
+  return str.slice(0, clampedStart) + maskChar.repeat(clampedEnd - clampedStart) + str.slice(clampedEnd);
+}
+var SATUAN = ["", "satu", "dua", "tiga", "empat", "lima", "enam", "tujuh", "delapan", "sembilan"];
+var BELASAN = ["sepuluh", "sebelas", "dua belas", "tiga belas", "empat belas", "lima belas", "enam belas", "tujuh belas", "delapan belas", "sembilan belas"];
+var PULUHAN = ["", "", "dua puluh", "tiga puluh", "empat puluh", "lima puluh", "enam puluh", "tujuh puluh", "delapan puluh", "sembilan puluh"];
+function _terbilang(n) {
+  if (n < 0) return "minus " + _terbilang(-n);
+  if (n === 0) return "nol";
+  if (n < 10) return SATUAN[n];
+  if (n < 20) return n === 10 ? "sepuluh" : n === 11 ? "sebelas" : BELASAN[n - 10];
+  if (n < 100) {
+    const pul = Math.floor(n / 10);
+    const sat = n % 10;
+    return PULUHAN[pul] + (sat > 0 ? " " + SATUAN[sat] : "");
+  }
+  if (n < 1e3) {
+    const ratus = Math.floor(n / 100);
+    const sis2 = n % 100;
+    const ratusStr = ratus === 1 ? "seratus" : SATUAN[ratus] + " ratus";
+    return ratusStr + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  if (n < 1e6) {
+    const rib = Math.floor(n / 1e3);
+    const sis2 = n % 1e3;
+    const ribStr = rib === 1 ? "seribu" : _terbilang(rib) + " ribu";
+    return ribStr + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  if (n < 1e9) {
+    const jut = Math.floor(n / 1e6);
+    const sis2 = n % 1e6;
+    return _terbilang(jut) + " juta" + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  if (n < 1e12) {
+    const mil = Math.floor(n / 1e9);
+    const sis2 = n % 1e9;
+    return _terbilang(mil) + " miliar" + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  const tril = Math.floor(n / 1e12);
+  const sis = n % 1e12;
+  return _terbilang(tril) + " triliun" + (sis > 0 ? " " + _terbilang(sis) : "");
+}
+function terbilang(value) {
+  if (!Number.isFinite(value)) throw new RangeError("Input must be a finite number");
+  if (value > Number.MAX_SAFE_INTEGER) throw new RangeError("Input terlalu besar");
+  return _terbilang(Math.floor(Math.abs(value)));
+}
+function formatRupiah(value, options) {
+  return formatCurrency(value, { locale: "id-ID", currency: "IDR", notation: options?.notation });
+}
+function formatBytes(bytes, options) {
+  if (bytes === 0) return "0 B";
+  if (!Number.isFinite(bytes) || bytes < 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB", "EB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const dm = options?.decimals ?? (i === 0 ? 0 : 1);
+  const index = Math.min(i, sizes.length - 1);
+  return parseFloat((bytes / Math.pow(k, index)).toFixed(dm)) + " " + sizes[index];
+}
+function randomString(length = 16) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const bytes = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    throw new Error("Crypto API unavailable. Cannot generate secure random string.");
+  }
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars[bytes[i] % chars.length];
+  }
+  return result;
+}
+function randomBoolean() {
+  return Math.random() >= 0.5;
+}
+function pluralize(count, singular) {
+  if (count === 1) return singular;
+  const last2 = singular[singular.length - 1];
+  const lastTwo = singular.slice(-2);
+  if (last2 === "s" || last2 === "x" || last2 === "z" || lastTwo === "ch" || lastTwo === "sh") {
+    return singular + "es";
+  }
+  if (last2 === "y" && singular.length > 2 && !"aeiou".includes(singular[singular.length - 2])) {
+    return singular.slice(0, -1) + "ies";
+  }
+  return singular + "s";
+}
+function stripHtml(str) {
+  return str.replace(/<[^>]*>/g, "");
+}
+function truncateWords(str, count, suffix = "...") {
+  const words2 = str.split(/\s+/).filter(Boolean);
+  if (words2.length <= count) return str;
+  return words2.slice(0, count).join(" ") + suffix;
+}
+function isPalindrome(str) {
+  const cleaned = str.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+  if (cleaned.length <= 1) return true;
+  let left = 0;
+  let right = cleaned.length - 1;
+  while (left < right) {
+    if (cleaned[left] !== cleaned[right]) return false;
+    left++;
+    right--;
+  }
+  return true;
+}
+function isAnagram(str1, str2) {
+  const clean = (s) => s.replace(/\s/g, "").toLowerCase().split("").sort().join("");
+  return clean(str1) === clean(str2);
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+  const bigrams = /* @__PURE__ */ new Map();
+  for (let i = 0; i < a.length - 1; i++) {
+    const bg = a.slice(i, i + 2);
+    bigrams.set(bg, (bigrams.get(bg) ?? 0) + 1);
+  }
+  let intersection2 = 0;
+  for (let i = 0; i < b.length - 1; i++) {
+    const bg = b.slice(i, i + 2);
+    const count = bigrams.get(bg) ?? 0;
+    if (count > 0) {
+      bigrams.set(bg, count - 1);
+      intersection2++;
+    }
+  }
+  return 2 * intersection2 / (a.length + b.length - 2);
+}
+function dedent(str) {
+  const lines = str.split("\n");
+  if (lines.length === 0) return str;
+  const indent = lines.reduce((min, line) => {
+    if (line.trim().length === 0) return min;
+    const leading = line.match(/^[ \t]*/)?.[0]?.length ?? 0;
+    return min === null ? leading : Math.min(min, leading);
+  }, null);
+  if (indent === null || indent === 0) return str;
+  return lines.map((line) => line.slice(indent)).join("\n");
+}
+function wordCount(str) {
+  const match = str.match(/[a-zA-Z0-9]+(?:['\u2019][a-zA-Z]+)?/g);
+  return match ? match.length : 0;
+}
+function swapCase(str) {
+  let result = "";
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (ch >= "a" && ch <= "z") {
+      result += ch.toUpperCase();
+    } else if (ch >= "A" && ch <= "Z") {
+      result += ch.toLowerCase();
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+function toCobolCase(str) {
+  const words2 = splitWords(str);
+  return words2.map((w) => w.toUpperCase()).join("_");
+}
+function charCount(str) {
+  const result = {};
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    result[ch] = (result[ch] ?? 0) + 1;
+  }
+  return result;
+}
+
+// src/async/queue.ts
+var Queue = class {
+  _tasks = [];
+  _running = 0;
+  _paused = false;
+  _idleResolve = null;
+  _maxConcurrency;
+  constructor(options) {
+    this._maxConcurrency = options?.concurrency ?? 1;
+    if (this._maxConcurrency < 1) this._maxConcurrency = 1;
+  }
+  get pending() {
+    return this._tasks.length;
+  }
+  get running() {
+    return this._running;
+  }
+  add(task, options) {
+    return new Promise((resolve2, reject) => {
+      this._tasks.push({
+        priority: options?.priority ?? 0,
+        task,
+        resolve: resolve2,
+        reject
+      });
+      this._tasks.sort((a, b) => b.priority - a.priority);
+      this._process();
+    });
+  }
+  pause() {
+    this._paused = true;
+  }
+  resume() {
+    this._paused = false;
+    this._process();
+  }
+  clear() {
+    const err = new Error("Queue cleared");
+    for (const t of this._tasks) t.reject(err);
+    this._tasks = [];
+  }
+  onIdle() {
+    if (this._running === 0 && this._tasks.length === 0) return Promise.resolve();
+    return new Promise((resolve2) => {
+      this._idleResolve = resolve2;
+    });
+  }
+  _process() {
+    if (this._paused) return;
+    while (this._running < this._maxConcurrency && this._tasks.length > 0) {
+      const item = this._tasks.shift();
+      this._running++;
+      item.task().then((result) => item.resolve(result)).catch((err) => item.reject(err)).finally(() => {
+        this._running--;
+        this._process();
+        if (this._running === 0 && this._tasks.length === 0 && this._idleResolve) {
+          this._idleResolve();
+          this._idleResolve = null;
+        }
+      });
+    }
+  }
+};
+
+// src/async/semaphore.ts
+var Semaphore = class {
+  _available;
+  _waiting = [];
+  constructor(concurrency) {
+    if (concurrency < 1) throw new RangeError("Semaphore concurrency must be >= 1");
+    this._available = concurrency;
+  }
+  get available() {
+    return this._available;
+  }
+  acquire() {
+    if (this._available > 0) {
+      this._available--;
+      return Promise.resolve(this._release.bind(this));
+    }
+    return new Promise((resolve2) => {
+      this._waiting.push(() => {
+        this._available--;
+        resolve2(this._release.bind(this));
+      });
+    });
+  }
+  async use(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  _release() {
+    this._available++;
+    if (this._waiting.length > 0) {
+      const next = this._waiting.shift();
+      if (next) next();
+    }
+  }
+};
+
+// src/async/memoize.ts
+function memoizeAsync(fn, options) {
+  const {
+    ttl = 6e4,
+    staleWhileRevalidate = false,
+    maxSize = 100,
+    resolver = (...args) => JSON.stringify(args)
+  } = options ?? {};
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = (async (...args) => {
+    const key = resolver(...args);
+    const now = Date.now();
+    const entry = cache.get(key);
+    if (entry && now - entry.timestamp < ttl) {
+      return entry.value;
+    }
+    if (entry && staleWhileRevalidate && now - entry.timestamp >= ttl) {
+      if (entry.promise) {
+        return entry.value;
+      }
+      entry.promise = fn(...args).then((result2) => {
+        entry.value = result2;
+        entry.timestamp = now;
+        entry.promise = void 0;
+        return result2;
+      }).catch((err) => {
+        entry.promise = void 0;
+        throw err;
+      });
+      return entry.value;
+    }
+    const result = await fn(...args);
+    cache.set(key, { value: result, timestamp: now });
+    if (cache.size > maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) cache.delete(firstKey);
+    }
+    return result;
+  });
+  memoized.cache = cache;
+  memoized.clear = () => cache.clear();
+  return memoized;
+}
+
+// src/async/ratelimit.ts
+var RateLimiter = class {
+  _maxRequests;
+  _perWindow;
+  _timestamps = [];
+  constructor(options) {
+    if (options.maxRequests < 1) throw new RangeError("maxRequests must be >= 1");
+    if (options.perWindow < 1) throw new RangeError("perWindow must be >= 1");
+    this._maxRequests = options.maxRequests;
+    this._perWindow = options.perWindow;
+  }
+  _prune() {
+    const now = Date.now();
+    const cutoff = now - this._perWindow;
+    while (this._timestamps.length > 0) {
+      const ts = this._timestamps[0];
+      if (ts === void 0 || ts > cutoff) break;
+      this._timestamps.shift();
+    }
+  }
+  /**
+   * Check if a request is allowed without waiting.
+   */
+  tryAcquire() {
+    this._prune();
+    if (this._timestamps.length < this._maxRequests) {
+      this._timestamps.push(Date.now());
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Wait until a request is allowed.
+   */
+  async acquire() {
+    while (true) {
+      this._prune();
+      if (this._timestamps.length < this._maxRequests) {
+        this._timestamps.push(Date.now());
+        return;
+      }
+      const oldest = this._timestamps[0] ?? Date.now();
+      const waitMs = oldest + this._perWindow - Date.now();
+      if (waitMs > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+      }
+    }
+  }
+  /**
+   * Current number of pending requests in the window.
+   */
+  get pending() {
+    this._prune();
+    return this._timestamps.length;
+  }
+};
+
+// src/async/mutex.ts
+var Mutex = class {
+  _locked = false;
+  _waiting = [];
+  /**
+   * Acquire the lock. Returns a release function to be called when done.
+   */
+  acquire() {
+    if (!this._locked) {
+      this._locked = true;
+      return Promise.resolve(this._release.bind(this));
+    }
+    return new Promise((resolve2) => {
+      this._waiting.push(() => {
+        resolve2(this._release.bind(this));
+      });
+    });
+  }
+  /**
+   * Run a function with the lock held and automatically release it.
+   */
+  async use(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Whether the mutex is currently locked.
+   */
+  get locked() {
+    return this._locked;
+  }
+  _release() {
+    if (this._waiting.length > 0) {
+      const next = this._waiting.shift();
+      if (next) next();
+    } else {
+      this._locked = false;
+    }
+  }
+};
+
+// src/async/batch.ts
+async function batch(items, batchSize, fn) {
+  if (batchSize < 1) throw new RangeError("batchSize must be >= 1");
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const chunk2 = items.slice(i, i + batchSize);
+    const batchResults = await fn(chunk2);
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/async/waterfall.ts
+async function waterfall(tasks, initial) {
+  let result = initial;
+  for (const task of tasks) {
+    result = await task(result);
+  }
+  return result;
+}
 
 // src/async/index.ts
 function sleep(ms) {
@@ -1208,6 +2629,7 @@ function parseCsv(input, options) {
     return body.map((row) => {
       const record = {};
       for (let i = 0; i < head.length; i++) {
+        if (head[i] === "__proto__" || head[i] === "constructor" || head[i] === "prototype") continue;
         record[head[i]] = row[i] ?? "";
       }
       return record;
@@ -1348,9 +2770,7 @@ function assertType(value, guard, message) {
 function ensureArray(value) {
   return Array.isArray(value) ? value : [value];
 }
-function castArray(value) {
-  return ensureArray(value);
-}
+var castArray = ensureArray;
 function getType2(value) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
@@ -2182,6 +3602,29 @@ function isNoRekening(value) {
   return true;
 }
 
+// src/validation/isNoSIM.ts
+function isNoSIM(value) {
+  const digits = value.replace(/\D/g, "");
+  return digits.length === 12;
+}
+
+// src/validation/isPassport.ts
+function isPassport(value) {
+  return /^[A-Za-z]{2}\d{7}$/.test(value.trim());
+}
+
+// src/validation/isNoBPJS.ts
+function isNoBPJS(value) {
+  const digits = value.replace(/\D/g, "");
+  return digits.length === 13;
+}
+
+// src/validation/isNoKK.ts
+function isNoKK(value) {
+  const digits = value.replace(/\D/g, "");
+  return digits.length === 16;
+}
+
 // src/error/createError.ts
 var defaultStatus = {
   "BAD_REQUEST": 400,
@@ -2545,6 +3988,98 @@ function meetsWCAG(hex1, hex2, level) {
   const threshold = level === "AAA" ? 7 : 4.5;
   return ratio >= threshold;
 }
+function isValidHex(value) {
+  return /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+}
+function hexToHsl(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return null;
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return { h: 0, s: 0, l: Math.round(l * 100) };
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h = 0;
+  switch (max) {
+    case r:
+      h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+      break;
+    case g:
+      h = ((b - r) / d + 2) / 6;
+      break;
+    case b:
+      h = ((r - g) / d + 4) / 6;
+      break;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHex(h, s, l) {
+  const hue = h / 360;
+  const sat = s / 100;
+  const lig = l / 100;
+  if (sat === 0) {
+    const val = Math.round(lig * 255);
+    return rgbToHex(val, val, val);
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p2 + (q2 - p2) * 6 * tt;
+    if (tt < 1 / 2) return q2;
+    if (tt < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tt) * 6;
+    return p2;
+  };
+  const q = lig < 0.5 ? lig * (1 + sat) : lig + sat - lig * sat;
+  const p = 2 * lig - q;
+  return rgbToHex(
+    Math.round(hue2rgb(p, q, hue + 1 / 3) * 255),
+    Math.round(hue2rgb(p, q, hue) * 255),
+    Math.round(hue2rgb(p, q, hue - 1 / 3) * 255)
+  );
+}
+function mix(color1, color2, weight = 0.5) {
+  const rgb1 = hexToRgb(color1);
+  const rgb2 = hexToRgb(color2);
+  if (!rgb1 || !rgb2) return color1;
+  const w = Math.max(0, Math.min(1, weight));
+  const lerp2 = (a, b) => Math.floor(a + (b - a) * w);
+  return rgbToHex(lerp2(rgb1.r, rgb2.r), lerp2(rgb1.g, rgb2.g), lerp2(rgb1.b, rgb2.b));
+}
+function randomColor() {
+  const r = Math.floor(Math.random() * 256);
+  const g = Math.floor(Math.random() * 256);
+  const b = Math.floor(Math.random() * 256);
+  return rgbToHex(r, g, b);
+}
+function isLight(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return false;
+  return (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255 > 0.5;
+}
+function isDark(hex) {
+  return !isLight(hex);
+}
+function complementary(hex) {
+  const hsl = hexToHsl(hex);
+  if (!hsl) return hex;
+  return hslToHex((hsl.h + 180) % 360, hsl.s, hsl.l);
+}
+function alpha(hex, opacity) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const a = Math.max(0, Math.min(1, opacity));
+  const alphaHex = Math.round(a * 255).toString(16).padStart(2, "0");
+  return rgbToHex(rgb.r, rgb.g, rgb.b) + alphaHex;
+}
 export {
   DivisionByZeroError,
   InvalidDateError,
@@ -2552,6 +4087,13 @@ export {
   KNOWN_MAPPINGS,
   Logger,
   MultiError,
+  Mutex,
+  Queue,
+  RateLimiter,
+  Semaphore,
+  TIMEZONE_WIB,
+  TIMEZONE_WIT,
+  TIMEZONE_WITA,
   TypedError,
   add,
   addBusinessDays,
@@ -2559,6 +4101,7 @@ export {
   addMonths,
   addYears,
   allSettledMap,
+  alpha,
   analyzeUsage,
   approxEqual,
   assertDefined,
@@ -2567,18 +4110,26 @@ export {
   base64Decode,
   base64Encode,
   basename,
+  batch,
   calculateAge,
   camelCase,
   capitalize,
   castArray,
   ceil,
+  charCount,
   checksum,
   chunk,
   clamp,
   collectErrors,
+  combinations,
+  compact,
+  complementary,
+  compose,
   consoleTransport,
   constantTimeEqual,
   contrastRatio,
+  correlation,
+  countBy,
   countOccurrences,
   createBufferedTransport,
   createConsoleTransport,
@@ -2587,12 +4138,21 @@ export {
   createJsonTransport,
   darken,
   dateDiff,
+  dayOfYear,
+  daysInMonth,
   debounce,
+  dedent,
   deepClone,
+  deepEqual,
+  deepGet,
   deepMerge,
+  deepSet,
   deferred,
+  difference,
   dirname,
   div,
+  drop,
+  dropRight,
   endOfDay,
   endOfMonth,
   endOfYear,
@@ -2602,63 +4162,125 @@ export {
   envInt,
   escapeHtml,
   extname,
+  factorial,
+  findIndex,
+  findLast,
   first,
   flatten,
   floor,
   format,
+  formatBytes,
+  formatCurrency,
   formatDate,
+  formatDuration,
+  formatInTimezone,
+  formatRupiah,
+  fuzzyMatch,
+  gcd,
   generateOTP,
   generateReport,
   generateToken,
+  geometricMean,
+  getIndonesianHolidayNames,
   getType2 as getType,
   groupBy,
   hash,
+  hexToHsl,
   hexToRgb,
+  hslToHex,
   identity,
   inRange,
+  intersection,
   isAbsolute,
   isAfter,
+  isAnagram,
   isArray,
   isBefore,
   isBetween,
   isBoolean,
   isBusinessDay,
+  isDark,
   isDate,
   isEmail,
   isEmpty,
+  isEven,
   isFunction,
+  isFuture,
+  isHolidayIndonesia,
   isKodepos,
   isLeapYear,
+  isLight,
   isMap,
   isNIK,
   isNPWP,
   isNil,
+  isNoBPJS,
+  isNoKK,
   isNoRekening,
+  isNoSIM,
   isNull,
   isNumber,
   isObject,
+  isOdd,
+  isPalindrome,
+  isPassport,
+  isPast,
   isPhone,
   isPlatNomor,
+  isPrime,
   isPromise,
   isRegExp,
+  isSameDay,
   isSet,
   isString,
+  isToday,
+  isTomorrow,
   isTypedError,
   isURL,
   isUndefined,
+  isValidHex,
   isWeekend,
+  isYesterday,
   join,
   kebabCase,
   keyBy,
   last,
+  lastFriday,
+  lastMonday,
+  lastSaturday,
+  lastSunday,
+  lastThursday,
+  lastTuesday,
+  lastWednesday,
+  lcm,
+  lerp,
+  levenshtein,
   lighten,
   logger,
+  mapRange,
+  maskString,
+  maxBy,
+  maxDate,
+  median,
   meetsWCAG,
   memoize,
+  memoizeAsync,
+  minBy,
+  minDate,
+  mix,
+  mode,
   mul,
   nanoid,
+  nextFriday,
+  nextMonday,
+  nextSaturday,
+  nextSunday,
+  nextThursday,
+  nextTuesday,
+  nextWednesday,
   noop,
   normalize,
+  nth,
   omit,
   once,
   orderBy,
@@ -2669,14 +4291,26 @@ export {
   parse,
   parseCsv,
   parseDate,
+  parseDuration,
   parseNIK,
+  partition,
   pascalCase,
+  percentageOf,
+  percentile,
+  permutations,
   pick,
+  pipe,
   pipeline,
   pluck,
+  pluralize,
+  quarter,
   raceWithTimeout,
+  randomBoolean,
+  randomColor,
   randomHex,
   randomInt,
+  randomString,
+  range,
   relative,
   resolve,
   retry,
@@ -2687,31 +4321,58 @@ export {
   safeJsonParse,
   sample,
   sampleSize,
+  sampleStddev,
   scanProject,
   shuffle,
+  similarity,
   simpleHash,
   sleep,
+  slidingWindows,
   slugify,
   snakeCase,
   sortBy,
   startOfDay,
   startOfMonth,
   startOfYear,
+  stddev,
   stringifyCsv,
+  stripHtml,
   sub,
   sum,
+  sumBy,
+  swapCase,
+  take,
+  takeRight,
   template,
+  terbilang,
   throttle,
+  timeAgo,
+  timeRemaining,
   timeout,
+  toCobolCase,
+  toDegrees,
+  toRadians,
+  toTimezone,
+  topoSort,
   trim,
   trimEnd,
   trimStart,
   truncate,
+  truncateWords,
+  tumblingWindows,
   unescapeHtml,
+  union,
   uniq,
   uniqueBy,
+  unzip,
   uuid,
+  waterfall,
+  weekOfYear,
+  weightedAverage,
+  without,
+  wordCount,
   words,
-  xorCipher
+  xorCipher,
+  zip
 };
 //# sourceMappingURL=index.js.map