qznt 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Cache: () => Cache,
+  Loop: () => Loop,
+  Pipe: () => Pipe,
+  Storage: () => Storage,
+  arr: () => arr,
+  async: () => async,
+  date: () => date,
+  default: () => index_default,
+  fn: () => fn,
+  format: () => format,
+  is: () => is,
+  math: () => math,
+  num: () => num,
+  obj: () => obj,
+  qznt: () => qznt,
+  rnd: () => rnd,
+  str: () => str2,
+  timing: () => timing,
+  to: () => to
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/arr.ts
+var arr_exports = {};
+__export(arr_exports, {
+  arr: () => arr
+});
+
+// src/rnd.ts
+var rnd_exports = {};
+__export(rnd_exports, {
+  rnd: () => rnd
+});
+var LOWER = "abcdefghijklmnopqrstuvwxyz";
+var UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var NUM = "0123456789";
+function chance(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, seed) {
+  const random = seed !== void 0 ? prng(seed) : Math.random;
+  return array[Math.floor(random() * array.length)];
+}
+function weighted(array, selector, seed) {
+  const random = seed !== void 0 ? prng(seed) : Math.random;
+  const cumulativeWeights = [];
+  let currentSum = 0;
+  for (const item of array) {
+    const weight = selector(item);
+    currentSum += weight;
+    cumulativeWeights.push(currentSum);
+  }
+  const decider = random() * currentSum;
+  let index2 = cumulativeWeights.findIndex((w) => w >= decider);
+  if (array.length < 20) {
+    cumulativeWeights.findIndex((w) => w >= decider);
+  } else {
+    let low = 0;
+    let high = cumulativeWeights.length - 1;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      if (decider > cumulativeWeights[mid]) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    index2 = low;
+  }
+  return array[index2];
+}
+function sampler(items, selector, 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 totalWeight = weights.reduce((a, b) => a + b, 0);
+  const scaledWeights = weights.map((w) => w * len / totalWeight);
+  const small = [];
+  const large = [];
+  scaledWeights.forEach((w, i) => (w < 1 ? small : large).push(i));
+  while (small.length && large.length) {
+    const s = small.pop();
+    const l = large.pop();
+    prob[s] = scaledWeights[s];
+    alias[s] = l;
+    scaledWeights[l] = scaledWeights[l] + scaledWeights[s] - 1;
+    (scaledWeights[l] < 1 ? small : large).push(l);
+  }
+  while (large.length) prob[large.pop()] = 1;
+  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.
+     */
+    pick: (seed2) => {
+      const random = seed2 !== void 0 ? prng(seed2) : callRandom || Math.random;
+      const i = Math.floor(random() * len);
+      return random() < prob[i] ? items[i] : items[alias[i]];
+    }
+  };
+}
+function prng(seed) {
+  return () => {
+    let t = seed += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function float(min, max, seed) {
+  const random = seed !== void 0 ? prng(seed) : Math.random;
+  return random() * (max - min) + min;
+}
+function index(array, seed) {
+  const random = seed !== void 0 ? prng(seed) : Math.random;
+  return Math.floor(random() * array.length);
+}
+function int(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 = {}) {
+  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];
+  let pool = { number: NUM, alpha: alphaPool, alphanumeric: alphaPool + NUM, custom: customChars }[mode];
+  if (exclude.length > 0) {
+    const excludeSet = new Set(Array.isArray(exclude) ? exclude : exclude.split(""));
+    pool = pool.split("").filter((char) => !excludeSet.has(char)).join("");
+  }
+  if (pool.length === 0) throw new Error("rndStr: Character pool is empty after exclusions.");
+  const result = new Array(len);
+  const poolLen = pool.length;
+  for (let i = 0; i < len; i++) {
+    result[i] = pool[Math.floor(random() * poolLen)];
+  }
+  return result.join("");
+}
+var rnd = {
+  chance,
+  choice,
+  weighted,
+  sampler,
+  prng,
+  float,
+  index,
+  int,
+  str
+};
+
+// src/arr.ts
+function chunk(array, size) {
+  if (size <= 0) throw new Error("chunk: Size must be a positive integer.");
+  const result = [];
+  const len = array.length;
+  for (let i = 0; i < len; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}
+function chunkAdj(array, predicate) {
+  if (array.length === 0) return [];
+  const results = [];
+  const len = array.length;
+  let currentChunk = [array[0]];
+  for (let i = 1; i < len; i++) {
+    const prev = array[i - 1];
+    const curr = array[i];
+    if (predicate(prev, curr)) {
+      currentChunk.push(curr);
+    } else {
+      results.push(currentChunk);
+      currentChunk = [curr];
+    }
+  }
+  results.push(currentChunk);
+  return results;
+}
+function cluster(array, iteratee, maxChunkSize) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of array) {
+    const key = iteratee(item);
+    const collection = groups.get(key);
+    if (!collection) {
+      groups.set(key, [item]);
+    } else {
+      collection.push(item);
+    }
+  }
+  const result = [];
+  for (const group of groups.values()) {
+    if (maxChunkSize && maxChunkSize > 0) {
+      for (let i = 0; i < group.length; i += maxChunkSize) {
+        result.push(group.slice(i, i + maxChunkSize));
+      }
+    } else {
+      result.push(group);
+    }
+  }
+  return result;
+}
+function compact(array, mode = "nullable") {
+  if (mode === "falsy") {
+    return array.filter(Boolean);
+  }
+  return array.filter((item) => item !== null && item !== void 0);
+}
+function forceArray(item) {
+  return Array.isArray(item) ? item : [item];
+}
+function search(array, target, comparator = (a, b) => a > b ? 1 : a < b ? -1 : 0) {
+  let low = 0;
+  let high = array.length - 1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const comp = comparator(array[mid], target);
+    if (comp < 0) low = mid + 1;
+    else if (comp > 0) high = mid - 1;
+    else return mid;
+  }
+  return ~low;
+}
+function seqMap(array, callback) {
+  const len = array.length;
+  const result = new Array(len);
+  for (let i = 0; i < len; i++) {
+    result[i] = callback(array[i], {
+      index: i,
+      lastElement: i > 0 ? result[i - 1] : void 0,
+      // NOTE: This is a reference to the array currently being built
+      newArray: result,
+      originalArray: array
+    });
+  }
+  return result;
+}
+function shuffle(array, seed) {
+  const random = seed !== void 0 ? rnd.prng(seed) : Math.random;
+  const result = [...array];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1));
+    const temp = result[i];
+    result[i] = result[j];
+    result[j] = temp;
+  }
+  return result;
+}
+function sortBy(array, selectorOrSelectors, order = "asc") {
+  const selectors = Array.isArray(selectorOrSelectors) ? selectorOrSelectors : [selectorOrSelectors];
+  if (array.length === 0 || selectors.length === 0) {
+    return [...array];
+  }
+  const modifier = order === "desc" ? -1 : 1;
+  const memos = array.map((item) => ({ item, keys: selectors.map((s) => s(item)) }));
+  memos.sort((a, b) => {
+    for (let i = 0; i < selectors.length; i++) {
+      const valA = a.keys[i];
+      const valB = b.keys[i];
+      if (valA === valB) continue;
+      if (valA == null) return 1;
+      if (valB == null) return -1;
+      if (valA < valB) return -1 * modifier;
+      if (valA > valB) return 1 * modifier;
+    }
+    return 0;
+  });
+  return memos.map((m) => m.item);
+}
+function unique(array, key) {
+  return Array.from(new Map(array.map((item) => [key(item), item])).values());
+}
+var arr = {
+  chunk,
+  chunkAdj,
+  cluster,
+  compact,
+  forceArray,
+  search,
+  seqMap,
+  shuffle,
+  sortBy,
+  unique
+};
+
+// src/async.ts
+var async_exports = {};
+__export(async_exports, {
+  async: () => async
+});
+async function retry(fn2, retries = 3, delay = 500) {
+  try {
+    return await fn2();
+  } catch (error) {
+    if (retries <= 0) throw error;
+    const jitter = Math.random() * 200;
+    return await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+  }
+}
+var async = {
+  retry
+};
+
+// src/fn.ts
+var fn_exports = {};
+__export(fn_exports, {
+  fn: () => fn
+});
+function memoize(fn2, 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 = fn2.apply(this, args);
+    cache.set(key, { value: result, timestamp: now });
+    return result;
+  };
+  memoized.clear = () => cache.clear();
+  return memoized;
+}
+var fn = {
+  memoize
+};
+
+// src/date.ts
+var date_exports = {};
+__export(date_exports, {
+  date: () => date
+});
+var MS_MAP = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5,
+  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(date2, locale) {
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  const elapsed = (typeof date2 === "number" ? date2 : date2.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 parse(str3, options = {}) {
+  if (typeof str3 === "number") return str3;
+  const matches = str3.matchAll(/(-?\d+)([a-z]+)/gi);
+  let totalMs = 0;
+  let found = false;
+  for (const [_, value, unit] of matches) {
+    if (!value || !unit) continue;
+    const factor = MS_MAP[unit.toLowerCase()];
+    if (factor) {
+      totalMs += parseInt(value) * factor;
+      found = true;
+    }
+  }
+  if (!found) throw new Error(`parse: Invalid time format: "${str3}"`);
+  const result = options.unit === "s" ? totalMs / 1e3 : totalMs;
+  return options.fromNow ? Date.now() + result : result;
+}
+var date = {
+  duration,
+  eta,
+  parse
+};
+
+// src/format.ts
+var format_exports = {};
+__export(format_exports, {
+  format: () => format
+});
+function currency(num2, options = {}) {
+  return new Intl.NumberFormat(options.locale, {
+    style: "currency",
+    currency: options.currency
+  }).format(num2);
+}
+function number(num2, options = {}) {
+  return new Intl.NumberFormat(options.locale, {
+    minimumFractionDigits: options.precision,
+    maximumFractionDigits: options.precision
+  }).format(num2);
+}
+function memory(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(num2, locale) {
+  const _num = Number(num2);
+  if (isNaN(_num)) throw new TypeError("Invalid input");
+  const pr = new Intl.PluralRules(locale, { type: "ordinal" });
+  const rule = pr.select(_num);
+  const suffixes = {
+    one: "st",
+    two: "nd",
+    few: "rd",
+    other: "th"
+  };
+  const suffix = suffixes[rule] || "th";
+  return _num.toLocaleString(locale) + suffix;
+}
+function compactNumber(num2, locale) {
+  return new Intl.NumberFormat(locale, {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: 1
+  }).format(num2);
+}
+var format = {
+  currency,
+  number,
+  memory,
+  ordinal,
+  compactNumber
+};
+
+// src/is.ts
+var is_exports = {};
+__export(is_exports, {
+  is: () => is
+});
+function defined(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;
+  return false;
+}
+function inRange(num2, a, b) {
+  let min = b !== void 0 ? a : 0;
+  let max = b !== void 0 ? b : a;
+  if (min > max) [min, max] = [max, min];
+  return num2 >= min && num2 <= max;
+}
+function object(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function sorted(arr2, comparator) {
+  for (let i = 0; i < arr2.length - 1; i++) {
+    const comp = comparator ? comparator(arr2[i], arr2[i + 1]) : arr2[i] > arr2[i + 1] ? 1 : -1;
+    if (comp > 0) return false;
+  }
+  return true;
+}
+function string(val) {
+  return typeof val === "string";
+}
+function today(date2) {
+  const d = date2 instanceof Date ? date2 : new Date(date2);
+  const today2 = /* @__PURE__ */ new Date();
+  return d.getDate() === today2.getDate() && d.getMonth() === today2.getMonth() && d.getFullYear() === today2.getFullYear();
+}
+var is = {
+  defined,
+  empty,
+  inRange,
+  object,
+  sorted,
+  string,
+  today
+};
+
+// src/math.ts
+var math_exports = {};
+__export(math_exports, {
+  math: () => math
+});
+function invLerp(start, end, value) {
+  if (start === end) return 0;
+  return (value - start) / (end - start);
+}
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+function ms(num2) {
+  return Math.floor(num2 * 1e3);
+}
+function percent(a, b, round = true) {
+  const result = a / b * 100;
+  return round ? Math.floor(result) : result;
+}
+function remap(value, inMin, inMax, outMin, outMax) {
+  const t = invLerp(inMin, inMax, value);
+  return lerp(outMin, outMax, t);
+}
+function secs(num2) {
+  return Math.floor(num2 / 1e3);
+}
+function sum(array, selector, ignoreNaN) {
+  return array.map(selector).reduce((a, b) => {
+    const invalid = isNaN(b) && !ignoreNaN;
+    if (invalid) throw new TypeError(`sum: '${b}' is not a valid number.`);
+    return (isNaN(b) ? 0 : b) < 0 ? a - -b : a + (b || 0);
+  }, 0);
+}
+var math = {
+  invLerp,
+  lerp,
+  ms,
+  percent,
+  remap,
+  secs,
+  sum
+};
+
+// src/num.ts
+var num_exports = {};
+__export(num_exports, {
+  num: () => num
+});
+function clamp(num2, 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(num2, max));
+}
+var num = {
+  clamp
+};
+
+// src/obj.ts
+var obj_exports = {};
+__export(obj_exports, {
+  obj: () => obj
+});
+function get(obj2, path2, defaultValue) {
+  if (!obj2) throw new Error("get: Target object is null or undefined");
+  const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj2;
+  const trace = [];
+  for (const part of parts) {
+    trace.push(part);
+    if (current === null || typeof current !== "object" || !(part in current)) {
+      if (arguments.length === 3) return defaultValue;
+      const reach = trace.join(".");
+      throw new Error(`get: Path broken at "${reach}". Property "${part}" is missing on ${typeof current}.`);
+    }
+    current = current[part];
+  }
+  if (current === void 0 && arguments.length === 3) {
+    return defaultValue;
+  }
+  return current;
+}
+function has(obj2, path2) {
+  if (!obj2 || !path2) return false;
+  const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj2;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (current === null || typeof current !== "object") {
+      return false;
+    }
+    if (!(part in current)) {
+      return false;
+    }
+    current = current[part];
+  }
+  return true;
+}
+function set(obj2, path2, value) {
+  const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj2;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const isLast = i === parts.length - 1;
+    if (isLast) {
+      current[part] = value;
+      return;
+    }
+    const nextPartIsNumber = !isNaN(Number(parts[i + 1]));
+    if (!(part in current) || current[part] === null || typeof current[part] !== "object") {
+      current[part] = nextPartIsNumber ? [] : {};
+    }
+    current = current[part];
+  }
+}
+function merge(target, ...sources) {
+  for (const source of sources) {
+    if (!source) continue;
+    Object.keys(source).forEach((key) => {
+      const targetValue = target[key];
+      const sourceValue = source[key];
+      if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+        target[key] = targetValue.concat(sourceValue);
+      } else if (targetValue && typeof targetValue === "object" && sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
+        merge(targetValue, sourceValue);
+      } else {
+        target[key] = sourceValue;
+      }
+    });
+  }
+  return target;
+}
+function pick(obj2, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj2) {
+      result[key] = obj2[key];
+    }
+  }
+  return result;
+}
+function omit(obj2, keys) {
+  const result = { ...obj2 };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+var obj = {
+  get,
+  has,
+  set,
+  merge,
+  pick,
+  omit
+};
+
+// src/str.ts
+var str_exports = {};
+__export(str_exports, {
+  str: () => str2
+});
+function escapeRegex(str3) {
+  return str3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getFlag(str3, flag, length) {
+  const regex = flag instanceof RegExp ? flag : new RegExp(`${escapeRegex(flag)}\\b`, "g");
+  const match = regex.exec(str3);
+  if (!match) return null;
+  const startIndex = match.index + match[0].length;
+  let result = str3.slice(startIndex).trimStart();
+  if (length !== void 0) {
+    return result.split(/\s+/).slice(0, length).join(" ");
+  }
+  return result || null;
+}
+function hasFlag(str3, flag) {
+  if (flag instanceof RegExp) return flag.test(str3);
+  const pattern = new RegExp(`${escapeRegex(flag)}\\b`);
+  return pattern.test(str3);
+}
+function toTitleCase(str3, smart = true) {
+  const minorWords = /^(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|v\.?|via)$/i;
+  return str3.replace(/\w\S*/g, (txt, index2) => {
+    if (smart && index2 !== 0 && minorWords.test(txt)) {
+      return txt.toLowerCase();
+    }
+    if (smart && txt.length > 1 && txt === txt.toUpperCase()) {
+      return txt;
+    }
+    return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+  });
+}
+var str2 = {
+  escapeRegex,
+  getFlag,
+  hasFlag,
+  toTitleCase
+};
+
+// src/timing.ts
+var timing_exports = {};
+__export(timing_exports, {
+  timing: () => timing
+});
+function debounce(fn2, 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) fn2.apply(this, args);
+    }, wait2);
+    if (callNow) fn2.apply(this, args);
+  };
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = void 0;
+    }
+  };
+  return debounced;
+}
+function throttle(fn2, limit) {
+  let inThrottle = false;
+  return function(...args) {
+    if (!inThrottle) {
+      fn2.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+function wait(ms2) {
+  return new Promise(
+    (resolve) => setTimeout(() => {
+      resolve(true);
+    }, ms2)
+  );
+}
+var timing = {
+  debounce,
+  throttle,
+  wait
+};
+
+// src/to.ts
+var to_exports = {};
+__export(to_exports, {
+  to: () => to
+});
+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;
+}
+var to = {
+  record
+};
+
+// src/Pipe.ts
+function Pipe(value, ...fns) {
+  return fns.reduce((acc, fn2) => fn2(acc), value);
+}
+
+// src/Storage.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var Storage = class {
+  isNode = typeof window === "undefined";
+  filePath = null;
+  memoryCache = /* @__PURE__ */ new Map();
+  loadFromFile() {
+    if (this.filePath && import_node_fs.default.existsSync(this.filePath)) {
+      try {
+        const data = JSON.parse(import_node_fs.default.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));
+      import_node_fs.default.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 = import_node_path.default.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
+var import_node_events = __toESM(require("events"));
+var TypedEmitterBase = import_node_events.default;
+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(fn2, delay, immediate = true) {
+    super();
+    this.fn = fn2;
+    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 $ = {
+  ...arr_exports,
+  ...async_exports,
+  ...fn_exports,
+  ...date_exports,
+  ...format_exports,
+  ...is_exports,
+  ...math_exports,
+  ...num_exports,
+  ...obj_exports,
+  ...timing_exports,
+  ...rnd_exports,
+  ...str_exports,
+  ...to_exports,
+  Pipe,
+  Storage,
+  Cache,
+  Loop
+};
+var qznt = $;
+var index_default = $;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache,
+  Loop,
+  Pipe,
+  Storage,
+  arr,
+  async,
+  date,
+  fn,
+  format,
+  is,
+  math,
+  num,
+  obj,
+  qznt,
+  rnd,
+  str,
+  timing,
+  to
+});
+//# sourceMappingURL=index.cjs.map