@vinicunca/perkakas 0.0.4 → 0.0.5

package/dist/index.cjs

@@ -0,0 +1,2300 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[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, {
+  KEY_CODES: () => KEY_CODES,
+  _setPath: () => _setPath,
+  addProp: () => addProp,
+  allPass: () => allPass,
+  anyPass: () => anyPass,
+  chunk: () => chunk,
+  clamp: () => clamp,
+  clone: () => clone,
+  compact: () => compact,
+  concat: () => concat,
+  convertToUnit: () => convertToUnit,
+  countBy: () => countBy,
+  createPipe: () => createPipe,
+  difference: () => difference,
+  differenceWith: () => differenceWith,
+  drop: () => drop,
+  dropLast: () => dropLast,
+  equals: () => equals,
+  filter: () => filter,
+  find: () => find,
+  findIndex: () => findIndex,
+  findLast: () => findLast,
+  findLastIndex: () => findLastIndex,
+  first: () => first,
+  flatMap: () => flatMap,
+  flatMapToObj: () => flatMapToObj,
+  flatten: () => flatten,
+  flattenDeep: () => flattenDeep,
+  forEach: () => forEach,
+  forEachObj: () => forEachObj,
+  fromPairs: () => fromPairs,
+  groupBy: () => groupBy,
+  humanReadableFileSize: () => humanReadableFileSize,
+  identity: () => identity,
+  increaseWithUnit: () => increaseWithUnit,
+  indexBy: () => indexBy,
+  intersection: () => intersection,
+  intersectionWith: () => intersectionWith,
+  invert: () => invert,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isBrowser: () => isBrowser,
+  isDate: () => isDate,
+  isDefined: () => isDefined,
+  isEmpty: () => isEmpty,
+  isError: () => isError,
+  isFunction: () => isFunction,
+  isNil: () => isNil,
+  isNonNull: () => isNonNull,
+  isNot: () => isNot,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isPromise: () => isPromise,
+  isString: () => isString,
+  isTruthy: () => isTruthy,
+  isUppercase: () => isUppercase,
+  join: () => join,
+  keys: () => keys,
+  last: () => last,
+  length: () => length,
+  map: () => map,
+  mapKeys: () => mapKeys,
+  mapToObj: () => mapToObj,
+  mapValues: () => mapValues,
+  maxBy: () => maxBy,
+  meanBy: () => meanBy,
+  merge: () => merge,
+  mergeAll: () => mergeAll,
+  minBy: () => minBy,
+  noop: () => noop,
+  omit: () => omit,
+  omitBy: () => omitBy,
+  once: () => once,
+  partition: () => partition,
+  pathOr: () => pathOr,
+  pick: () => pick,
+  pickBy: () => pickBy,
+  pipe: () => pipe,
+  prop: () => prop,
+  purry: () => purry,
+  randomString: () => randomString,
+  range: () => range,
+  reduce: () => reduce,
+  reject: () => reject,
+  reverse: () => reverse,
+  sample: () => sample,
+  set: () => set,
+  setPath: () => setPath,
+  shuffle: () => shuffle,
+  sleep: () => sleep,
+  sort: () => sort,
+  sortBy: () => sortBy,
+  splitAt: () => splitAt,
+  splitByCase: () => splitByCase,
+  splitWhen: () => splitWhen,
+  stringToPath: () => stringToPath,
+  sumBy: () => sumBy,
+  swapIndices: () => swapIndices,
+  swapProps: () => swapProps,
+  take: () => take,
+  takeWhile: () => takeWhile,
+  toCamelCase: () => toCamelCase,
+  toKebabCase: () => toKebabCase,
+  toLowerFirst: () => toLowerFirst,
+  toPairs: () => toPairs,
+  toPascalCase: () => toPascalCase,
+  toSnakeCase: () => toSnakeCase,
+  toUpperFirst: () => toUpperFirst,
+  type: () => type,
+  uniq: () => uniq,
+  uniqBy: () => uniqBy,
+  uniqWith: () => uniqWith,
+  values: () => values,
+  zip: () => zip,
+  zipObj: () => zipObj,
+  zipWith: () => zipWith
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/aria/key-codes.ts
+var KEY_CODES = {
+  TAB: "Tab",
+  ARROW_DOWN: "ArrowDown",
+  ARROW_UP: "ArrowUp",
+  ARROW_LEFT: "ArrowLeft",
+  ARROW_RIGHT: "ArrowRight",
+  ENTER: "Enter",
+  ESC: "Escape",
+  SPACE: "Space",
+  SHIFT: "Shift",
+  KEY_F: "KEY_F",
+  CTRL: "Control",
+  ALT: "Alt",
+  META: "Meta",
+  AT: "@",
+  DELETE: "Delete",
+  BACKSPACE: "Backspace",
+  HOME: "Home",
+  END: "End",
+  PAGE_UP: "PageUp",
+  PAGE_DOWN: "PageDown"
+};
+
+// src/function/pipe.ts
+function pipe(value, ...operations) {
+  let ret = value;
+  const lazyOps = operations.map((op) => {
+    const { lazy, lazyArgs } = op;
+    if (lazy) {
+      const fn = lazy(...lazyArgs || []);
+      fn.indexed = lazy.indexed;
+      fn.single = lazy.single;
+      fn.index = 0;
+      fn.items = [];
+      return fn;
+    }
+    return null;
+  });
+  let opIdx = 0;
+  while (opIdx < operations.length) {
+    const op = operations[opIdx];
+    const lazyOp = lazyOps[opIdx];
+    if (!lazyOp) {
+      ret = op(ret);
+      opIdx++;
+      continue;
+    }
+    const lazySeq = [];
+    for (let j = opIdx; j < operations.length; j++) {
+      if (lazyOps[j]) {
+        lazySeq.push(lazyOps[j]);
+        if (lazyOps[j].single) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    const acc = [];
+    for (const item of ret) {
+      if (_processItem({ item, acc, lazySeq })) {
+        break;
+      }
+    }
+    const lastLazySeq = lazySeq[lazySeq.length - 1];
+    if (lastLazySeq.single) {
+      ret = acc[0];
+    } else {
+      ret = acc;
+    }
+    opIdx += lazySeq.length;
+  }
+  return ret;
+}
+function _processItem({
+  item,
+  lazySeq,
+  acc
+}) {
+  if (lazySeq.length === 0) {
+    acc.push(item);
+    return false;
+  }
+  let lazyResult = { done: false, hasNext: false };
+  let isDone = false;
+  for (let i = 0; i < lazySeq.length; i++) {
+    const lazyFn = lazySeq[i];
+    const indexed = lazyFn.indexed;
+    const index = lazyFn.index;
+    const items = lazyFn.items;
+    items.push(item);
+    lazyResult = indexed ? lazyFn(item, index, items) : lazyFn(item);
+    lazyFn.index++;
+    if (lazyResult.hasNext) {
+      if (lazyResult.hasMany) {
+        const nextValues = lazyResult.next;
+        for (const subItem of nextValues) {
+          const subResult = _processItem({
+            item: subItem,
+            acc,
+            lazySeq: lazySeq.slice(i + 1)
+          });
+          if (subResult) {
+            return true;
+          }
+        }
+        return false;
+      } else {
+        item = lazyResult.next;
+      }
+    }
+    if (!lazyResult.hasNext) {
+      break;
+    }
+    if (lazyResult.done) {
+      isDone = true;
+    }
+  }
+  if (lazyResult.hasNext) {
+    acc.push(item);
+  }
+  if (isDone) {
+    return true;
+  }
+  return false;
+}
+
+// src/function/create-pipe.ts
+function createPipe(...operations) {
+  return (value) => pipe(value, ...operations);
+}
+
+// src/function/identity.ts
+function identity(value) {
+  return value;
+}
+
+// src/function/noop.ts
+function noop() {
+  return void 0;
+}
+
+// src/function/once.ts
+function once(fn) {
+  let called = false;
+  let ret;
+  return () => {
+    if (!called) {
+      ret = fn();
+      called = true;
+    }
+    return ret;
+  };
+}
+
+// src/function/purry.ts
+function purry(fn, args, lazy) {
+  const diff = fn.length - args.length;
+  const arrayArgs = Array.from(args);
+  if (diff === 0) {
+    return fn(...arrayArgs);
+  }
+  if (diff === 1) {
+    const ret = (data) => fn(data, ...arrayArgs);
+    if (lazy || fn.lazy) {
+      ret.lazy = lazy || fn.lazy;
+      ret.lazyArgs = args;
+    }
+    return ret;
+  }
+  throw new Error("Wrong number of arguments");
+}
+
+// src/array/all-pass.ts
+function allPass() {
+  return purry(_allPass, arguments);
+}
+function _allPass(data, fns) {
+  return fns.every((fn) => fn(data));
+}
+
+// src/array/any-pass.ts
+function anyPass() {
+  return purry(_anyPass, arguments);
+}
+function _anyPass(data, fns) {
+  return fns.some((fn) => fn(data));
+}
+
+// src/array/chunk.ts
+function chunk() {
+  return purry(_chunk, arguments);
+}
+function _chunk(array, size) {
+  const ret = Array.from({
+    length: Math.ceil(array.length / size)
+  });
+  for (let index = 0; index < ret.length; index += 1) {
+    ret[index] = array.slice(index * size, (index + 1) * size);
+  }
+  return ret;
+}
+
+// src/guard/is-array.ts
+function isArray(data) {
+  return Array.isArray(data);
+}
+
+// src/guard/is-boolean.ts
+function isBoolean(data) {
+  return typeof data === "boolean";
+}
+
+// src/guard/is-date.ts
+function isDate(data) {
+  return data instanceof Date;
+}
+
+// src/guard/is-defined.ts
+function isDefined(data) {
+  return typeof data !== "undefined" && data !== null;
+}
+((isDefined2) => {
+  function strict(data) {
+    return data !== void 0;
+  }
+  isDefined2.strict = strict;
+})(isDefined || (isDefined = {}));
+
+// src/base.ts
+function toString(value) {
+  return Object.prototype.toString.call(value);
+}
+
+// src/guard/is-object.ts
+function isObject(data) {
+  return toString(data) === "[object Object]";
+}
+
+// src/guard/is-string.ts
+function isString(data) {
+  return typeof data === "string";
+}
+
+// src/guard/is-empty.ts
+function isEmpty(data) {
+  if (isArray(data) || isString(data)) {
+    return data.length === 0;
+  }
+  if (isObject(data)) {
+    for (const _ in data) {
+      return false;
+    }
+    return !(data instanceof RegExp);
+  }
+  return false;
+}
+
+// src/guard/is-error.ts
+function isError(data) {
+  return data instanceof Error;
+}
+
+// src/guard/is-function.ts
+function isFunction(data) {
+  return typeof data === "function";
+}
+
+// src/guard/is-nil.ts
+function isNil(data) {
+  return data == null;
+}
+
+// src/guard/is-non-null.ts
+function isNonNull(data) {
+  return data !== null;
+}
+
+// src/guard/is-not.ts
+function isNot(predicate) {
+  return (data) => {
+    return !predicate(data);
+  };
+}
+
+// src/guard/is-number.ts
+function isNumber(data) {
+  return typeof data === "number" && !Number.isNaN(data);
+}
+
+// src/guard/is-promise.ts
+function isPromise(data) {
+  return data instanceof Promise;
+}
+
+// src/guard/is-truthy.ts
+function isTruthy(data) {
+  return !!data;
+}
+
+// src/array/compact.ts
+function compact(items) {
+  return items.filter(isTruthy);
+}
+
+// src/array/concat.ts
+function concat() {
+  return purry(_concat, arguments);
+}
+function _concat(arr1, arr2) {
+  return arr1.concat(arr2);
+}
+
+// src/array/count-by.ts
+function _countBy(indexed) {
+  return (array, fn) => {
+    return array.reduce((ret, item, index) => {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      return ret + (value ? 1 : 0);
+    }, 0);
+  };
+}
+function countBy() {
+  return purry(_countBy(false), arguments);
+}
+((countBy2) => {
+  function indexed() {
+    return purry(_countBy(true), arguments);
+  }
+  countBy2.indexed = indexed;
+})(countBy || (countBy = {}));
+
+// src/utils/reduce-lazy.ts
+function _reduceLazy(array, lazy, indexed) {
+  const newArray = [];
+  for (let index = 0; index < array.length; index++) {
+    const item = array[index];
+    const result = indexed ? lazy(item, index, array) : lazy(item);
+    if (result.hasMany === true) {
+      newArray.push(...result.next);
+    } else if (result.hasNext) {
+      newArray.push(result.next);
+    }
+  }
+  return newArray;
+}
+
+// src/array/difference-with.ts
+function differenceWith() {
+  return purry(_differenceWith, arguments, differenceWith.lazy);
+}
+function _differenceWith(array, other, isEquals) {
+  const lazy = differenceWith.lazy(other, isEquals);
+  return _reduceLazy(array, lazy);
+}
+((differenceWith2) => {
+  function lazy(other, isEquals) {
+    return (value) => {
+      if (other.every((otherValue) => !isEquals(value, otherValue))) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  differenceWith2.lazy = lazy;
+})(differenceWith || (differenceWith = {}));
+
+// src/array/difference.ts
+function difference() {
+  return purry(_difference, arguments, difference.lazy);
+}
+function _difference(array, other) {
+  const lazy = difference.lazy(other);
+  return _reduceLazy(array, lazy);
+}
+((difference2) => {
+  function lazy(other) {
+    const set2 = new Set(other);
+    return (value) => {
+      if (!set2.has(value)) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  difference2.lazy = lazy;
+})(difference || (difference = {}));
+
+// src/array/drop-last.ts
+function dropLast() {
+  return purry(_dropLast, arguments);
+}
+function _dropLast(array, n) {
+  const copy = [...array];
+  if (n > 0) {
+    copy.splice(-n);
+  }
+  return copy;
+}
+
+// src/array/drop.ts
+function drop() {
+  return purry(_drop, arguments, drop.lazy);
+}
+function _drop(array, n) {
+  return _reduceLazy(array, drop.lazy(n));
+}
+((drop2) => {
+  function lazy(n) {
+    let left = n;
+    return (value) => {
+      if (left > 0) {
+        left--;
+        return {
+          done: false,
+          hasNext: false
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  drop2.lazy = lazy;
+})(drop || (drop = {}));
+
+// src/utils/to-lazy-indexed.ts
+function toLazyIndexed(fn) {
+  fn.indexed = true;
+  return fn;
+}
+
+// src/array/filter.ts
+function filter() {
+  return purry(_filter(false), arguments, filter.lazy);
+}
+function _filter(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? filter.lazyIndexed(fn) : filter.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      if (valid) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  };
+}
+((filter2) => {
+  function indexed() {
+    return purry(_filter(true), arguments, filter2.lazyIndexed);
+  }
+  filter2.indexed = indexed;
+  filter2.lazy = _lazy(false);
+  filter2.lazyIndexed = toLazyIndexed(_lazy(true));
+})(filter || (filter = {}));
+
+// src/utils/to-single.ts
+function toSingle(fn) {
+  fn.single = true;
+  return fn;
+}
+
+// src/array/find-index.ts
+function findIndex() {
+  return purry(_findIndex(false), arguments, findIndex.lazy);
+}
+function _findIndex(indexed) {
+  return (array, fn) => {
+    if (indexed) {
+      return array.findIndex(fn);
+    }
+    return array.findIndex((x) => fn(x));
+  };
+}
+function _lazy2(indexed) {
+  return (fn) => {
+    let i = 0;
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      if (valid) {
+        return {
+          done: true,
+          hasNext: true,
+          next: i
+        };
+      }
+      i++;
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  };
+}
+((findIndex2) => {
+  function indexed() {
+    return purry(_findIndex(true), arguments, findIndex2.lazyIndexed);
+  }
+  findIndex2.indexed = indexed;
+  findIndex2.lazy = toSingle(_lazy2(false));
+  findIndex2.lazyIndexed = toSingle(toLazyIndexed(_lazy2(true)));
+})(findIndex || (findIndex = {}));
+
+// src/array/find-last-index.ts
+function findLastIndex() {
+  return purry(_findLastIndex(false), arguments);
+}
+function _findLastIndex(indexed) {
+  return (array, fn) => {
+    for (let i = array.length - 1; i >= 0; i--) {
+      if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+((findLastIndex2) => {
+  function indexed() {
+    return purry(_findLastIndex(true), arguments);
+  }
+  findLastIndex2.indexed = indexed;
+})(findLastIndex || (findLastIndex = {}));
+
+// src/array/find-last.ts
+function findLast() {
+  return purry(_findLast(false), arguments);
+}
+function _findLast(indexed) {
+  return (array, fn) => {
+    for (let i = array.length - 1; i >= 0; i--) {
+      if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+        return array[i];
+      }
+    }
+  };
+}
+((findLast2) => {
+  function indexed() {
+    return purry(_findLast(true), arguments);
+  }
+  findLast2.indexed = indexed;
+})(findLast || (findLast = {}));
+
+// src/array/find.ts
+function find() {
+  return purry(_find(false), arguments, find.lazy);
+}
+function _find(indexed) {
+  return (array, fn) => {
+    if (indexed) {
+      return array.find(fn);
+    }
+    return array.find((x) => fn(x));
+  };
+}
+function _lazy3(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      return {
+        done: valid,
+        hasNext: valid,
+        next: value
+      };
+    };
+  };
+}
+((find2) => {
+  function indexed() {
+    return purry(_find(true), arguments, find2.lazyIndexed);
+  }
+  find2.indexed = indexed;
+  find2.lazy = toSingle(_lazy3(false));
+  find2.lazyIndexed = toSingle(toLazyIndexed(_lazy3(true)));
+})(find || (find = {}));
+
+// src/array/first.ts
+function first() {
+  return purry(_first, arguments, first.lazy);
+}
+function _first([first2]) {
+  return first2;
+}
+((first2) => {
+  function lazy() {
+    return (value) => {
+      return {
+        done: true,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  first2.lazy = lazy;
+  ((lazy2) => {
+    lazy2.single = true;
+  })(lazy = first2.lazy || (first2.lazy = {}));
+})(first || (first = {}));
+
+// src/array/flat-map-to-obj.ts
+function flatMapToObj() {
+  return purry(_flatMapToObj(false), arguments);
+}
+function _flatMapToObj(indexed) {
+  return (array, fn) => {
+    return array.reduce((result, element, index) => {
+      const items = indexed ? fn(element, index, array) : fn(element);
+      items.forEach(([key, value]) => {
+        result[key] = value;
+      });
+      return result;
+    }, {});
+  };
+}
+((flatMapToObj2) => {
+  function indexed() {
+    return purry(_flatMapToObj(true), arguments);
+  }
+  flatMapToObj2.indexed = indexed;
+})(flatMapToObj || (flatMapToObj = {}));
+
+// src/array/flatten.ts
+function flatten() {
+  return purry(_flatten, arguments, flatten.lazy);
+}
+function _flatten(items) {
+  return _reduceLazy(items, flatten.lazy());
+}
+((flatten2) => {
+  function lazy() {
+    return (next) => {
+      if (Array.isArray(next)) {
+        return {
+          done: false,
+          hasNext: true,
+          hasMany: true,
+          next
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next
+      };
+    };
+  }
+  flatten2.lazy = lazy;
+})(flatten || (flatten = {}));
+
+// src/array/flat-map.ts
+function flatMap() {
+  return purry(_flatMap, arguments, flatMap.lazy);
+}
+function _flatMap(array, fn) {
+  return flatten(array.map((item) => fn(item)));
+}
+((flatMap2) => {
+  function lazy(fn) {
+    return (value) => {
+      const next = fn(value);
+      if (Array.isArray(next)) {
+        return {
+          done: false,
+          hasNext: true,
+          hasMany: true,
+          next
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next
+      };
+    };
+  }
+  flatMap2.lazy = lazy;
+})(flatMap || (flatMap = {}));
+
+// src/array/flatten-deep.ts
+function flattenDeep() {
+  return purry(_flattenDeep, arguments, flattenDeep.lazy);
+}
+function _flattenDeep(items) {
+  return _reduceLazy(items, flattenDeep.lazy());
+}
+function _flattenDeepValue(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  const ret = [];
+  value.forEach((item) => {
+    if (Array.isArray(item)) {
+      ret.push(...flattenDeep(item));
+    } else {
+      ret.push(item);
+    }
+  });
+  return ret;
+}
+((flattenDeep2) => {
+  function lazy() {
+    return (value) => {
+      const next = _flattenDeepValue(value);
+      if (Array.isArray(next)) {
+        return {
+          done: false,
+          hasNext: true,
+          hasMany: true,
+          next
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next
+      };
+    };
+  }
+  flattenDeep2.lazy = lazy;
+})(flattenDeep || (flattenDeep = {}));
+
+// src/array/for-each.ts
+function forEach() {
+  return purry(_forEach(false), arguments, forEach.lazy);
+}
+function _forEach(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy4(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      if (indexed) {
+        fn(value, index, array);
+      } else {
+        fn(value);
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  };
+}
+((forEach2) => {
+  function indexed() {
+    return purry(_forEach(true), arguments, forEach2.lazyIndexed);
+  }
+  forEach2.indexed = indexed;
+  forEach2.lazy = _lazy4(false);
+  forEach2.lazyIndexed = toLazyIndexed(_lazy4(true));
+})(forEach || (forEach = {}));
+
+// src/array/group-by.ts
+function groupBy() {
+  return purry(_groupBy(false), arguments);
+}
+function _groupBy(indexed) {
+  return (array, fn) => {
+    const ret = {};
+    array.forEach((item, index) => {
+      const key = indexed ? fn(item, index, array) : fn(item);
+      if (key !== void 0) {
+        const actualKey = String(key);
+        if (!ret[actualKey]) {
+          ret[actualKey] = [];
+        }
+        ret[actualKey].push(item);
+      }
+    });
+    return ret;
+  };
+}
+((groupBy2) => {
+  function indexed() {
+    return purry(_groupBy(true), arguments);
+  }
+  groupBy2.indexed = indexed;
+  groupBy2.strict = groupBy2;
+})(groupBy || (groupBy = {}));
+
+// src/array/index-by.ts
+function indexBy() {
+  return purry(_indexBy(false), arguments);
+}
+function _indexBy(indexed) {
+  return (array, fn) => {
+    return array.reduce((ret, item, index) => {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      const key = String(value);
+      ret[key] = item;
+      return ret;
+    }, {});
+  };
+}
+((indexBy2) => {
+  function indexed() {
+    return purry(_indexBy(true), arguments);
+  }
+  indexBy2.indexed = indexed;
+})(indexBy || (indexBy = {}));
+
+// src/array/intersection.ts
+function intersection() {
+  return purry(_intersection, arguments, intersection.lazy);
+}
+function _intersection(array, other) {
+  const lazy = intersection.lazy(other);
+  return _reduceLazy(array, lazy);
+}
+((intersection2) => {
+  function lazy(other) {
+    return (value) => {
+      const set2 = new Set(other);
+      if (set2.has(value)) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  intersection2.lazy = lazy;
+})(intersection || (intersection = {}));
+
+// src/array/intersection-with.ts
+function intersectionWith() {
+  return purry(_intersectionWith, arguments, intersectionWith.lazy);
+}
+function _intersectionWith(array, other, comparator) {
+  const lazy = intersectionWith.lazy(other, comparator);
+  return _reduceLazy(array, lazy);
+}
+((intersectionWith2) => {
+  function lazy(other, comparator) {
+    return (value) => {
+      if (other.some((otherValue) => comparator(value, otherValue))) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  }
+  intersectionWith2.lazy = lazy;
+})(intersectionWith || (intersectionWith = {}));
+
+// src/array/join.ts
+function join() {
+  return purry(joinImplementation, arguments);
+}
+function joinImplementation(data, glue) {
+  return data.join(glue);
+}
+
+// src/array/last.ts
+function last() {
+  return purry(_last, arguments);
+}
+function _last(array) {
+  return array[array.length - 1];
+}
+
+// src/array/length.ts
+function length() {
+  return purry(_length, arguments);
+}
+function _length(items) {
+  return "length" in items ? items.length : Array.from(items).length;
+}
+
+// src/array/map.ts
+function map() {
+  return purry(_map(false), arguments, map.lazy);
+}
+function _map(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? map.lazyIndexed(fn) : map.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy5(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      return {
+        done: false,
+        hasNext: true,
+        next: indexed ? fn(value, index, array) : fn(value)
+      };
+    };
+  };
+}
+((map2) => {
+  function indexed() {
+    return purry(_map(true), arguments, map2.lazyIndexed);
+  }
+  map2.indexed = indexed;
+  map2.lazy = _lazy5(false);
+  map2.lazyIndexed = toLazyIndexed(_lazy5(true));
+  map2.strict = map2;
+})(map || (map = {}));
+
+// src/array/map-to-obj.ts
+function mapToObj() {
+  return purry(_mapToObj(false), arguments);
+}
+function _mapToObj(indexed) {
+  return (array, fn) => {
+    return array.reduce((result, element, index) => {
+      const [key, value] = indexed ? fn(element, index, array) : fn(element);
+      result[key] = value;
+      return result;
+    }, {});
+  };
+}
+((mapToObj2) => {
+  function indexed() {
+    return purry(_mapToObj(true), arguments);
+  }
+  mapToObj2.indexed = indexed;
+})(mapToObj || (mapToObj = {}));
+
+// src/array/max-by.ts
+function _maxBy(indexed) {
+  return (array, fn) => {
+    let ret;
+    let retMax;
+    array.forEach((item, i) => {
+      const max = indexed ? fn(item, i, array) : fn(item);
+      if (retMax === void 0 || max > retMax) {
+        ret = item;
+        retMax = max;
+      }
+    });
+    return ret;
+  };
+}
+function maxBy() {
+  return purry(_maxBy(false), arguments);
+}
+((maxBy2) => {
+  function indexed() {
+    return purry(_maxBy(true), arguments);
+  }
+  maxBy2.indexed = indexed;
+})(maxBy || (maxBy = {}));
+
+// src/array/mean-by.ts
+function _meanBy(indexed) {
+  return (array, fn) => {
+    if (array.length === 0) {
+      return Number.NaN;
+    }
+    let sum = 0;
+    array.forEach((item, i) => {
+      sum += indexed ? fn(item, i, array) : fn(item);
+    });
+    return sum / array.length;
+  };
+}
+function meanBy() {
+  return purry(_meanBy(false), arguments);
+}
+((meanBy2) => {
+  function indexed() {
+    return purry(_meanBy(true), arguments);
+  }
+  meanBy2.indexed = indexed;
+})(meanBy || (meanBy = {}));
+
+// src/array/merge-all.ts
+function mergeAll(items) {
+  return items.reduce((acc, x) => ({ ...acc, ...x }), {});
+}
+
+// src/array/min-by.ts
+function _minBy(indexed) {
+  return (array, fn) => {
+    let ret;
+    let retMin;
+    array.forEach((item, i) => {
+      const min = indexed ? fn(item, i, array) : fn(item);
+      if (retMin === void 0 || min < retMin) {
+        ret = item;
+        retMin = min;
+      }
+    });
+    return ret;
+  };
+}
+function minBy() {
+  return purry(_minBy(false), arguments);
+}
+((minBy2) => {
+  function indexed() {
+    return purry(_minBy(true), arguments);
+  }
+  minBy2.indexed = indexed;
+})(minBy || (minBy = {}));
+
+// src/array/partition.ts
+function partition() {
+  return purry(_partition(false), arguments);
+}
+function _partition(indexed) {
+  return (array, fn) => {
+    const ret = [[], []];
+    array.forEach((item, index) => {
+      const matches = indexed ? fn(item, index, array) : fn(item);
+      ret[matches ? 0 : 1].push(item);
+    });
+    return ret;
+  };
+}
+((partition2) => {
+  function indexed() {
+    return purry(_partition(true), arguments);
+  }
+  partition2.indexed = indexed;
+})(partition || (partition = {}));
+
+// src/array/range.ts
+function range() {
+  return purry(_range, arguments);
+}
+function _range(start, end) {
+  const ret = [];
+  for (let i = start; i < end; i++) {
+    ret.push(i);
+  }
+  return ret;
+}
+
+// src/array/reduce.ts
+function reduce() {
+  return purry(_reduce(false), arguments);
+}
+function _reduce(indexed) {
+  return (items, fn, initialValue) => {
+    return items.reduce(
+      (acc, item, index) => indexed ? fn(acc, item, index, items) : fn(acc, item),
+      initialValue
+    );
+  };
+}
+((reduce2) => {
+  function indexed() {
+    return purry(_reduce(true), arguments);
+  }
+  reduce2.indexed = indexed;
+})(reduce || (reduce = {}));
+
+// src/array/reject.ts
+function reject() {
+  return purry(_reject(false), arguments, reject.lazy);
+}
+function _reject(indexed) {
+  return (array, fn) => {
+    return _reduceLazy(
+      array,
+      indexed ? reject.lazyIndexed(fn) : reject.lazy(fn),
+      indexed
+    );
+  };
+}
+function _lazy6(indexed) {
+  return (fn) => {
+    return (value, index, array) => {
+      const valid = indexed ? fn(value, index, array) : fn(value);
+      if (!valid) {
+        return {
+          done: false,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: false
+      };
+    };
+  };
+}
+((reject2) => {
+  function indexed() {
+    return purry(_reject(true), arguments, reject2.lazyIndexed);
+  }
+  reject2.indexed = indexed;
+  reject2.lazy = _lazy6(false);
+  reject2.lazyIndexed = toLazyIndexed(_lazy6(true));
+})(reject || (reject = {}));
+
+// src/array/reverse.ts
+function reverse() {
+  return purry(_reverse, arguments);
+}
+function _reverse(array) {
+  return array.slice().reverse();
+}
+
+// src/array/sample.ts
+function sample(...args) {
+  return purry(sampleImplementation, args);
+}
+function sampleImplementation(data, sampleSize) {
+  if (sampleSize < 0) {
+    throw new RangeError(`sampleSize must cannot be negative: ${sampleSize}`);
+  }
+  if (!Number.isInteger(sampleSize)) {
+    throw new TypeError(`sampleSize must be an integer: ${sampleSize}`);
+  }
+  if (sampleSize >= data.length) {
+    return data;
+  }
+  if (sampleSize === 0) {
+    return [];
+  }
+  const actualSampleSize = Math.min(sampleSize, data.length - sampleSize);
+  const sampleIndices = /* @__PURE__ */ new Set();
+  while (sampleIndices.size < actualSampleSize) {
+    const randomIndex = Math.floor(Math.random() * data.length);
+    sampleIndices.add(randomIndex);
+  }
+  if (sampleSize === actualSampleSize) {
+    return Array.from(sampleIndices).sort((a, b) => a - b).map((index) => data[index]);
+  }
+  return data.filter((_, index) => !sampleIndices.has(index));
+}
+
+// src/array/shuffle.ts
+function shuffle() {
+  return purry(_shuffle, arguments);
+}
+function _shuffle(items) {
+  const result = items.slice();
+  for (let index = 0; index < items.length; index += 1) {
+    const rand = index + Math.floor(Math.random() * (items.length - index));
+    const value = result[rand];
+    result[rand] = result[index];
+    result[index] = value;
+  }
+  return result;
+}
+
+// src/array/sort.ts
+function sort() {
+  return purry(_sort, arguments);
+}
+function _sort(items, cmp) {
+  const ret = [...items];
+  ret.sort(cmp);
+  return ret;
+}
+((sort2) => {
+  sort2.strict = sort2;
+})(sort || (sort = {}));
+
+// src/array/sort-by.ts
+var ALL_DIRECTIONS = ["asc", "desc"];
+var COMPARATOR = {
+  asc: (x, y) => x > y,
+  desc: (x, y) => x < y
+};
+function sortBy(arrayOrSortRule, ...sortRules) {
+  const args = isSortRule(arrayOrSortRule) ? (
+    // *data-last invocation*: put all sort rules into a single array to be
+    // passed as the first param.
+    [[arrayOrSortRule, ...sortRules]]
+  ) : (
+    // *data-first invocation*: put the arrayOrSort (which is array now) as
+    // the first param, and all the sorts (as an array) into the second param.
+    // `purry` would pick the right "flavour" based on the length of the
+    // params tuple.
+    [arrayOrSortRule, sortRules]
+  );
+  return purry(_sortBy, args);
+}
+function isSortRule(x) {
+  if (typeof x === "function") {
+    return true;
+  }
+  const [maybeProjection, maybeDirection, ...rest] = x;
+  if (rest.length > 0) {
+    return false;
+  }
+  return typeof maybeProjection === "function" && ALL_DIRECTIONS.includes(maybeDirection);
+}
+function _sortBy(array, sorts) {
+  return [...array].sort(comparer(...sorts));
+}
+function comparer(primaryRule, secondaryRule, ...otherRules) {
+  const projector = typeof primaryRule === "function" ? primaryRule : primaryRule[0];
+  const direction = typeof primaryRule === "function" ? "asc" : primaryRule[1];
+  const comparator = COMPARATOR[direction];
+  const nextComparer = secondaryRule === void 0 ? void 0 : comparer(secondaryRule, ...otherRules);
+  return (a, b) => {
+    const projectedA = projector(a);
+    const projectedB = projector(b);
+    if (comparator(projectedA, projectedB)) {
+      return 1;
+    }
+    if (comparator(projectedB, projectedA)) {
+      return -1;
+    }
+    return nextComparer?.(a, b) ?? 0;
+  };
+}
+((sortBy2) => {
+  sortBy2.strict = sortBy2;
+})(sortBy || (sortBy = {}));
+
+// src/array/split-at.ts
+function splitAt() {
+  return purry(_splitAt, arguments);
+}
+function _splitAt(array, index) {
+  const copy = [...array];
+  const tail = copy.splice(index);
+  return [copy, tail];
+}
+
+// src/array/split-when.ts
+function splitWhen() {
+  return purry(_splitWhen, arguments);
+}
+function _splitWhen(array, fn) {
+  for (let i = 0; i < array.length; i++) {
+    if (fn(array[i])) {
+      return splitAt(array, i);
+    }
+  }
+  return [array, []];
+}
+
+// src/array/sum-by.ts
+function _sumBy(indexed) {
+  return (array, fn) => {
+    let sum = 0;
+    array.forEach((item, i) => {
+      const summand = indexed ? fn(item, i, array) : fn(item);
+      sum += summand;
+    });
+    return sum;
+  };
+}
+function sumBy() {
+  return purry(_sumBy(false), arguments);
+}
+((sumBy2) => {
+  function indexed() {
+    return purry(_sumBy(true), arguments);
+  }
+  sumBy2.indexed = indexed;
+})(sumBy || (sumBy = {}));
+
+// src/array/swap-indices.ts
+function swapIndices(...args) {
+  return purry(_swapIndices, args);
+}
+function _swapIndices(item, index1, index2) {
+  return typeof item === "string" ? _swapString(item, index1, index2) : _swapArray(item, index1, index2);
+}
+function _swapArray(item, index1, index2) {
+  const result = item.slice();
+  if (Number.isNaN(index1) || Number.isNaN(index2)) {
+    return result;
+  }
+  const positiveIndexA = index1 < 0 ? item.length + index1 : index1;
+  const positiveIndexB = index2 < 0 ? item.length + index2 : index2;
+  if (positiveIndexA < 0 || positiveIndexA > item.length) {
+    return result;
+  }
+  if (positiveIndexB < 0 || positiveIndexB > item.length) {
+    return result;
+  }
+  result[positiveIndexA] = item[positiveIndexB];
+  result[positiveIndexB] = item[positiveIndexA];
+  return result;
+}
+function _swapString(item, index1, index2) {
+  const result = _swapArray(item.split(""), index1, index2);
+  return result.join("");
+}
+
+// src/array/take.ts
+function take() {
+  return purry(_take, arguments, take.lazy);
+}
+function _take(array, n) {
+  return _reduceLazy(array, take.lazy(n));
+}
+((take2) => {
+  function lazy(n) {
+    return (value) => {
+      if (n === 0) {
+        return {
+          done: true,
+          hasNext: false
+        };
+      }
+      n--;
+      if (n === 0) {
+        return {
+          done: true,
+          hasNext: true,
+          next: value
+        };
+      }
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  take2.lazy = lazy;
+})(take || (take = {}));
+
+// src/array/take-while.ts
+function takeWhile() {
+  return purry(_takeWhile, arguments);
+}
+function _takeWhile(array, fn) {
+  const ret = [];
+  for (const item of array) {
+    if (!fn(item)) {
+      break;
+    }
+    ret.push(item);
+  }
+  return ret;
+}
+
+// src/array/uniq.ts
+function uniq() {
+  return purry(_uniq, arguments, uniq.lazy);
+}
+function _uniq(array) {
+  return _reduceLazy(array, uniq.lazy());
+}
+((uniq2) => {
+  function lazy() {
+    const set2 = /* @__PURE__ */ new Set();
+    return (value) => {
+      if (set2.has(value)) {
+        return {
+          done: false,
+          hasNext: false
+        };
+      }
+      set2.add(value);
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    };
+  }
+  uniq2.lazy = lazy;
+})(uniq || (uniq = {}));
+
+// src/array/uniq-by.ts
+function uniqBy() {
+  return purry(_uniqBy, arguments, lazyUniqBy);
+}
+function _uniqBy(array, transformer) {
+  return _reduceLazy(array, lazyUniqBy(transformer));
+}
+function lazyUniqBy(transformer) {
+  const set2 = /* @__PURE__ */ new Set();
+  return (value) => {
+    const appliedItem = transformer(value);
+    if (set2.has(appliedItem)) {
+      return {
+        done: false,
+        hasNext: false
+      };
+    }
+    set2.add(appliedItem);
+    return {
+      done: false,
+      hasNext: true,
+      next: value
+    };
+  };
+}
+
+// src/array/uniq-with.ts
+function uniqWith() {
+  return purry(_uniqWith, arguments, uniqWith.lazy);
+}
+function _uniqWith(array, isEquals) {
+  const lazy = uniqWith.lazy(isEquals);
+  return _reduceLazy(array, lazy, true);
+}
+function _lazy7(isEquals) {
+  return (value, index, array) => {
+    if (array && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
+      return {
+        done: false,
+        hasNext: true,
+        next: value
+      };
+    }
+    return {
+      done: false,
+      hasNext: false
+    };
+  };
+}
+((uniqWith2) => {
+  uniqWith2.lazy = toLazyIndexed(_lazy7);
+})(uniqWith || (uniqWith = {}));
+
+// src/array/zip.ts
+function zip() {
+  return purry(_zip, arguments);
+}
+function _zip(first2, second) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push([first2[i], second[i]]);
+  }
+  return result;
+}
+
+// src/array/zip-obj.ts
+function zipObj() {
+  return purry(_zipObj, arguments);
+}
+function _zipObj(first2, second) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = {};
+  for (let i = 0; i < resultLength; i++) {
+    result[first2[i]] = second[i];
+  }
+  return result;
+}
+
+// src/array/zip-with.ts
+function zipWith() {
+  const args = Array.from(arguments);
+  if (typeof args[0] === "function" && args.length === 1) {
+    return function(f, s) {
+      return _zipWith(f, s, args[0]);
+    };
+  }
+  if (typeof args[0] === "function" && args.length === 2) {
+    return function(f) {
+      return _zipWith(f, args[1], args[0]);
+    };
+  }
+  if (args.length === 3) {
+    return _zipWith(args[0], args[1], args[2]);
+  }
+}
+function _zipWith(first2, second, fn) {
+  const resultLength = first2.length > second.length ? second.length : first2.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push(fn(first2[i], second[i]));
+  }
+  return result;
+}
+
+// src/helpers/index.ts
+function convertToUnit(str, unit = "px") {
+  if (isNil(str) || str === "") {
+    return void 0;
+  } else if (Number.isNaN(+str)) {
+    return String(str);
+  } else if (!Number.isFinite(+str)) {
+    return void 0;
+  } else {
+    return `${Number(str)}${unit}`;
+  }
+}
+function increaseWithUnit({ target, delta }) {
+  if (isNumber(target)) {
+    return target + delta;
+  }
+  const value = target.match(/^-?[0-9]+\.?[0-9]*/)?.[0] || "";
+  const unit = target.slice(value.length);
+  const result = Number.parseFloat(value) + delta;
+  if (Number.isNaN(result)) {
+    return target;
+  }
+  return result + unit;
+}
+function humanReadableFileSize(bytes, base = 1e3) {
+  if (bytes < base) {
+    return `${bytes} B`;
+  }
+  const prefix = base === 1024 ? ["Ki", "Mi", "Gi"] : ["k", "M", "G"];
+  let unit = -1;
+  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {
+    bytes /= base;
+    ++unit;
+  }
+  return `${bytes.toFixed(1)} ${prefix[unit]}B`;
+}
+function sleep(timeout) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+}
+
+// src/number/clamp.ts
+function clamp() {
+  return purry(_clamp, arguments);
+}
+function _clamp(value, limits) {
+  if (limits.min != null && limits.min > value) {
+    return limits.min;
+  }
+  if (limits.max != null && limits.max < value) {
+    return limits.max;
+  }
+  return value;
+}
+
+// src/object/add-prop.ts
+function addProp(...args) {
+  return purry(_addProp, args);
+}
+function _addProp(obj, prop2, value) {
+  return {
+    ...obj,
+    [prop2]: value
+  };
+}
+
+// src/type/type.ts
+function type(val) {
+  return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
+}
+
+// src/object/clone.ts
+function _cloneRegExp(pattern) {
+  return new RegExp(
+    pattern.source,
+    (pattern.global ? "g" : "") + (pattern.ignoreCase ? "i" : "") + (pattern.multiline ? "m" : "") + (pattern.sticky ? "y" : "") + (pattern.unicode ? "u" : "")
+  );
+}
+function _clone(value, refFrom, refTo, deep) {
+  function copy(copiedValue) {
+    const len = refFrom.length;
+    let idx = 0;
+    while (idx < len) {
+      if (value === refFrom[idx]) {
+        return refTo[idx];
+      }
+      idx += 1;
+    }
+    refFrom[idx + 1] = value;
+    refTo[idx + 1] = copiedValue;
+    for (const key in value) {
+      copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];
+    }
+    return copiedValue;
+  }
+  switch (type(value)) {
+    case "Object":
+      return copy({});
+    case "Array":
+      return copy([]);
+    case "Date":
+      return new Date(value.valueOf());
+    case "RegExp":
+      return _cloneRegExp(value);
+    default:
+      return value;
+  }
+}
+function clone(value) {
+  return value != null && typeof value.clone === "function" ? value.clone() : _clone(value, [], [], true);
+}
+
+// src/object/equals.ts
+var isArray2 = Array.isArray;
+var keyList = Object.keys;
+function equals() {
+  return purry(_equals, arguments);
+}
+function _equals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const arrA = isArray2(a);
+    const arrB = isArray2(b);
+    let i;
+    let length2;
+    let key;
+    if (arrA && arrB) {
+      length2 = a.length;
+      if (length2 !== b.length) {
+        return false;
+      }
+      for (i = length2; i-- !== 0; ) {
+        if (!equals(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (arrA !== arrB) {
+      return false;
+    }
+    const dateA = a instanceof Date;
+    const dateB = b instanceof Date;
+    if (dateA !== dateB) {
+      return false;
+    }
+    if (dateA && dateB) {
+      return a.getTime() === b.getTime();
+    }
+    const regexpA = a instanceof RegExp;
+    const regexpB = b instanceof RegExp;
+    if (regexpA !== regexpB) {
+      return false;
+    }
+    if (regexpA && regexpB) {
+      return a.toString() === b.toString();
+    }
+    const keys2 = keyList(a);
+    length2 = keys2.length;
+    if (length2 !== keyList(b).length) {
+      return false;
+    }
+    for (i = length2; i-- !== 0; ) {
+      if (!Object.prototype.hasOwnProperty.call(b, keys2[i])) {
+        return false;
+      }
+    }
+    for (i = length2; i-- !== 0; ) {
+      key = keys2[i];
+      if (!equals(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+
+// src/object/for-each-obj.ts
+function forEachObj() {
+  return purry(_forEachObj(false), arguments);
+}
+function _forEachObj(indexed) {
+  return (object, fn) => {
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        const val = object[key];
+        if (indexed) {
+          fn(val, key, object);
+        } else {
+          fn(val);
+        }
+      }
+    }
+    return object;
+  };
+}
+((forEachObj2) => {
+  function indexed() {
+    return purry(_forEachObj(true), arguments);
+  }
+  forEachObj2.indexed = indexed;
+})(forEachObj || (forEachObj = {}));
+
+// src/object/from-pairs.ts
+function fromPairs(entries) {
+  const out = {};
+  for (const [key, value] of entries) {
+    out[key] = value;
+  }
+  return out;
+}
+((fromPairs2) => {
+  fromPairs2.strict = fromPairs2;
+})(fromPairs || (fromPairs = {}));
+
+// src/object/invert.ts
+function invert() {
+  return purry(_invert, arguments);
+}
+function _invert(object) {
+  const result = {};
+  for (const key in object) {
+    result[object[key]] = key;
+  }
+  return result;
+}
+
+// src/object/keys.ts
+function keys(source) {
+  return Object.keys(source);
+}
+((keys2) => {
+  keys2.strict = keys2;
+})(keys || (keys = {}));
+
+// src/object/map-keys.ts
+function mapKeys(arg1, arg2) {
+  if (arguments.length === 1) {
+    return (data) => _mapKeys(data, arg1);
+  }
+  return _mapKeys(arg1, arg2);
+}
+function _mapKeys(obj, fn) {
+  return Object.keys(obj).reduce((acc, key) => {
+    acc[fn(key, obj[key])] = obj[key];
+    return acc;
+  }, {});
+}
+
+// src/object/map-values.ts
+function mapValues(arg1, arg2) {
+  if (arguments.length === 1) {
+    return (data) => _mapValues(data, arg1);
+  }
+  return _mapValues(arg1, arg2);
+}
+function _mapValues(obj, fn) {
+  return Object.keys(obj).reduce((acc, key) => {
+    acc[key] = fn(obj[key], key);
+    return acc;
+  }, {});
+}
+
+// src/object/merge.ts
+function merge() {
+  return purry(_merge, arguments);
+}
+function _merge(a, b) {
+  return Object.assign({}, a, b);
+}
+
+// src/object/omit.ts
+function omit() {
+  return purry(_omit, arguments);
+}
+function _omit(data, propNames) {
+  if (propNames.length === 0) {
+    return { ...data };
+  }
+  if (propNames.length === 1) {
+    const [propName] = propNames;
+    const {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- use destructuring to remove a single key, letting JS optimize here...
+      [propName]: omitted,
+      ...remaining
+    } = data;
+    return remaining;
+  }
+  if (!propNames.some((propName) => propName in data)) {
+    return { ...data };
+  }
+  const asSet = new Set(propNames);
+  return fromPairs(
+    Object.entries(data).filter(([key]) => !asSet.has(key))
+  );
+}
+
+// src/object/omit-by.ts
+function omitBy() {
+  return purry(_omitBy, arguments);
+}
+function _omitBy(object, fn) {
+  return Object.keys(object).reduce((acc, key) => {
+    if (!fn(object[key], key)) {
+      acc[key] = object[key];
+    }
+    return acc;
+  }, {});
+}
+
+// src/object/path-or.ts
+function pathOr() {
+  return purry(_pathOr, arguments);
+}
+function _pathOr(object, path, defaultValue) {
+  let current = object;
+  for (const prop2 of path) {
+    if (current == null || current[prop2] == null) {
+      return defaultValue;
+    }
+    current = current[prop2];
+  }
+  return current;
+}
+
+// src/object/pick.ts
+function pick() {
+  return purry(_pick, arguments);
+}
+function _pick(object, names) {
+  if (object == null) {
+    return {};
+  }
+  return names.reduce((acc, name) => {
+    if (name in object) {
+      acc[name] = object[name];
+    }
+    return acc;
+  }, {});
+}
+
+// src/object/pick-by.ts
+function pickBy() {
+  return purry(_pickBy, arguments);
+}
+function _pickBy(object, fn) {
+  if (object == null) {
+    return {};
+  }
+  return Object.keys(object).reduce((acc, key) => {
+    if (fn(object[key], key)) {
+      acc[key] = object[key];
+    }
+    return acc;
+  }, {});
+}
+
+// src/object/prop.ts
+function prop(propName) {
+  return ({ [propName]: value }) => value;
+}
+
+// src/object/set.ts
+function set() {
+  return purry(_set, arguments);
+}
+function _set(obj, prop2, value) {
+  return {
+    ...obj,
+    [prop2]: value
+  };
+}
+
+// src/object/set-path.ts
+function setPath() {
+  return purry(_setPath, arguments);
+}
+function _setPath(object, path, defaultValue) {
+  if (path.length === 0) {
+    return defaultValue;
+  }
+  if (Array.isArray(object)) {
+    return object.map((item, index) => {
+      if (index === path[0]) {
+        return _setPath(item, path.slice(1), defaultValue);
+      }
+      return item;
+    });
+  }
+  return {
+    ...object,
+    [path[0]]: _setPath(object[path[0]], path.slice(1), defaultValue)
+  };
+}
+
+// src/object/swap-props.ts
+function swapProps() {
+  return purry(_swapProps, arguments);
+}
+function _swapProps(obj, key1, key2) {
+  const { [key1]: value1, [key2]: value2 } = obj;
+  return {
+    ...obj,
+    [key1]: value2,
+    [key2]: value1
+  };
+}
+
+// src/object/to-pairs.ts
+function toPairs(object) {
+  return Object.entries(object);
+}
+((toPairs2) => {
+  function strict(object) {
+    return Object.entries(object);
+  }
+  toPairs2.strict = strict;
+})(toPairs || (toPairs = {}));
+
+// src/object/values.ts
+function values(source) {
+  return Object.values(source);
+}
+
+// src/string/cases.ts
+var RE_NUMBER_CHAR = /\d/;
+var STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (RE_NUMBER_CHAR.test(char)) {
+    return void 0;
+  }
+  return char.toUpperCase() === char;
+}
+function splitByCase(string_, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!string_ || !isString(string_)) {
+    return parts;
+  }
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of string_) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff[buff.length - 1];
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function toUpperFirst(string_) {
+  return !string_ ? "" : string_[0].toUpperCase() + string_.slice(1);
+}
+function toLowerFirst(string_) {
+  return !string_ ? "" : string_[0].toLowerCase() + string_.slice(1);
+}
+function toPascalCase(string_) {
+  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => toUpperFirst(p)).join("");
+}
+function toCamelCase(string_) {
+  return toLowerFirst(toPascalCase(string_ || ""));
+}
+function toKebabCase(string_, joiner) {
+  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => p.toLowerCase()).join(joiner ?? "-");
+}
+function toSnakeCase(string_) {
+  return toKebabCase(string_ || "", "_");
+}
+
+// src/string/random-string.ts
+function randomString(length2) {
+  const characterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const randomChar = () => characterSet[Math.floor(Math.random() * characterSet.length)];
+  return range(0, length2).reduce((text) => text + randomChar(), "");
+}
+
+// src/string/string-to-path.ts
+function stringToPath(path) {
+  return _stringToPath(path);
+}
+function _stringToPath(path) {
+  if (path.length === 0) {
+    return [];
+  }
+  const match = path.match(/^\[(.+?)\](.*)$/) ?? path.match(/^\.?([^.[\]]+)(.*)$/);
+  if (match) {
+    const [, key, rest] = match;
+    return [key, ..._stringToPath(rest)];
+  }
+  return [path];
+}
+
+// src/index.ts
+var isBrowser = typeof window !== "undefined";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KEY_CODES,
+  _setPath,
+  addProp,
+  allPass,
+  anyPass,
+  chunk,
+  clamp,
+  clone,
+  compact,
+  concat,
+  convertToUnit,
+  countBy,
+  createPipe,
+  difference,
+  differenceWith,
+  drop,
+  dropLast,
+  equals,
+  filter,
+  find,
+  findIndex,
+  findLast,
+  findLastIndex,
+  first,
+  flatMap,
+  flatMapToObj,
+  flatten,
+  flattenDeep,
+  forEach,
+  forEachObj,
+  fromPairs,
+  groupBy,
+  humanReadableFileSize,
+  identity,
+  increaseWithUnit,
+  indexBy,
+  intersection,
+  intersectionWith,
+  invert,
+  isArray,
+  isBoolean,
+  isBrowser,
+  isDate,
+  isDefined,
+  isEmpty,
+  isError,
+  isFunction,
+  isNil,
+  isNonNull,
+  isNot,
+  isNumber,
+  isObject,
+  isPromise,
+  isString,
+  isTruthy,
+  isUppercase,
+  join,
+  keys,
+  last,
+  length,
+  map,
+  mapKeys,
+  mapToObj,
+  mapValues,
+  maxBy,
+  meanBy,
+  merge,
+  mergeAll,
+  minBy,
+  noop,
+  omit,
+  omitBy,
+  once,
+  partition,
+  pathOr,
+  pick,
+  pickBy,
+  pipe,
+  prop,
+  purry,
+  randomString,
+  range,
+  reduce,
+  reject,
+  reverse,
+  sample,
+  set,
+  setPath,
+  shuffle,
+  sleep,
+  sort,
+  sortBy,
+  splitAt,
+  splitByCase,
+  splitWhen,
+  stringToPath,
+  sumBy,
+  swapIndices,
+  swapProps,
+  take,
+  takeWhile,
+  toCamelCase,
+  toKebabCase,
+  toLowerFirst,
+  toPairs,
+  toPascalCase,
+  toSnakeCase,
+  toUpperFirst,
+  type,
+  uniq,
+  uniqBy,
+  uniqWith,
+  values,
+  zip,
+  zipObj,
+  zipWith
+});