radashi 12.2.0-beta.c59abfd → 12.2.0-beta.cf2d48e

package/dist/radashi.cjs

@@ -21,15 +21,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var mod_exports = {};
 __export(mod_exports, {
   AggregateError: () => AggregateError,
+  DefaultCloningStrategy: () => DefaultCloningStrategy,
+  FastCloningStrategy: () => FastCloningStrategy,
   all: () => all,
   alphabetical: () => alphabetical,
+  always: () => always,
   assign: () => assign,
   boil: () => boil,
   callable: () => callable,
   camel: () => camel,
   capitalize: () => capitalize,
+  castArray: () => castArray,
+  castArrayIfExists: () => castArrayIfExists,
+  castComparator: () => castComparator,
+  castMapping: () => castMapping,
   chain: () => chain,
+  clamp: () => clamp,
   clone: () => clone,
+  cloneDeep: () => cloneDeep,
   cluster: () => cluster,
   compose: () => compose,
   construct: () => construct,
@@ -52,6 +61,7 @@ __export(mod_exports, {
   intersects: () => intersects,
   invert: () => invert,
   isArray: () => isArray,
+  isBoolean: () => isBoolean,
   isDate: () => isDate,
   isEmpty: () => isEmpty,
   isEqual: () => isEqual,
@@ -59,16 +69,24 @@ __export(mod_exports, {
   isFunction: () => isFunction,
   isInt: () => isInt,
   isIntString: () => isIntString,
+  isIterable: () => isIterable,
+  isMap: () => isMap,
   isNumber: () => isNumber,
   isObject: () => isObject,
   isPlainObject: () => isPlainObject,
   isPrimitive: () => isPrimitive,
   isPromise: () => isPromise,
+  isRegExp: () => isRegExp,
+  isSet: () => isSet,
   isString: () => isString,
   isSymbol: () => isSymbol,
+  isTagged: () => isTagged,
+  isWeakMap: () => isWeakMap,
+  isWeakSet: () => isWeakSet,
   iterate: () => iterate,
   keys: () => keys,
   last: () => last,
+  lerp: () => lerp,
   list: () => list,
   listify: () => listify,
   lowerize: () => lowerize,
@@ -81,8 +99,10 @@ __export(mod_exports, {
   memo: () => memo,
   merge: () => merge,
   min: () => min,
+  noop: () => noop,
   objectify: () => objectify,
   omit: () => omit,
+  once: () => once,
   parallel: () => parallel,
   partial: () => partial,
   partob: () => partob,
@@ -114,6 +134,7 @@ __export(mod_exports, {
   toFloat: () => toFloat,
   toInt: () => toInt,
   toggle: () => toggle,
+  traverse: () => traverse,
   trim: () => trim,
   try: () => tryit,
   tryit: () => tryit,
@@ -144,6 +165,16 @@ function boil(array, compareFunc) {
   return array.reduce(compareFunc);
 }
 
+// src/array/castArray.ts
+function castArray(value) {
+  return Array.isArray(value) ? value.slice() : [value];
+}
+
+// src/array/castArrayIfExists.ts
+function castArrayIfExists(value) {
+  return Array.isArray(value) ? value.slice() : value != null ? [value] : value;
+}
+
 // src/array/cluster.ts
 function cluster(array, size = 2) {
   const clusters = [];
@@ -263,20 +294,11 @@ function list(startOrLength, end, valueOrMapper, step) {
 function mapify(array, getKey, getValue = (item) => item) {
   const map2 = /* @__PURE__ */ new Map();
   for (const item of array) {
-    map2.set(getKey(item), getValue(item));
+    map2.set(getKey(item, map2.size), getValue(item, map2.size));
   }
   return map2;
 }
 
-// src/array/max.ts
-function max(array, getter) {
-  if (!array || (array.length ?? 0) === 0) {
-    return null;
-  }
-  const get2 = getter ?? ((v) => v);
-  return array.reduce((a, b) => get2(a) > get2(b) ? a : b);
-}
-
 // src/array/merge.ts
 function merge(prev, array, toKey) {
   if (!array && !prev) {
@@ -298,15 +320,6 @@ function merge(prev, array, toKey) {
   });
 }
 
-// src/array/min.ts
-function min(array, getter) {
-  if (!array || (array.length ?? 0) === 0) {
-    return null;
-  }
-  const get2 = getter ?? ((v) => v);
-  return array.reduce((a, b) => get2(a) < get2(b) ? a : b);
-}
-
 // src/array/objectify.ts
 function objectify(array, getKey, getValue = (item) => item) {
   return array.reduce(
@@ -318,19 +331,6 @@ function objectify(array, getKey, getValue = (item) => item) {
   );
 }
 
-// src/array/range.ts
-function* range(startOrLength, end, valueOrMapper = (i) => i, step = 1) {
-  const mapper = isFunction(valueOrMapper) ? valueOrMapper : () => valueOrMapper;
-  const start = end ? startOrLength : 0;
-  const final = end ?? startOrLength;
-  for (let i = start; i <= final; i += step) {
-    yield mapper(i);
-    if (i + step > final) {
-      break;
-    }
-  }
-}
-
 // src/array/replace.ts
 function replace(array, newItem, match) {
   if (!array) {
@@ -427,32 +427,20 @@ function sort(array, getter, desc = false) {
   return array.slice().sort(desc === true ? dsc : asc);
 }
 
-// src/array/sum.ts
-function sum(array, fn) {
-  return (array || []).reduce((acc, item) => acc + (fn ? fn(item) : item), 0);
-}
-
 // src/array/toggle.ts
 function toggle(array, item, toKey, options) {
-  if (!array && !item) {
-    return [];
-  }
   if (!array) {
-    return [item];
+    return item !== void 0 ? [item] : [];
   }
-  if (!item) {
+  if (item === void 0) {
     return [...array];
   }
   const matcher = toKey ? (x, idx) => toKey(x, idx) === toKey(item, idx) : (x) => x === item;
   const existing = array.find(matcher);
-  if (existing) {
+  if (existing !== void 0) {
     return array.filter((x, idx) => !matcher(x, idx));
   }
-  const strategy = (options == null ? void 0 : options.strategy) ?? "append";
-  if (strategy === "append") {
-    return [...array, item];
-  }
-  return [item, ...array];
+  return (options == null ? void 0 : options.strategy) === "prepend" ? [item, ...array] : [...array, item];
 }
 
 // src/array/unique.ts
@@ -658,7 +646,7 @@ async function retry(options, func) {
     if (err._exited) {
       throw err._exited;
     }
-    if (++i === times) {
+    if (++i >= times) {
       throw err;
     }
     if (delay) {
@@ -770,6 +758,22 @@ function memo(func, options = {}) {
   return memoize({}, func, options.key ?? null, options.ttl ?? null);
 }
 
+// src/curry/once.ts
+var onceSymbol = Symbol();
+var once = (fn) => {
+  const onceFn = function(...args) {
+    if (onceFn[onceSymbol] === onceSymbol) {
+      onceFn[onceSymbol] = fn.apply(this, args);
+    }
+    return onceFn[onceSymbol];
+  };
+  onceFn[onceSymbol] = onceSymbol;
+  return onceFn;
+};
+once.reset = (fn) => {
+  fn[onceSymbol] = onceSymbol;
+};
+
 // src/curry/partial.ts
 function partial(fn, ...args) {
   return (...rest) => fn(...[...args, ...rest]);
@@ -811,6 +815,42 @@ function throttle({ interval }, func) {
   return throttled;
 }
 
+// src/function/always.ts
+function always(value) {
+  return () => value;
+}
+
+// src/function/castComparator.ts
+function castComparator(mapping, compare, reverse) {
+  const map2 = isFunction(mapping) ? mapping : (obj) => obj[mapping];
+  const comparator = (left, right) => {
+    const mappedLeft = map2(left);
+    const mappedRight = map2(right);
+    if (compare) {
+      return compare(mappedLeft, mappedRight);
+    }
+    return mappedLeft > mappedRight ? 1 : mappedLeft < mappedRight ? -1 : 0;
+  };
+  return reverse ? flip(comparator) : comparator;
+}
+
+// src/function/castMapping.ts
+function castMapping(mapping) {
+  return isFunction(mapping) ? mapping : mapping != null ? (input) => input[mapping] : (input) => input;
+}
+
+// src/function/noop.ts
+function noop() {
+}
+
+// src/number/clamp.ts
+function clamp(n, min2, max2) {
+  if (max2 != null && min2 != null && min2 > max2) {
+    throw new Error("invalid clamp range");
+  }
+  return max2 != null && n > max2 ? max2 : min2 != null && n < min2 ? min2 : n;
+}
+
 // src/number/inRange.ts
 function inRange(number, start, end) {
   const isTypeSafe = typeof number === "number" && typeof start === "number" && (typeof end === "undefined" || typeof end === "number");
@@ -824,6 +864,42 @@ function inRange(number, start, end) {
   return number >= Math.min(start, end) && number < Math.max(start, end);
 }
 
+// src/number/lerp.ts
+function lerp(from, to, amount) {
+  return from + (to - from) * amount;
+}
+
+// src/number/max.ts
+function max(array, getter) {
+  if (!array || (array.length ?? 0) === 0) {
+    return null;
+  }
+  const get2 = getter ?? ((v) => v);
+  return array.reduce((a, b) => get2(a) > get2(b) ? a : b);
+}
+
+// src/number/min.ts
+function min(array, getter) {
+  if (!array || (array.length ?? 0) === 0) {
+    return null;
+  }
+  const get2 = getter ?? ((v) => v);
+  return array.reduce((a, b) => get2(a) < get2(b) ? a : b);
+}
+
+// src/number/range.ts
+function* range(startOrLength, end, valueOrMapper = (i) => i, step = 1) {
+  const mapper = isFunction(valueOrMapper) ? valueOrMapper : () => valueOrMapper;
+  const start = end ? startOrLength : 0;
+  const final = end ?? startOrLength;
+  for (let i = start; i <= final; i += step) {
+    yield mapper(i);
+    if (i + step > final) {
+      break;
+    }
+  }
+}
+
 // src/number/round.ts
 function round(value, precision, toInteger = Math.round) {
   if (precision) {
@@ -835,6 +911,11 @@ function round(value, precision, toInteger = Math.round) {
   return toInteger(value);
 }
 
+// src/number/sum.ts
+function sum(array, fn) {
+  return (array || []).reduce((acc, item) => acc + (fn ? fn(item) : item), 0);
+}
+
 // src/number/toFloat.ts
 function toFloat(value, defaultValue) {
   const parsedValue = isSymbol(value) ? Number.NaN : Number.parseFloat(value);
@@ -854,10 +935,8 @@ function assign(initial, override) {
   }
   const proto = Object.getPrototypeOf(initial);
   const merged = proto ? { ...initial } : Object.assign(Object.create(proto), initial);
-  for (const key in override) {
-    if (Object.prototype.hasOwnProperty.call(override, key)) {
-      merged[key] = isPlainObject(initial[key]) ? assign(initial[key], override[key]) : override[key];
-    }
+  for (const key of Object.keys(override)) {
+    merged[key] = isPlainObject(initial[key]) && isPlainObject(override[key]) ? assign(initial[key], override[key]) : override[key];
   }
   return merged;
 }
@@ -878,6 +957,73 @@ function clone(obj) {
   return newObj;
 }
 
+// src/object/cloneDeep.ts
+var DefaultCloningStrategy = {
+  cloneMap(input, track, clone2) {
+    const output = track(/* @__PURE__ */ new Map());
+    for (const [key, value] of input) {
+      output.set(key, clone2(value));
+    }
+    return output;
+  },
+  cloneSet(input, track, clone2) {
+    const output = track(/* @__PURE__ */ new Set());
+    for (const value of input) {
+      output.add(clone2(value));
+    }
+    return output;
+  },
+  cloneArray(input, track, clone2) {
+    const output = track(new Array(input.length));
+    input.forEach((value, index) => {
+      output[index] = clone2(value);
+    });
+    return output;
+  },
+  cloneObject(input, track, clone2) {
+    const output = track(Object.create(Object.getPrototypeOf(input)));
+    for (const key of Reflect.ownKeys(input)) {
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if ("value" in descriptor) {
+        descriptor.value = clone2(descriptor.value);
+      }
+      Object.defineProperty(output, key, descriptor);
+    }
+    return output;
+  },
+  cloneOther(input, track) {
+    return track(input);
+  }
+};
+var FastCloningStrategy = {
+  cloneObject: (input, track, clone2) => {
+    const output = track({ ...input });
+    for (const key of Object.keys(input)) {
+      output[key] = clone2(input[key]);
+    }
+    return output;
+  }
+};
+function cloneDeep(root, customStrategy) {
+  const strategy = { ...DefaultCloningStrategy, ...customStrategy };
+  const tracked = /* @__PURE__ */ new Map();
+  const track = (parent, newParent) => {
+    tracked.set(parent, newParent);
+    return newParent;
+  };
+  const clone2 = (value) => value && typeof value === "object" ? tracked.get(value) ?? cloneDeep2(value, strategy) : value;
+  const cloneDeep2 = (parent, strategy2) => {
+    const cloneParent = isObject(parent) ? strategy2.cloneObject : isArray(parent) ? strategy2.cloneArray : isMap(parent) ? strategy2.cloneMap : isSet(parent) ? strategy2.cloneSet : strategy2.cloneOther;
+    const newParent = cloneParent(parent, track.bind(null, parent), clone2);
+    if (!newParent) {
+      return cloneDeep2(parent, DefaultCloningStrategy);
+    }
+    tracked.set(parent, newParent);
+    return newParent;
+  };
+  return cloneDeep2(root, strategy);
+}
+
 // src/object/construct.ts
 function construct(obj) {
   if (!obj) {
@@ -1048,19 +1194,22 @@ function omit(obj, keys2) {
 }
 
 // src/object/pick.ts
-function pick(obj, keys2) {
+function pick(obj, filter) {
   if (!obj) {
     return {};
   }
-  return keys2.reduce(
-    (acc, key) => {
-      if (Object.hasOwnProperty.call(obj, key)) {
-        acc[key] = obj[key];
-      }
-      return acc;
-    },
-    {}
-  );
+  let keys2 = filter;
+  if (isArray(filter)) {
+    filter = null;
+  } else {
+    keys2 = Reflect.ownKeys(obj);
+  }
+  return keys2.reduce((acc, key) => {
+    if (filterKey(obj, key, filter)) {
+      acc[key] = obj[key];
+    }
+    return acc;
+  }, {});
 }
 
 // src/object/set.ts
@@ -1096,6 +1245,104 @@ function shake(obj, filter = (value) => value === void 0) {
   }, {});
 }
 
+// src/object/traverse.ts
+function traverse(root, visitor, options, outerContext) {
+  const context = outerContext ?? {
+    value: null,
+    key: null,
+    parent: null,
+    parents: [],
+    path: [],
+    skipped: /* @__PURE__ */ new Set(),
+    skip(obj) {
+      context.skipped.add(obj ?? context.value);
+    }
+  };
+  const { rootNeedsVisit } = options ??= {};
+  const ownKeys = options.ownKeys ?? Object.keys;
+  const nestedOptions = {
+    ...options,
+    rootNeedsVisit: null
+  };
+  let ok = true;
+  const visit = (value, key) => {
+    if (context.parent.constructor === Map) {
+      ;
+      [key, value] = value;
+    }
+    context.path.push(key);
+    const result = visitor(
+      context.value = value,
+      context.key = key,
+      context.parent,
+      context,
+      nestedOptions
+    );
+    if (result === false) {
+      return ok = false;
+    }
+    if (value !== null && typeof value === "object" && (isArray(value) || isPlainObject(value)) && !context.skipped.has(value) && !context.parents.includes(value)) {
+      traverse2(value, result);
+    }
+    context.path.pop();
+    return ok;
+  };
+  const traverse2 = (parent, parentResult) => {
+    context.parents.push(parent);
+    context.parent = parent;
+    if (rootNeedsVisit && parent === root) {
+      parentResult = visitor(
+        context.value = parent,
+        context.key = null,
+        context.parent,
+        context,
+        nestedOptions
+      );
+      if (parentResult === false) {
+        return ok;
+      }
+    }
+    if (isArray(parent)) {
+      parent.slice().forEach((value, index, values) => {
+        if (visit(value, index) === false) {
+          values.length = 0;
+        }
+      });
+    } else if (parent === root && isIterable(parent)) {
+      let index = 0;
+      for (const value of parent) {
+        if (visit(value, index) === false) {
+          return ok;
+        }
+        index++;
+      }
+    } else {
+      for (const key of ownKeys(parent)) {
+        if (visit(parent[key], key) === false) {
+          return ok;
+        }
+      }
+    }
+    context.parents.pop();
+    context.parent = last(context.parents);
+    if (ok && isFunction(parentResult)) {
+      ok = parentResult() !== false;
+    }
+    return ok;
+  };
+  if (outerContext) {
+    if (outerContext.skipped.has(root)) {
+      return true;
+    }
+    const { value, key } = context;
+    traverse2(root);
+    context.value = value;
+    context.key = key;
+    return ok;
+  }
+  return traverse2(root);
+}
+
 // src/object/upperize.ts
 function upperize(obj) {
   return mapKeys(obj, (k) => k.toUpperCase());
@@ -1291,9 +1538,14 @@ function trim(str, charsToTrim = " ") {
 // src/typed/isArray.ts
 var isArray = Array.isArray;
 
+// src/typed/isBoolean.ts
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
 // src/typed/isDate.ts
 function isDate(value) {
-  return Object.prototype.toString.call(value) === "[object Date]";
+  return isTagged(value, "[object Date]");
 }
 
 // src/typed/isEmpty.ts
@@ -1369,9 +1621,7 @@ function isFunction(value) {
 }
 
 // src/typed/isInt.ts
-function isInt(value) {
-  return isNumber(value) && value % 1 === 0;
-}
+var isInt = Number.isInteger;
 
 // src/typed/isIntString.ts
 function isIntString(value) {
@@ -1382,18 +1632,24 @@ function isIntString(value) {
   return Number.isInteger(num) && `${num}` === value;
 }
 
+// src/typed/isIterable.ts
+function isIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.iterator in value;
+}
+
+// src/typed/isMap.ts
+function isMap(value) {
+  return isTagged(value, "[object Map]");
+}
+
 // src/typed/isNumber.ts
 function isNumber(value) {
-  try {
-    return Number(value) === value;
-  } catch {
-    return false;
-  }
+  return typeof value === "number" && !Number.isNaN(value);
 }
 
 // src/typed/isObject.ts
 function isObject(value) {
-  return !!value && value.constructor === Object;
+  return isTagged(value, "[object Object]");
 }
 
 // src/typed/isPlainObject.ts
@@ -1402,7 +1658,12 @@ function isPlainObject(value) {
     return false;
   }
   const prototype = Object.getPrototypeOf(value);
-  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+  return (
+    // Fast path for most common objects.
+    prototype === Object.prototype || // Support objects created without a prototype.
+    prototype === null || // Support plain objects from other realms.
+    Object.getPrototypeOf(prototype) === null
+  );
 }
 
 // src/typed/isPrimitive.ts
@@ -1415,27 +1676,61 @@ function isPromise(value) {
   return !!value && isFunction(value.then);
 }
 
+// src/typed/isRegExp.ts
+function isRegExp(value) {
+  return isTagged(value, "[object RegExp]");
+}
+
+// src/typed/isSet.ts
+function isSet(value) {
+  return isTagged(value, "[object Set]");
+}
+
 // src/typed/isString.ts
 function isString(value) {
-  return typeof value === "string" || value instanceof String;
+  return typeof value === "string";
 }
 
 // src/typed/isSymbol.ts
 function isSymbol(value) {
   return typeof value === "symbol";
 }
+
+// src/typed/isTagged.ts
+function isTagged(value, tag) {
+  return Object.prototype.toString.call(value) === tag;
+}
+
+// src/typed/isWeakMap.ts
+function isWeakMap(value) {
+  return isTagged(value, "[object WeakMap]");
+}
+
+// src/typed/isWeakSet.ts
+function isWeakSet(value) {
+  return isTagged(value, "[object WeakSet]");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AggregateError,
+  DefaultCloningStrategy,
+  FastCloningStrategy,
   all,
   alphabetical,
+  always,
   assign,
   boil,
   callable,
   camel,
   capitalize,
+  castArray,
+  castArrayIfExists,
+  castComparator,
+  castMapping,
   chain,
+  clamp,
   clone,
+  cloneDeep,
   cluster,
   compose,
   construct,
@@ -1458,6 +1753,7 @@ function isSymbol(value) {
   intersects,
   invert,
   isArray,
+  isBoolean,
   isDate,
   isEmpty,
   isEqual,
@@ -1465,16 +1761,24 @@ function isSymbol(value) {
   isFunction,
   isInt,
   isIntString,
+  isIterable,
+  isMap,
   isNumber,
   isObject,
   isPlainObject,
   isPrimitive,
   isPromise,
+  isRegExp,
+  isSet,
   isString,
   isSymbol,
+  isTagged,
+  isWeakMap,
+  isWeakSet,
   iterate,
   keys,
   last,
+  lerp,
   list,
   listify,
   lowerize,
@@ -1487,8 +1791,10 @@ function isSymbol(value) {
   memo,
   merge,
   min,
+  noop,
   objectify,
   omit,
+  once,
   parallel,
   partial,
   partob,
@@ -1520,6 +1826,7 @@ function isSymbol(value) {
   toFloat,
   toInt,
   toggle,
+  traverse,
   trim,
   try: null,
   tryit,