radashi 12.1.0-pr11.e33bd36

package/dist/index.cjs

@@ -0,0 +1,1254 @@
+"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/index.ts
+var src_exports = {};
+__export(src_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,
+  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,
+  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,
+  select: () => select,
+  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,
+  upperize: () => upperize,
+  zip: () => zip,
+  zipToObject: () => zipToObject
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/array/alphabetical.ts
+var alphabetical = (array, getter, dir = "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);
+};
+
+// src/array/boil.ts
+var boil = (array, compareFunc) => {
+  if (!array || (array.length ?? 0) === 0) return null;
+  return array.reduce(compareFunc);
+};
+
+// src/array/cluster.ts
+var 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);
+  });
+};
+
+// src/array/counting.ts
+var counting = (list2, identity) => {
+  if (!list2) return {};
+  return list2.reduce((acc, item) => {
+    const id = identity(item);
+    acc[id] = (acc[id] ?? 0) + 1;
+    return acc;
+  }, {});
+};
+
+// src/array/diff.ts
+var diff = (root, other, identity = (t) => t) => {
+  if (!(root == null ? void 0 : root.length) && !(other == null ? void 0 : other.length)) return [];
+  if ((root == null ? void 0 : root.length) === void 0) return [...other];
+  if (!(other == null ? void 0 : other.length)) return [...root];
+  const bKeys = other.reduce((acc, item) => {
+    acc[identity(item)] = true;
+    return acc;
+  }, {});
+  return root.filter((a) => !bKeys[identity(a)]);
+};
+
+// src/array/first.ts
+var first = (array, defaultValue = void 0) => {
+  return (array == null ? void 0 : array.length) > 0 ? array[0] : defaultValue;
+};
+
+// src/array/flat.ts
+var flat = (lists) => {
+  return lists.reduce((acc, list2) => {
+    acc.push(...list2);
+    return acc;
+  }, []);
+};
+
+// src/array/fork.ts
+var fork = (list2, condition) => {
+  if (!list2) return [[], []];
+  return list2.reduce(
+    (acc, item) => {
+      const [a, b] = acc;
+      if (condition(item)) {
+        return [[...a, item], b];
+      } else {
+        return [a, [...b, item]];
+      }
+    },
+    [[], []]
+  );
+};
+
+// src/array/group.ts
+var group = (array, getGroupId) => {
+  return array.reduce((acc, item) => {
+    const groupId = getGroupId(item);
+    if (!acc[groupId]) acc[groupId] = [];
+    acc[groupId].push(item);
+    return acc;
+  }, {});
+};
+
+// src/array/intersects.ts
+var intersects = (listA, listB, identity) => {
+  if (!listA || !listB) return false;
+  if (identity) {
+    const known = new Set(listA.map(identity));
+    return listB.some((item) => known.has(identity(item)));
+  }
+  return listB.some((item) => listA.includes(item));
+};
+
+// src/array/iterate.ts
+var iterate = (count, func, initValue) => {
+  let value = initValue;
+  for (let i = 1; i <= count; i++) {
+    value = func(value, i);
+  }
+  return value;
+};
+
+// src/array/last.ts
+var last = (array, defaultValue = void 0) => {
+  return (array == null ? void 0 : array.length) > 0 ? array[array.length - 1] : defaultValue;
+};
+
+// src/array/list.ts
+var 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/merge.ts
+var merge = (root, others, matcher) => {
+  if (!others && !root) return [];
+  if (!others) return root;
+  if (!root) return [];
+  if (!matcher) return root;
+  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);
+}
+
+// src/array/objectify.ts
+var 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;
+  }
+}
+
+// src/array/replace.ts
+var replace = (list2, newItem, match) => {
+  if (!list2) 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 [...list2];
+};
+
+// src/array/replaceOrAppend.ts
+var replaceOrAppend = (list2, newItem, match) => {
+  if (!list2 && !newItem) return [];
+  if (!newItem) return [...list2];
+  if (!list2) 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)
+      ];
+    }
+  }
+  return [...list2, newItem];
+};
+
+// src/array/select.ts
+var select = (array, mapper, condition) => {
+  if (!array) return [];
+  return array.reduce((acc, item, index) => {
+    if (!condition(item, index)) return acc;
+    acc.push(mapper(item, index));
+    return acc;
+  }, []);
+};
+
+// src/array/shift.ts
+function shift(arr, n) {
+  if (arr.length === 0) return arr;
+  const shiftNumber = n % arr.length;
+  if (shiftNumber === 0) return arr;
+  return [...arr.slice(-shiftNumber, arr.length), ...arr.slice(0, -shiftNumber)];
+}
+
+// src/array/sift.ts
+var sift = (list2) => {
+  return (list2 == null ? void 0 : list2.filter((x) => !!x)) ?? [];
+};
+
+// src/array/sort.ts
+var sort = (array, getter, desc = false) => {
+  if (!array) return [];
+  const asc = (a, b) => getter(a) - getter(b);
+  const dsc = (a, b) => getter(b) - getter(a);
+  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
+var toggle = (list2, item, toKey, options) => {
+  if (!list2 && !item) return [];
+  if (!list2) return [item];
+  if (!item) return [...list2];
+  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];
+  return [item, ...list2];
+};
+
+// src/array/unique.ts
+var unique = (array, toKey) => {
+  const valueMap = array.reduce((acc, item) => {
+    const key = toKey ? toKey(item) : item;
+    if (acc[key]) return acc;
+    acc[key] = item;
+    return acc;
+  }, {});
+  return Object.values(valueMap);
+};
+
+// src/array/zip.ts
+function zip(...arrays) {
+  if (!arrays || !arrays.length) return [];
+  return new Array(Math.max(...arrays.map(({ length }) => length))).fill([]).map((_, idx) => arrays.map((array) => array[idx]));
+}
+
+// src/array/zipToObject.ts
+function zipToObject(keys2, values) {
+  if (!keys2 || !keys2.length) {
+    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;
+  }, {});
+}
+
+// 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;
+  }
+};
+
+// src/async/all.ts
+async function all(promises) {
+  const entries = isArray(promises) ? promises.map((p) => [null, p]) : Object.entries(promises);
+  const results = await Promise.all(
+    entries.map(
+      ([key, value]) => value.then((result) => ({ result, exc: null, key })).catch((exc) => ({ result: null, exc, key }))
+    )
+  );
+  const exceptions = results.filter((r) => r.exc);
+  if (exceptions.length > 0) {
+    throw new AggregateError(exceptions.map((e) => e.exc));
+  }
+  if (isArray(promises)) {
+    return results.map((r) => r.result);
+  }
+  return results.reduce(
+    (acc, item) => ({
+      ...acc,
+      [item.key]: item.result
+    }),
+    {}
+  );
+}
+
+// src/async/defer.ts
+var defer = async (func) => {
+  const callbacks = [];
+  const register = (fn, options) => callbacks.push({
+    fn,
+    rethrow: (options == null ? void 0 : options.rethrow) ?? false
+  });
+  const [err, response] = await tryit(func)(register);
+  for (const { fn, rethrow } of callbacks) {
+    const [rethrown] = await tryit(fn)(err);
+    if (rethrown && rethrow) throw rethrown;
+  }
+  if (err) throw err;
+  return response;
+};
+
+// src/async/guard.ts
+var guard = (func, shouldGuard) => {
+  const _guard = (err) => {
+    if (shouldGuard && !shouldGuard(err)) throw err;
+    return void 0;
+  };
+  try {
+    const result = func();
+    return result instanceof Promise ? result.catch(_guard) : result;
+  } catch (err) {
+    return _guard(err);
+  }
+};
+
+// src/async/map.ts
+var map = async (array, asyncMapFunc) => {
+  if (!array) return [];
+  let result = [];
+  let index = 0;
+  for (const value of array) {
+    const newValue = await asyncMapFunc(value, index++);
+    result.push(newValue);
+  }
+  return result;
+};
+
+// src/async/parallel.ts
+var parallel = async (limit, array, func) => {
+  const work = array.map((item, index) => ({
+    index,
+    item
+  }));
+  const processor = async (res) => {
+    const results2 = [];
+    while (true) {
+      const next = work.pop();
+      if (!next) return res(results2);
+      const [error, result] = await tryit(func)(next.item);
+      results2.push({
+        error,
+        result,
+        index: next.index
+      });
+    }
+  };
+  const queues = list(1, limit).map(() => new Promise(processor));
+  const itemResults = await Promise.all(queues);
+  const [errors, results] = fork(
+    sort(itemResults.flat(), (r) => r.index),
+    (x) => !!x.error
+  );
+  if (errors.length > 0) {
+    throw new AggregateError(errors.map((error) => error.error));
+  }
+  return results.map((r) => r.result);
+};
+
+// src/async/reduce.ts
+var reduce = async (array, asyncReducer, initValue) => {
+  const initProvided = initValue !== void 0;
+  if (!initProvided && (array == null ? void 0 : array.length) < 1) {
+    throw new Error("Cannot reduce empty array with no init value");
+  }
+  const iter = initProvided ? array : array.slice(1);
+  let value = initProvided ? initValue : array[0];
+  for (const [i, item] of iter.entries()) {
+    value = await asyncReducer(value, item, i);
+  }
+  return value;
+};
+
+// src/async/retry.ts
+var retry = async (options, func) => {
+  const times = (options == null ? void 0 : options.times) ?? 3;
+  const delay = options == null ? void 0 : options.delay;
+  const backoff = (options == null ? void 0 : options.backoff) ?? null;
+  let i = 0;
+  while (true) {
+    const [err, result] = await tryit(func)((err2) => {
+      throw { _exited: err2 };
+    });
+    if (!err) return result;
+    if (err._exited) throw err._exited;
+    if (++i === times) throw err;
+    if (delay) await sleep(delay);
+    if (backoff) await sleep(backoff(i));
+  }
+};
+
+// src/async/sleep.ts
+var sleep = (milliseconds) => {
+  return new Promise((res) => setTimeout(res, milliseconds));
+};
+
+// src/async/tryit.ts
+var tryit = (func) => {
+  return (...args) => {
+    try {
+      const result = func(...args);
+      if (isPromise(result)) {
+        return result.then((value) => [void 0, value]).catch((err) => [err, void 0]);
+      }
+      return [void 0, result];
+    } catch (err) {
+      return [err, void 0];
+    }
+  };
+};
+
+// src/curry/callable.ts
+var 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;
+    },
+    apply: (target, self, args) => fn(Object.assign({}, target))(...args)
+  });
+};
+
+// src/curry/chain.ts
+function chain(...funcs) {
+  return (...args) => {
+    return funcs.slice(1).reduce((acc, fn) => fn(acc), funcs[0](...args));
+  };
+}
+
+// src/curry/compose.ts
+function compose(...funcs) {
+  return funcs.reverse().reduce((acc, fn) => fn(acc));
+}
+
+// src/curry/debounce.ts
+var debounce = ({ delay }, func) => {
+  let timer = void 0;
+  let active = true;
+  const debounced = (...args) => {
+    if (active) {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        active && func(...args);
+        timer = void 0;
+      }, delay);
+    } else {
+      func(...args);
+    }
+  };
+  debounced.isPending = () => {
+    return timer !== void 0;
+  };
+  debounced.cancel = () => {
+    active = false;
+  };
+  debounced.flush = (...args) => func(...args);
+  return debounced;
+};
+
+// src/curry/memo.ts
+var memoize = (cache, func, keyFunc, ttl) => {
+  return function callWithMemo(...args) {
+    const key = keyFunc ? keyFunc(...args) : JSON.stringify({ args });
+    const existing = cache[key];
+    if (existing !== void 0) {
+      if (!existing.exp) return existing.value;
+      if (existing.exp > (/* @__PURE__ */ new Date()).getTime()) {
+        return existing.value;
+      }
+    }
+    const result = func(...args);
+    cache[key] = {
+      exp: ttl ? (/* @__PURE__ */ new Date()).getTime() + ttl : null,
+      value: result
+    };
+    return result;
+  };
+};
+var memo = (func, options = {}) => {
+  return memoize({}, func, options.key ?? null, options.ttl ?? null);
+};
+
+// src/curry/partial.ts
+var partial = (fn, ...args) => {
+  return (...rest) => fn(...[...args, ...rest]);
+};
+
+// src/curry/partob.ts
+var partob = (fn, argobj) => {
+  return (restobj) => fn({
+    ...argobj,
+    ...restobj
+  });
+};
+
+// src/curry/proxied.ts
+var proxied = (handler) => {
+  return new Proxy(
+    {},
+    {
+      get: (target, propertyName) => handler(propertyName)
+    }
+  );
+};
+
+// src/curry/throttle.ts
+var throttle = ({ interval }, func) => {
+  let ready = true;
+  let timer = void 0;
+  const throttled = (...args) => {
+    if (!ready) return;
+    func(...args);
+    ready = false;
+    timer = setTimeout(() => {
+      ready = true;
+      timer = void 0;
+    }, interval);
+  };
+  throttled.isThrottled = () => {
+    return timer !== void 0;
+  };
+  return throttled;
+};
+
+// src/number/inRange.ts
+function inRange(number, start, end) {
+  const isTypeSafe = typeof number === "number" && typeof start === "number" && (typeof end === "undefined" || typeof end === "number");
+  if (!isTypeSafe) {
+    return false;
+  }
+  if (typeof end === "undefined") {
+    end = start;
+    start = 0;
+  }
+  return number >= Math.min(start, end) && number < Math.max(start, end);
+}
+
+// src/number/toInt.ts
+var toInt = (value, defaultValue) => {
+  const def = defaultValue === void 0 ? 0 : defaultValue;
+  if (value === null || value === void 0) {
+    return def;
+  }
+  const result = parseInt(value);
+  return isNaN(result) ? def : result;
+};
+
+// src/number/toFloat.ts
+var toFloat = (value, defaultValue) => {
+  const def = defaultValue === void 0 ? 0 : defaultValue;
+  if (value === null || value === void 0) {
+    return def;
+  }
+  const result = parseFloat(value);
+  return isNaN(result) ? def : result;
+};
+
+// src/object/assign.ts
+var assign = (initial, override) => {
+  if (!initial || !override) return 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];
+    }
+  }
+  return merged;
+};
+
+// src/object/clone.ts
+var clone = (obj) => {
+  if (isPrimitive(obj)) {
+    return obj;
+  }
+  if (typeof obj === "function") {
+    return obj.bind({});
+  }
+  const proto = Object.getPrototypeOf(obj);
+  const newObj = typeof (proto == null ? void 0 : proto.constructor) === "function" ? new proto.constructor() : Object.create(proto);
+  Object.getOwnPropertyNames(obj).forEach((key) => {
+    newObj[key] = obj[key];
+  });
+  return newObj;
+};
+
+// src/object/construct.ts
+var construct = (obj) => {
+  if (!obj) return {};
+  return Object.keys(obj).reduce((acc, path) => {
+    return set(acc, path, obj[path]);
+  }, {});
+};
+
+// src/object/crush.ts
+var crush = (value) => {
+  if (!value) return {};
+  return objectify(
+    keys(value),
+    (k) => k,
+    (k) => get(value, k)
+  );
+};
+
+// src/object/get.ts
+var get = (value, path, defaultValue) => {
+  const segments = path.split(/[\.\[\]]/g);
+  let current = value;
+  for (const key of segments) {
+    if (current === null) return defaultValue;
+    if (current === void 0) return defaultValue;
+    const dequoted = key.replace(/['"]/g, "");
+    if (dequoted.trim() === "") continue;
+    current = current[dequoted];
+  }
+  if (current === void 0) return defaultValue;
+  return current;
+};
+
+// src/object/invert.ts
+var invert = (obj) => {
+  if (!obj) return {};
+  const keys2 = Object.keys(obj);
+  return keys2.reduce((acc, key) => {
+    acc[obj[key]] = key;
+    return acc;
+  }, {});
+};
+
+// src/object/keys.ts
+var keys = (value) => {
+  if (!value) return [];
+  const getKeys = (nested, paths) => {
+    if (isPlainObject(nested)) {
+      return Object.entries(nested).flatMap(
+        ([k, v]) => getKeys(v, [...paths, k])
+      );
+    }
+    if (isArray(nested)) {
+      return nested.flatMap((item, i) => getKeys(item, [...paths, `${i}`]));
+    }
+    return [paths.join(".")];
+  };
+  return getKeys(value, []);
+};
+
+// src/object/listify.ts
+var listify = (obj, toItem) => {
+  if (!obj) return [];
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return [];
+  return entries.reduce((acc, entry) => {
+    acc.push(toItem(entry[0], entry[1]));
+    return acc;
+  }, []);
+};
+
+// src/object/lowerize.ts
+var lowerize = (obj) => mapKeys(obj, (k) => k.toLowerCase());
+
+// src/object/mapEntries.ts
+var 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;
+  }, {});
+};
+
+// src/object/mapKeys.ts
+var mapKeys = (obj, mapFunc) => {
+  const keys2 = Object.keys(obj);
+  return keys2.reduce((acc, key) => {
+    acc[mapFunc(key, obj[key])] = obj[key];
+    return acc;
+  }, {});
+};
+
+// src/object/mapValues.ts
+var mapValues = (obj, mapFunc) => {
+  const keys2 = Object.keys(obj);
+  return keys2.reduce((acc, key) => {
+    acc[key] = mapFunc(obj[key], key);
+    return acc;
+  }, {});
+};
+
+// src/object/omit.ts
+var omit = (obj, keys2) => {
+  if (!obj) return {};
+  if (!keys2 || keys2.length === 0) return obj;
+  return keys2.reduce(
+    (acc, key) => {
+      delete acc[key];
+      return acc;
+    },
+    { ...obj }
+  );
+};
+
+// src/object/pick.ts
+var pick = (obj, keys2) => {
+  if (!obj) return {};
+  return keys2.reduce((acc, key) => {
+    if (Object.hasOwnProperty.call(obj, key)) acc[key] = obj[key];
+    return acc;
+  }, {});
+};
+
+// src/object/set.ts
+var set = (initial, path, value) => {
+  if (!initial) return {};
+  if (!path || value === void 0) return initial;
+  const root = clone(initial);
+  const keys2 = path.match(/[^.[\]]+/g);
+  if (keys2)
+    keys2.reduce(
+      (object, key, i) => i < keys2.length - 1 ? object[key] ??= isIntString(keys2[i + 1]) ? [] : {} : object[key] = value,
+      root
+    );
+  return root;
+};
+
+// src/object/shake.ts
+var shake = (obj, filter = (value) => value === void 0) => {
+  if (!obj) return {};
+  const keys2 = Object.keys(obj);
+  return keys2.reduce((acc, key) => {
+    if (!filter(obj[key])) {
+      acc[key] = obj[key];
+    }
+    return acc;
+  }, {});
+};
+
+// src/object/upperize.ts
+var upperize = (obj) => mapKeys(obj, (k) => k.toUpperCase());
+
+// src/random/draw.ts
+var draw = (array) => {
+  const max2 = array.length;
+  if (max2 === 0) {
+    return null;
+  }
+  const index = random(0, max2 - 1);
+  return array[index];
+};
+
+// src/random/random.ts
+var random = (min2, max2) => {
+  return Math.floor(Math.random() * (max2 - min2 + 1) + min2);
+};
+
+// src/random/shuffle.ts
+var shuffle = (array) => {
+  return array.map((a) => ({ rand: Math.random(), value: a })).sort((a, b) => a.rand - b.rand).map((a) => a.value);
+};
+
+// src/random/uid.ts
+var uid = (length, specials = "") => {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" + specials;
+  return iterate(
+    length,
+    (acc) => {
+      return acc + characters.charAt(random(0, characters.length - 1));
+    },
+    ""
+  );
+};
+
+// 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 min2 = (a, b) => {
+    return indexesByKey[toKey(a)] < indexesByKey[toKey(b)] ? a : b;
+  };
+  const max2 = (a, b) => {
+    return indexesByKey[toKey(a)] > indexesByKey[toKey(b)] ? a : b;
+  };
+  const first2 = () => {
+    return itemsByIndex[0];
+  };
+  const last2 = () => {
+    return itemsByIndex[items.length - 1];
+  };
+  const next = (current, defaultValue) => {
+    return itemsByIndex[indexesByKey[toKey(current)] + 1] ?? defaultValue ?? first2();
+  };
+  const previous = (current, defaultValue) => {
+    return itemsByIndex[indexesByKey[toKey(current)] - 1] ?? defaultValue ?? last2();
+  };
+  const spin = (current, num) => {
+    if (num === 0) return current;
+    const abs = Math.abs(num);
+    const rel = abs > items.length ? abs % items.length : abs;
+    return list(0, rel - 1).reduce(
+      (acc) => num > 0 ? next(acc) : previous(acc),
+      current
+    );
+  };
+  return {
+    min: min2,
+    max: max2,
+    first: first2,
+    last: last2,
+    next,
+    previous,
+    spin
+  };
+};
+
+// src/string/camel.ts
+var camel = (str) => {
+  var _a;
+  const parts = ((_a = str == null ? void 0 : str.replace(/([A-Z])+/g, capitalize)) == null ? void 0 : _a.split(/(?=[A-Z])|[\.\-\s_]/).map((x) => x.toLowerCase())) ?? [];
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return parts.reduce((acc, part) => {
+    return `${acc}${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+  });
+};
+
+// src/string/capitalize.ts
+var capitalize = (str) => {
+  if (!str || str.length === 0) return "";
+  const lower = str.toLowerCase();
+  return lower.substring(0, 1).toUpperCase() + lower.substring(1, lower.length);
+};
+
+// src/string/dash.ts
+var dash = (str) => {
+  var _a;
+  const parts = ((_a = str == null ? void 0 : str.replace(/([A-Z])+/g, capitalize)) == null ? void 0 : _a.split(/(?=[A-Z])|[\.\-\s_]/).map((x) => x.toLowerCase())) ?? [];
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return parts.reduce((acc, part) => {
+    return `${acc}-${part.toLowerCase()}`;
+  });
+};
+
+// src/string/pascal.ts
+var pascal = (str) => {
+  const parts = (str == null ? void 0 : str.split(/[\.\-\s_]/).map((x) => x.toLowerCase())) ?? [];
+  if (parts.length === 0) return "";
+  return parts.map((str2) => str2.charAt(0).toUpperCase() + str2.slice(1)).join("");
+};
+
+// src/string/snake.ts
+var snake = (str, options) => {
+  const parts = (str == null ? void 0 : str.replace(/([A-Z])+/g, capitalize).split(/(?=[A-Z])|[\.\-\s_]/).map((x) => x.toLowerCase())) ?? [];
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  const result = parts.reduce((acc, part) => {
+    return `${acc}_${part.toLowerCase()}`;
+  });
+  return (options == null ? void 0 : options.splitOnNumber) === false ? result : result.replace(/([A-Za-z]{1}[0-9]{1})/, (val) => `${val[0]}_${val[1]}`);
+};
+
+// src/string/template.ts
+var template = (str, data, regex = /\{\{(.+?)\}\}/g) => {
+  return Array.from(str.matchAll(regex)).reduce((acc, match) => {
+    return acc.replace(match[0], data[match[1]]);
+  }, str);
+};
+
+// src/string/title.ts
+var title = (str) => {
+  if (!str) return "";
+  return str.split(/(?=[A-Z])|[\.\-\s_]/).map((s) => s.trim()).filter((s) => !!s).map((s) => capitalize(s.toLowerCase())).join(" ");
+};
+
+// src/string/trim.ts
+var trim = (str, charsToTrim = " ") => {
+  if (!str) return "";
+  const toTrim = charsToTrim.replace(/[\W]{1}/g, "\\$&");
+  const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, "g");
+  return str.replace(regex, "");
+};
+
+// src/typed/isArray.ts
+var isArray = Array.isArray;
+
+// src/typed/isDate.ts
+var isDate = (value) => {
+  return Object.prototype.toString.call(value) === "[object Date]";
+};
+
+// src/typed/isEmpty.ts
+var isEmpty = (value) => {
+  if (value === true || value === false) return true;
+  if (value === null || value === void 0) return true;
+  if (isNumber(value)) return value === 0;
+  if (isDate(value)) return isNaN(value.getTime());
+  if (isFunction(value)) return false;
+  if (isSymbol(value)) return false;
+  const length = value.length;
+  if (isNumber(length)) return length === 0;
+  const size = value.size;
+  if (isNumber(size)) return size === 0;
+  const keys2 = Object.keys(value).length;
+  return keys2 === 0;
+};
+
+// src/typed/isEqual.ts
+var isEqual = (x, y) => {
+  if (Object.is(x, y)) return true;
+  if (x instanceof Date && y instanceof Date) {
+    return x.getTime() === y.getTime();
+  }
+  if (x instanceof RegExp && y instanceof RegExp) {
+    return x.toString() === y.toString();
+  }
+  if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) {
+    return false;
+  }
+  const keysX = Reflect.ownKeys(x);
+  const keysY = Reflect.ownKeys(y);
+  if (keysX.length !== keysY.length) return false;
+  for (let i = 0; i < keysX.length; i++) {
+    if (!Reflect.has(y, keysX[i])) return false;
+    if (!isEqual(x[keysX[i]], y[keysX[i]])) return false;
+  }
+  return true;
+};
+
+// src/typed/isFloat.ts
+var isFloat = (value) => {
+  return isNumber(value) && value % 1 !== 0;
+};
+
+// src/typed/isFunction.ts
+var isFunction = (value) => {
+  return !!(value && value.constructor && value.call && value.apply);
+};
+
+// src/typed/isInt.ts
+var isInt = (value) => {
+  return isNumber(value) && value % 1 === 0;
+};
+
+// src/typed/isIntString.ts
+var isIntString = (value) => {
+  if (!isString(value)) return false;
+  const num = +value;
+  return Number.isInteger(num) && `${num}` === value;
+};
+
+// src/typed/isNumber.ts
+var isNumber = (value) => {
+  try {
+    return Number(value) === value;
+  } catch {
+    return false;
+  }
+};
+
+// src/typed/isObject.ts
+var isObject = (value) => {
+  return !!value && value.constructor === Object;
+};
+
+// src/typed/isPlainObject.ts
+var isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null) {
+    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);
+};
+
+// src/typed/isPrimitive.ts
+var isPrimitive = (value) => {
+  return value === void 0 || value === null || typeof value !== "object" && typeof value !== "function";
+};
+
+// src/typed/isPromise.ts
+var isPromise = (value) => {
+  if (!value) return false;
+  if (!value.then) return false;
+  if (!isFunction(value.then)) return false;
+  return true;
+};
+
+// src/typed/isString.ts
+var isString = (value) => {
+  return typeof value === "string" || value instanceof String;
+};
+
+// src/typed/isSymbol.ts
+var isSymbol = (value) => {
+  return !!value && value.constructor === 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,
+  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,
+  max,
+  memo,
+  merge,
+  min,
+  objectify,
+  omit,
+  parallel,
+  partial,
+  partob,
+  pascal,
+  pick,
+  proxied,
+  random,
+  range,
+  reduce,
+  replace,
+  replaceOrAppend,
+  retry,
+  select,
+  series,
+  set,
+  shake,
+  shift,
+  shuffle,
+  sift,
+  sleep,
+  snake,
+  sort,
+  sum,
+  template,
+  throttle,
+  title,
+  toFloat,
+  toInt,
+  toggle,
+  trim,
+  try: null,
+  tryit,
+  uid,
+  unique,
+  upperize,
+  zip,
+  zipToObject
+});