radashi 12.2.0-beta.6bdfb09 → 12.2.0-beta.7fb6e89

package/dist/radashi.cjs

@@ -1,129 +1,4 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/mod.ts
-var mod_exports = {};
-__export(mod_exports, {
-  AggregateError: () => AggregateError,
-  all: () => all,
-  alphabetical: () => alphabetical,
-  assign: () => assign,
-  boil: () => boil,
-  callable: () => callable,
-  camel: () => camel,
-  capitalize: () => capitalize,
-  chain: () => chain,
-  clone: () => clone,
-  cluster: () => cluster,
-  compose: () => compose,
-  construct: () => construct,
-  counting: () => counting,
-  crush: () => crush,
-  dash: () => dash,
-  debounce: () => debounce,
-  defer: () => defer,
-  diff: () => diff,
-  draw: () => draw,
-  filterKey: () => filterKey,
-  first: () => first,
-  flat: () => flat,
-  fork: () => fork,
-  get: () => get,
-  group: () => group,
-  guard: () => guard,
-  inRange: () => inRange,
-  intersects: () => intersects,
-  invert: () => invert,
-  isArray: () => isArray,
-  isDate: () => isDate,
-  isEmpty: () => isEmpty,
-  isEqual: () => isEqual,
-  isFloat: () => isFloat,
-  isFunction: () => isFunction,
-  isInt: () => isInt,
-  isIntString: () => isIntString,
-  isNumber: () => isNumber,
-  isObject: () => isObject,
-  isPlainObject: () => isPlainObject,
-  isPrimitive: () => isPrimitive,
-  isPromise: () => isPromise,
-  isString: () => isString,
-  isSymbol: () => isSymbol,
-  iterate: () => iterate,
-  keys: () => keys,
-  last: () => last,
-  list: () => list,
-  listify: () => listify,
-  lowerize: () => lowerize,
-  map: () => map,
-  mapEntries: () => mapEntries,
-  mapKeys: () => mapKeys,
-  mapValues: () => mapValues,
-  mapify: () => mapify,
-  max: () => max,
-  memo: () => memo,
-  merge: () => merge,
-  min: () => min,
-  objectify: () => objectify,
-  omit: () => omit,
-  parallel: () => parallel,
-  partial: () => partial,
-  partob: () => partob,
-  pascal: () => pascal,
-  pick: () => pick,
-  proxied: () => proxied,
-  random: () => random,
-  range: () => range,
-  reduce: () => reduce,
-  replace: () => replace,
-  replaceOrAppend: () => replaceOrAppend,
-  retry: () => retry,
-  round: () => round,
-  select: () => select,
-  selectFirst: () => selectFirst,
-  series: () => series,
-  set: () => set,
-  shake: () => shake,
-  shift: () => shift,
-  shuffle: () => shuffle,
-  sift: () => sift,
-  sleep: () => sleep,
-  snake: () => snake,
-  sort: () => sort,
-  sum: () => sum,
-  template: () => template,
-  throttle: () => throttle,
-  title: () => title,
-  toFloat: () => toFloat,
-  toInt: () => toInt,
-  toggle: () => toggle,
-  trim: () => trim,
-  try: () => tryit,
-  tryit: () => tryit,
-  uid: () => uid,
-  unique: () => unique,
-  unzip: () => unzip,
-  upperize: () => upperize,
-  zip: () => zip,
-  zipToObject: () => zipToObject
-});
-module.exports = __toCommonJS(mod_exports);
+'use strict';
 
 // src/array/alphabetical.ts
 function alphabetical(array, getter, direction = "asc") {
@@ -143,6 +18,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 = [];
@@ -262,20 +147,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) {
@@ -297,15 +173,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(
@@ -317,19 +184,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) {
@@ -402,11 +256,11 @@ function selectFirst(array, mapper, condition) {
 // src/array/shift.ts
 function shift(arr, n) {
   if (arr.length === 0) {
-    return arr;
+    return [...arr];
   }
   const shiftNumber = n % arr.length;
   if (shiftNumber === 0) {
-    return arr;
+    return [...arr];
   }
   return [...arr.slice(-shiftNumber, arr.length), ...arr.slice(0, -shiftNumber)];
 }
@@ -426,32 +280,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
@@ -507,18 +349,21 @@ function zipToObject(keys2, values) {
 }
 
 // src/async/AggregateError.ts
-var AggregateError = class extends Error {
-  errors;
-  constructor(errors = []) {
-    var _a, _b;
-    super();
-    const name = ((_a = errors.find((e) => e.name)) == null ? void 0 : _a.name) ?? "";
-    this.name = `AggregateError(${name}...)`;
-    this.message = `AggregateError with ${errors.length} errors`;
-    this.stack = ((_b = errors.find((e) => e.stack)) == null ? void 0 : _b.stack) ?? this.stack;
-    this.errors = errors;
+var AggregateErrorOrPolyfill = /* @__PURE__ */ (() => (
+  // eslint-disable-next-line compat/compat
+  globalThis.AggregateError ?? class AggregateError extends Error {
+    errors;
+    constructor(errors = []) {
+      var _a, _b;
+      super();
+      const name = ((_a = errors.find((e) => e.name)) == null ? void 0 : _a.name) ?? "";
+      this.name = `AggregateError(${name}...)`;
+      this.message = `AggregateError with ${errors.length} errors`;
+      this.stack = ((_b = errors.find((e) => e.stack)) == null ? void 0 : _b.stack) ?? this.stack;
+      this.errors = errors;
+    }
   }
-};
+))();
 
 // src/async/all.ts
 async function all(promises) {
@@ -530,7 +375,7 @@ async function all(promises) {
   );
   const exceptions = results.filter((r) => r.exc);
   if (exceptions.length > 0) {
-    throw new AggregateError(exceptions.map((e) => e.exc));
+    throw new AggregateErrorOrPolyfill(exceptions.map((e) => e.exc));
   }
   if (isArray(promises)) {
     return results.map((r) => r.result);
@@ -622,7 +467,7 @@ async function parallel(limit, array, func) {
     (x) => !!x.error
   );
   if (errors.length > 0) {
-    throw new AggregateError(errors.map((error) => error.error));
+    throw new AggregateErrorOrPolyfill(errors.map((error) => error.error));
   }
   return results.map((r) => r.result);
 }
@@ -657,7 +502,7 @@ async function retry(options, func) {
     if (err._exited) {
       throw err._exited;
     }
-    if (++i === times) {
+    if (++i >= times) {
       throw err;
     }
     if (delay) {
@@ -694,7 +539,6 @@ function callable(obj, fn) {
   return new Proxy(Object.assign(fn.bind(null), obj), {
     get: (target, key) => target[key],
     set: (target, key, value) => {
-      ;
       target[key] = value;
       return true;
     },
@@ -739,6 +583,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) {
@@ -764,6 +613,25 @@ function memo(func, options = {}) {
   return memoize({}, func, options.key ?? null, options.ttl ?? null);
 }
 
+// src/curry/once.ts
+var onceSymbol = /* @__PURE__ */ Symbol();
+var once = /* @__PURE__ */ (() => {
+  const once2 = (fn) => {
+    const onceFn = function(...args) {
+      if (onceFn[onceSymbol] === onceSymbol) {
+        onceFn[onceSymbol] = fn.apply(this, args);
+      }
+      return onceFn[onceSymbol];
+    };
+    onceFn[onceSymbol] = onceSymbol;
+    return onceFn;
+  };
+  once2.reset = (fn) => {
+    fn[onceSymbol] = onceSymbol;
+  };
+  return once2;
+})();
+
 // src/curry/partial.ts
 function partial(fn, ...args) {
   return (...rest) => fn(...[...args, ...rest]);
@@ -785,26 +653,70 @@ function proxied(handler) {
 }
 
 // src/curry/throttle.ts
-function throttle({ interval }, func) {
-  let ready = true;
-  let timer = void 0;
+function throttle({ interval, trailing }, func) {
+  let timer;
+  let lastCalled = 0;
+  let trailingArgs;
   const throttled = (...args) => {
-    if (!ready) {
-      return;
+    if (!isThrottled()) {
+      trigger(...args);
+    } else if (trailing) {
+      trailingArgs = args;
     }
-    func(...args);
-    ready = false;
-    timer = setTimeout(() => {
-      ready = true;
-      timer = void 0;
-    }, interval);
   };
-  throttled.isThrottled = () => {
-    return timer !== void 0;
+  const isThrottled = () => Date.now() - lastCalled < interval;
+  throttled.isThrottled = isThrottled;
+  const trigger = throttled.trigger = (...args) => {
+    func(...args);
+    lastCalled = Date.now();
+    if (trailing) {
+      trailingArgs = void 0;
+      clearTimeout(timer);
+      timer = setTimeout(
+        () => trailingArgs && trigger(...trailingArgs),
+        interval
+      );
+    }
   };
   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");
@@ -818,6 +730,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) {
@@ -829,6 +777,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);
@@ -848,10 +801,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;
 }
@@ -872,6 +823,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) {
@@ -887,11 +905,16 @@ function crush(value) {
   if (!value) {
     return {};
   }
-  return objectify(
-    keys(value),
-    (k) => k,
-    (k) => get(value, k)
-  );
+  return function crushReducer(crushed, value2, path) {
+    if (isObject(value2) || isArray(value2)) {
+      for (const [prop, propValue] of Object.entries(value2)) {
+        crushReducer(crushed, propValue, path ? `${path}.${prop}` : prop);
+      }
+    } else {
+      crushed[path] = value2;
+    }
+    return crushed;
+  }({}, value, "");
 }
 
 // src/object/filterKey.ts
@@ -1042,19 +1065,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
@@ -1090,6 +1116,103 @@ 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());
@@ -1111,8 +1234,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
@@ -1230,6 +1360,54 @@ function pascal(str) {
   return parts.map((str2) => str2.charAt(0).toUpperCase() + str2.slice(1)).join("");
 }
 
+// src/string/similarity.ts
+function similarity(str1, str2) {
+  if (str1 === str2) {
+    return 0;
+  }
+  let start = 0;
+  let end1 = str1.length - 1;
+  let end2 = str2.length - 1;
+  while (start <= end1 && start <= end2 && str1[start] === str2[start]) {
+    start++;
+  }
+  while (end1 >= start && end2 >= start && str1[end1] === str2[end2]) {
+    end1--;
+    end2--;
+  }
+  const length1 = end1 - start + 1;
+  const length2 = end2 - start + 1;
+  if (length1 === 0) {
+    return length2;
+  }
+  if (length2 === 0) {
+    return length1;
+  }
+  const numRows = length1 + 1;
+  const numColumns = length2 + 1;
+  const distances = new Array(numRows * numColumns).fill(0);
+  for (let x = 1; x < numColumns; x++) {
+    distances[x] = x;
+  }
+  for (let y = 1; y < numRows; y++) {
+    distances[y * numColumns] = y;
+  }
+  for (let x = 1; x < numColumns; x++) {
+    for (let y = 1; y < numRows; y++) {
+      const i = y * numColumns + x;
+      distances[i] = Math.min(
+        // Cost of a deletion.
+        distances[i - numColumns] + 1,
+        // Cost of an insertion.
+        distances[i - 1] + 1,
+        // Cost of a substitution.
+        distances[i - numColumns - 1] + (str1[start + y - 1] === str2[start + x - 1] ? 0 : 1)
+      );
+    }
+  }
+  return distances[length1 * numColumns + length2];
+}
+
 // src/string/snake.ts
 function snake(str, options) {
   const parts = (str == null ? void 0 : str.replace(/([A-Z])+/g, capitalize).split(/(?=[A-Z])|[\.\-\s_]/).map((x) => x.toLowerCase())) ?? [];
@@ -1276,11 +1454,16 @@ function trim(str, charsToTrim = " ") {
 }
 
 // src/typed/isArray.ts
-var isArray = Array.isArray;
+var isArray = /* @__PURE__ */ (() => 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
@@ -1356,9 +1539,7 @@ function isFunction(value) {
 }
 
 // src/typed/isInt.ts
-function isInt(value) {
-  return isNumber(value) && value % 1 === 0;
-}
+var isInt = /* @__PURE__ */ (() => Number.isInteger)();
 
 // src/typed/isIntString.ts
 function isIntString(value) {
@@ -1369,18 +1550,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
@@ -1389,7 +1576,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
@@ -1402,117 +1594,163 @@ 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";
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AggregateError,
-  all,
-  alphabetical,
-  assign,
-  boil,
-  callable,
-  camel,
-  capitalize,
-  chain,
-  clone,
-  cluster,
-  compose,
-  construct,
-  counting,
-  crush,
-  dash,
-  debounce,
-  defer,
-  diff,
-  draw,
-  filterKey,
-  first,
-  flat,
-  fork,
-  get,
-  group,
-  guard,
-  inRange,
-  intersects,
-  invert,
-  isArray,
-  isDate,
-  isEmpty,
-  isEqual,
-  isFloat,
-  isFunction,
-  isInt,
-  isIntString,
-  isNumber,
-  isObject,
-  isPlainObject,
-  isPrimitive,
-  isPromise,
-  isString,
-  isSymbol,
-  iterate,
-  keys,
-  last,
-  list,
-  listify,
-  lowerize,
-  map,
-  mapEntries,
-  mapKeys,
-  mapValues,
-  mapify,
-  max,
-  memo,
-  merge,
-  min,
-  objectify,
-  omit,
-  parallel,
-  partial,
-  partob,
-  pascal,
-  pick,
-  proxied,
-  random,
-  range,
-  reduce,
-  replace,
-  replaceOrAppend,
-  retry,
-  round,
-  select,
-  selectFirst,
-  series,
-  set,
-  shake,
-  shift,
-  shuffle,
-  sift,
-  sleep,
-  snake,
-  sort,
-  sum,
-  template,
-  throttle,
-  title,
-  toFloat,
-  toInt,
-  toggle,
-  trim,
-  try: null,
-  tryit,
-  uid,
-  unique,
-  unzip,
-  upperize,
-  zip,
-  zipToObject
-});
+
+// 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]");
+}
+
+exports.AggregateError = AggregateErrorOrPolyfill;
+exports.DefaultCloningStrategy = DefaultCloningStrategy;
+exports.FastCloningStrategy = FastCloningStrategy;
+exports.all = all;
+exports.alphabetical = alphabetical;
+exports.always = always;
+exports.assign = assign;
+exports.boil = boil;
+exports.callable = callable;
+exports.camel = camel;
+exports.capitalize = capitalize;
+exports.castArray = castArray;
+exports.castArrayIfExists = castArrayIfExists;
+exports.castComparator = castComparator;
+exports.castMapping = castMapping;
+exports.chain = chain;
+exports.clamp = clamp;
+exports.clone = clone;
+exports.cloneDeep = cloneDeep;
+exports.cluster = cluster;
+exports.compose = compose;
+exports.construct = construct;
+exports.counting = counting;
+exports.crush = crush;
+exports.dash = dash;
+exports.debounce = debounce;
+exports.defer = defer;
+exports.diff = diff;
+exports.draw = draw;
+exports.filterKey = filterKey;
+exports.first = first;
+exports.flat = flat;
+exports.flip = flip;
+exports.fork = fork;
+exports.get = get;
+exports.group = group;
+exports.guard = guard;
+exports.inRange = inRange;
+exports.intersects = intersects;
+exports.invert = invert;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isEqual = isEqual;
+exports.isFloat = isFloat;
+exports.isFunction = isFunction;
+exports.isInt = isInt;
+exports.isIntString = isIntString;
+exports.isIterable = isIterable;
+exports.isMap = isMap;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTagged = isTagged;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;
+exports.iterate = iterate;
+exports.keys = keys;
+exports.last = last;
+exports.lerp = lerp;
+exports.list = list;
+exports.listify = listify;
+exports.lowerize = lowerize;
+exports.map = map;
+exports.mapEntries = mapEntries;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.mapify = mapify;
+exports.max = max;
+exports.memo = memo;
+exports.merge = merge;
+exports.min = min;
+exports.noop = noop;
+exports.objectify = objectify;
+exports.omit = omit;
+exports.once = once;
+exports.parallel = parallel;
+exports.partial = partial;
+exports.partob = partob;
+exports.pascal = pascal;
+exports.pick = pick;
+exports.proxied = proxied;
+exports.random = random;
+exports.range = range;
+exports.reduce = reduce;
+exports.replace = replace;
+exports.replaceOrAppend = replaceOrAppend;
+exports.retry = retry;
+exports.round = round;
+exports.select = select;
+exports.selectFirst = selectFirst;
+exports.series = series;
+exports.set = set;
+exports.shake = shake;
+exports.shift = shift;
+exports.shuffle = shuffle;
+exports.sift = sift;
+exports.similarity = similarity;
+exports.sleep = sleep;
+exports.snake = snake;
+exports.sort = sort;
+exports.sum = sum;
+exports.template = template;
+exports.throttle = throttle;
+exports.title = title;
+exports.toFloat = toFloat;
+exports.toInt = toInt;
+exports.toggle = toggle;
+exports.traverse = traverse;
+exports.trim = trim;
+exports.try = tryit;
+exports.tryit = tryit;
+exports.uid = uid;
+exports.unique = unique;
+exports.unzip = unzip;
+exports.upperize = upperize;
+exports.zip = zip;
+exports.zipToObject = zipToObject;