@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/index.cjs

@@ -1,2843 +0,0 @@
-"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,
-  add: () => add,
-  addProp: () => addProp,
-  allPass: () => allPass,
-  anyPass: () => anyPass,
-  ceil: () => ceil,
-  chunk: () => chunk,
-  clamp: () => clamp,
-  clone: () => clone,
-  compact: () => compact,
-  concat: () => concat,
-  conditional: () => conditional,
-  countBy: () => countBy,
-  createPipe: () => createPipe,
-  debounce: () => debounce,
-  difference: () => difference,
-  differenceWith: () => differenceWith,
-  divide: () => divide,
-  drop: () => drop,
-  dropFirstBy: () => dropFirstBy,
-  dropLast: () => dropLast,
-  dropLastWhile: () => dropLastWhile,
-  dropWhile: () => dropWhile,
-  equals: () => equals,
-  filter: () => filter,
-  find: () => find,
-  findIndex: () => findIndex,
-  findLast: () => findLast,
-  findLastIndex: () => findLastIndex,
-  first: () => first,
-  firstBy: () => firstBy,
-  flatMap: () => flatMap,
-  flatMapToObj: () => flatMapToObj,
-  flatten: () => flatten,
-  flattenDeep: () => flattenDeep,
-  floor: () => floor,
-  forEach: () => forEach,
-  forEachObj: () => forEachObj,
-  fromPairs: () => fromPairs,
-  groupBy: () => groupBy,
-  hasAtLeast: () => hasAtLeast,
-  humanReadableFileSize: () => humanReadableFileSize,
-  identity: () => identity,
-  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,
-  isSymbol: () => isSymbol,
-  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,
-  mergeDeep: () => mergeDeep,
-  minBy: () => minBy,
-  multiply: () => multiply,
-  noop: () => noop,
-  nthBy: () => nthBy,
-  omit: () => omit,
-  omitBy: () => omitBy,
-  once: () => once,
-  only: () => only,
-  partition: () => partition2,
-  pathOr: () => pathOr,
-  pick: () => pick,
-  pickBy: () => pickBy,
-  pipe: () => pipe,
-  prop: () => prop,
-  purry: () => purry,
-  randomString: () => randomString,
-  range: () => range,
-  rankBy: () => rankBy,
-  reduce: () => reduce,
-  reject: () => reject,
-  reverse: () => reverse,
-  round: () => round,
-  sample: () => sample,
-  set: () => set,
-  setPath: () => setPath,
-  shuffle: () => shuffle,
-  sleep: () => sleep,
-  slugify: () => slugify,
-  sort: () => sort,
-  sortBy: () => sortBy,
-  splice: () => splice,
-  splitAt: () => splitAt,
-  splitByCase: () => splitByCase,
-  splitWhen: () => splitWhen,
-  stringToPath: () => stringToPath,
-  subtract: () => subtract,
-  sumBy: () => sumBy,
-  swapIndices: () => swapIndices,
-  swapProps: () => swapProps,
-  take: () => take,
-  takeFirstBy: () => takeFirstBy,
-  takeWhile: () => takeWhile,
-  titleCase: () => titleCase,
-  toCamelCase: () => toCamelCase,
-  toFlatCase: () => toFlatCase,
-  toKebabCase: () => toKebabCase,
-  toLowerFirst: () => toLowerFirst,
-  toPairs: () => toPairs,
-  toPascalCase: () => toPascalCase,
-  toSnakeCase: () => toSnakeCase,
-  toTrainCase: () => toTrainCase,
-  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 = {
-  ALT: "Alt",
-  ARROW_DOWN: "ArrowDown",
-  ARROW_LEFT: "ArrowLeft",
-  ARROW_RIGHT: "ArrowRight",
-  ARROW_UP: "ArrowUp",
-  AT: "@",
-  BACKSPACE: "Backspace",
-  CTRL: "Control",
-  DELETE: "Delete",
-  END: "End",
-  ENTER: "Enter",
-  ESC: "Escape",
-  HOME: "Home",
-  KEY_F: "KEY_F",
-  META: "Meta",
-  PAGE_DOWN: "PageDown",
-  PAGE_UP: "PageUp",
-  SHIFT: "Shift",
-  SPACE: "Space",
-  TAB: "Tab"
-};
-
-// 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(...args) {
-  return purry(_allPass, args);
-}
-function _allPass(data, fns) {
-  return fns.every((fn) => fn(data));
-}
-
-// src/array/any-pass.ts
-function anyPass(...args) {
-  return purry(_anyPass, args);
-}
-function _anyPass(data, fns) {
-  return fns.some((fn) => fn(data));
-}
-
-// src/array/chunk.ts
-function chunk(...args) {
-  return purry(_chunk, args);
-}
-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-truthy.ts
-function isTruthy(data) {
-  return !!data;
-}
-
-// src/array/compact.ts
-function compact(items) {
-  return items.filter(isTruthy);
-}
-
-// src/array/concat.ts
-function concat(...args) {
-  return purry(_concat, args);
-}
-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(...args) {
-  return purry(_countBy(false), args);
-}
-((countBy2) => {
-  function indexed(...args) {
-    return purry(_countBy(true), args);
-  }
-  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(...args) {
-  return purry(_differenceWith, args, 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(...args) {
-  return purry(_difference, args, 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(...args) {
-  return purry(_dropLast, args);
-}
-function _dropLast(array, n) {
-  const copy = [...array];
-  if (n > 0) {
-    copy.splice(-n);
-  }
-  return copy;
-}
-
-// src/array/drop.ts
-function drop(...args) {
-  return purry(_drop, args, 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/array/has-at-least.ts
-function hasAtLeast(...args) {
-  return purry(hasAtLeastImplementation, args);
-}
-function hasAtLeastImplementation(data, minimum) {
-  return data.length >= minimum;
-}
-
-// src/utils/swap-in-place.ts
-function swapInPlace(data, i, j) {
-  [data[i], data[j]] = [data[j], data[i]];
-}
-
-// src/utils/heap.ts
-function heapify(heap, compareFn) {
-  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
-    heapSiftDown(heap, i, compareFn);
-  }
-}
-function heapMaybeInsert(heap, compareFn, item) {
-  if (!hasAtLeast(heap, 1)) {
-    return;
-  }
-  const head = heap[0];
-  if (compareFn(item, head) >= 0) {
-    return;
-  }
-  heap[0] = item;
-  heapSiftDown(heap, 0, compareFn);
-  return head;
-}
-function heapSiftDown(heap, index, compareFn) {
-  let currentIndex = index;
-  while (currentIndex * 2 + 1 < heap.length) {
-    const firstChildIndex = currentIndex * 2 + 1;
-    let swapIndex = compareFn(heap[currentIndex], heap[firstChildIndex]) < 0 ? firstChildIndex : currentIndex;
-    const secondChildIndex = firstChildIndex + 1;
-    if (secondChildIndex < heap.length && compareFn(heap[swapIndex], heap[secondChildIndex]) < 0) {
-      swapIndex = secondChildIndex;
-    }
-    if (swapIndex === currentIndex) {
-      return;
-    }
-    swapInPlace(heap, currentIndex, swapIndex);
-    currentIndex = swapIndex;
-  }
-}
-
-// src/utils/purry-order-rules.ts
-var COMPARATORS = {
-  asc: (x, y) => x > y,
-  desc: (x, y) => x < y
-};
-function purryOrderRules(func, inputArgs) {
-  const [dataOrRule, ...rules] = Array.isArray(inputArgs) ? inputArgs : Array.from(inputArgs);
-  if (!isOrderRule(dataOrRule)) {
-    const compareFn2 = orderRuleComparer(...rules);
-    return func(dataOrRule, compareFn2);
-  }
-  const compareFn = orderRuleComparer(dataOrRule, ...rules);
-  return (data) => func(data, compareFn);
-}
-function purryOrderRulesWithArgument(func, inputArgs) {
-  const [first2, second, ...rest] = Array.from(inputArgs);
-  let arg;
-  let argRemoved;
-  if (isOrderRule(second)) {
-    arg = first2;
-    argRemoved = [second, ...rest];
-  } else {
-    arg = second;
-    argRemoved = [first2, ...rest];
-  }
-  return purryOrderRules((...args) => func(...args, arg), argRemoved);
-}
-function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
-  const projector = typeof primaryRule === "function" ? primaryRule : primaryRule[0];
-  const direction = typeof primaryRule === "function" ? "asc" : primaryRule[1];
-  const comparator = COMPARATORS[direction];
-  const nextComparer = secondaryRule === void 0 ? void 0 : orderRuleComparer(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;
-  };
-}
-function isOrderRule(x) {
-  if (isProjection(x)) {
-    return true;
-  }
-  if (typeof x !== "object" || !Array.isArray(x)) {
-    return false;
-  }
-  const [maybeProjection, maybeDirection, ...rest] = x;
-  return isProjection(maybeProjection) && maybeDirection in COMPARATORS && rest.length === 0;
-}
-function isProjection(x) {
-  return typeof x === "function" && x.length === 1;
-}
-
-// src/array/drop-first-by.ts
-function dropFirstBy(...args) {
-  return purryOrderRulesWithArgument(dropFirstByImplementation, args);
-}
-function dropFirstByImplementation(data, compareFn, n) {
-  if (n >= data.length) {
-    return [];
-  }
-  if (n <= 0) {
-    return [...data];
-  }
-  const heap = data.slice(0, n);
-  heapify(heap, compareFn);
-  const out = [];
-  const rest = data.slice(n);
-  for (const item of rest) {
-    const previousHead = heapMaybeInsert(heap, compareFn, item);
-    out.push(previousHead ?? item);
-  }
-  return out;
-}
-
-// src/array/drop-last-while.ts
-function dropLastWhile(...args) {
-  return purry(_dropLastWhile, args);
-}
-function _dropLastWhile(data, predicate) {
-  for (let i = data.length - 1; i >= 0; i--) {
-    if (!predicate(data[i])) {
-      return data.slice(0, i + 1);
-    }
-  }
-  return [];
-}
-
-// src/array/drop-while.ts
-function dropWhile(...args) {
-  return purry(_dropWhile, args);
-}
-function _dropWhile(data, predicate) {
-  for (let i = 0; i < data.length; i++) {
-    if (!predicate(data[i])) {
-      return data.slice(i);
-    }
-  }
-  return [];
-}
-
-// src/utils/to-lazy-indexed.ts
-function toLazyIndexed(fn) {
-  return Object.assign(fn, { indexed: true });
-}
-
-// src/array/filter.ts
-function filter(...args) {
-  return purry(filter_(false), args, 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(...args) {
-    return purry(filter_(true), args, 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(...args) {
-  return purry(_findIndex(false), args, findIndex.lazy);
-}
-function _findIndex(indexed) {
-  return (array, fn) => {
-    if (indexed) {
-      return array.findIndex(fn);
-    }
-    return array.findIndex((x) => fn(x));
-  };
-}
-function _lazy(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(...args) {
-    return purry(_findIndex(true), args, findIndex2.lazyIndexed);
-  }
-  findIndex2.indexed = indexed;
-  findIndex2.lazy = toSingle(_lazy(false));
-  findIndex2.lazyIndexed = toSingle(toLazyIndexed(_lazy(true)));
-})(findIndex || (findIndex = {}));
-
-// src/array/find-last-index.ts
-function findLastIndex(...args) {
-  return purry(_findLastIndex(false), args);
-}
-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(...args) {
-    return purry(_findLastIndex(true), args);
-  }
-  findLastIndex2.indexed = indexed;
-})(findLastIndex || (findLastIndex = {}));
-
-// src/array/find-last.ts
-function findLast(...args) {
-  return purry(_findLast(false), args);
-}
-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];
-      }
-    }
-    return void 0;
-  };
-}
-((findLast2) => {
-  function indexed(...args) {
-    return purry(_findLast(true), args);
-  }
-  findLast2.indexed = indexed;
-})(findLast || (findLast = {}));
-
-// src/array/find.ts
-function find(...args) {
-  return purry(_find(false), args, find.lazy);
-}
-function _find(indexed) {
-  return (array, fn) => {
-    if (indexed) {
-      return array.find(fn);
-    }
-    return array.find((x) => fn(x));
-  };
-}
-function _lazy2(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(...args) {
-    return purry(_find(true), args, find2.lazyIndexed);
-  }
-  find2.indexed = indexed;
-  find2.lazy = toSingle(_lazy2(false));
-  find2.lazyIndexed = toSingle(toLazyIndexed(_lazy2(true)));
-})(find || (find = {}));
-
-// src/array/first.ts
-function first(...args) {
-  return purry(_first, args, 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/first-by.ts
-function firstBy(...args) {
-  return purryOrderRules(firstByImplementation, args);
-}
-function firstByImplementation(data, compareFn) {
-  if (!hasAtLeast(data, 2)) {
-    return data[0];
-  }
-  let [currentFirst] = data;
-  const [, ...rest] = data;
-  for (const item of rest) {
-    if (compareFn(item, currentFirst) < 0) {
-      currentFirst = item;
-    }
-  }
-  return currentFirst;
-}
-
-// src/array/flat-map-to-obj.ts
-function flatMapToObj(...args) {
-  return purry(_flatMapToObj(false), args);
-}
-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(...args) {
-    return purry(_flatMapToObj(true), args);
-  }
-  flatMapToObj2.indexed = indexed;
-})(flatMapToObj || (flatMapToObj = {}));
-
-// src/array/flatten.ts
-function flatten(...args) {
-  return purry(_flatten, args, flatten.lazy);
-}
-function _flatten(items) {
-  return reduceLazy(items, flatten.lazy());
-}
-((flatten2) => {
-  function lazy() {
-    return (next) => {
-      if (Array.isArray(next)) {
-        return {
-          done: false,
-          hasMany: true,
-          hasNext: true,
-          next
-        };
-      }
-      return {
-        done: false,
-        hasNext: true,
-        next
-      };
-    };
-  }
-  flatten2.lazy = lazy;
-})(flatten || (flatten = {}));
-
-// src/array/flat-map.ts
-function flatMap(...args) {
-  return purry(_flatMap, args, 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,
-          hasMany: true,
-          hasNext: true,
-          next
-        };
-      }
-      return {
-        done: false,
-        hasNext: true,
-        next
-      };
-    };
-  }
-  flatMap2.lazy = lazy;
-})(flatMap || (flatMap = {}));
-
-// src/array/flatten-deep.ts
-function flattenDeep(...args) {
-  return purry(_flattenDeep, args, 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,
-          hasMany: true,
-          hasNext: true,
-          next
-        };
-      }
-      return {
-        done: false,
-        hasNext: true,
-        next
-      };
-    };
-  }
-  flattenDeep2.lazy = lazy;
-})(flattenDeep || (flattenDeep = {}));
-
-// src/array/for-each.ts
-function forEach(...args) {
-  return purry(_forEach(false), args, forEach.lazy);
-}
-function _forEach(indexed) {
-  return (array, fn) => {
-    return reduceLazy(
-      array,
-      indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
-      indexed
-    );
-  };
-}
-function _lazy3(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(...args) {
-    return purry(_forEach(true), args, forEach2.lazyIndexed);
-  }
-  forEach2.indexed = indexed;
-  forEach2.lazy = _lazy3(false);
-  forEach2.lazyIndexed = toLazyIndexed(_lazy3(true));
-})(forEach || (forEach = {}));
-
-// src/array/group-by.ts
-function groupBy(...args) {
-  return purry(_groupBy(false), args);
-}
-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);
-        let items = ret[actualKey];
-        if (items === void 0) {
-          items = [];
-          ret[actualKey] = items;
-        }
-        items.push(item);
-      }
-    });
-    return ret;
-  };
-}
-((groupBy2) => {
-  function indexed(...args) {
-    return purry(_groupBy(true), args);
-  }
-  groupBy2.indexed = indexed;
-  groupBy2.strict = groupBy2;
-})(groupBy || (groupBy = {}));
-
-// src/array/index-by.ts
-function indexBy(...args) {
-  return purry(_indexBy(false), args);
-}
-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(...args) {
-    return purry(_indexBy(true), args);
-  }
-  indexBy2.indexed = indexed;
-})(indexBy || (indexBy = {}));
-
-// src/array/intersection.ts
-function intersection(...args) {
-  return purry(_intersection, args, 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(...args) {
-  return purry(_intersectionWith, args, 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(...args) {
-  return purry(joinImplementation, args);
-}
-function joinImplementation(data, glue) {
-  return data.join(glue);
-}
-
-// src/array/last.ts
-function last(...args) {
-  return purry(_last, args);
-}
-function _last(array) {
-  return array[array.length - 1];
-}
-
-// src/array/length.ts
-function length(...args) {
-  return purry(_length, args);
-}
-function _length(items) {
-  return "length" in items ? items.length : Array.from(items).length;
-}
-
-// src/array/map.ts
-function map(...args) {
-  return purry(_map(false), args, map.lazy);
-}
-function _map(indexed) {
-  return (array, fn) => {
-    return reduceLazy(
-      array,
-      indexed ? map.lazyIndexed(fn) : map.lazy(fn),
-      indexed
-    );
-  };
-}
-function _lazy4(indexed) {
-  return (fn) => {
-    return (value, index, array) => {
-      return {
-        done: false,
-        hasNext: true,
-        next: indexed ? fn(value, index, array) : fn(value)
-      };
-    };
-  };
-}
-((map2) => {
-  function indexed(...args) {
-    return purry(_map(true), args, map2.lazyIndexed);
-  }
-  map2.indexed = indexed;
-  map2.lazy = _lazy4(false);
-  map2.lazyIndexed = toLazyIndexed(_lazy4(true));
-  map2.strict = map2;
-})(map || (map = {}));
-
-// src/array/map-to-obj.ts
-function mapToObj(...args) {
-  return purry(_mapToObj(false), args);
-}
-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(...args) {
-    return purry(_mapToObj(true), args);
-  }
-  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(...args) {
-  return purry(_maxBy(false), args);
-}
-((maxBy2) => {
-  function indexed(...args) {
-    return purry(_maxBy(true), args);
-  }
-  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(...args) {
-  return purry(_meanBy(false), args);
-}
-((meanBy2) => {
-  function indexed(...args) {
-    return purry(_meanBy(true), args);
-  }
-  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(...args) {
-  return purry(_minBy(false), args);
-}
-((minBy2) => {
-  function indexed(...args) {
-    return purry(_minBy(true), args);
-  }
-  minBy2.indexed = indexed;
-})(minBy || (minBy = {}));
-
-// src/utils/quick-select.ts
-function quickSelect(data, index, compareFn) {
-  return index < 0 || index >= data.length ? void 0 : quickSelectImplementation(
-    // We need to clone the array because quickSelect mutates it in-place.
-    [...data],
-    0,
-    data.length - 1,
-    index,
-    compareFn
-  );
-}
-function quickSelectImplementation(data, left, right, index, compareFn) {
-  if (left === right) {
-    return data[left];
-  }
-  const pivotIndex = partition(data, left, right, compareFn);
-  return index === pivotIndex ? data[index] : quickSelectImplementation(
-    data,
-    // We continue by recursing into the partition where index would be
-    index < pivotIndex ? left : pivotIndex + 1,
-    index < pivotIndex ? pivotIndex - 1 : right,
-    index,
-    compareFn
-  );
-}
-function partition(data, left, right, compareFn) {
-  const pivot = data[right];
-  let i = left;
-  for (let j = left; j < right; j++) {
-    if (compareFn(data[j], pivot) < 0) {
-      swapInPlace(data, i, j);
-      i++;
-    }
-  }
-  swapInPlace(data, i, right);
-  return i;
-}
-
-// src/array/nth-by.ts
-function nthBy(...args) {
-  return purryOrderRulesWithArgument(nthByImplementation, args);
-}
-function nthByImplementation(data, compareFn, index) {
-  return quickSelect(
-    data,
-    // Allow negative indices gracefully
-    index >= 0 ? index : data.length + index,
-    compareFn
-  );
-}
-
-// src/array/only.ts
-function only(...args) {
-  return purry(_only, args);
-}
-function _only(array) {
-  if (array.length === 1) {
-    return array[0];
-  }
-  return void 0;
-}
-
-// src/array/partition.ts
-function partition2(...args) {
-  return purry(_partition(false), args);
-}
-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;
-  };
-}
-((partition3) => {
-  function indexed(...args) {
-    return purry(_partition(true), args);
-  }
-  partition3.indexed = indexed;
-})(partition2 || (partition2 = {}));
-
-// src/array/range.ts
-function range(...args) {
-  return purry(_range, args);
-}
-function _range(start, end) {
-  const ret = [];
-  for (let i = start; i < end; i++) {
-    ret.push(i);
-  }
-  return ret;
-}
-
-// src/array/rank-by.ts
-function rankBy(...args) {
-  return purryOrderRulesWithArgument(rankByImplementation, args);
-}
-function rankByImplementation(data, compareFn, targetItem) {
-  let rank = 0;
-  for (const item of data) {
-    if (compareFn(targetItem, item) > 0) {
-      rank++;
-    }
-  }
-  return rank;
-}
-
-// src/array/reduce.ts
-function reduce(...args) {
-  return purry(_reduce(false), args);
-}
-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(...args) {
-    return purry(_reduce(true), args);
-  }
-  reduce2.indexed = indexed;
-})(reduce || (reduce = {}));
-
-// src/array/reject.ts
-function reject(...args) {
-  return purry(_reject(false), args, reject.lazy);
-}
-function _reject(indexed) {
-  return (array, fn) => {
-    return reduceLazy(
-      array,
-      indexed ? reject.lazyIndexed(fn) : reject.lazy(fn),
-      indexed
-    );
-  };
-}
-function _lazy5(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(...args) {
-    return purry(_reject(true), args, reject2.lazyIndexed);
-  }
-  reject2.indexed = indexed;
-  reject2.lazy = _lazy5(false);
-  reject2.lazyIndexed = toLazyIndexed(_lazy5(true));
-})(reject || (reject = {}));
-
-// src/array/reverse.ts
-function reverse(...args) {
-  return purry(_reverse, args);
-}
-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(...args) {
-  return purry(_shuffle, args);
-}
-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(...args) {
-  return purry(_sort, args);
-}
-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) ? [[arrayOrSortRule, ...sortRules]] : [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/splice.ts
-function splice(...args) {
-  return purry(_splice, args);
-}
-function _splice(items, start, deleteCount, replacement) {
-  const result = [...items];
-  result.splice(start, deleteCount, ...replacement);
-  return result;
-}
-
-// src/array/split-at.ts
-function splitAt(...args) {
-  return purry(_splitAt, args);
-}
-function _splitAt(array, index) {
-  const copy = [...array];
-  const tail = copy.splice(index);
-  return [copy, tail];
-}
-
-// src/array/split-when.ts
-function splitWhen(...args) {
-  return purry(_splitWhen, args);
-}
-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(...args) {
-  return purry(_sumBy(false), args);
-}
-((sumBy2) => {
-  function indexed(...args) {
-    return purry(_sumBy(true), args);
-  }
-  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(...args) {
-  return purry(_take, args, 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-first-by.ts
-function takeFirstBy(...args) {
-  return purryOrderRulesWithArgument(takeFirstByImplementation, args);
-}
-function takeFirstByImplementation(data, compareFn, n) {
-  if (n <= 0) {
-    return [];
-  }
-  if (n >= data.length) {
-    return [...data];
-  }
-  const heap = data.slice(0, n);
-  heapify(heap, compareFn);
-  const rest = data.slice(n);
-  for (const item of rest) {
-    heapMaybeInsert(heap, compareFn, item);
-  }
-  return heap;
-}
-
-// src/array/take-while.ts
-function takeWhile(...args) {
-  return purry(_takeWhile, args);
-}
-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(...args) {
-  return purry(_uniq, args, 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(...args) {
-  return purry(_uniqBy, args, 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(...args) {
-  return purry(_uniqWith, args, uniqWith.lazy);
-}
-function _uniqWith(array, isEquals) {
-  const lazy = uniqWith.lazy(isEquals);
-  return reduceLazy(array, lazy, true);
-}
-function _lazy6(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(_lazy6);
-})(uniqWith || (uniqWith = {}));
-
-// src/array/zip.ts
-function zip(...args) {
-  return purry(_zip, args);
-}
-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;
-}
-((zip2) => {
-  zip2.strict = zip2;
-})(zip || (zip = {}));
-
-// src/array/zip-obj.ts
-function zipObj(...args) {
-  return purry(_zipObj, args);
-}
-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(arg0, arg1, arg2) {
-  if (typeof arg0 === "function") {
-    return arg1 === void 0 ? (f, s) => _zipWith(f, s, arg0) : (f) => _zipWith(f, arg1, arg0);
-  }
-  if (arg1 === void 0 || arg2 === void 0) {
-    throw new Error("zipWith: Missing arguments in dataFirst function call");
-  }
-  return _zipWith(arg0, arg1, arg2);
-}
-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/utils/purry-on.ts
-function purryOn(isArg, implementation, args) {
-  const callArgs = Array.from(args);
-  return isArg(args[0]) ? (data) => implementation(data, ...callArgs) : implementation(...callArgs);
-}
-
-// src/function/conditional.ts
-function conditional(...args) {
-  return purryOn(isCase, conditionalImplementation, args);
-}
-function conditionalImplementation(data, ...cases) {
-  for (const [when, then] of cases) {
-    if (when(data)) {
-      return then(data);
-    }
-  }
-  throw new Error("conditional: data failed for all cases");
-}
-function isCase(maybeCase) {
-  if (!Array.isArray(maybeCase)) {
-    return false;
-  }
-  const [when, then, ...rest] = maybeCase;
-  return typeof when === "function" && when.length <= 1 && typeof then === "function" && then.length <= 1 && rest.length === 0;
-}
-var trivialDefaultCase = () => void 0;
-((conditional2) => {
-  function defaultCase(then = trivialDefaultCase) {
-    return [() => true, then];
-  }
-  conditional2.defaultCase = defaultCase;
-})(conditional || (conditional = {}));
-
-// src/function/pipe.ts
-function pipe(input, ...operations) {
-  let output = input;
-  const lazyOperations = operations.map(
-    (op) => "lazy" in op ? toPipedLazy(op) : void 0
-  );
-  let operationIndex = 0;
-  while (operationIndex < operations.length) {
-    const lazyOperation = lazyOperations[operationIndex];
-    if (lazyOperation === void 0 || !isIterable(output)) {
-      const operation = operations[operationIndex];
-      output = operation(output);
-      operationIndex++;
-      continue;
-    }
-    const lazySequence = [];
-    for (let j = operationIndex; j < operations.length; j++) {
-      const lazyOp = lazyOperations[j];
-      if (lazyOp === void 0) {
-        break;
-      }
-      lazySequence.push(lazyOp);
-      if (lazyOp.isSingle) {
-        break;
-      }
-    }
-    const accumulator = [];
-    const iterator = output[Symbol.iterator]();
-    while (true) {
-      const result = iterator.next();
-      if (result.done ?? false) {
-        break;
-      }
-      const shouldExitEarly = processItem_(
-        result.value,
-        accumulator,
-        lazySequence
-      );
-      if (shouldExitEarly) {
-        break;
-      }
-    }
-    const { isSingle } = lazySequence[lazySequence.length - 1];
-    if (isSingle) {
-      output = accumulator[0];
-    } else {
-      output = accumulator;
-    }
-    operationIndex += lazySequence.length;
-  }
-  return output;
-}
-function processItem_(item, accumulator, lazySequence) {
-  if (lazySequence.length === 0) {
-    accumulator.push(item);
-    return false;
-  }
-  let lazyResult = { done: false, hasNext: false };
-  let isDone = false;
-  for (let i = 0; i < lazySequence.length; i++) {
-    const lazyFn = lazySequence[i];
-    const { index, isIndexed, items } = lazyFn;
-    items.push(item);
-    lazyResult = isIndexed ? 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_(
-            subItem,
-            accumulator,
-            lazySequence.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) {
-    accumulator.push(item);
-  }
-  return isDone;
-}
-function toPipedLazy(op) {
-  const { lazy, lazyArgs } = op;
-  const fn = lazy(...lazyArgs ?? []);
-  return Object.assign(fn, {
-    index: 0,
-    isIndexed: lazy.indexed,
-    isSingle: lazy.single,
-    items: []
-  });
-}
-function isIterable(something) {
-  return typeof something === "string" || typeof something === "object" && something !== null && Symbol.iterator in something;
-}
-
-// 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/debounce.ts
-function debounce(func, {
-  maxWaitMs,
-  timing = "trailing",
-  waitMs
-}) {
-  if (maxWaitMs !== void 0 && waitMs !== void 0 && maxWaitMs < waitMs) {
-    throw new Error(
-      `debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`
-    );
-  }
-  let coolDownTimeoutId;
-  let maxWaitTimeoutId;
-  let latestCallArgs;
-  let result;
-  function handleDebouncedCall(args) {
-    latestCallArgs = args;
-    if (maxWaitMs !== void 0 && maxWaitTimeoutId === void 0) {
-      maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);
-    }
-  }
-  function handleInvoke() {
-    if (latestCallArgs === void 0) {
-      return;
-    }
-    if (maxWaitTimeoutId !== void 0) {
-      const timeoutId = maxWaitTimeoutId;
-      maxWaitTimeoutId = void 0;
-      clearTimeout(timeoutId);
-    }
-    const args = latestCallArgs;
-    latestCallArgs = void 0;
-    result = func(...args);
-  }
-  function handleCoolDownEnd() {
-    if (coolDownTimeoutId === void 0) {
-      return;
-    }
-    const timeoutId = coolDownTimeoutId;
-    coolDownTimeoutId = void 0;
-    clearTimeout(timeoutId);
-    if (latestCallArgs !== void 0) {
-      handleInvoke();
-    }
-  }
-  return {
-    get cachedValue() {
-      return result;
-    },
-    call: (...args) => {
-      if (coolDownTimeoutId === void 0) {
-        if (timing === "trailing") {
-          handleDebouncedCall(args);
-        } else {
-          result = func(...args);
-        }
-      } else {
-        if (timing !== "leading") {
-          handleDebouncedCall(args);
-        }
-        const timeoutId = coolDownTimeoutId;
-        coolDownTimeoutId = void 0;
-        clearTimeout(timeoutId);
-      }
-      coolDownTimeoutId = setTimeout(
-        handleCoolDownEnd,
-        // If waitMs is not defined but maxWaitMs *is* it means the user is only
-        // interested in the leaky-bucket nature of the debouncer which is
-        // achieved by setting waitMs === maxWaitMs. If both are not defined we
-        // default to 0 which would wait until the end of the execution frame.
-        waitMs ?? maxWaitMs ?? 0
-      );
-      return result;
-    },
-    cancel: () => {
-      if (coolDownTimeoutId !== void 0) {
-        const timeoutId = coolDownTimeoutId;
-        coolDownTimeoutId = void 0;
-        clearTimeout(timeoutId);
-      }
-      if (maxWaitTimeoutId !== void 0) {
-        const timeoutId = maxWaitTimeoutId;
-        maxWaitTimeoutId = void 0;
-        clearTimeout(timeoutId);
-      }
-      latestCallArgs = void 0;
-    },
-    flush: () => {
-      handleCoolDownEnd();
-      return result;
-    },
-    get isPending() {
-      return coolDownTimeoutId !== void 0;
-    }
-  };
-}
-
-// src/function/sleep.ts
-function sleep(timeout) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
-  });
-}
-
-// 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/guard/is-object.ts
-function isObject(data) {
-  if (typeof data !== "object" || data === null) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(data);
-  return proto === null || proto === Object.prototype;
-}
-
-// 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-symbol.ts
-function isSymbol(data) {
-  return typeof data === "symbol";
-}
-
-// src/number/add.ts
-function add(...args) {
-  return purry(_add, args);
-}
-function _add(value, addend) {
-  return value + addend;
-}
-
-// src/utils/with-precision.ts
-var MAX_PRECISION = 15;
-function withPrecision(roundingFn) {
-  return (value, precision) => {
-    if (precision === 0) {
-      return roundingFn(value);
-    }
-    if (!Number.isInteger(precision)) {
-      throw new TypeError(`precision must be an integer: ${precision}`);
-    }
-    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {
-      throw new RangeError(`precision must be between ${-MAX_PRECISION} and ${MAX_PRECISION}`);
-    }
-    if (Number.isNaN(value) || !Number.isFinite(value)) {
-      return roundingFn(value);
-    }
-    const multiplier = 10 ** precision;
-    return roundingFn(value * multiplier) / multiplier;
-  };
-}
-
-// src/number/ceil.ts
-function ceil(...args) {
-  return purry(withPrecision(Math.ceil), args);
-}
-
-// src/number/clamp.ts
-function clamp(...args) {
-  return purry(_clamp, args);
-}
-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/number/divide.ts
-function divide(...args) {
-  return purry(_divide, args);
-}
-function _divide(value, divisor) {
-  return value / divisor;
-}
-
-// src/number/floor.ts
-function floor(...args) {
-  return purry(withPrecision(Math.floor), args);
-}
-
-// src/number/multiply.ts
-function multiply(...args) {
-  return purry(_multiply, args);
-}
-function _multiply(value, multiplicand) {
-  return value * multiplicand;
-}
-
-// src/number/round.ts
-function round(...args) {
-  return purry(withPrecision(Math.round), args);
-}
-
-// src/number/subtract.ts
-function subtract(...args) {
-  return purry(_subtract, args);
-}
-function _subtract(value, subtrahend) {
-  return value - subtrahend;
-}
-
-// 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) {
-  if (val === null) {
-    return "Null";
-  }
-  if (val === void 0) {
-    return "Undefined";
-  }
-  return 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(...args) {
-  return purry(_equals, args);
-}
-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(...args) {
-  return purry(_forEachObj(false), args);
-}
-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(...args) {
-    return purry(_forEachObj(true), args);
-  }
-  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(...args) {
-  return purry(_invert, args);
-}
-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/to-pairs.ts
-function toPairs(...args) {
-  return purry(Object.entries, args);
-}
-((toPairs2) => {
-  toPairs2.strict = toPairs2;
-})(toPairs || (toPairs = {}));
-
-// src/object/map-keys.ts
-function mapKeys(...args) {
-  return purry(_mapKeys, args);
-}
-function _mapKeys(data, fn) {
-  const out = {};
-  for (const [key, value] of toPairs.strict(data)) {
-    out[fn(key, value)] = value;
-  }
-  return out;
-}
-
-// src/object/map-values.ts
-function mapValues(...args) {
-  return purry(_mapValues, args);
-}
-function _mapValues(data, fn) {
-  const out = {};
-  for (const [key, value] of toPairs.strict(data)) {
-    out[key] = fn(value, key);
-  }
-  return out;
-}
-
-// src/object/merge.ts
-function merge(...args) {
-  return purry(_merge, args);
-}
-function _merge(a, b) {
-  return Object.assign({}, a, b);
-}
-
-// src/object/merge-deep.ts
-function mergeDeep(...args) {
-  return purry(mergeDeepImplementation, args);
-}
-function mergeDeepImplementation(destination, source) {
-  const output = { ...destination, ...source };
-  for (const key in source) {
-    if (!(key in destination)) {
-      continue;
-    }
-    const destinationValue = destination[key];
-    if (!isRecord(destinationValue)) {
-      continue;
-    }
-    const sourceValue = source[key];
-    if (!isRecord(sourceValue)) {
-      continue;
-    }
-    output[key] = mergeDeepImplementation(destinationValue, sourceValue);
-  }
-  return output;
-}
-function isRecord(object) {
-  return typeof object === "object" && object !== null && Object.getPrototypeOf(object) === Object.prototype;
-}
-
-// src/object/omit.ts
-function omit(...args) {
-  return purry(_omit, args);
-}
-function _omit(data, propNames) {
-  if (!hasAtLeast(propNames, 1)) {
-    return { ...data };
-  }
-  if (!hasAtLeast(propNames, 2)) {
-    const [propName] = propNames;
-    const {
-      [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(...args) {
-  return purry(_omitBy, args);
-}
-function _omitBy(object, fn) {
-  if (object === void 0 || object === null) {
-    return object;
-  }
-  return keys.strict(object).reduce((acc, key) => {
-    if (!fn(object[key], key)) {
-      acc[key] = object[key];
-    }
-    return acc;
-  }, {});
-}
-
-// src/object/path-or.ts
-function pathOr(...args) {
-  return purry(_pathOr, args);
-}
-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(...args) {
-  return purry(_pick, args);
-}
-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(...args) {
-  return purry(_pickBy, args);
-}
-function _pickBy(object, fn) {
-  if (object == null) {
-    return {};
-  }
-  return keys.strict(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(...args) {
-  return purry(_set, args);
-}
-function _set(obj, prop2, value) {
-  return {
-    ...obj,
-    [prop2]: value
-  };
-}
-
-// src/object/set-path.ts
-function setPath(...args) {
-  return purry(_setPath, args);
-}
-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(...args) {
-  return purry(_swapProps, args);
-}
-function _swapProps(obj, key1, key2) {
-  const { [key1]: value1, [key2]: value2 } = obj;
-  return {
-    ...obj,
-    [key1]: value2,
-    [key2]: value1
-  };
-}
-
-// 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 !== char.toLowerCase();
-}
-function splitByCase(str, separators) {
-  const splitters = separators ?? STR_SPLITTERS;
-  const parts = [];
-  if (!str || !isString(str)) {
-    return parts;
-  }
-  let buff = "";
-  let previousUpper;
-  let previousSplitter;
-  for (const char of str) {
-    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.at(-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(str) {
-  return str ? str[0].toUpperCase() + str.slice(1) : "";
-}
-function toLowerFirst(str) {
-  return str ? str[0].toLowerCase() + str.slice(1) : "";
-}
-function toPascalCase(str, opts) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
-}
-function toCamelCase(str, opts) {
-  return toLowerFirst(toPascalCase(str || "", opts));
-}
-function toKebabCase(str, joiner) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
-}
-function toSnakeCase(str) {
-  return toKebabCase(str || "", "_");
-}
-function toFlatCase(str) {
-  return toKebabCase(str || "", "");
-}
-function toTrainCase(str, opts) {
-  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join("-");
-}
-var titleCaseExceptions = /^(a|an|and|as|at|but|by|for|if|in|is|nor|of|on|or|the|to|with)$/i;
-function titleCase(str, opts) {
-  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => titleCaseExceptions.test(p) ? p.toLowerCase() : toUpperFirst(opts?.normalize ? p.toLowerCase() : p)).join(" ");
-}
-
-// src/string/human-readable-file-size.ts
-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`;
-}
-
-// 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/slugify.ts
-function slugify(str) {
-  return str.normalize("NFD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z0-9]/g, " ").trim().replace(/\s+/g, "-");
-}
-
-// 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,
-  add,
-  addProp,
-  allPass,
-  anyPass,
-  ceil,
-  chunk,
-  clamp,
-  clone,
-  compact,
-  concat,
-  conditional,
-  countBy,
-  createPipe,
-  debounce,
-  difference,
-  differenceWith,
-  divide,
-  drop,
-  dropFirstBy,
-  dropLast,
-  dropLastWhile,
-  dropWhile,
-  equals,
-  filter,
-  find,
-  findIndex,
-  findLast,
-  findLastIndex,
-  first,
-  firstBy,
-  flatMap,
-  flatMapToObj,
-  flatten,
-  flattenDeep,
-  floor,
-  forEach,
-  forEachObj,
-  fromPairs,
-  groupBy,
-  hasAtLeast,
-  humanReadableFileSize,
-  identity,
-  indexBy,
-  intersection,
-  intersectionWith,
-  invert,
-  isArray,
-  isBoolean,
-  isBrowser,
-  isDate,
-  isDefined,
-  isEmpty,
-  isError,
-  isFunction,
-  isNil,
-  isNonNull,
-  isNot,
-  isNumber,
-  isObject,
-  isPromise,
-  isString,
-  isSymbol,
-  isTruthy,
-  isUppercase,
-  join,
-  keys,
-  last,
-  length,
-  map,
-  mapKeys,
-  mapToObj,
-  mapValues,
-  maxBy,
-  meanBy,
-  merge,
-  mergeAll,
-  mergeDeep,
-  minBy,
-  multiply,
-  noop,
-  nthBy,
-  omit,
-  omitBy,
-  once,
-  only,
-  partition,
-  pathOr,
-  pick,
-  pickBy,
-  pipe,
-  prop,
-  purry,
-  randomString,
-  range,
-  rankBy,
-  reduce,
-  reject,
-  reverse,
-  round,
-  sample,
-  set,
-  setPath,
-  shuffle,
-  sleep,
-  slugify,
-  sort,
-  sortBy,
-  splice,
-  splitAt,
-  splitByCase,
-  splitWhen,
-  stringToPath,
-  subtract,
-  sumBy,
-  swapIndices,
-  swapProps,
-  take,
-  takeFirstBy,
-  takeWhile,
-  titleCase,
-  toCamelCase,
-  toFlatCase,
-  toKebabCase,
-  toLowerFirst,
-  toPairs,
-  toPascalCase,
-  toSnakeCase,
-  toTrainCase,
-  toUpperFirst,
-  type,
-  uniq,
-  uniqBy,
-  uniqWith,
-  values,
-  zip,
-  zipObj,
-  zipWith
-});