qznt 1.0.34 → 1.0.36

package/dist/index.cjs

@@ -9,13 +9,13 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to2, from, except, desc) => {
+var __copyProps = (to, 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 });
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to2;
+  return to;
 };
 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
@@ -35,33 +35,98 @@ __export(index_exports, {
   Loop: () => Loop,
   Pipe: () => Pipe,
   Storage: () => Storage,
-  arr: () => arr,
-  async: () => async,
-  date: () => date,
+  chance: () => chance,
+  choice: () => choice,
+  chunk: () => chunk,
+  chunkAdj: () => chunkAdj,
+  clamp: () => clamp,
+  cluster: () => cluster,
+  compact: () => compact,
+  compactNumber: () => compactNumber,
+  currency: () => currency,
+  debounce: () => debounce,
   default: () => index_default,
-  fn: () => fn,
-  format: () => format,
-  fs: () => fs,
-  is: () => is,
-  math: () => math,
-  obj: () => obj,
-  rnd: () => rnd,
-  str: () => str2,
-  timing: () => timing,
-  to: () => to
+  defined: () => defined,
+  duration: () => duration,
+  empty: () => empty,
+  escapeRegex: () => escapeRegex,
+  eta: () => eta,
+  float: () => float,
+  forceArray: () => forceArray,
+  get: () => get,
+  getAge: () => getAge,
+  getFlag: () => getFlag,
+  has: () => has,
+  hasFlag: () => hasFlag,
+  inRange: () => inRange,
+  index: () => index,
+  int: () => int,
+  invLerp: () => invLerp,
+  lerp: () => lerp,
+  memoize: () => memoize,
+  memory: () => memory,
+  merge: () => merge,
+  ms: () => ms,
+  number: () => number,
+  object: () => object,
+  omit: () => omit,
+  ordinal: () => ordinal,
+  parse: () => parse,
+  percent: () => percent,
+  pick: () => pick,
+  prng: () => prng,
+  readDir: () => readDir,
+  record: () => record,
+  remap: () => remap,
+  retry: () => retry,
+  sampler: () => sampler,
+  search: () => search,
+  secs: () => secs,
+  seqMap: () => seqMap,
+  set: () => set,
+  shuffle: () => shuffle,
+  sortBy: () => sortBy,
+  sorted: () => sorted,
+  str: () => str,
+  string: () => string,
+  sum: () => sum,
+  throttle: () => throttle,
+  toTitleCase: () => toTitleCase,
+  today: () => today,
+  unique: () => unique,
+  wait: () => wait,
+  weighted: () => weighted,
+  wrap: () => wrap
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/arr.ts
 var arr_exports = {};
 __export(arr_exports, {
-  arr: () => arr
+  chunk: () => chunk,
+  chunkAdj: () => chunkAdj,
+  cluster: () => cluster,
+  compact: () => compact,
+  forceArray: () => forceArray,
+  search: () => search,
+  seqMap: () => seqMap,
+  shuffle: () => shuffle,
+  sortBy: () => sortBy,
+  unique: () => unique
 });
 
 // src/rnd.ts
 var rnd_exports = {};
 __export(rnd_exports, {
-  rnd: () => rnd
+  chance: () => chance,
+  choice: () => choice,
+  float: () => float,
+  index: () => index,
+  int: () => int,
+  prng: () => prng,
+  sampler: () => sampler,
+  str: () => str,
+  weighted: () => weighted
 });
 var LOWER = "abcdefghijklmnopqrstuvwxyz";
 var UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -75,13 +140,13 @@ function chance(percent2 = 0.5, seed) {
 function choice(array, options = {}) {
   const { seed, not, maxRerolls = 10 } = options;
   const random = seed !== void 0 ? prng(seed) : Math.random;
-  const rnd2 = () => array[Math.floor(random() * array.length)];
-  let result = rnd2();
+  const rnd = () => array[Math.floor(random() * array.length)];
+  let result = rnd();
   if (seed === void 0 && array.length > 1 && not !== void 0) {
     let rerolls = 0;
     const shouldReroll = () => typeof not === "function" ? not(result) : result === not;
     while (shouldReroll() && rerolls < maxRerolls) {
-      result = rnd2();
+      result = rnd();
       rerolls++;
     }
   }
@@ -163,13 +228,13 @@ function float(min, max, seed) {
 function index(array, options = {}) {
   const { seed, not, maxRerolls = 10 } = options;
   const random = seed !== void 0 ? prng(seed) : Math.random;
-  const rnd2 = () => Math.floor(random() * array.length);
-  let result = rnd2();
+  const rnd = () => Math.floor(random() * array.length);
+  let result = rnd();
   if (seed === void 0 && array.length > 1 && not !== void 0) {
     let rerolls = 0;
     const shouldReroll = () => typeof not === "function" ? not(result) : result === not;
     while (shouldReroll() && rerolls < maxRerolls) {
-      result = rnd2();
+      result = rnd();
       rerolls++;
     }
   }
@@ -196,17 +261,6 @@ function str(len, mode, options = {}) {
   }
   return result.join("");
 }
-var rnd = {
-  chance,
-  choice,
-  weighted,
-  sampler,
-  prng,
-  float,
-  index,
-  int,
-  str
-};
 
 // src/arr.ts
 function chunk(array, size) {
@@ -295,7 +349,7 @@ function seqMap(array, callback) {
   return result;
 }
 function shuffle(array, seed) {
-  const random = seed !== void 0 ? rnd.prng(seed) : Math.random;
+  const random = seed !== void 0 ? prng(seed) : Math.random;
   const result = [...array];
   for (let i = result.length - 1; i > 0; i--) {
     const j = Math.floor(random() * (i + 1));
@@ -329,31 +383,48 @@ function sortBy(array, selectorOrSelectors, order = "asc") {
 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
+  retry: () => retry,
+  wait: () => wait
 });
-async function retry(fn2, retries = 3, delay = 500) {
+async function retry(fn, options = {}) {
+  const { retries = 3, delay = 500, timeout, signal } = options;
+  if (signal?.aborted) throw new Error("Operation aborted");
+  const executeWithTimeout = async () => {
+    if (!timeout) return fn(signal);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      return await fn(controller.signal);
+    } catch (err) {
+      if (controller.signal.aborted) throw new Error(`Attempt timed out after ${timeout}ms`);
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
   try {
-    return await fn2();
+    return await executeWithTimeout();
   } catch (error) {
+    if (signal?.aborted) throw error;
     if (retries <= 0) throw error;
     const jitter = Math.random() * 200;
-    return await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+    const totalDelay = delay + jitter;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, totalDelay);
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          reject(new Error("Operation aborted"));
+        },
+        { once: true }
+      );
+    });
+    return retry(fn, { ...options, retries: retries - 1, delay: delay * 2 });
   }
 }
 function wait(ms2) {
@@ -363,17 +434,13 @@ function wait(ms2) {
     }, ms2)
   );
 }
-var async = {
-  retry,
-  wait
-};
 
 // src/fn.ts
 var fn_exports = {};
 __export(fn_exports, {
-  fn: () => fn
+  memoize: () => memoize
 });
-function memoize(fn2, options = {}) {
+function memoize(fn, options = {}) {
   const cache = /* @__PURE__ */ new Map();
   const { resolver, maxAge } = options;
   const memoized = function(...args) {
@@ -386,21 +453,21 @@ function memoize(fn2, options = {}) {
       }
       cache.delete(key);
     }
-    const result = fn2.apply(this, args);
+    const result = fn.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
+  duration: () => duration,
+  eta: () => eta,
+  getAge: () => getAge,
+  parse: () => parse
 });
 var MS_MAP = {
   ms: 1,
@@ -440,9 +507,9 @@ function duration(target, style = "hms", options = {}) {
   const last = result.pop();
   return `${result.join(", ")} and ${last}`;
 }
-function eta(date2, locale) {
+function eta(date, locale) {
   const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
-  const elapsed = (typeof date2 === "number" ? date2 : date2.getTime()) - Date.now();
+  const elapsed = (typeof date === "number" ? date : date.getTime()) - Date.now();
   const units = [
     { unit: "year", ms: 31536e6 },
     { unit: "month", ms: 2628e6 },
@@ -458,9 +525,18 @@ function eta(date2, locale) {
   }
   return "";
 }
-function parse(str3, options = {}) {
-  if (typeof str3 === "number") return str3;
-  const matches = str3.matchAll(/(-?\d+)([a-z]+)/gi);
+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()) {
+    age--;
+  }
+  return age;
+}
+function parse(str2, options = {}) {
+  if (typeof str2 === "number") return str2;
+  const matches = str2.matchAll(/(-?\d+)([a-z]+)/gi);
   let totalMs = 0;
   let found = false;
   for (const [_, value, unit] of matches) {
@@ -471,20 +547,19 @@ function parse(str3, options = {}) {
       found = true;
     }
   }
-  if (!found) throw new Error(`parse: Invalid time format: "${str3}"`);
+  if (!found) throw new Error(`parse: Invalid time format: "${str2}"`);
   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
+  compactNumber: () => compactNumber,
+  currency: () => currency,
+  memory: () => memory,
+  number: () => number,
+  ordinal: () => ordinal
 });
 function currency(num, options = {}) {
   return new Intl.NumberFormat(options.locale, {
@@ -525,18 +600,11 @@ function compactNumber(num, locale) {
     maximumFractionDigits: 1
   }).format(num);
 }
-var format = {
-  currency,
-  number,
-  memory,
-  ordinal,
-  compactNumber
-};
 
 // src/fs.ts
 var fs_exports = {};
 __export(fs_exports, {
-  fs: () => fs
+  readDir: () => readDir
 });
 var import_node_fs = __toESM(require("fs"));
 var import_node_path = require("path");
@@ -544,8 +612,8 @@ function readDir(path2, options = {}) {
   const { recursive = true } = options;
   if (!import_node_fs.default.existsSync(path2)) return [];
   if (!recursive) {
-    return import_node_fs.default.readdirSync(path2).filter((fn2) => {
-      return import_node_fs.default.statSync((0, import_node_path.join)(path2, fn2)).isFile();
+    return import_node_fs.default.readdirSync(path2).filter((fn) => {
+      return import_node_fs.default.statSync((0, import_node_path.join)(path2, fn)).isFile();
     });
   }
   const walk = (dir, base = "") => {
@@ -564,14 +632,17 @@ function readDir(path2, options = {}) {
   };
   return walk(path2);
 }
-var fs = {
-  readDir
-};
 
 // src/is.ts
 var is_exports = {};
 __export(is_exports, {
-  is: () => is
+  defined: () => defined,
+  empty: () => empty,
+  inRange: () => inRange,
+  object: () => object,
+  sorted: () => sorted,
+  string: () => string,
+  today: () => today
 });
 function defined(val) {
   return val !== void 0 && val !== null;
@@ -591,9 +662,9 @@ function inRange(num, a, b) {
 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;
+function sorted(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;
@@ -601,25 +672,24 @@ function sorted(arr2, comparator) {
 function string(val) {
   return typeof val === "string";
 }
-function today(date2) {
-  const d = date2 instanceof Date ? date2 : new Date(date2);
+function today(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();
 }
-var is = {
-  defined,
-  empty,
-  inRange,
-  object,
-  sorted,
-  string,
-  today
-};
 
 // src/math.ts
 var math_exports = {};
 __export(math_exports, {
-  math: () => math
+  clamp: () => clamp,
+  invLerp: () => invLerp,
+  lerp: () => lerp,
+  ms: () => ms,
+  percent: () => percent,
+  remap: () => remap,
+  secs: () => secs,
+  sum: () => sum,
+  wrap: () => wrap
 });
 function clamp(num, a, b) {
   let min = b !== void 0 ? a : 0;
@@ -657,26 +727,24 @@ function sum(array, selector) {
     return (isNaN(b) ? 0 : b) < 0 ? a - -b : a + (b || 0);
   }, 0);
 }
-var math = {
-  clamp,
-  invLerp,
-  lerp,
-  ms,
-  percent,
-  remap,
-  secs,
-  sum
-};
+function wrap(num, max) {
+  return (num % max + max) % max;
+}
 
 // src/obj.ts
 var obj_exports = {};
 __export(obj_exports, {
-  obj: () => obj
+  get: () => get,
+  has: () => has,
+  merge: () => merge,
+  omit: () => omit,
+  pick: () => pick,
+  set: () => set
 });
-function get(obj2, path2, defaultValue) {
-  if (!obj2) throw new Error("get: Target object is null or undefined");
+function get(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 = obj2;
+  let current = obj;
   const trace = [];
   for (const part of parts) {
     trace.push(part);
@@ -692,10 +760,10 @@ function get(obj2, path2, defaultValue) {
   }
   return current;
 }
-function has(obj2, path2) {
-  if (!obj2 || !path2) return false;
+function has(obj, path2) {
+  if (!obj || !path2) return false;
   const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
-  let current = obj2;
+  let current = obj;
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
     if (current === null || typeof current !== "object") {
@@ -708,9 +776,9 @@ function has(obj2, path2) {
   }
   return true;
 }
-function set(obj2, path2, value) {
+function set(obj, path2, value) {
   const parts = path2.replace(/\[(\d+)\]/g, ".$1").split(".");
-  let current = obj2;
+  let current = obj;
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
     const isLast = i === parts.length - 1;
@@ -742,58 +810,53 @@ function merge(target, ...sources) {
   }
   return target;
 }
-function pick(obj2, keys) {
+function pick(obj, keys) {
   const result = {};
   for (const key of keys) {
-    if (key in obj2) {
-      result[key] = obj2[key];
+    if (key in obj) {
+      result[key] = obj[key];
     }
   }
   return result;
 }
-function omit(obj2, keys) {
-  const result = { ...obj2 };
+function omit(obj, keys) {
+  const result = { ...obj };
   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
+  escapeRegex: () => escapeRegex,
+  getFlag: () => getFlag,
+  hasFlag: () => hasFlag,
+  toTitleCase: () => toTitleCase
 });
-function escapeRegex(str3) {
-  return str3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str2) {
+  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function getFlag(str3, flag, length) {
+function getFlag(str2, flag, length) {
   const regex = flag instanceof RegExp ? flag : new RegExp(`${escapeRegex(flag)}\\b`, "g");
-  const match = regex.exec(str3);
+  const match = regex.exec(str2);
   if (!match) return null;
   const startIndex = match.index + match[0].length;
-  let result = str3.slice(startIndex).trimStart();
+  let result = str2.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);
+function hasFlag(str2, flag) {
+  if (flag instanceof RegExp) return flag.test(str2);
   const pattern = new RegExp(`${escapeRegex(flag)}\\b`);
-  return pattern.test(str3);
+  return pattern.test(str2);
 }
-function toTitleCase(str3, smart = true) {
+function toTitleCase(str2, 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) => {
+  return str2.replace(/\w\S*/g, (txt, index2) => {
     if (smart && index2 !== 0 && minorWords.test(txt)) {
       return txt.toLowerCase();
     }
@@ -803,19 +866,14 @@ function toTitleCase(str3, smart = true) {
     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
+  debounce: () => debounce,
+  throttle: () => throttle
 });
-function debounce(fn2, wait2, options = {}) {
+function debounce(fn, wait2, options = {}) {
   let timeoutId;
   const leading = options.immediate ?? false;
   const debounced = function(...args) {
@@ -823,9 +881,9 @@ function debounce(fn2, wait2, options = {}) {
     if (timeoutId) clearTimeout(timeoutId);
     timeoutId = setTimeout(() => {
       timeoutId = void 0;
-      if (!leading) fn2.apply(this, args);
+      if (!leading) fn.apply(this, args);
     }, wait2);
-    if (callNow) fn2.apply(this, args);
+    if (callNow) fn.apply(this, args);
   };
   debounced.cancel = () => {
     if (timeoutId) {
@@ -835,25 +893,21 @@ function debounce(fn2, wait2, options = {}) {
   };
   return debounced;
 }
-function throttle(fn2, limit) {
+function throttle(fn, limit) {
   let inThrottle = false;
   return function(...args) {
     if (!inThrottle) {
-      fn2.apply(this, args);
+      fn.apply(this, args);
       inThrottle = true;
       setTimeout(() => inThrottle = false, limit);
     }
   };
 }
-var timing = {
-  debounce,
-  throttle
-};
 
 // src/to.ts
 var to_exports = {};
 __export(to_exports, {
-  to: () => to
+  record: () => record
 });
 function record(array, callback) {
   const result = {};
@@ -871,13 +925,10 @@ function record(array, callback) {
   }
   return result;
 }
-var to = {
-  record
-};
 
 // src/Pipe.ts
 function Pipe(value, ...fns) {
-  return fns.reduce((acc, fn2) => fn2(acc), value);
+  return fns.reduce((acc, fn) => fn(acc), value);
 }
 
 // src/Storage.ts
@@ -1055,9 +1106,9 @@ var Loop = class extends TypedEmitterBase {
    * @param delay The delay between runs in milliseconds.
    * @param immediate Whether to start the loop immediately. [default: true]
    */
-  constructor(fn2, delay, immediate = true) {
+  constructor(fn, delay, immediate = true) {
     super();
-    this.fn = fn2;
+    this.fn = fn;
     this.delay = delay;
     if (immediate) this.start();
   }
@@ -1114,19 +1165,19 @@ var Loop = class extends TypedEmitterBase {
 
 // src/index.ts
 var qznt = {
-  ...arr_exports,
-  ...async_exports,
-  ...fn_exports,
-  ...date_exports,
-  ...format_exports,
-  ...fs_exports,
-  ...is_exports,
-  ...math_exports,
-  ...obj_exports,
-  ...timing_exports,
-  ...rnd_exports,
-  ...str_exports,
-  ...to_exports,
+  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,
@@ -1141,18 +1192,66 @@ var index_default = qznt;
   Loop,
   Pipe,
   Storage,
-  arr,
-  async,
-  date,
-  fn,
-  format,
-  fs,
-  is,
-  math,
-  obj,
-  rnd,
+  chance,
+  choice,
+  chunk,
+  chunkAdj,
+  clamp,
+  cluster,
+  compact,
+  compactNumber,
+  currency,
+  debounce,
+  defined,
+  duration,
+  empty,
+  escapeRegex,
+  eta,
+  float,
+  forceArray,
+  get,
+  getAge,
+  getFlag,
+  has,
+  hasFlag,
+  inRange,
+  index,
+  int,
+  invLerp,
+  lerp,
+  memoize,
+  memory,
+  merge,
+  ms,
+  number,
+  object,
+  omit,
+  ordinal,
+  parse,
+  percent,
+  pick,
+  prng,
+  readDir,
+  record,
+  remap,
+  retry,
+  sampler,
+  search,
+  secs,
+  seqMap,
+  set,
+  shuffle,
+  sortBy,
+  sorted,
   str,
-  timing,
-  to
+  string,
+  sum,
+  throttle,
+  toTitleCase,
+  today,
+  unique,
+  wait,
+  weighted,
+  wrap
 });
 //# sourceMappingURL=index.cjs.map