qznt 1.0.37 → 2.0.0

package/dist/index.js

@@ -1,47 +1,251 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+// src/Cache.ts
+var Cache = class {
+  cache = /* @__PURE__ */ new Map();
+  interval;
+  /**
+   * A lightweight, high-performant in-memory cache.
+   * Uses Map for O(1) lookups and an optional cleanup interval.
+   * @param cleanupMs The interval in milliseconds to run the cleanup function. [default: 60000 (1 minute)]
+   */
+  constructor(cleanupMs = 6e4) {
+    if (cleanupMs > 0) {
+      this.interval = setInterval(() => this.cleanup(), cleanupMs);
+      if (this.interval.unref) this.interval.unref();
+    }
+  }
+  set(key, value, ttlMs) {
+    this.cache.set(key, {
+      value,
+      expiresAt: ttlMs ? Date.now() + ttlMs : null
+    });
+  }
+  get(key) {
+    const data = this.cache.get(key);
+    if (!data) return null;
+    if (data.expiresAt && Date.now() > data.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return data.value;
+  }
+  cleanup() {
+    if (this.cache.size === 0) return;
+    const now = Date.now();
+    let keysProcessed = 0;
+    const maxKeysToScan = 20;
+    for (const [key, data] of this.cache) {
+      if (data.expiresAt && now > data.expiresAt) {
+        this.cache.delete(key);
+      }
+      keysProcessed++;
+      if (keysProcessed >= maxKeysToScan) break;
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
 };
 
-// src/arr.ts
-var arr_exports = {};
-__export(arr_exports, {
-  chunk: () => chunk,
-  chunkAdj: () => chunkAdj,
-  cluster: () => cluster,
-  compact: () => compact,
-  forceArray: () => forceArray,
-  search: () => search,
-  seqMap: () => seqMap,
-  shuffle: () => shuffle,
-  sortBy: () => sortBy,
-  unique: () => unique
-});
+// src/Loop.ts
+import EventEmitter from "events";
+var TypedEmitterBase = EventEmitter;
+var Loop = class extends TypedEmitterBase {
+  _state = "stopped";
+  timeoutId = null;
+  delay;
+  fn;
+  startTime = 0;
+  remaining = 0;
+  async run() {
+    const currentState = this._state;
+    if (currentState === "stopped" || currentState === "paused") return;
+    try {
+      const result = await this.fn(this);
+      this.emit("tick", result);
+    } catch (err) {
+      this.emit("error", err);
+    }
+    if (this._state === "running") {
+      this.startTime = Date.now();
+      this.remaining = 0;
+      this.clearTimer();
+      this.timeoutId = setTimeout(() => this.run(), this.delay);
+    }
+  }
+  clearTimer() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  /**
+   * Creates an interval. If the function is async, it will wait for it to complete before scheduling the next run.
+   * @param fn The function to run.
+   * @param delay The delay between runs in milliseconds.
+   * @param immediate Whether to start the loop immediately. [default: true]
+   */
+  constructor(fn, delay, immediate = true) {
+    super();
+    this.fn = fn;
+    this.delay = delay;
+    if (immediate) this.start();
+  }
+  get state() {
+    return this._state;
+  }
+  /** Starts the loop. */
+  start() {
+    if (this._state !== "stopped") return;
+    this._state = "running";
+    this.emit("start");
+    this.run();
+  }
+  /** Resumes a paused loop. */
+  resume() {
+    if (this._state !== "paused") return;
+    this._state = "running";
+    this.emit("resume");
+    if (this.remaining <= 0) {
+      this.run();
+    } else {
+      this.timeoutId = setTimeout(() => this.run(), this.remaining);
+    }
+  }
+  /** Stops the loop. */
+  stop() {
+    const wasRunning = this._state !== "stopped";
+    this._state = "stopped";
+    this.remaining = 0;
+    this.clearTimer();
+    if (wasRunning) this.emit("stop");
+  }
+  /** Pauses the execution. */
+  pause() {
+    if (this._state !== "running") return;
+    this._state = "paused";
+    const elapsed = Date.now() - this.startTime;
+    this.remaining = Math.max(0, this.delay - elapsed);
+    this.emit("pause", { remaining: this.remaining });
+    this.clearTimer();
+  }
+  /**
+   * Sets the delay between runs
+   * @param ms The new delay in milliseconds.
+   */
+  setDelay(ms) {
+    this.delay = ms;
+  }
+  /** Manually trigger the function once without affecting the loop. */
+  async execute() {
+    await this.fn(this);
+  }
+};
+
+// src/Pipe.ts
+function Pipe(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
+
+// src/Storage.ts
+import fs from "fs";
+import path from "path";
+var Storage = class {
+  isNode = typeof window === "undefined";
+  filePath = null;
+  memoryCache = /* @__PURE__ */ new Map();
+  loadFromFile() {
+    if (this.filePath && fs.existsSync(this.filePath)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+        Object.entries(data).forEach(([k, v]) => this.memoryCache.set(k, JSON.stringify(v)));
+      } catch (err) {
+        console.error(`Store: Failed to load file '${this.filePath}'`, err);
+      }
+    }
+  }
+  persist() {
+    if (this.isNode && this.filePath) {
+      const out = {};
+      this.memoryCache.forEach((v, k) => out[k] = JSON.parse(v));
+      fs.writeFileSync(this.filePath, JSON.stringify(out, null, 2));
+    }
+  }
+  /**
+   * A lightweight, high-performant persistent storage system.
+   * Uses JSON files in Node.js, localStorage in the browser
+   * @param fileName Only used in Node.js to create a persistent .json file
+   * @param directory The directory for the file. Defaults to current working directory
+   */
+  constructor(fileName, directory = process.cwd()) {
+    if (this.isNode && fileName) {
+      this.filePath = path.join(directory, fileName.endsWith(".json") ? fileName : `${fileName}.json`);
+      this.loadFromFile();
+    }
+  }
+  has(key) {
+    if (!this.isNode && window.localStorage) {
+      return localStorage.getItem(key) !== null;
+    }
+    return this.memoryCache.has(key);
+  }
+  get(key) {
+    let raw = null;
+    if (!this.isNode && window.localStorage) {
+      raw = localStorage.getItem(key);
+    } else {
+      raw = this.memoryCache.get(key) || null;
+    }
+    if (!raw) return null;
+    const payload = JSON.parse(raw);
+    if (payload.expiry && Date.now() > payload.expiry) {
+      this.remove(key);
+      this.persist();
+      return null;
+    }
+    return payload.value;
+  }
+  set(key, value, ttl) {
+    const payload = {
+      value,
+      expiry: ttl ? Date.now() + ttl : null
+    };
+    const serialized = JSON.stringify(payload);
+    if (!this.isNode && window.localStorage) {
+      localStorage.setItem(key, serialized);
+    } else {
+      this.memoryCache.set(key, serialized);
+      this.persist();
+    }
+  }
+  remove(key) {
+    if (!this.isNode && window.localStorage) {
+      localStorage.removeItem(key);
+    } else {
+      this.memoryCache.delete(key);
+      this.persist();
+    }
+  }
+  clear() {
+    if (!this.isNode && window.localStorage) {
+      localStorage.clear();
+    } else {
+      this.memoryCache.clear();
+      this.persist();
+    }
+  }
+};
 
-// src/rnd.ts
-var rnd_exports = {};
-__export(rnd_exports, {
-  chance: () => chance,
-  choice: () => choice,
-  float: () => float,
-  index: () => index,
-  int: () => int,
-  prng: () => prng,
-  sampler: () => sampler,
-  str: () => str,
-  weighted: () => weighted
-});
+// src/random.ts
 var LOWER = "abcdefghijklmnopqrstuvwxyz";
 var UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 var NUM = "0123456789";
-function chance(percent2 = 0.5, seed) {
+function rndChance(percent2 = 0.5, seed) {
   if (percent2 <= 0) return false;
   if (percent2 >= 1) return true;
   const random = seed !== void 0 ? prng(seed) : Math.random;
   return random() < percent2;
 }
-function choice(array, options = {}) {
+function rndChoice(array, options = {}) {
   const { seed, not, maxRerolls = 10 } = options;
   const random = seed !== void 0 ? prng(seed) : Math.random;
   const rnd = () => array[Math.floor(random() * array.length)];
@@ -56,19 +260,19 @@ function choice(array, options = {}) {
   }
   return result;
 }
-function weighted(array, selector, seed) {
+function weightedRnd(array, predicate, seed) {
   const random = seed !== void 0 ? prng(seed) : Math.random;
   const cumulativeWeights = [];
   let currentSum = 0;
   for (const item of array) {
-    const weight = selector(item);
+    const weight = predicate(item);
     currentSum += weight;
     cumulativeWeights.push(currentSum);
   }
   const decider = random() * currentSum;
-  let index2;
+  let index;
   if (array.length < 20) {
-    index2 = cumulativeWeights.findIndex((w) => w >= decider);
+    index = cumulativeWeights.findIndex((w) => w >= decider);
   } else {
     let low = 0;
     let high = cumulativeWeights.length - 1;
@@ -80,16 +284,16 @@ function weighted(array, selector, seed) {
         high = mid;
       }
     }
-    index2 = low;
+    index = low;
   }
-  return array[index2];
+  return array[index];
 }
-function sampler(items, selector, seed) {
+function createSampler(items, predicate, seed) {
   const callRandom = seed ? prng(seed) : void 0;
   const len = items.length;
   const prob = new Array(len);
   const alias = new Array(len);
-  const weights = items.map(selector);
+  const weights = items.map(predicate);
   const totalWeight = weights.reduce((a, b) => a + b, 0);
   const scaledWeights = weights.map((w) => w * len / totalWeight);
   const small = [];
@@ -107,8 +311,8 @@ function sampler(items, selector, seed) {
   while (small.length) prob[small.pop()] = 1;
   return {
     /**
-     * Returns a random item from the given array in O(1) time.
-     * @param seed Optional seed for RNG.
+     * Returns a random item from the given array in O(1) time
+     * @param seed Optional seed for RNG
      */
     pick: (seed2) => {
       const random = seed2 !== void 0 ? prng(seed2) : callRandom || Math.random;
@@ -125,11 +329,11 @@ function prng(seed) {
     return ((t ^ t >>> 14) >>> 0) / 4294967296;
   };
 }
-function float(min, max, seed) {
+function rndFloat(min, max, seed) {
   const random = seed !== void 0 ? prng(seed) : Math.random;
   return random() * (max - min) + min;
 }
-function index(array, options = {}) {
+function rndIndex(array, options = {}) {
   const { seed, not, maxRerolls = 10 } = options;
   const random = seed !== void 0 ? prng(seed) : Math.random;
   const rnd = () => Math.floor(random() * array.length);
@@ -144,11 +348,11 @@ function index(array, options = {}) {
   }
   return result;
 }
-function int(min, max, seed) {
+function rndInt(min, max, seed) {
   const random = seed !== void 0 ? prng(seed) : Math.random;
   return Math.floor(random() * (max - min + 1)) + min;
 }
-function str(len, mode, options = {}) {
+function rndString(len, mode, options = {}) {
   const { casing = "lower", seed, customChars = "", exclude = "" } = options;
   const random = seed !== void 0 ? prng(seed) : Math.random;
   const alphaPool = { lower: LOWER, upper: UPPER, mixed: LOWER + UPPER }[casing];
@@ -217,7 +421,7 @@ function cluster(array, iteratee, maxChunkSize) {
   }
   return result;
 }
-function compact(array, mode = "nullable") {
+function compactArray(array, mode = "nullable") {
   if (mode === "falsy") {
     return array.filter(Boolean);
   }
@@ -226,7 +430,7 @@ function compact(array, mode = "nullable") {
 function forceArray(item) {
   return Array.isArray(item) ? item : [item];
 }
-function search(array, target, comparator = (a, b) => a > b ? 1 : a < b ? -1 : 0) {
+function searchSorted(array, target, comparator = (a, b) => a > b ? 1 : a < b ? -1 : 0) {
   let low = 0;
   let high = array.length - 1;
   while (low <= high) {
@@ -289,13 +493,8 @@ function unique(array, key) {
 }
 
 // src/async.ts
-var async_exports = {};
-__export(async_exports, {
-  retry: () => retry,
-  wait: () => wait
-});
-async function retry(fn, options = {}) {
-  const { retries = 3, delay = 500, timeout, signal } = options;
+async function retryPromise(fn, options = {}) {
+  const { attempts = 3, delay = 500, timeout, signal } = options;
   if (signal?.aborted) throw new Error("Operation aborted");
   const executeWithTimeout = async () => {
     if (!timeout) return fn(signal);
@@ -314,7 +513,7 @@ async function retry(fn, options = {}) {
     return await executeWithTimeout();
   } catch (error) {
     if (signal?.aborted) throw error;
-    if (retries <= 0) throw error;
+    if (attempts <= 0) throw error;
     const jitter = Math.random() * 200;
     const totalDelay = delay + jitter;
     await new Promise((resolve, reject) => {
@@ -328,51 +527,14 @@ async function retry(fn, options = {}) {
         { once: true }
       );
     });
-    return retry(fn, { ...options, retries: retries - 1, delay: delay * 2 });
+    return retryPromise(fn, { ...options, attempts: attempts - 1, delay: delay * 2 });
   }
 }
-function wait(ms2) {
-  return new Promise(
-    (resolve) => setTimeout(() => {
-      resolve(true);
-    }, ms2)
-  );
-}
-
-// src/fn.ts
-var fn_exports = {};
-__export(fn_exports, {
-  memoize: () => memoize
-});
-function memoize(fn, options = {}) {
-  const cache = /* @__PURE__ */ new Map();
-  const { resolver, maxAge } = options;
-  const memoized = function(...args) {
-    const key = resolver ? resolver(...args) : JSON.stringify(args);
-    const now = Date.now();
-    const entry = cache.get(key);
-    if (entry) {
-      if (!maxAge || now - entry.timestamp < maxAge) {
-        return entry.value;
-      }
-      cache.delete(key);
-    }
-    const result = fn.apply(this, args);
-    cache.set(key, { value: result, timestamp: now });
-    return result;
-  };
-  memoized.clear = () => cache.clear();
-  return memoized;
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(() => resolve(true), ms));
 }
 
 // src/date.ts
-var date_exports = {};
-__export(date_exports, {
-  duration: () => duration,
-  eta: () => eta,
-  getAge: () => getAge,
-  parse: () => parse
-});
 var MS_MAP = {
   ms: 1,
   s: 1e3,
@@ -383,64 +545,18 @@ var MS_MAP = {
   mth: 24192e5,
   y: 31536e6
 };
-function duration(target, style = "hms", options = {}) {
-  const targetMs = target instanceof Date ? target.getTime() : Number(target);
-  const sinceMs = options.since instanceof Date ? options.since.getTime() : Number(options.since) || Date.now();
-  const diff = Math.abs(targetMs - sinceMs);
-  if (diff === 0) return style === "digital" ? "00:00" : "now";
-  const s = Math.floor(diff / 1e3) % 60;
-  const m = Math.floor(diff / 6e4) % 60;
-  const h = Math.floor(diff / 36e5) % 24;
-  const d = Math.floor(diff / 864e5);
-  if (style === "digital") {
-    const parts = [m, s].map((v) => String(v).padStart(2, "0"));
-    if (h > 0 || d > 0) parts.unshift(String(h).padStart(2, "0"));
-    if (d > 0) parts.unshift(String(d));
-    return parts.join(":");
-  }
-  const result = [];
-  const push = (val, label) => {
-    if (val > 0) result.push(`${val} ${label}${val === 1 ? "" : "s"}`);
-  };
-  if (style === "ymdhms") push(d, "day");
-  push(h, "hour");
-  push(m, "minute");
-  push(s, "second");
-  if (result.length === 0) return "0 seconds";
-  if (result.length === 1) return result[0];
-  const last = result.pop();
-  return `${result.join(", ")} and ${last}`;
-}
-function eta(date, locale) {
-  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
-  const elapsed = (typeof date === "number" ? date : date.getTime()) - Date.now();
-  const units = [
-    { unit: "year", ms: 31536e6 },
-    { unit: "month", ms: 2628e6 },
-    { unit: "day", ms: 864e5 },
-    { unit: "hour", ms: 36e5 },
-    { unit: "minute", ms: 6e4 },
-    { unit: "second", ms: 1e3 }
-  ];
-  for (const { unit, ms: ms2 } of units) {
-    if (Math.abs(elapsed) >= ms2 || unit === "second") {
-      return rtf.format(Math.round(elapsed / ms2), unit);
-    }
-  }
-  return "";
-}
 function getAge(birthdate) {
-  const today2 = /* @__PURE__ */ new Date();
-  let age = today2.getFullYear() - birthdate.getFullYear();
-  const monthDiff = today2.getMonth() - birthdate.getMonth();
-  if (monthDiff < 0 || monthDiff === 0 && today2.getDate() < birthdate.getDate()) {
+  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;
 }
-function parse(str2, options = {}) {
-  if (typeof str2 === "number") return str2;
-  const matches = str2.matchAll(/(-?\d+)([a-z]+)/gi);
+function parseTime(str, options = {}) {
+  if (typeof str === "number") return str;
+  const matches = str.matchAll(/(-?\d+)([a-z]+)/gi);
   let totalMs = 0;
   let found = false;
   for (const [_, value, unit] of matches) {
@@ -451,39 +567,85 @@ function parse(str2, options = {}) {
       found = true;
     }
   }
-  if (!found) throw new Error(`parse: Invalid time format: "${str2}"`);
+  if (!found) throw new Error(`parse: Invalid time format: "${str}"`);
   const result = options.unit === "s" ? totalMs / 1e3 : totalMs;
   return options.fromNow ? Date.now() + result : result;
 }
 
+// src/exec.ts
+function debounce(fn, wait2, options = {}) {
+  let timeoutId;
+  const leading = options.immediate ?? false;
+  const debounced = function(...args) {
+    const callNow = leading && !timeoutId;
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timeoutId = void 0;
+      if (!leading) fn.apply(this, args);
+    }, wait2);
+    if (callNow) fn.apply(this, args);
+  };
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = void 0;
+    }
+  };
+  return debounced;
+}
+function throttle(fn, limit) {
+  let inThrottle = false;
+  return function(...args) {
+    if (!inThrottle) {
+      fn.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+
+// src/fn.ts
+function memoize(fn, options = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const { resolver, maxAge } = options;
+  const memoized = function(...args) {
+    const key = resolver ? resolver(...args) : JSON.stringify(args);
+    const now = Date.now();
+    const entry = cache.get(key);
+    if (entry) {
+      if (!maxAge || now - entry.timestamp < maxAge) {
+        return entry.value;
+      }
+      cache.delete(key);
+    }
+    const result = fn.apply(this, args);
+    cache.set(key, { value: result, timestamp: now });
+    return result;
+  };
+  memoized.clear = () => cache.clear();
+  return memoized;
+}
+
 // src/format.ts
-var format_exports = {};
-__export(format_exports, {
-  compactNumber: () => compactNumber,
-  currency: () => currency,
-  memory: () => memory,
-  number: () => number,
-  ordinal: () => ordinal
-});
-function currency(num, options = {}) {
+function formatCurrency(num, options = {}) {
   return new Intl.NumberFormat(options.locale, {
     style: "currency",
     currency: options.currency
   }).format(num);
 }
-function number(num, options = {}) {
+function formatNumber(num, options = {}) {
   return new Intl.NumberFormat(options.locale, {
     minimumFractionDigits: options.precision,
     maximumFractionDigits: options.precision
   }).format(num);
 }
-function memory(bytes, decimals = 1, units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]) {
+function formatMemory(bytes, decimals = 1, units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]) {
   if (bytes <= 0) return `0 ${units[0]}`;
   const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
   const val = bytes / Math.pow(1024, i);
   return `${val.toFixed(i === 0 ? 0 : decimals)} ${units[i]}`;
 }
-function ordinal(num, locale) {
+function formatOrdinal(num, locale) {
   const _num = Number(num);
   if (isNaN(_num)) throw new TypeError("Invalid input");
   const pr = new Intl.PluralRules(locale, { type: "ordinal" });
@@ -497,19 +659,61 @@ function ordinal(num, locale) {
   const suffix = suffixes[rule] || "th";
   return _num.toLocaleString(locale) + suffix;
 }
-function compactNumber(num, locale) {
+function FormatNumberCompact(num, locale) {
   return new Intl.NumberFormat(locale, {
     notation: "compact",
     compactDisplay: "short",
     maximumFractionDigits: 1
   }).format(num);
 }
+function formatDuration(target, style = "hms", options = {}) {
+  const targetMs = target instanceof Date ? target.getTime() : Number(target);
+  const sinceMs = options.since instanceof Date ? options.since.getTime() : Number(options.since) || Date.now();
+  const diff = Math.abs(targetMs - sinceMs);
+  if (diff === 0) return style === "digital" ? "00:00" : "now";
+  const s = Math.floor(diff / 1e3) % 60;
+  const m = Math.floor(diff / 6e4) % 60;
+  const h = Math.floor(diff / 36e5) % 24;
+  const d = Math.floor(diff / 864e5);
+  if (style === "digital") {
+    const parts = [m, s].map((v) => String(v).padStart(2, "0"));
+    if (h > 0 || d > 0) parts.unshift(String(h).padStart(2, "0"));
+    if (d > 0) parts.unshift(String(d));
+    return parts.join(":");
+  }
+  const result = [];
+  const push = (val, label) => {
+    if (val > 0) result.push(`${val} ${label}${val === 1 ? "" : "s"}`);
+  };
+  if (style === "ymdhms") push(d, "day");
+  push(h, "hour");
+  push(m, "minute");
+  push(s, "second");
+  if (result.length === 0) return "0 seconds";
+  if (result.length === 1) return result[0];
+  const last = result.pop();
+  return `${result.join(", ")} and ${last}`;
+}
+function formatETA(date, locale) {
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  const elapsed = (typeof date === "number" ? date : date.getTime()) - Date.now();
+  const units = [
+    { unit: "year", ms: 31536e6 },
+    { unit: "month", ms: 2628e6 },
+    { unit: "day", ms: 864e5 },
+    { unit: "hour", ms: 36e5 },
+    { unit: "minute", ms: 6e4 },
+    { unit: "second", ms: 1e3 }
+  ];
+  for (const { unit, ms } of units) {
+    if (Math.abs(elapsed) >= ms || unit === "second") {
+      return rtf.format(Math.round(elapsed / ms), unit);
+    }
+  }
+  return "";
+}
 
 // src/fs.ts
-var fs_exports = {};
-__export(fs_exports, {
-  readDir: () => readDir
-});
 import _fs from "fs";
 import { join } from "path";
 function readDir(path2, options = {}) {
@@ -538,77 +742,58 @@ function readDir(path2, options = {}) {
 }
 
 // src/is.ts
-var is_exports = {};
-__export(is_exports, {
-  defined: () => defined,
-  empty: () => empty,
-  inRange: () => inRange,
-  object: () => object,
-  sorted: () => sorted,
-  string: () => string,
-  today: () => today
-});
-function defined(val) {
+function isDefined(val) {
   return val !== void 0 && val !== null;
 }
-function empty(val) {
-  if (!defined(val)) return true;
-  if (string(val) || Array.isArray(val)) return val.length === 0;
-  if (object(val)) return Object.keys(val).length === 0;
+function isEmpty(val) {
+  if (!isDefined(val)) return true;
+  if (isString(val) || Array.isArray(val)) return val.length === 0;
+  if (isObject(val)) return Object.keys(val).length === 0;
   return false;
 }
-function inRange(num, a, b) {
+function isObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isInRange(num, a, b) {
   let min = b !== void 0 ? a : 0;
   let max = b !== void 0 ? b : a;
   if (min > max) [min, max] = [max, min];
   return num >= min && num <= max;
 }
-function object(val) {
-  return val !== null && typeof val === "object" && !Array.isArray(val);
-}
-function sorted(arr, comparator) {
+function isSortedArray(arr, comparator) {
   for (let i = 0; i < arr.length - 1; i++) {
     const comp = comparator ? comparator(arr[i], arr[i + 1]) : arr[i] > arr[i + 1] ? 1 : -1;
     if (comp > 0) return false;
   }
   return true;
 }
-function string(val) {
-  return typeof val === "string";
-}
-function today(date) {
+function isToday(date) {
   const d = date instanceof Date ? date : new Date(date);
-  const today2 = /* @__PURE__ */ new Date();
-  return d.getDate() === today2.getDate() && d.getMonth() === today2.getMonth() && d.getFullYear() === today2.getFullYear();
+  const today = /* @__PURE__ */ new Date();
+  return d.getDate() === today.getDate() && d.getMonth() === today.getMonth() && d.getFullYear() === today.getFullYear();
 }
 
 // src/math.ts
-var math_exports = {};
-__export(math_exports, {
-  clamp: () => clamp,
-  invLerp: () => invLerp,
-  lerp: () => lerp,
-  ms: () => ms,
-  percent: () => percent,
-  remap: () => remap,
-  secs: () => secs,
-  sum: () => sum,
-  wrap: () => wrap
-});
-function clamp(num, a, b) {
+function clampNumber(num, a, b) {
   let min = b !== void 0 ? a : 0;
   let max = b !== void 0 ? b : a;
   if (min > max) [min, max] = [max, min];
   return Math.max(min, Math.min(num, max));
 }
-function invLerp(start, end, value) {
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+function inverseLerp(start, end, value) {
   if (start === end) return 0;
   return (value - start) / (end - start);
 }
-function lerp(start, end, t) {
-  return start + (end - start) * t;
+function msToSecs(num) {
+  return Math.floor(num / 1e3);
 }
-function ms(num) {
+function secsToMs(num) {
   return Math.floor(num * 1e3);
 }
 function percent(a, b, round = true) {
@@ -616,36 +801,19 @@ function percent(a, b, round = true) {
   return round ? Math.floor(result) : result;
 }
 function remap(value, inMin, inMax, outMin, outMax) {
-  const t = invLerp(inMin, inMax, value);
+  const t = inverseLerp(inMin, inMax, value);
   return lerp(outMin, outMax, t);
 }
-function secs(num) {
-  return Math.floor(num / 1e3);
-}
 function sum(array, selector) {
   const _array = selector ? array.map(selector) : array;
-  if (!_array.every((v) => typeof v === "number")) {
-    throw new TypeError(`sum: Array must only contain numbers.`);
-  }
-  return _array.reduce((a, b) => {
-    return (isNaN(b) ? 0 : b) < 0 ? a - -b : a + (b || 0);
-  }, 0);
+  return _array.reduce((a, b) => b < 0 ? a - -b : a + (b || 0), 0);
 }
 function wrap(num, max) {
   return (num % max + max) % max;
 }
 
 // src/obj.ts
-var obj_exports = {};
-__export(obj_exports, {
-  get: () => get,
-  has: () => has,
-  merge: () => merge,
-  omit: () => omit,
-  pick: () => pick,
-  set: () => set
-});
-function get(obj, path2, defaultValue) {
+function getProp(obj, path2, defaultValue) {
   if (!obj) throw new Error("get: Target object is null or undefined");
   const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
   let current = obj;
@@ -664,7 +832,7 @@ function get(obj, path2, defaultValue) {
   }
   return current;
 }
-function has(obj, path2) {
+function hasProp(obj, path2) {
   if (!obj || !path2) return false;
   const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
   let current = obj;
@@ -680,7 +848,7 @@ function has(obj, path2) {
   }
   return true;
 }
-function set(obj, path2, value) {
+function setProp(obj, path2, value) {
   const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
   let current = obj;
   for (let i = 0; i < parts.length; i++) {
@@ -732,36 +900,32 @@ function omit(obj, keys) {
 }
 
 // src/str.ts
-var str_exports = {};
-__export(str_exports, {
-  escapeRegex: () => escapeRegex,
-  getFlag: () => getFlag,
-  hasFlag: () => hasFlag,
-  toTitleCase: () => toTitleCase
-});
-function escapeRegex(str2) {
-  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function getFlag(str2, flag, length) {
+function getFlag(str, flag, length) {
   const regex = flag instanceof RegExp ? flag : new RegExp(`${escapeRegex(flag)}\\b`, "g");
-  const match = regex.exec(str2);
+  const match = regex.exec(str);
   if (!match) return null;
   const startIndex = match.index + match[0].length;
-  let result = str2.slice(startIndex).trimStart();
+  let result = str.slice(startIndex).trimStart();
   if (length !== void 0) {
     return result.split(/\s+/).slice(0, length).join(" ");
   }
   return result || null;
 }
-function hasFlag(str2, flag) {
-  if (flag instanceof RegExp) return flag.test(str2);
+function hasFlag(str, flag) {
+  if (flag instanceof RegExp) return flag.test(str);
   const pattern = new RegExp(`${escapeRegex(flag)}\\b`);
-  return pattern.test(str2);
+  return pattern.test(str);
+}
+function pluralize(count, singular, plural = `${singular}s`) {
+  return count === 1 ? singular : plural;
 }
-function toTitleCase(str2, smart = true) {
+function toTitleCase(str, smart = true) {
   const minorWords = /^(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|v\.?|via)$/i;
-  return str2.replace(/\w\S*/g, (txt, index2) => {
-    if (smart && index2 !== 0 && minorWords.test(txt)) {
+  return str.replace(/\w\S*/g, (txt, index) => {
+    if (smart && index !== 0 && minorWords.test(txt)) {
       return txt.toLowerCase();
     }
     if (smart && txt.length > 1 && txt === txt.toUpperCase()) {
@@ -770,391 +934,70 @@ function toTitleCase(str2, smart = true) {
     return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
   });
 }
-
-// src/timing.ts
-var timing_exports = {};
-__export(timing_exports, {
-  debounce: () => debounce,
-  throttle: () => throttle
-});
-function debounce(fn, wait2, options = {}) {
-  let timeoutId;
-  const leading = options.immediate ?? false;
-  const debounced = function(...args) {
-    const callNow = leading && !timeoutId;
-    if (timeoutId) clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => {
-      timeoutId = void 0;
-      if (!leading) fn.apply(this, args);
-    }, wait2);
-    if (callNow) fn.apply(this, args);
-  };
-  debounced.cancel = () => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = void 0;
-    }
-  };
-  return debounced;
-}
-function throttle(fn, limit) {
-  let inThrottle = false;
-  return function(...args) {
-    if (!inThrottle) {
-      fn.apply(this, args);
-      inThrottle = true;
-      setTimeout(() => inThrottle = false, limit);
-    }
-  };
-}
-
-// src/to.ts
-var to_exports = {};
-__export(to_exports, {
-  record: () => record
-});
-function record(array, callback) {
-  const result = {};
-  let lastValue = void 0;
-  for (let i = 0; i < array.length; i++) {
-    const { key, value } = callback(array[i], {
-      index: i,
-      lastValue,
-      // NOTE: This is a reference to the object currently being built
-      newRecord: result,
-      originalArray: array
-    });
-    result[key] = value;
-    lastValue = value;
-  }
-  return result;
-}
-
-// src/Pipe.ts
-function Pipe(value, ...fns) {
-  return fns.reduce((acc, fn) => fn(acc), value);
-}
-
-// src/Storage.ts
-import fs from "fs";
-import path from "path";
-var Storage = class {
-  isNode = typeof window === "undefined";
-  filePath = null;
-  memoryCache = /* @__PURE__ */ new Map();
-  loadFromFile() {
-    if (this.filePath && fs.existsSync(this.filePath)) {
-      try {
-        const data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
-        Object.entries(data).forEach(([k, v]) => this.memoryCache.set(k, JSON.stringify(v)));
-      } catch (err) {
-        console.error(`Store: Failed to load file '${this.filePath}'`, err);
-      }
-    }
-  }
-  persist() {
-    if (this.isNode && this.filePath) {
-      const out = {};
-      this.memoryCache.forEach((v, k) => out[k] = JSON.parse(v));
-      fs.writeFileSync(this.filePath, JSON.stringify(out, null, 2));
-    }
-  }
-  /**
-   * A lightweight, high-performant persistent storage system.
-   * Uses JSON files in Node.js, localStorage in the browser.
-   * @param fileName Only used in Node.js to create a persistent .json file.
-   * @param directory The directory for the file. Defaults to current working directory.
-   */
-  constructor(fileName, directory = process.cwd()) {
-    if (this.isNode && fileName) {
-      this.filePath = path.join(directory, fileName.endsWith(".json") ? fileName : `${fileName}.json`);
-      this.loadFromFile();
-    }
-  }
-  has(key) {
-    if (!this.isNode && window.localStorage) {
-      return localStorage.getItem(key) !== null;
-    }
-    return this.memoryCache.has(key);
-  }
-  get(key) {
-    let raw = null;
-    if (!this.isNode && window.localStorage) {
-      raw = localStorage.getItem(key);
-    } else {
-      raw = this.memoryCache.get(key) || null;
-    }
-    if (!raw) return null;
-    const payload = JSON.parse(raw);
-    if (payload.expiry && Date.now() > payload.expiry) {
-      this.remove(key);
-      this.persist();
-      return null;
-    }
-    return payload.value;
-  }
-  set(key, value, ttl) {
-    const payload = {
-      value,
-      expiry: ttl ? Date.now() + ttl : null
-    };
-    const serialized = JSON.stringify(payload);
-    if (!this.isNode && window.localStorage) {
-      localStorage.setItem(key, serialized);
-    } else {
-      this.memoryCache.set(key, serialized);
-      this.persist();
-    }
-  }
-  remove(key) {
-    if (!this.isNode && window.localStorage) {
-      localStorage.removeItem(key);
-    } else {
-      this.memoryCache.delete(key);
-      this.persist();
-    }
-  }
-  clear() {
-    if (!this.isNode && window.localStorage) {
-      localStorage.clear();
-    } else {
-      this.memoryCache.clear();
-      this.persist();
-    }
-  }
-};
-
-// src/Cache.ts
-var Cache = class {
-  cache = /* @__PURE__ */ new Map();
-  interval;
-  /**
-   * A lightweight, high-performant in-memory cache.
-   * Uses Map for O(1) lookups and an optional cleanup interval.
-   * @param cleanupMs The interval in milliseconds to run the cleanup function. [default: 60000 (1 minute)]
-   */
-  constructor(cleanupMs = 6e4) {
-    if (cleanupMs > 0) {
-      this.interval = setInterval(() => this.cleanup(), cleanupMs);
-      if (this.interval.unref) this.interval.unref();
-    }
-  }
-  set(key, value, ttlMs) {
-    this.cache.set(key, {
-      value,
-      expiresAt: ttlMs ? Date.now() + ttlMs : null
-    });
-  }
-  get(key) {
-    const data = this.cache.get(key);
-    if (!data) return null;
-    if (data.expiresAt && Date.now() > data.expiresAt) {
-      this.cache.delete(key);
-      return null;
-    }
-    return data.value;
-  }
-  cleanup() {
-    if (this.cache.size === 0) return;
-    const now = Date.now();
-    let keysProcessed = 0;
-    const maxKeysToScan = 20;
-    for (const [key, data] of this.cache) {
-      if (data.expiresAt && now > data.expiresAt) {
-        this.cache.delete(key);
-      }
-      keysProcessed++;
-      if (keysProcessed >= maxKeysToScan) break;
-    }
-  }
-  clear() {
-    this.cache.clear();
-  }
-};
-
-// src/Loop.ts
-import EventEmitter from "events";
-var TypedEmitterBase = EventEmitter;
-var Loop = class extends TypedEmitterBase {
-  _state = "stopped";
-  timeoutId = null;
-  delay;
-  fn;
-  startTime = 0;
-  remaining = 0;
-  async run() {
-    const currentState = this._state;
-    if (currentState === "stopped" || currentState === "paused") return;
-    try {
-      const result = await this.fn(this);
-      this.emit("tick", result);
-    } catch (err) {
-      this.emit("error", err);
-    }
-    if (this._state === "running") {
-      this.startTime = Date.now();
-      this.remaining = 0;
-      this.clearTimer();
-      this.timeoutId = setTimeout(() => this.run(), this.delay);
-    }
-  }
-  clearTimer() {
-    if (this.timeoutId) {
-      clearTimeout(this.timeoutId);
-      this.timeoutId = null;
-    }
-  }
-  /**
-   * Creates an interval. If the function is async, it will wait for it to complete before scheduling the next run.
-   * @param fn The function to run.
-   * @param delay The delay between runs in milliseconds.
-   * @param immediate Whether to start the loop immediately. [default: true]
-   */
-  constructor(fn, delay, immediate = true) {
-    super();
-    this.fn = fn;
-    this.delay = delay;
-    if (immediate) this.start();
-  }
-  get state() {
-    return this._state;
-  }
-  /** Starts the loop. */
-  start() {
-    if (this._state !== "stopped") return;
-    this._state = "running";
-    this.emit("start");
-    this.run();
-  }
-  /** Resumes a paused loop. */
-  resume() {
-    if (this._state !== "paused") return;
-    this._state = "running";
-    this.emit("resume");
-    if (this.remaining <= 0) {
-      this.run();
-    } else {
-      this.timeoutId = setTimeout(() => this.run(), this.remaining);
-    }
-  }
-  /** Stops the loop. */
-  stop() {
-    const wasRunning = this._state !== "stopped";
-    this._state = "stopped";
-    this.remaining = 0;
-    this.clearTimer();
-    if (wasRunning) this.emit("stop");
-  }
-  /** Pauses the execution. */
-  pause() {
-    if (this._state !== "running") return;
-    this._state = "paused";
-    const elapsed = Date.now() - this.startTime;
-    this.remaining = Math.max(0, this.delay - elapsed);
-    this.emit("pause", { remaining: this.remaining });
-    this.clearTimer();
-  }
-  /**
-   * Sets the delay between runs
-   * @param ms The new delay in milliseconds.
-   */
-  setDelay(ms2) {
-    this.delay = ms2;
-  }
-  /** Manually trigger the function once without affecting the loop. */
-  async execute() {
-    await this.fn(this);
-  }
-};
-
-// src/index.ts
-var qznt = {
-  arr: arr_exports,
-  async: async_exports,
-  fn: fn_exports,
-  date: date_exports,
-  format: format_exports,
-  fs: fs_exports,
-  is: is_exports,
-  math: math_exports,
-  obj: obj_exports,
-  timing: timing_exports,
-  rnd: rnd_exports,
-  str: str_exports,
-  to: to_exports,
-  Pipe,
-  Storage,
-  Cache,
-  Loop
-};
-var $ = qznt;
-var index_default = qznt;
 export {
-  $,
   Cache,
+  FormatNumberCompact,
   Loop,
   Pipe,
   Storage,
-  chance,
-  choice,
   chunk,
   chunkAdj,
-  clamp,
+  clampNumber,
   cluster,
-  compact,
-  compactNumber,
-  currency,
+  compactArray,
+  createSampler,
   debounce,
-  index_default as default,
-  defined,
-  duration,
-  empty,
   escapeRegex,
-  eta,
-  float,
   forceArray,
-  get,
+  formatCurrency,
+  formatDuration,
+  formatETA,
+  formatMemory,
+  formatNumber,
+  formatOrdinal,
   getAge,
   getFlag,
-  has,
+  getProp,
   hasFlag,
-  inRange,
-  index,
-  int,
-  invLerp,
+  hasProp,
+  inverseLerp,
+  isDefined,
+  isEmpty,
+  isInRange,
+  isObject,
+  isSortedArray,
+  isString,
+  isToday,
   lerp,
   memoize,
-  memory,
   merge,
-  ms,
-  number,
-  object,
+  msToSecs,
   omit,
-  ordinal,
-  parse,
+  parseTime,
   percent,
   pick,
+  pluralize,
   prng,
   readDir,
-  record,
   remap,
-  retry,
-  sampler,
-  search,
-  secs,
+  retryPromise,
+  rndChance,
+  rndChoice,
+  rndFloat,
+  rndIndex,
+  rndInt,
+  rndString,
+  searchSorted,
+  secsToMs,
   seqMap,
-  set,
+  setProp,
   shuffle,
   sortBy,
-  sorted,
-  str,
-  string,
   sum,
   throttle,
   toTitleCase,
-  today,
   unique,
   wait,
-  weighted,
+  weightedRnd,
   wrap
 };