speexjs-core 0.7.0

package/dist/index.js

@@ -0,0 +1,4378 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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];
+      if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+      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;
+  };
+}
+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 {
+  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);
+  const shifted = Number((value * factor).toPrecision(15));
+  return Math.round(shifted) / 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;
+}
+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 {
+  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 year = parseInt(dmyMatch[3], 10);
+    const month = parseInt(dmyMatch[2], 10) - 1;
+    const day = parseInt(dmyMatch[1], 10);
+    const d = new Date(year, month, day);
+    if (!isNaN(d.getTime()) && d.getMonth() === month && d.getDate() === day) 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 year = parseInt(textMatch[3], 10);
+      const day = parseInt(textMatch[1], 10);
+      const d = new Date(year, monthIndex, day);
+      if (!isNaN(d.getTime()) && d.getMonth() === monthIndex && d.getDate() === day) 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;
+}
+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) {
+  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) {
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(size);
+    crypto.getRandomValues(bytes);
+    return bytes;
+  }
+  throw new Error("Crypto API unavailable. Cannot generate secure random 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;
+}
+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;
+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, (_2, key) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return `{{${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;
+  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[bytes[i] % len];
+  }
+  return result;
+}
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "`": "&#96;",
+  "/": "&#x2F;"
+};
+var HTML_UNESCAPE_MAP = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#96;": "`",
+  "&#x2F;": "/"
+};
+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|#96|#x2F);/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;
+}
+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) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function timeout(promise, ms, errorMessage) {
+  let timer;
+  const timeoutPromise = new Promise((_2, 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++) {
+        if (head[i] === "__proto__" || head[i] === "constructor" || head[i] === "prototype") continue;
+        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];
+}
+var castArray = ensureArray;
+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";
+}
+
+// src/dep-exray/scanner/index.ts
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join as join2, basename as basename2 } from "path";
+
+// src/dep-exray/known-mappings.ts
+var KNOWN_MAPPINGS = [
+  {
+    name: "lodash",
+    size: "4.2 MB",
+    replacement: "jscore-core",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "Most lodash functions have direct replacements in jscore-core with 99% API compatibility",
+    detectionPattern: `from ['"]lodash['"]|require\\(['"]lodash['"]\\)`
+  },
+  {
+    name: "moment",
+    size: "2.5 MB",
+    replacement: "jscore-core/date",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "date utilities in jscore-core cover 95% of common moment use cases",
+    detectionPattern: `from ['"]moment['"]|require\\(['"]moment['"]\\)`
+  },
+  {
+    name: "date-fns",
+    size: "1.2 MB (tree-shaked ~50KB)",
+    replacement: "jscore-core/date",
+    confidence: "medium",
+    autoPrReady: false,
+    reason: "Partially overlapping \u2014 jscore-core covers basic date ops but not all locale support",
+    detectionPattern: `from ['"]date-fns['"]|require\\(['"]date-fns['"]\\)`
+  },
+  {
+    name: "axios",
+    size: "1.6 MB",
+    replacement: "native fetch + jscore-core/async/retry",
+    confidence: "medium",
+    autoPrReady: false,
+    reason: "Native fetch covers most use cases; needs manual review for interceptors",
+    detectionPattern: `from ['"]axios['"]|require\\(['"]axios['"]\\)`
+  },
+  {
+    name: "uuid",
+    size: "30 KB",
+    replacement: "crypto.randomUUID() (native)",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "crypto.randomUUID() is available in all modern Node.js and browsers",
+    detectionPattern: `from ['"]uuid['"]|require\\(['"]uuid['"]\\)`
+  },
+  {
+    name: "deepmerge",
+    size: "15 KB",
+    replacement: "jscore-core",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "jscore-core provides deepMerge out of the box",
+    detectionPattern: `from ['"]deepmerge['"]|require\\(['"]deepmerge['"]\\)`
+  },
+  {
+    name: "lodash.merge",
+    size: "25 KB",
+    replacement: "jscore-core",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "jscore-core provides deepMerge out of the box",
+    detectionPattern: `from ['"]lodash\\.(merge|clone|pick|omit|get|set)['"]`
+  },
+  {
+    name: "chalk",
+    size: "45 KB",
+    replacement: "picocolors",
+    confidence: "medium",
+    autoPrReady: false,
+    reason: "picocolors is 3KB vs chalk's 45KB with same API",
+    detectionPattern: `from ['"]chalk['"]|require\\(['"]chalk['"]\\)`
+  },
+  {
+    name: "nanoid",
+    size: "8 KB",
+    replacement: "jscore-core/string (nanoid)",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "jscore-core provides nanoid with same API",
+    detectionPattern: `from ['"]nanoid['"]|require\\(['"]nanoid['"]\\)`
+  },
+  {
+    name: "dayjs",
+    size: "50 KB",
+    replacement: "jscore-core/date",
+    confidence: "medium",
+    autoPrReady: false,
+    reason: "Partially overlapping \u2014 covers basics but not all plugins",
+    detectionPattern: `from ['"]dayjs['"]|require\\(['"]dayjs['"]\\)`
+  },
+  {
+    name: "clsx",
+    size: "5 KB",
+    replacement: "native template literals",
+    confidence: "high",
+    autoPrReady: true,
+    reason: "Can be replaced with simple template literal conditional pattern",
+    detectionPattern: `from ['"]clsx['"]|require\\(['"]clsx['"]\\)`
+  }
+];
+var KNOWN_CVES = {
+  "ansi-regex": [
+    { cve: "CVE-2021-3807", severity: "high", fix: "Update to ansi-regex@6.0.1 or later" }
+  ],
+  "semver": [
+    { cve: "CVE-2022-25883", severity: "medium", fix: "Update to semver@7.5.2 or later" }
+  ],
+  "json5": [
+    { cve: "CVE-2022-46175", severity: "high", fix: "Update to json5@2.2.3 or later" }
+  ],
+  "lodash": [
+    { cve: "CVE-2020-28502", severity: "high", fix: "Update to lodash@4.17.21 or later" },
+    { cve: "CVE-2020-8203", severity: "medium", fix: "Update to lodash@4.17.21 or later" }
+  ]
+};
+
+// src/dep-exray/scanner/index.ts
+function parsePackageJson(path) {
+  const raw = readFileSync(path, "utf-8");
+  const json = JSON.parse(raw);
+  return {
+    name: json.name ?? basename2(join2(path, "..")),
+    dependencies: json.dependencies ?? {},
+    devDependencies: json.devDependencies ?? {}
+  };
+}
+function parseLockfile(projectPath) {
+  const lockPath = join2(projectPath, "package-lock.json");
+  if (!existsSync(lockPath)) return null;
+  try {
+    const raw = readFileSync(lockPath, "utf-8");
+    const json = JSON.parse(raw);
+    const packages = {};
+    if (json.packages) {
+      for (const [key, val] of Object.entries(json.packages)) {
+        if (key) {
+          packages[key] = val;
+        }
+      }
+    }
+    if (json.dependencies && Object.keys(packages).length === 0) {
+      for (const [key, val] of Object.entries(json.dependencies)) {
+        packages[key] = { version: val.version, dependencies: val.requires };
+      }
+    }
+    return { packages };
+  } catch {
+    return null;
+  }
+}
+function detectImportInFile(filePath, regex) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return regex.test(content);
+  } catch {
+    return false;
+  }
+}
+function detectImportsInSrc(projectPath, mapping) {
+  const regex = new RegExp(mapping.detectionPattern);
+  const srcDir = join2(projectPath, "src");
+  if (!existsSync(srcDir)) return false;
+  try {
+    const files = collectSourceFiles(srcDir);
+    for (const file of files) {
+      if (detectImportInFile(file, regex)) return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function collectSourceFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git" || entry.name === "coverage" || entry.name === ".tsup") {
+        continue;
+      }
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...collectSourceFiles(full));
+      } else if (entry.isFile()) {
+        const ext = entry.name.split(".").pop();
+        if (ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx" || ext === "mjs" || ext === "cjs") {
+          results.push(full);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function estimateTransitiveCount(lockfile, directNames) {
+  if (!lockfile) return 0;
+  let count = 0;
+  for (const key of Object.keys(lockfile.packages)) {
+    if (!key || key === "") continue;
+    const name = key.startsWith("node_modules/") ? key.slice("node_modules/".length) : key;
+    const rootName = name.startsWith("@") ? `${name.split("/")[0]}/${name.split("/")[1]}` : name.split("/")[0];
+    if (rootName && !directNames.has(rootName)) {
+      count++;
+    }
+  }
+  return count;
+}
+function parseSize(value) {
+  const cleaned = value.replace(/\(.*?\)/g, "").trim();
+  const match = cleaned.match(/^([\d.]+)\s*(KB|MB)/i);
+  if (!match) return 0;
+  const num = Number.parseFloat(match[1]);
+  if (!match[2]) return 0;
+  if (match[2].toUpperCase() === "MB") return num * 1024;
+  return num;
+}
+async function scanProject(config) {
+  const projectPath = config.path ?? ".";
+  const pkgPath = join2(projectPath, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(`No package.json found at ${projectPath}. Run dep-exray in a JavaScript/TypeScript project directory.`);
+  }
+  const pkg = parsePackageJson(pkgPath);
+  const lockfile = parseLockfile(projectPath);
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const directNames = new Set(Object.keys(allDeps));
+  const transitiveCount = estimateTransitiveCount(lockfile, directNames);
+  const highImpactReplacements = [];
+  const mediumImpactReplacements = [];
+  const securityIssues = [];
+  const sizeMap = {};
+  for (const m of KNOWN_MAPPINGS) {
+    sizeMap[m.name] = m.size;
+  }
+  for (const mapping of KNOWN_MAPPINGS) {
+    const isDirect = directNames.has(mapping.name);
+    if (!isDirect) continue;
+    const isUsed = detectImportsInSrc(projectPath, mapping);
+    if (!isUsed && !config.verbose) continue;
+    const mappingSize = parseSize(sizeMap[mapping.name] ?? "0 KB");
+    const replacementSize = mapping.replacement.startsWith("native") ? 0 : 5;
+    const reductionStr = mappingSize > 1024 ? `${(mappingSize / 1024).toFixed(1)} MB \u2192 ${replacementSize} KB` : `${mappingSize.toFixed(0)} KB \u2192 ${replacementSize} KB`;
+    const suggestion = {
+      packageName: mapping.name,
+      reason: mapping.reason,
+      replacement: mapping.replacement,
+      estimatedSizeReduction: reductionStr,
+      confidence: mapping.confidence,
+      autoPrReady: mapping.autoPrReady
+    };
+    if (mapping.confidence === "high") {
+      highImpactReplacements.push(suggestion);
+    } else {
+      mediumImpactReplacements.push(suggestion);
+    }
+  }
+  for (const [name, cves] of Object.entries(KNOWN_CVES)) {
+    if (directNames.has(name)) {
+      for (const cveItem of cves) {
+        securityIssues.push({
+          packageName: name,
+          cveId: cveItem.cve,
+          severity: cveItem.severity,
+          fix: cveItem.fix
+        });
+      }
+    }
+  }
+  let totalSizeKB = 0;
+  for (const depName of directNames) {
+    const sizeStr = sizeMap[depName];
+    if (sizeStr) {
+      totalSizeKB += parseSize(sizeStr);
+    } else {
+      totalSizeKB += 50;
+    }
+  }
+  totalSizeKB += transitiveCount * 30;
+  const totalSizeStr = totalSizeKB > 1024 ? `${(totalSizeKB / 1024).toFixed(1)} MB` : `${totalSizeKB.toFixed(0)} KB`;
+  return {
+    projectName: pkg.name,
+    directDeps: directNames.size,
+    transitiveDeps: transitiveCount,
+    totalEstimatedSize: totalSizeStr,
+    highImpactReplacements,
+    mediumImpactReplacements,
+    securityIssues
+  };
+}
+
+// src/dep-exray/reporter/index.ts
+var _ = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function style(text, codes) {
+  return codes.join("") + text + _.reset;
+}
+function severityColor(severity) {
+  switch (severity) {
+    case "critical":
+      return style(severity.toUpperCase(), [_.bold, _.red]);
+    case "high":
+      return style(severity.toUpperCase(), [_.red]);
+    case "medium":
+      return style(severity.toUpperCase(), [_.yellow]);
+    case "low":
+      return style(severity.toUpperCase(), [_.dim]);
+  }
+}
+function confidenceIcon(confidence) {
+  switch (confidence) {
+    case "high":
+      return style("\u25CF", [_.green]);
+    case "medium":
+      return style("\u25CF", [_.yellow]);
+    case "low":
+      return style("\u25CF", [_.red]);
+  }
+}
+function generateReport(result, jsonOutput) {
+  if (jsonOutput) {
+    return JSON.stringify(result, null, 2);
+  }
+  const lines = [];
+  const t = (text, codes = [_.cyan]) => style(text, [_.bold, ...codes]);
+  lines.push(t(`\u250C${"\u2500".repeat(58)}\u2510`));
+  lines.push(t(`\u2502${" ".repeat(18)}dep-exray Report${" ".repeat(21)}\u2502`));
+  lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+  lines.push(t(`\u2502  ${style("\u{1F4E6} PROJECT:", [_.white])} ${style(result.projectName, [_.bold])}${" ".repeat(Math.max(1, 47 - result.projectName.length))}\u2502`));
+  lines.push(t(`\u2502  ${style("\u{1F4CA} DEPENDENCIES:", [_.white])} ${style(String(result.directDeps), [_.bold])} direct + ${style(String(result.transitiveDeps), [_.bold])} transitive${" ".repeat(Math.max(1, 27 - String(result.transitiveDeps).length))}\u2502`));
+  lines.push(t(`\u2502  ${style("\u{1F4BE} TOTAL SIZE:", [_.white])} ${style(result.totalEstimatedSize, [_.bold])}${" ".repeat(Math.max(1, 42 - result.totalEstimatedSize.length))}\u2502`));
+  lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+  if (result.highImpactReplacements.length > 0) {
+    lines.push(t(`\u2502  ${style("\u{1F7E2}", [_.green])} ${style("HIGH IMPACT REPLACEMENTS", [_.bold, _.green])}${" ".repeat(23)}\u2502`));
+    for (const item of result.highImpactReplacements) {
+      const autoPr = item.autoPrReady ? style("\u2713 Auto-PR ready", [_.green]) : style("Manual review needed", [_.dim]);
+      const confIcon = confidenceIcon(item.confidence);
+      lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+      lines.push(t(`\u2502  ${style("\u2717", [_.red])} ${style(item.packageName, [_.bold])} (${item.estimatedSizeReduction})${" ".repeat(Math.max(1, 38 - item.estimatedSizeReduction.length))}\u2502`));
+      lines.push(t(`\u2502  ${style("\u2192", [_.dim])} ${style(item.replacement, [_.cyan])}${" ".repeat(Math.max(1, 51 - item.replacement.length))}\u2502`));
+      lines.push(t(`\u2502  ${style("\u2514\u2500", [_.dim])} ${autoPr}  ${confIcon} ${item.confidence}${" ".repeat(Math.max(1, 35))}\u2502`));
+    }
+  }
+  if (result.mediumImpactReplacements.length > 0) {
+    lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+    lines.push(t(`\u2502  ${style("\u{1F7E1}", [_.yellow])} ${style("MEDIUM IMPACT REPLACEMENTS", [_.bold, _.yellow])}${" ".repeat(20)}\u2502`));
+    for (const item of result.mediumImpactReplacements) {
+      const autoPr = item.autoPrReady ? style("\u2713 Auto-PR ready", [_.green]) : style("Manual review needed", [_.dim]);
+      const confIcon = confidenceIcon(item.confidence);
+      lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+      lines.push(t(`\u2502  ${style("\u2717", [_.red])} ${style(item.packageName, [_.bold])} (${item.estimatedSizeReduction})${" ".repeat(Math.max(1, 38 - item.estimatedSizeReduction.length))}\u2502`));
+      lines.push(t(`\u2502  ${style("\u2192", [_.dim])} ${style(item.replacement, [_.cyan])}${" ".repeat(Math.max(1, 51 - item.replacement.length))}\u2502`));
+      lines.push(t(`\u2502  ${style("\u2514\u2500", [_.dim])} ${autoPr}  ${confIcon} ${item.confidence}${" ".repeat(Math.max(1, 35))}\u2502`));
+    }
+  }
+  if (result.securityIssues.length > 0) {
+    lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+    lines.push(t(`\u2502  ${style("\u{1F534}", [_.red])} ${style("SECURITY ISSUES", [_.bold, _.red])}${" ".repeat(33)}\u2502`));
+    for (const issue of result.securityIssues) {
+      lines.push(t(`\u251C${"\u2500".repeat(58)}\u2524`));
+      lines.push(t(`\u2502  ${severityColor(issue.severity)} ${style(issue.cveId, [_.bold])} in ${issue.packageName}${" ".repeat(Math.max(1, 40 - issue.packageName.length))}\u2502`));
+      lines.push(t(`\u2502  ${style("\u2192", [_.dim])} ${issue.fix}${" ".repeat(Math.max(1, 52 - issue.fix.length))}\u2502`));
+    }
+  }
+  lines.push(t(`\u2514${"\u2500".repeat(58)}\u2518`));
+  return lines.join("\n");
+}
+
+// src/dep-exray/analyzer/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { readdirSync as readdirSync2, statSync } from "fs";
+import { join as join3, extname as extname2 } from "path";
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+function isSourceFile(file) {
+  return SOURCE_EXTENSIONS.has(extname2(file));
+}
+function collectSourceFiles2(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git" || entry.name === "coverage" || entry.name === ".tsup") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        results.push(...collectSourceFiles2(fullPath));
+      } else if (entry.isFile() && isSourceFile(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function analyzeUsage(projectPath, packageName) {
+  const importLocations = [];
+  const escaped = escapeRegex(packageName);
+  const importRegex = new RegExp(
+    `(?:from\\s+['"]${escaped}(?:/['"]|['"])|require\\(\\s*['"]${escaped}(?:/|['"]))`,
+    "g"
+  );
+  const srcDir = join3(projectPath, "src");
+  let files;
+  try {
+    if (statSync(srcDir).isDirectory()) {
+      files = collectSourceFiles2(srcDir);
+    } else {
+      files = collectSourceFiles2(projectPath);
+    }
+  } catch {
+    files = collectSourceFiles2(projectPath);
+  }
+  for (const file of files) {
+    try {
+      const content = readFileSync2(file, "utf-8");
+      importRegex.lastIndex = 0;
+      if (importRegex.test(content)) {
+        importLocations.push(file);
+      }
+    } catch {
+    }
+  }
+  return {
+    isUsed: importLocations.length > 0,
+    importCount: importLocations.length,
+    importLocations
+  };
+}
+
+// src/validation/isNIK.ts
+function isNIK(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 16) return false;
+  const rawDay = Number.parseInt(digits.slice(6, 8), 10);
+  const month = Number.parseInt(digits.slice(8, 10), 10);
+  const year = Number.parseInt(digits.slice(10, 12), 10);
+  if (rawDay < 1 || rawDay > 71) return false;
+  if (month < 1 || month > 12) return false;
+  let day = rawDay;
+  if (day >= 41) day -= 40;
+  const fullYear = year < 70 ? 2e3 + year : 1900 + year;
+  const date = new Date(fullYear, month - 1, day);
+  return date.getFullYear() === fullYear && date.getMonth() === month - 1 && date.getDate() === day;
+}
+
+// src/validation/isNPWP.ts
+function isNPWP(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 15 && digits.length !== 16) return false;
+  const nums = [];
+  for (let i = 0; i < digits.length; i++) {
+    nums.push(Number.parseInt(digits[i], 10));
+  }
+  const checkDigit = nums[nums.length - 1];
+  let sum2 = 0;
+  for (let i = 0; i < nums.length - 1; i++) {
+    sum2 += nums[i] * [3, 7, 1][i % 3];
+  }
+  const computed = (11 - sum2 % 11) % 10;
+  return computed === checkDigit;
+}
+
+// src/validation/isPhone.ts
+var INDONESIAN_PREFIXES = [
+  [11, 19],
+  [21, 29],
+  [51, 59],
+  [77, 79],
+  [95, 99]
+];
+function isValidIndonesianPrefix(prefix) {
+  for (const [min, max] of INDONESIAN_PREFIXES) {
+    if (prefix >= min && prefix <= max) return true;
+  }
+  return false;
+}
+function isPhone(value, country = "id") {
+  const digits = value.replace(/\D/g, "");
+  if (country === "any") {
+    return digits.length >= 10 && digits.length <= 15;
+  }
+  if (digits.length < 10) return false;
+  let normalized;
+  if (digits.startsWith("62")) {
+    normalized = digits.slice(2);
+  } else if (digits.startsWith("0")) {
+    normalized = digits.slice(1);
+  } else {
+    normalized = digits;
+  }
+  if (normalized.length < 10 || normalized.length > 13) return false;
+  if (!normalized.startsWith("8")) return false;
+  const prefix = Number.parseInt(normalized.slice(1, 3), 10);
+  return isValidIndonesianPrefix(prefix);
+}
+
+// src/validation/isEmail.ts
+var LOCAL_SPECIAL = "!#$%&'*+/=?^_`{|}~-";
+function isQuotedLocalPart(local) {
+  if (local.length < 2) return false;
+  let i = 1;
+  while (i < local.length - 1) {
+    const ch = local[i];
+    if (ch === "\\") {
+      i++;
+      if (i >= local.length - 1) return false;
+    } else if (ch === '"') {
+      return false;
+    }
+    i++;
+  }
+  return true;
+}
+function isUnquotedLocalPart(local) {
+  if (local.length === 0 || local.startsWith(".") || local.endsWith(".")) return false;
+  for (let i = 0; i < local.length; i++) {
+    const ch = local[i];
+    if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "." || LOCAL_SPECIAL.includes(ch)) {
+      continue;
+    }
+    return false;
+  }
+  for (let i = 1; i < local.length; i++) {
+    if (local[i] === "." && local[i - 1] === ".") return false;
+  }
+  return true;
+}
+function isValidDomain(domain) {
+  if (domain.length === 0 || domain.startsWith(".") || domain.endsWith(".")) return false;
+  const labels = domain.split(".");
+  if (labels.length < 2) return false;
+  for (const label of labels) {
+    if (label.length === 0 || label.length > 63) return false;
+    if (label.startsWith("-") || label.endsWith("-")) return false;
+    for (let i = 0; i < label.length; i++) {
+      const ch = label[i];
+      if (!(ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "-")) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isEmail(value) {
+  if (value.length > 254) return false;
+  const atIndex = value.lastIndexOf("@");
+  if (atIndex < 1 || atIndex === value.length - 1) return false;
+  const localPart = value.slice(0, atIndex);
+  const domainPart = value.slice(atIndex + 1);
+  if (localPart.length > 64) return false;
+  if (domainPart.length > 255) return false;
+  if (localPart.startsWith('"') && localPart.endsWith('"')) {
+    if (!isQuotedLocalPart(localPart)) return false;
+  } else {
+    if (!isUnquotedLocalPart(localPart)) return false;
+  }
+  return isValidDomain(domainPart);
+}
+
+// src/validation/isURL.ts
+var IPV4_OCTET = /^(?:[0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/;
+function isValidIPv4(hostname) {
+  const octets = hostname.split(".");
+  if (octets.length !== 4) return false;
+  return octets.every((octet) => IPV4_OCTET.test(octet));
+}
+function isValidDNSHostname(hostname) {
+  if (hostname.startsWith(".") || hostname.endsWith(".")) return false;
+  const labels = hostname.split(".");
+  if (labels.length < 2) return false;
+  for (const label of labels) {
+    if (label.length === 0 || label.length > 63) return false;
+    if (label.startsWith("-") || label.endsWith("-")) return false;
+    for (let i = 0; i < label.length; i++) {
+      const ch = label[i];
+      if (!(ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "-")) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isValidHostname(hostname) {
+  if (hostname.length === 0) return false;
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    return hostname.length > 2;
+  }
+  if (/^\d/.test(hostname) || /\d$/.test(hostname)) {
+    if (isValidIPv4(hostname)) return true;
+  }
+  if (hostname === "localhost") return true;
+  return isValidDNSHostname(hostname);
+}
+function isURL(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return false;
+    }
+    return isValidHostname(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+// src/validation/parseNIK.ts
+function parseNIK(value) {
+  const digits = value.replace(/\D/g, "");
+  const info = {
+    nik: value,
+    valid: false,
+    gender: null,
+    birthDate: null,
+    province: null,
+    provinceCode: null,
+    city: null,
+    cityCode: null,
+    district: null,
+    districtCode: null,
+    uniqueCode: null
+  };
+  if (digits.length !== 16) return info;
+  const provinceCode = digits.slice(0, 2);
+  const cityCode = digits.slice(2, 4);
+  const districtCode = digits.slice(4, 6);
+  const rawDay = Number.parseInt(digits.slice(6, 8), 10);
+  const month = Number.parseInt(digits.slice(8, 10), 10);
+  const year = Number.parseInt(digits.slice(10, 12), 10);
+  const uniqueCode = digits.slice(12, 16);
+  if (rawDay < 1 || rawDay > 71 || month < 1 || month > 12) return info;
+  const gender = rawDay >= 41 ? "PEREMPUAN" : "LAKI-LAKI";
+  let day = rawDay;
+  if (day >= 41) day -= 40;
+  const fullYear = year < 70 ? 2e3 + year : 1900 + year;
+  const birthDate = new Date(fullYear, month - 1, day);
+  if (birthDate.getFullYear() !== fullYear || birthDate.getMonth() !== month - 1 || birthDate.getDate() !== day) {
+    return info;
+  }
+  return {
+    nik: value,
+    valid: true,
+    gender,
+    birthDate,
+    province: PROVINCE_CODES[provinceCode] ?? null,
+    provinceCode,
+    city: null,
+    cityCode,
+    district: null,
+    districtCode,
+    uniqueCode
+  };
+}
+var PROVINCE_CODES = {
+  "11": "ACEH",
+  "12": "SUMATERA UTARA",
+  "13": "SUMATERA BARAT",
+  "14": "RIAU",
+  "15": "JAMBI",
+  "16": "SUMATERA SELATAN",
+  "17": "BENGKULU",
+  "18": "LAMPUNG",
+  "19": "KEPULAUAN BANGKA BELITUNG",
+  "21": "KEPULAUAN RIAU",
+  "31": "DKI JAKARTA",
+  "32": "JAWA BARAT",
+  "33": "JAWA TENGAH",
+  "34": "DI YOGYAKARTA",
+  "35": "JAWA TIMUR",
+  "36": "BANTEN",
+  "51": "BALI",
+  "52": "NUSA TENGGARA BARAT",
+  "53": "NUSA TENGGARA TIMUR",
+  "61": "KALIMANTAN BARAT",
+  "62": "KALIMANTAN TENGAH",
+  "63": "KALIMANTAN SELATAN",
+  "64": "KALIMANTAN TIMUR",
+  "65": "KALIMANTAN UTARA",
+  "71": "SULAWESI UTARA",
+  "72": "SULAWESI TENGAH",
+  "73": "SULAWESI SELATAN",
+  "74": "SULAWESI TENGGARA",
+  "75": "GORONTALO",
+  "76": "SULAWESI BARAT",
+  "81": "MALUKU",
+  "82": "MALUKU UTARA",
+  "91": "PAPUA",
+  "92": "PAPUA BARAT",
+  "93": "PAPUA SELATAN",
+  "94": "PAPUA TENGAH",
+  "95": "PAPUA PEGUNUNGAN"
+};
+
+// src/validation/isPlatNomor.ts
+function isPlatNomor(value) {
+  const trimmed = value.trim().toUpperCase();
+  const regex = /^([A-Z]{1,2})\s*(\d{1,4})\s*([A-Z]{0,3})$/;
+  const match = trimmed.match(regex);
+  if (!match) return false;
+  const kodeDepan = match[1];
+  const angka = parseInt(match[2], 10);
+  const kodeBelakang = match[3] || "";
+  if (!KODE_DAERAH.includes(kodeDepan)) return false;
+  if (angka < 1 || angka > 9999) return false;
+  if (kodeBelakang.length > 3) return false;
+  return true;
+}
+var KODE_DAERAH = [
+  "A",
+  "AA",
+  "AB",
+  "AD",
+  "AE",
+  "AG",
+  "B",
+  "BA",
+  "BB",
+  "BD",
+  "BE",
+  "BG",
+  "BH",
+  "BK",
+  "BL",
+  "BM",
+  "BN",
+  "BP",
+  "BR",
+  "BT",
+  "BU",
+  "BV",
+  "BW",
+  "D",
+  "DA",
+  "DB",
+  "DC",
+  "DD",
+  "DE",
+  "DF",
+  "DG",
+  "DH",
+  "DK",
+  "DL",
+  "DM",
+  "DN",
+  "DP",
+  "DR",
+  "DT",
+  "DU",
+  "DW",
+  "E",
+  "EA",
+  "EB",
+  "ED",
+  "EE",
+  "F",
+  "G",
+  "H",
+  "K",
+  "KB",
+  "KH",
+  "KI",
+  "KU",
+  "KT",
+  "L",
+  "M",
+  "N",
+  "NB",
+  "NG",
+  "NK",
+  "NM",
+  "P",
+  "PA",
+  "PB",
+  "R",
+  "S",
+  "ST",
+  "T",
+  "W",
+  "Z"
+];
+
+// src/validation/isKodepos.ts
+function isKodepos(value) {
+  if (value.length !== 5) return false;
+  return /^\d{5}$/.test(value);
+}
+
+// src/validation/isNoRekening.ts
+function isNoRekening(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 8 || digits.length > 16) return false;
+  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,
+  "UNAUTHORIZED": 401,
+  "FORBIDDEN": 403,
+  "NOT_FOUND": 404,
+  "CONFLICT": 409,
+  "VALIDATION_ERROR": 422,
+  "TOO_MANY": 429,
+  "INTERNAL": 500,
+  "BAD_GATEWAY": 502,
+  "UNAVAILABLE": 503
+};
+var TypedError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "TypedError";
+    this.code = code;
+    this.status = options?.status ?? defaultStatus[code] ?? 500;
+    this.details = options?.details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Serialize the error to a plain JSON-safe object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      details: this.details,
+      cause: this.cause,
+      ...this.stack ? { stack: this.stack } : {}
+    };
+  }
+  toString() {
+    return `${this.name} [${this.code}]: ${this.message}`;
+  }
+};
+function createError(code, message, options) {
+  return new TypedError(code, message, options);
+}
+function isTypedError(error) {
+  return error instanceof TypedError;
+}
+
+// src/error/MultiError.ts
+var MultiError = class extends Error {
+  errors;
+  constructor(errors, message) {
+    const joined = errors.map((e) => e.message).join("; ");
+    super(message ?? joined);
+    this.name = "MultiError";
+    this.errors = [...errors];
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /** Number of collected errors. */
+  get length() {
+    return this.errors.length;
+  }
+  /**
+   * Check if any collected error satisfies `predicate`.
+   *
+   * @example
+   * ```ts
+   * if (err.some(e => e.message.includes('timeout'))) { … }
+   * ```
+   */
+  some(predicate) {
+    return this.errors.some(predicate);
+  }
+  /** Array of all error messages. */
+  get messages() {
+    return this.errors.map((e) => e.message);
+  }
+  /**
+   * Serialize to a plain JSON-safe object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      errors: this.errors.map((e) => ({
+        name: e.name,
+        message: e.message,
+        ...e.stack ? { stack: e.stack } : {}
+      })),
+      ...this.stack ? { stack: this.stack } : {}
+    };
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+};
+function collectErrors(fn) {
+  try {
+    return { result: fn(), errors: [] };
+  } catch (err) {
+    return {
+      errors: [err instanceof Error ? err : new Error(String(err))]
+    };
+  }
+}
+
+// src/logger/logger.ts
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+var Logger = class _Logger {
+  _level;
+  _name;
+  _transport;
+  _extraMeta;
+  constructor(options) {
+    this._level = options?.level ?? "info";
+    this._name = options?.name;
+    this._transport = options?.transport ?? consoleTransport;
+    this._extraMeta = /* @__PURE__ */ Object.create(null);
+  }
+  _shouldLog(target) {
+    return LEVEL_ORDER[this._level] <= LEVEL_ORDER[target];
+  }
+  _log(level, message, meta) {
+    if (level !== "error" && !this._shouldLog(level)) return;
+    const merged = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(this._extraMeta)) {
+      merged[key] = this._extraMeta[key];
+    }
+    if (meta !== void 0) {
+      for (const key of Object.keys(meta)) {
+        merged[key] = meta[key];
+      }
+    }
+    const label = this._name !== void 0 ? `[${this._name}] ${message}` : message;
+    const finalMeta = Object.keys(merged).length > 0 ? merged : void 0;
+    this._transport.log(level, label, finalMeta);
+  }
+  /** Log at `debug` level. Only emitted when the current level is `'debug'`. */
+  debug = (message, meta) => this._log("debug", message, meta);
+  /** Log at `info` level. Emitted when level is `'debug'` or `'info'`. */
+  info = (message, meta) => this._log("info", message, meta);
+  /** Log at `warn` level. Emitted when level is `'debug'`, `'info'`, or `'warn'`. */
+  warn = (message, meta) => this._log("warn", message, meta);
+  /** Log at `error` level. Always emitted regardless of current level. */
+  error = (message, meta) => this._log("error", message, meta);
+  /**
+   * Creates a child logger that inherits the parent's level, name, and transport,
+   * but merges `extraMeta` into every log call. Child metadata is shallow-merged
+   * on top of the parent's inherited metadata.
+   *
+   * @param extraMeta - Additional context to include in every log entry.
+   */
+  child(extraMeta) {
+    const child = new _Logger({
+      level: this._level,
+      name: this._name,
+      transport: this._transport
+    });
+    const inherited = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(this._extraMeta)) {
+      inherited[key] = this._extraMeta[key];
+    }
+    for (const key of Object.keys(extraMeta)) {
+      inherited[key] = extraMeta[key];
+    }
+    child._extraMeta = inherited;
+    return child;
+  }
+  /** Updates the minimum log level for this instance. */
+  setLevel(level) {
+    this._level = level;
+  }
+  /** Returns the current minimum log level. */
+  getLevel() {
+    return this._level;
+  }
+  /**
+   * Creates a new named Logger.
+   * Convenience shorthand for `new Logger({ ...options, name })`.
+   *
+   * @param name - The name tag shown in log output.
+   * @param options - Additional configuration.
+   */
+  static create(name, options) {
+    return new _Logger({ ...options, name });
+  }
+};
+var consoleTransport = {
+  log(level, message, meta) {
+    const metaStr = meta !== void 0 && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+    console.log(`[${level.toUpperCase()}] ${message}${metaStr}`);
+  }
+};
+var logger = new Logger();
+
+// src/logger/transports.ts
+var LEVEL_COLORS = {
+  debug: "\x1B[90m",
+  info: "\x1B[34m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var RESET = "\x1B[0m";
+function createConsoleTransport(options) {
+  const useColors = options?.colors !== false;
+  const showTimestamp = options?.timestamp ?? false;
+  return {
+    log(level, message, meta) {
+      const parts = [];
+      if (showTimestamp) {
+        parts.push((/* @__PURE__ */ new Date()).toISOString());
+      }
+      if (useColors) {
+        const color = LEVEL_COLORS[level];
+        parts.push(`${color}[${level.toUpperCase()}]${RESET}`);
+      } else {
+        parts.push(`[${level.toUpperCase()}]`);
+      }
+      parts.push(message);
+      if (meta !== void 0 && Object.keys(meta).length > 0) {
+        parts.push(JSON.stringify(meta));
+      }
+      console.log(parts.join(" "));
+    }
+  };
+}
+function createJsonTransport(options) {
+  const writeStream = options?.stream ?? (typeof process !== "undefined" && typeof process.stdout !== "undefined" && typeof process.stdout.write === "function" ? process.stdout : void 0);
+  return {
+    log(level, message, meta) {
+      const entry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        message
+      };
+      if (meta !== void 0 && Object.keys(meta).length > 0) {
+        entry.meta = meta;
+      }
+      const line = JSON.stringify(entry);
+      if (writeStream !== void 0) {
+        writeStream.write(line + "\n");
+      } else {
+        console.log(line);
+      }
+    }
+  };
+}
+function createFileTransport(filename, _options) {
+  let fs = null;
+  try {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const m = __require("fs");
+      fs = m;
+    }
+  } catch {
+  }
+  return {
+    log(level, message, meta) {
+      if (fs === null) return;
+      const metaStr = meta !== void 0 && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+      const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level.toUpperCase()}] ${message}${metaStr}
+`;
+      try {
+        fs.appendFileSync(filename, line);
+      } catch {
+      }
+    }
+  };
+}
+function createBufferedTransport(transport, options) {
+  const maxSize = options?.maxSize ?? 100;
+  const flushIntervalMs = options?.flushIntervalMs ?? 5e3;
+  const buffer = [];
+  let timer;
+  function flush() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    for (let i = 0; i < buffer.length; i++) {
+      const entry = buffer[i];
+      transport.log(entry.level, entry.message, entry.meta);
+    }
+    buffer.length = 0;
+  }
+  function scheduleFlush() {
+    if (timer !== void 0 || flushIntervalMs <= 0) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      flush();
+    }, flushIntervalMs);
+  }
+  return {
+    log(level, message, meta) {
+      buffer.push({ level, message, meta });
+      if (buffer.length >= maxSize) {
+        flush();
+      } else {
+        scheduleFlush();
+      }
+    }
+  };
+}
+
+// src/color/index.ts
+function hexToRgb(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  if (h.length !== 6) return null;
+  const num = Number.parseInt(h, 16);
+  if (isNaN(num)) return null;
+  return {
+    r: num >> 16 & 255,
+    g: num >> 8 & 255,
+    b: num & 255
+  };
+}
+function rgbToHex(r, g, b) {
+  const toHex = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+  return "#" + toHex(r) + toHex(g) + toHex(b);
+}
+function lighten(hex, percent) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const factor = percent / 100;
+  return rgbToHex(
+    rgb.r + (255 - rgb.r) * factor,
+    rgb.g + (255 - rgb.g) * factor,
+    rgb.b + (255 - rgb.b) * factor
+  );
+}
+function darken(hex, percent) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  const factor = percent / 100;
+  return rgbToHex(
+    rgb.r * (1 - factor),
+    rgb.g * (1 - factor),
+    rgb.b * (1 - factor)
+  );
+}
+function contrastRatio(hex1, hex2) {
+  const lum1 = relativeLuminance(hex1);
+  const lum2 = relativeLuminance(hex2);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return Number(((lighter + 0.05) / (darker + 0.05)).toFixed(2));
+}
+function relativeLuminance(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return 0;
+  const vals = [rgb.r / 255, rgb.g / 255, rgb.b / 255].map((c) => {
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * vals[0] + 0.7152 * vals[1] + 0.0722 * vals[2];
+}
+function meetsWCAG(hex1, hex2, level) {
+  const ratio = contrastRatio(hex1, hex2);
+  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,
+  KNOWN_CVES,
+  KNOWN_MAPPINGS,
+  Logger,
+  MultiError,
+  Mutex,
+  Queue,
+  RateLimiter,
+  Semaphore,
+  TIMEZONE_WIB,
+  TIMEZONE_WIT,
+  TIMEZONE_WITA,
+  TypedError,
+  add,
+  addBusinessDays,
+  addDays,
+  addMonths,
+  addYears,
+  allSettledMap,
+  alpha,
+  analyzeUsage,
+  approxEqual,
+  assertDefined,
+  assertType,
+  average,
+  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,
+  createError,
+  createFileTransport,
+  createJsonTransport,
+  darken,
+  dateDiff,
+  dayOfYear,
+  daysInMonth,
+  debounce,
+  dedent,
+  deepClone,
+  deepEqual,
+  deepGet,
+  deepMerge,
+  deepSet,
+  deferred,
+  difference,
+  dirname,
+  div,
+  drop,
+  dropRight,
+  endOfDay,
+  endOfMonth,
+  endOfYear,
+  ensureArray,
+  env,
+  envBool,
+  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,
+  pad,
+  padEnd,
+  padStart,
+  parallelMap,
+  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,
+  retryAsync,
+  reverse,
+  rgbToHex,
+  round,
+  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,
+  zip
+};
+//# sourceMappingURL=index.js.map