radashi 12.2.0-beta.cd4d01e → 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,
@@ -43,6 +52,7 @@ __export(mod_exports, {
   filterKey: () => filterKey,
   first: () => first,
   flat: () => flat,
+  flip: () => flip,
   fork: () => fork,
   get: () => get,
   group: () => group,
@@ -51,6 +61,7 @@ __export(mod_exports, {
   intersects: () => intersects,
   invert: () => invert,
   isArray: () => isArray,
+  isBoolean: () => isBoolean,
   isDate: () => isDate,
   isEmpty: () => isEmpty,
   isEqual: () => isEqual,
@@ -58,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,
@@ -75,12 +94,15 @@ __export(mod_exports, {
   mapEntries: () => mapEntries,
   mapKeys: () => mapKeys,
   mapValues: () => mapValues,
+  mapify: () => mapify,
   max: () => max,
   memo: () => memo,
   merge: () => merge,
   min: () => min,
+  noop: () => noop,
   objectify: () => objectify,
   omit: () => omit,
+  once: () => once,
   parallel: () => parallel,
   partial: () => partial,
   partob: () => partob,
@@ -93,7 +115,9 @@ __export(mod_exports, {
   replace: () => replace,
   replaceOrAppend: () => replaceOrAppend,
   retry: () => retry,
+  round: () => round,
   select: () => select,
+  selectFirst: () => selectFirst,
   series: () => series,
   set: () => set,
   shake: () => shake,
@@ -110,11 +134,13 @@ __export(mod_exports, {
   toFloat: () => toFloat,
   toInt: () => toInt,
   toggle: () => toggle,
+  traverse: () => traverse,
   trim: () => trim,
   try: () => tryit,
   tryit: () => tryit,
   uid: () => uid,
   unique: () => unique,
+  unzip: () => unzip,
   upperize: () => upperize,
   zip: () => zip,
   zipToObject: () => zipToObject
@@ -122,13 +148,13 @@ __export(mod_exports, {
 module.exports = __toCommonJS(mod_exports);
 
 // src/array/alphabetical.ts
-function alphabetical(array, getter, dir = "asc") {
+function alphabetical(array, getter, direction = "asc") {
   if (!array) {
     return [];
   }
   const asc = (a, b) => `${getter(a)}`.localeCompare(getter(b));
   const dsc = (a, b) => `${getter(b)}`.localeCompare(getter(a));
-  return array.slice().sort(dir === "desc" ? dsc : asc);
+  return array.slice().sort(direction === "desc" ? dsc : asc);
 }
 
 // src/array/boil.ts
@@ -139,12 +165,23 @@ 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(list2, size = 2) {
-  const clusterCount = Math.ceil(list2.length / size);
-  return new Array(clusterCount).fill(null).map((_c, i) => {
-    return list2.slice(i * size, i * size + size);
-  });
+function cluster(array, size = 2) {
+  const clusters = [];
+  for (let i = 0; i < array.length; i += size) {
+    clusters.push(array.slice(i, i + size));
+  }
+  return clusters;
 }
 
 // src/array/counting.ts
@@ -152,11 +189,14 @@ function counting(array, identity) {
   if (!array) {
     return {};
   }
-  return array.reduce((acc, item) => {
-    const id = identity(item);
-    acc[id] = (acc[id] ?? 0) + 1;
-    return acc;
-  }, {});
+  return array.reduce(
+    (acc, item) => {
+      const id = identity(item);
+      acc[id] = (acc[id] ?? 0) + 1;
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/array/diff.ts
@@ -170,10 +210,13 @@ function diff(root, other, identity = (t) => t) {
   if (!(other == null ? void 0 : other.length)) {
     return [...root];
   }
-  const bKeys = other.reduce((acc, item) => {
-    acc[identity(item)] = true;
-    return acc;
-  }, {});
+  const bKeys = other.reduce(
+    (acc, item) => {
+      acc[identity(item)] = true;
+      return acc;
+    },
+    {}
+  );
   return root.filter((a) => !bKeys[identity(a)]);
 }
 
@@ -203,14 +246,17 @@ function fork(array, condition) {
 
 // src/array/group.ts
 function group(array, getGroupId) {
-  return array.reduce((acc, item) => {
-    const groupId = getGroupId(item);
-    if (!acc[groupId]) {
-      acc[groupId] = [];
-    }
-    acc[groupId].push(item);
-    return acc;
-  }, {});
+  return array.reduce(
+    (acc, item) => {
+      const groupId = getGroupId(item);
+      if (!acc[groupId]) {
+        acc[groupId] = [];
+      }
+      acc[groupId].push(item);
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/array/intersects.ts
@@ -244,107 +290,85 @@ function list(startOrLength, end, valueOrMapper, step) {
   return Array.from(range(startOrLength, end, valueOrMapper, step));
 }
 
-// src/array/max.ts
-function max(array, getter) {
-  const get2 = getter ?? ((v) => v);
-  return boil(array, (a, b) => get2(a) > get2(b) ? a : b);
+// src/array/mapify.ts
+function mapify(array, getKey, getValue = (item) => item) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const item of array) {
+    map2.set(getKey(item, map2.size), getValue(item, map2.size));
+  }
+  return map2;
 }
 
 // src/array/merge.ts
-function merge(root, others, matcher) {
-  if (!others && !root) {
+function merge(prev, array, toKey) {
+  if (!array && !prev) {
     return [];
   }
-  if (!others) {
-    return [...root];
+  if (!array) {
+    return [...prev];
   }
-  if (!root) {
+  if (!prev) {
     return [];
   }
-  if (!matcher) {
-    return [...root];
+  if (!toKey) {
+    return [...prev];
   }
-  return root.reduce((acc, r) => {
-    const matched = others.find((o) => matcher(r) === matcher(o));
-    if (matched) {
-      acc.push(matched);
-    } else {
-      acc.push(r);
-    }
-    return acc;
-  }, []);
-}
-
-// src/array/min.ts
-function min(array, getter) {
-  const get2 = getter ?? ((v) => v);
-  return boil(array, (a, b) => get2(a) < get2(b) ? a : b);
+  const keys2 = array.map(toKey);
+  return prev.map((prevItem) => {
+    const index = keys2.indexOf(toKey(prevItem));
+    return index > -1 ? array[index] : prevItem;
+  });
 }
 
 // src/array/objectify.ts
 function objectify(array, getKey, getValue = (item) => item) {
-  return array.reduce((acc, item) => {
-    acc[getKey(item)] = getValue(item);
-    return acc;
-  }, {});
-}
-
-// 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;
-    }
-  }
+  return array.reduce(
+    (acc, item) => {
+      acc[getKey(item)] = getValue(item);
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/array/replace.ts
-function replace(list2, newItem, match) {
-  if (!list2) {
+function replace(array, newItem, match) {
+  if (!array) {
     return [];
   }
   if (newItem === void 0) {
-    return [...list2];
-  }
-  for (let idx = 0; idx < list2.length; idx++) {
-    const item = list2[idx];
-    if (match(item, idx)) {
-      return [
-        ...list2.slice(0, idx),
-        newItem,
-        ...list2.slice(idx + 1, list2.length)
-      ];
+    return [...array];
+  }
+  const out = array.slice();
+  for (let index = 0; index < array.length; index++) {
+    if (match(array[index], index)) {
+      out[index] = newItem;
+      break;
     }
   }
-  return [...list2];
+  return out;
 }
 
 // src/array/replaceOrAppend.ts
-function replaceOrAppend(list2, newItem, match) {
-  if (!list2 && !newItem) {
+function replaceOrAppend(array, newItem, match) {
+  if (!array && !newItem) {
     return [];
   }
   if (!newItem) {
-    return [...list2];
+    return [...array];
   }
-  if (!list2) {
+  if (!array) {
     return [newItem];
   }
-  for (let idx = 0; idx < list2.length; idx++) {
-    const item = list2[idx];
-    if (match(item, idx)) {
-      return [
-        ...list2.slice(0, idx),
-        newItem,
-        ...list2.slice(idx + 1, list2.length)
-      ];
+  const out = array.slice();
+  for (let index = 0; index < array.length; index++) {
+    if (match(array[index], index)) {
+      out[index] = newItem;
+      return out;
     }
   }
-  return [...list2, newItem];
+  out.push(newItem);
+  return out;
 }
 
 // src/array/select.ts
@@ -363,6 +387,19 @@ function select(array, mapper, condition) {
   }, []);
 }
 
+// src/array/selectFirst.ts
+function selectFirst(array, mapper, condition) {
+  if (!array) {
+    return void 0;
+  }
+  let foundIndex = -1;
+  const found = array.find((item, index) => {
+    foundIndex = index;
+    return condition ? condition(item, index) : mapper(item, index) != null;
+  });
+  return found === void 0 ? void 0 : mapper(found, foundIndex);
+}
+
 // src/array/shift.ts
 function shift(arr, n) {
   if (arr.length === 0) {
@@ -376,8 +413,8 @@ function shift(arr, n) {
 }
 
 // src/array/sift.ts
-function sift(list2) {
-  return (list2 == null ? void 0 : list2.filter((x) => !!x)) ?? [];
+function sift(array) {
+  return (array == null ? void 0 : array.filter((x) => !!x)) ?? [];
 }
 
 // src/array/sort.ts
@@ -390,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(list2, item, toKey, options) {
-  if (!list2 && !item) {
-    return [];
-  }
-  if (!list2) {
-    return [item];
+function toggle(array, item, toKey, options) {
+  if (!array) {
+    return item !== void 0 ? [item] : [];
   }
-  if (!item) {
-    return [...list2];
+  if (item === void 0) {
+    return [...array];
   }
   const matcher = toKey ? (x, idx) => toKey(x, idx) === toKey(item, idx) : (x) => x === item;
-  const existing = list2.find(matcher);
-  if (existing) {
-    return list2.filter((x, idx) => !matcher(x, idx));
-  }
-  const strategy = (options == null ? void 0 : options.strategy) ?? "append";
-  if (strategy === "append") {
-    return [...list2, item];
+  const existing = array.find(matcher);
+  if (existing !== void 0) {
+    return array.filter((x, idx) => !matcher(x, idx));
   }
-  return [item, ...list2];
+  return (options == null ? void 0 : options.strategy) === "prepend" ? [item, ...array] : [...array, item];
 }
 
 // src/array/unique.ts
@@ -434,12 +459,25 @@ function unique(array, toKey) {
   return [...new Set(array)];
 }
 
-// src/array/zip.ts
-function zip(...arrays) {
+// src/array/unzip.ts
+function unzip(arrays) {
   if (!arrays || !arrays.length) {
     return [];
   }
-  return new Array(Math.max(...arrays.map(({ length }) => length))).fill([]).map((_, idx) => arrays.map((array) => array[idx]));
+  const out = new Array(
+    arrays.reduce((max2, arr) => Math.max(max2, arr.length), 0)
+  );
+  let index = 0;
+  const get2 = (array) => array[index];
+  for (; index < out.length; index++) {
+    out[index] = Array.from(arrays, get2);
+  }
+  return out;
+}
+
+// src/array/zip.ts
+function zip(...arrays) {
+  return unzip(arrays);
 }
 
 // src/array/zipToObject.ts
@@ -448,10 +486,13 @@ function zipToObject(keys2, values) {
     return {};
   }
   const getValue = isFunction(values) ? values : isArray(values) ? (_k, i) => values[i] : (_k, _i) => values;
-  return keys2.reduce((acc, key, idx) => {
-    acc[key] = getValue(key, idx);
-    return acc;
-  }, {});
+  return keys2.reduce(
+    (acc, key, idx) => {
+      acc[key] = getValue(key, idx);
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/async/AggregateError.ts
@@ -483,10 +524,13 @@ async function all(promises) {
   if (isArray(promises)) {
     return results.map((r) => r.result);
   }
-  return results.reduce((acc, item) => {
-    acc[item.key] = item.result;
-    return acc;
-  }, {});
+  return results.reduce(
+    (acc, item) => {
+      acc[item.key] = item.result;
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/async/defer.ts
@@ -602,7 +646,7 @@ async function retry(options, func) {
     if (err._exited) {
       throw err._exited;
     }
-    if (++i === times) {
+    if (++i >= times) {
       throw err;
     }
     if (delay) {
@@ -684,6 +728,11 @@ function debounce({ delay }, func) {
   return debounced;
 }
 
+// src/curry/flip.ts
+function flip(fn) {
+  return (arg2, arg1, ...args) => fn(arg1, arg2, ...args);
+}
+
 // src/curry/memo.ts
 function memoize(cache, func, keyFunc, ttl) {
   return function callWithMemo(...args) {
@@ -709,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]);
@@ -716,10 +781,7 @@ function partial(fn, ...args) {
 
 // src/curry/partob.ts
 function partob(fn, argobj) {
-  return (restobj) => fn({
-    ...argobj,
-    ...restobj
-  });
+  return (restobj) => fn({ ...argobj, ...restobj });
 }
 
 // src/curry/proxied.ts
@@ -753,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");
@@ -766,24 +864,68 @@ 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) {
+    const p = precision > 0 ? Math.min(precision, 292) : Math.max(precision, -323);
+    let [q, e] = `${value}e`.split("e");
+    [q, e] = `${toInteger(+`${q}e${+e + p}`)}e`.split("e");
+    return +`${q}e${+e - p}`;
+  }
+  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 def = defaultValue === void 0 ? 0 : defaultValue;
-  if (value === null || value === void 0) {
-    return def;
-  }
-  const result = Number.parseFloat(value);
-  return Number.isNaN(result) ? def : result;
+  const parsedValue = isSymbol(value) ? Number.NaN : Number.parseFloat(value);
+  return Number.isNaN(parsedValue) ? defaultValue !== void 0 ? defaultValue : 0 : parsedValue;
 }
 
 // src/number/toInt.ts
 function toInt(value, defaultValue) {
-  const def = defaultValue === void 0 ? 0 : defaultValue;
-  if (value === null || value === void 0) {
-    return def;
-  }
-  const result = Number.parseInt(value);
-  return Number.isNaN(result) ? def : result;
+  const parsedValue = isSymbol(value) ? Number.NaN : Number.parseInt(value);
+  return Number.isNaN(parsedValue) ? defaultValue !== void 0 ? defaultValue : 0 : parsedValue;
 }
 
 // src/object/assign.ts
@@ -793,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;
 }
@@ -817,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) {
@@ -873,10 +1080,13 @@ function invert(obj) {
     return {};
   }
   const keys2 = Object.keys(obj);
-  return keys2.reduce((acc, key) => {
-    acc[obj[key]] = key;
-    return acc;
-  }, {});
+  return keys2.reduce(
+    (acc, key) => {
+      acc[obj[key]] = key;
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/object/keys.ts
@@ -932,29 +1142,38 @@ function mapEntries(obj, toEntry) {
   if (!obj) {
     return {};
   }
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const [newKey, newValue] = toEntry(key, value);
-    acc[newKey] = newValue;
-    return acc;
-  }, {});
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      const [newKey, newValue] = toEntry(key, value);
+      acc[newKey] = newValue;
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/object/mapKeys.ts
 function mapKeys(obj, mapFunc) {
   const keys2 = Object.keys(obj);
-  return keys2.reduce((acc, key) => {
-    acc[mapFunc(key, obj[key])] = obj[key];
-    return acc;
-  }, {});
+  return keys2.reduce(
+    (acc, key) => {
+      acc[mapFunc(key, obj[key])] = obj[key];
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/object/mapValues.ts
 function mapValues(obj, mapFunc) {
   const keys2 = Object.keys(obj);
-  return keys2.reduce((acc, key) => {
-    acc[key] = mapFunc(obj[key], key);
-    return acc;
-  }, {});
+  return keys2.reduce(
+    (acc, key) => {
+      acc[key] = mapFunc(obj[key], key);
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/object/omit.ts
@@ -975,12 +1194,18 @@ function omit(obj, keys2) {
 }
 
 // src/object/pick.ts
-function pick(obj, keys2) {
+function pick(obj, filter) {
   if (!obj) {
     return {};
   }
+  let keys2 = filter;
+  if (isArray(filter)) {
+    filter = null;
+  } else {
+    keys2 = Reflect.ownKeys(obj);
+  }
   return keys2.reduce((acc, key) => {
-    if (Object.hasOwnProperty.call(obj, key)) {
+    if (filterKey(obj, key, filter)) {
       acc[key] = obj[key];
     }
     return acc;
@@ -1020,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());
@@ -1041,8 +1364,15 @@ function random(min2, max2) {
 }
 
 // src/random/shuffle.ts
-function shuffle(array) {
-  return array.map((a) => ({ rand: Math.random(), value: a })).sort((a, b) => a.rand - b.rand).map((a) => a.value);
+function shuffle(array, random2 = random) {
+  const newArray = array.slice();
+  for (let idx = 0, randomIdx, item; idx < array.length; idx++) {
+    randomIdx = random2(0, array.length - 1);
+    item = newArray[randomIdx];
+    newArray[randomIdx] = newArray[idx];
+    newArray[idx] = item;
+  }
+  return newArray;
 }
 
 // src/random/uid.ts
@@ -1059,22 +1389,13 @@ function uid(length, specials = "") {
 
 // src/series/series.ts
 var series = (items, toKey = (item) => `${item}`) => {
-  const { indexesByKey, itemsByIndex } = items.reduce(
-    (acc, item, idx) => ({
-      indexesByKey: {
-        ...acc.indexesByKey,
-        [toKey(item)]: idx
-      },
-      itemsByIndex: {
-        ...acc.itemsByIndex,
-        [idx]: item
-      }
-    }),
-    {
-      indexesByKey: {},
-      itemsByIndex: {}
-    }
-  );
+  const indexesByKey = {};
+  const itemsByIndex = {};
+  for (const idx of range(items.length - 1)) {
+    const item = items[idx];
+    indexesByKey[toKey(item)] = idx;
+    itemsByIndex[idx] = item;
+  }
   const first2 = () => itemsByIndex[0];
   const last2 = () => itemsByIndex[items.length - 1];
   const next = (current, defaultValue) => itemsByIndex[indexesByKey[toKey(current)] + 1] ?? defaultValue ?? first2();
@@ -1186,9 +1507,14 @@ function snake(str, options) {
 
 // src/string/template.ts
 function template(str, data, regex = /\{\{(.+?)\}\}/g) {
-  return Array.from(str.matchAll(regex)).reduce((acc, match) => {
-    return acc.replace(match[0], data[match[1]]);
-  }, str);
+  let result = "";
+  let from = 0;
+  let match;
+  while (match = regex.exec(str)) {
+    result += str.slice(from, match.index) + data[match[1]];
+    from = regex.lastIndex;
+  }
+  return result + str.slice(from);
 }
 
 // src/string/title.ts
@@ -1212,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
@@ -1290,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) {
@@ -1303,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
@@ -1323,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
@@ -1336,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 !!value && value.constructor === Symbol;
+  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,
@@ -1370,6 +1744,7 @@ function isSymbol(value) {
   filterKey,
   first,
   flat,
+  flip,
   fork,
   get,
   group,
@@ -1378,6 +1753,7 @@ function isSymbol(value) {
   intersects,
   invert,
   isArray,
+  isBoolean,
   isDate,
   isEmpty,
   isEqual,
@@ -1385,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,
@@ -1402,12 +1786,15 @@ function isSymbol(value) {
   mapEntries,
   mapKeys,
   mapValues,
+  mapify,
   max,
   memo,
   merge,
   min,
+  noop,
   objectify,
   omit,
+  once,
   parallel,
   partial,
   partob,
@@ -1420,7 +1807,9 @@ function isSymbol(value) {
   replace,
   replaceOrAppend,
   retry,
+  round,
   select,
+  selectFirst,
   series,
   set,
   shake,
@@ -1437,11 +1826,13 @@ function isSymbol(value) {
   toFloat,
   toInt,
   toggle,
+  traverse,
   trim,
   try: null,
   tryit,
   uid,
   unique,
+  unzip,
   upperize,
   zip,
   zipToObject