@vinicunca/perkakas 0.5.3 → 0.5.4

package/dist/index.cjs

@@ -0,0 +1,2285 @@
+'use strict';
+
+function purry(fn, args, lazyFactory) {
+  const callArgs = Array.from(args);
+  const diff = fn.length - args.length;
+  if (diff === 0) {
+    return fn(...callArgs);
+  }
+  if (diff === 1) {
+    const ret = (data) => fn(data, ...callArgs);
+    const lazy = lazyFactory ?? fn.lazy;
+    return lazy === void 0 ? ret : Object.assign(ret, { lazy, lazyArgs: args });
+  }
+  throw new Error("Wrong number of arguments");
+}
+
+function addProp(...args) {
+  return purry(addProp_, args);
+}
+function addProp_(obj, prop, value) {
+  return {
+    ...obj,
+    [prop]: value
+  };
+}
+
+function add(...args) {
+  return purry(add_, args);
+}
+function add_(value, addend) {
+  return value + addend;
+}
+
+function allPass(...args) {
+  return purry(allPass_, args);
+}
+function allPass_(data, fns) {
+  return fns.every((fn) => fn(data));
+}
+
+function anyPass(...args) {
+  return purry(anyPass_, args);
+}
+function anyPass_(data, fns) {
+  return fns.some((fn) => fn(data));
+}
+
+function isString(data) {
+  return typeof data === "string";
+}
+
+const RE_NUMBER_CHAR = /\d/;
+const 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) {
+  var _a;
+  return str ? ((_a = str[0]) == null ? void 0 : _a.toUpperCase()) + str.slice(1) : "";
+}
+function toLowerFirst(str) {
+  var _a;
+  return str ? ((_a = str[0]) == null ? void 0 : _a.toLowerCase()) + str.slice(1) : "";
+}
+function toPascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => toUpperFirst((opts == null ? void 0 : 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 == null ? void 0 : opts.normalize) ? p.toLowerCase() : p)).join("-");
+}
+const titleCaseExceptions = /^(a|an|and|as|at|but|by|for|if|in|is|nor|of|on|or|the|to|with)$/i;
+function toTitleCase(str, opts) {
+  return (Array.isArray(str) ? str : splitByCase(str)).filter(Boolean).map((p) => titleCaseExceptions.test(p) ? p.toLowerCase() : toUpperFirst((opts == null ? void 0 : opts.normalize) ? p.toLowerCase() : p)).join(" ");
+}
+
+const 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;
+  };
+}
+
+function ceil(...args) {
+  return purry(_withPrecision(Math.ceil), args);
+}
+
+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++) {
+    ret[index] = array.slice(index * size, (index + 1) * size);
+  }
+  return ret;
+}
+
+function clamp(...args) {
+  return purry(clamp_, args);
+}
+function clamp_(value, { max, min }) {
+  if (min !== void 0 && value < min) {
+    return min;
+  }
+  if (max !== void 0 && value > max) {
+    return max;
+  }
+  return value;
+}
+
+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);
+}
+function type(val) {
+  if (val === null) {
+    return "Null";
+  }
+  if (val === void 0) {
+    return "Undefined";
+  }
+  return Object.prototype.toString.call(val).slice(8, -1);
+}
+
+function concat(...args) {
+  return purry(concat_, args);
+}
+function concat_(arr1, arr2) {
+  return arr1.concat(arr2);
+}
+
+function purryOn(isArg, implementation, args) {
+  const callArgs = Array.from(args);
+  return isArg(args[0]) ? (data) => implementation(data, ...callArgs) : implementation(...callArgs);
+}
+
+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;
+}
+const trivialDefaultCase = () => void 0;
+((conditional2) => {
+  function defaultCase(then = trivialDefaultCase) {
+    return [() => true, then];
+  }
+  conditional2.defaultCase = defaultCase;
+})(conditional || (conditional = {}));
+
+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;
+    }
+  };
+}
+
+function _reduceLazy(array, lazy, isIndexed = false) {
+  const out = [];
+  for (let index = 0; index < array.length; index++) {
+    const item = array[index];
+    const result = isIndexed ? lazy(item, index, array) : lazy(item);
+    if (result.hasMany === true) {
+      out.push(...result.next);
+    } else if (result.hasNext) {
+      out.push(result.next);
+    }
+    if (result.done) {
+      break;
+    }
+  }
+  return out;
+}
+
+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) => other.every((otherValue) => !isEquals(value, otherValue)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+  }
+  differenceWith2.lazy = lazy;
+})(differenceWith || (differenceWith = {}));
+
+function divide(...args) {
+  return purry(divide_, args);
+}
+function divide_(value, divisor) {
+  return value / divisor;
+}
+
+function swapInPlace(data, i, j) {
+  [data[i], data[j]] = [data[j], data[i]];
+}
+
+function hasAtLeast(...args) {
+  return purry(hasAtLeastImplementation, args);
+}
+function hasAtLeastImplementation(data, minimum) {
+  return data.length >= minimum;
+}
+
+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;
+  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;
+  }
+}
+
+const 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 [first, second, ...rest] = Array.from(inputArgs);
+  let arg;
+  let argRemoved;
+  if (isOrderRule(second)) {
+    arg = first;
+    argRemoved = [second, ...rest];
+  } else {
+    arg = second;
+    argRemoved = [first, ...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 { [direction]: comparator } = COMPARATORS;
+  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 == null ? void 0 : 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;
+}
+
+function dropFirstBy(...args) {
+  return purryOrderRulesWithArgument(dropFirstByImplementation, args);
+}
+function dropFirstByImplementation(data, compareFn, n) {
+  if (n >= data.length) {
+    return [];
+  }
+  if (n <= 0) {
+    return data.slice();
+  }
+  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;
+}
+
+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 [];
+}
+
+function dropLast(...args) {
+  return purry(dropLast_, args);
+}
+function dropLast_(array, n) {
+  const copy = array.slice();
+  if (n > 0) {
+    copy.splice(-n);
+  }
+  return copy;
+}
+
+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 [];
+}
+
+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 -= 1;
+        return { done: false, hasNext: false };
+      }
+      return { done: false, hasNext: true, next: value };
+    };
+  }
+  drop2.lazy = lazy;
+})(drop || (drop = {}));
+
+function entries(...args) {
+  return purry(Object.entries, args);
+}
+((entries2) => {
+  entries2.strict = entries2;
+})(entries || (entries = {}));
+
+function _toLazyIndexed(fn) {
+  return Object.assign(fn, { indexed: true });
+}
+
+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_$5(indexed) {
+  return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+}
+((filter2) => {
+  function indexed(...args) {
+    return purry(filter_(true), args, filter2.lazyIndexed);
+  }
+  filter2.indexed = indexed;
+  filter2.lazy = lazy_$5(false);
+  filter2.lazyIndexed = _toLazyIndexed(lazy_$5(true));
+})(filter || (filter = {}));
+
+function _toSingle(fn) {
+  return Object.assign(fn, { single: true });
+}
+
+function findIndex(...args) {
+  return purry(findIndex_(false), args, findIndex.lazy);
+}
+function findIndex_(indexed) {
+  return (array, fn) => array.findIndex((item, index, input) => indexed ? fn(item, index, input) : fn(item));
+}
+function lazy_$4(indexed) {
+  return (fn) => {
+    let actualIndex = 0;
+    return (value, index, array) => {
+      if (indexed ? fn(value, index, array) : fn(value)) {
+        return { done: true, hasNext: true, next: actualIndex };
+      }
+      actualIndex += 1;
+      return { done: false, hasNext: false };
+    };
+  };
+}
+((findIndex2) => {
+  function indexed(...args) {
+    return purry(findIndex_(true), args, findIndex2.lazyIndexed);
+  }
+  findIndex2.indexed = indexed;
+  findIndex2.lazy = _toSingle(lazy_$4(false));
+  findIndex2.lazyIndexed = _toSingle(_toLazyIndexed(lazy_$4(true)));
+})(findIndex || (findIndex = {}));
+
+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 = {}));
+
+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 = {}));
+
+function find(...args) {
+  return purry(find_(false), args, find.lazy);
+}
+function find_(indexed) {
+  return (array, fn) => array.find((item, index, input) => indexed ? fn(item, index, input) : fn(item));
+}
+function lazy_$3(indexed) {
+  return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value)) ? { done: true, hasNext: true, next: value } : { done: false, hasNext: false };
+}
+((find2) => {
+  function indexed(...args) {
+    return purry(find_(true), args, find2.lazyIndexed);
+  }
+  find2.indexed = indexed;
+  find2.lazy = _toSingle(lazy_$3(false));
+  find2.lazyIndexed = _toSingle(_toLazyIndexed(lazy_$3(true)));
+})(find || (find = {}));
+
+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;
+}
+
+function first(...args) {
+  return purry(first_, args, first.lazy);
+}
+function first_([item]) {
+  return item;
+}
+((first2) => {
+  function lazy() {
+    return (value) => ({ done: true, hasNext: true, next: value });
+  }
+  first2.lazy = lazy;
+  ((lazy2) => {
+    lazy2.single = true;
+  })(lazy = first2.lazy || (first2.lazy = {}));
+})(first || (first = {}));
+
+function flatten(...args) {
+  return purry(flatten_, args, flatten.lazy);
+}
+function flatten_(items) {
+  return _reduceLazy(items, flatten.lazy());
+}
+((flatten2) => {
+  function lazy() {
+    return (item) => (
+      // @ts-expect-error [ts2322] - We need to make LazyMany better so it accommodate the typing here...
+      Array.isArray(item) ? { done: false, hasMany: true, hasNext: true, next: item } : { done: false, hasNext: true, next: item }
+    );
+  }
+  flatten2.lazy = lazy;
+})(flatten || (flatten = {}));
+
+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);
+      return Array.isArray(next) ? { done: false, hasMany: true, hasNext: true, next } : { done: false, hasNext: true, next };
+    };
+  }
+  flatMap2.lazy = lazy;
+})(flatMap || (flatMap = {}));
+
+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 = [];
+  for (const item of value) {
+    if (Array.isArray(item)) {
+      ret.push(...flattenDeep(item));
+    } else {
+      ret.push(item);
+    }
+  }
+  return ret;
+}
+((flattenDeep2) => {
+  function lazy() {
+    return (value) => {
+      const next = flattenDeepValue_(value);
+      return Array.isArray(next) ? { done: false, hasMany: true, hasNext: true, next } : { done: false, hasNext: true, next };
+    };
+  }
+  flattenDeep2.lazy = lazy;
+})(flattenDeep || (flattenDeep = {}));
+
+function floor(...args) {
+  return purry(_withPrecision(Math.floor), args);
+}
+
+function forEachObj(...args) {
+  return purry(forEachObj_(false), args);
+}
+function forEachObj_(indexed) {
+  return (data, fn) => {
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        const { [key]: val } = data;
+        if (indexed) {
+          fn(val, key, data);
+        } else {
+          fn(val);
+        }
+      }
+    }
+    return data;
+  };
+}
+((forEachObj2) => {
+  function indexed(...args) {
+    return purry(forEachObj_(true), args);
+  }
+  forEachObj2.indexed = indexed;
+})(forEachObj || (forEachObj = {}));
+
+function forEach(...args) {
+  return purry(forEach_(false), args, forEach.lazy);
+}
+function forEach_(indexed) {
+  return (array, fn) => _reduceLazy(
+    array,
+    indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn),
+    indexed
+  );
+}
+function lazy_$2(indexed) {
+  return (fn) => (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 = lazy_$2(false);
+  forEach2.lazyIndexed = _toLazyIndexed(lazy_$2(true));
+})(forEach || (forEach = {}));
+
+function fromEntries(...args) {
+  return purry(fromEntriesImplementation, args);
+}
+function fromEntriesImplementation(entries) {
+  const out = {};
+  for (const [key, value] of entries) {
+    out[key] = value;
+  }
+  return out;
+}
+((fromEntries2) => {
+  fromEntries2.strict = fromEntries2;
+})(fromEntries || (fromEntries = {}));
+
+function fromKeys(...args) {
+  return purry(fromKeysImplementation, args);
+}
+function fromKeysImplementation(data, mapper) {
+  const result = {};
+  for (const key of data) {
+    result[key] = mapper(key);
+  }
+  return result;
+}
+
+function groupBy(...args) {
+  return purry(groupBy_(false), args);
+}
+function groupBy_(indexed) {
+  return (array, fn) => {
+    const ret = {};
+    for (const [index, item] of array.entries()) {
+      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 = {}));
+
+function isDeepEqual(...args) {
+  return purry(isDeepEqualImplementation, args);
+}
+function isDeepEqualImplementation(data, other) {
+  if (data === other) {
+    return true;
+  }
+  if (typeof data === "number" && typeof other === "number") {
+    return data !== data && other !== other;
+  }
+  if (typeof data !== "object" || typeof other !== "object") {
+    return false;
+  }
+  if (data === null || other === null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(data) !== Object.getPrototypeOf(other)) {
+    return false;
+  }
+  if (Array.isArray(data)) {
+    if (data.length !== other.length) {
+      return false;
+    }
+    for (let i = 0; i < data.length; i++) {
+      if (!isDeepEqualImplementation(
+        data[i],
+        other[i]
+      )) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (data instanceof Date) {
+    return data.getTime() === other.getTime();
+  }
+  if (data instanceof RegExp) {
+    return data.toString() === other.toString();
+  }
+  const keys = Object.keys(data);
+  if (keys.length !== Object.keys(other).length) {
+    return false;
+  }
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(other, key)) {
+      return false;
+    }
+    if (!isDeepEqualImplementation(data[key], other[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function hasSubObject(...args) {
+  return purry(_hasSubObject, args);
+}
+function _hasSubObject(data, subObject) {
+  for (const key of Object.keys(subObject)) {
+    if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      return false;
+    }
+    if (!isDeepEqual(subObject[key], data[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+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 identity(value) {
+  return value;
+}
+
+function indexBy(...args) {
+  return purry(indexBy_(false), args);
+}
+function indexBy_(indexed) {
+  return (array, fn) => {
+    const out = {};
+    for (const [index, item] of array.entries()) {
+      const value = indexed ? fn(item, index, array) : fn(item);
+      const key = String(value);
+      out[key] = item;
+    }
+    return out;
+  };
+}
+function indexByStrict(...args) {
+  return purry(indexByStrict_, args);
+}
+function indexByStrict_(array, fn) {
+  const out = {};
+  for (const item of array) {
+    const key = fn(item);
+    out[key] = item;
+  }
+  return out;
+}
+((indexBy2) => {
+  function indexed(...args) {
+    return purry(indexBy_(true), args);
+  }
+  indexBy2.indexed = indexed;
+  indexBy2.strict = indexByStrict;
+})(indexBy || (indexBy = {}));
+
+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) => other.some((otherValue) => comparator(value, otherValue)) ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+  }
+  intersectionWith2.lazy = lazy;
+})(intersectionWith || (intersectionWith = {}));
+
+function invert(...args) {
+  return purry(invert_, args);
+}
+function invert_(object) {
+  const result = {};
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      result[object[key]] = key;
+    }
+  }
+  return result;
+}
+
+function isArray(data) {
+  return Array.isArray(data);
+}
+
+function isBoolean(data) {
+  return typeof data === "boolean";
+}
+
+function isDate(data) {
+  return data instanceof Date;
+}
+
+function isDefined(data) {
+  return data !== void 0 && data !== null;
+}
+((isDefined2) => {
+  function strict(data) {
+    return data !== void 0;
+  }
+  isDefined2.strict = strict;
+})(isDefined || (isDefined = {}));
+
+function isObject(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(data);
+  return proto === null || proto === Object.prototype;
+}
+
+function isEmpty(data) {
+  if (data === void 0) {
+    return true;
+  }
+  if (isArray(data) || isString(data)) {
+    return data.length === 0;
+  }
+  if (isObject(data)) {
+    return Object.keys(data).length === 0;
+  }
+  return false;
+}
+
+function isError(data) {
+  return data instanceof Error;
+}
+
+function isFunction(data) {
+  return typeof data === "function";
+}
+
+function isIncludedIn(dataOrContainer, container) {
+  if (container === void 0) {
+    const asSet = new Set(dataOrContainer);
+    return (data) => asSet.has(data);
+  }
+  return container.includes(dataOrContainer);
+}
+
+function isNonNull(data) {
+  return data !== null;
+}
+
+function isNot(predicate) {
+  return (data) => !predicate(data);
+}
+
+function isNullish(data) {
+  return data === null || data === void 0;
+}
+
+function isNumber(data) {
+  return typeof data === "number" && !Number.isNaN(data);
+}
+
+function isPromise(data) {
+  return data instanceof Promise;
+}
+
+function isSymbol(data) {
+  return typeof data === "symbol";
+}
+
+function isTruthy(data) {
+  return !!data;
+}
+
+function join(...args) {
+  return purry(joinImplementation, args);
+}
+function joinImplementation(data, glue) {
+  return data.join(glue);
+}
+
+const 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"
+};
+
+function keys(...args) {
+  return purry(Object.keys, args);
+}
+((keys2) => {
+  keys2.strict = keys2;
+})(keys || (keys = {}));
+
+function last(...args) {
+  return purry(last_, args);
+}
+function last_(array) {
+  return array[array.length - 1];
+}
+
+function length(...args) {
+  return purry(length_, args);
+}
+function length_(items) {
+  return "length" in items ? items.length : Array.from(items).length;
+}
+
+function mapKeys(...args) {
+  return purry(mapKeys_, args);
+}
+function mapKeys_(data, fn) {
+  const out = {};
+  for (const [key, value] of entries.strict(data)) {
+    out[fn(key, value)] = value;
+  }
+  return out;
+}
+
+function mapToObj(...args) {
+  return purry(mapToObj_(false), args);
+}
+function mapToObj_(indexed) {
+  return (array, fn) => {
+    const out = {};
+    for (const [index, element] of array.entries()) {
+      const [key, value] = indexed ? fn(element, index, array) : fn(element);
+      out[key] = value;
+    }
+    return out;
+  };
+}
+((mapToObj2) => {
+  function indexed(...args) {
+    return purry(mapToObj_(true), args);
+  }
+  mapToObj2.indexed = indexed;
+})(mapToObj || (mapToObj = {}));
+
+function mapValues(...args) {
+  return purry(mapValues_, args);
+}
+function mapValues_(data, fn) {
+  const out = {};
+  for (const [key, value] of entries.strict(data)) {
+    out[key] = fn(value, key);
+  }
+  return out;
+}
+
+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 lazy_$1(indexed) {
+  return (fn) => (value, index, array) => ({
+    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 = lazy_$1(false);
+  map2.lazyIndexed = _toLazyIndexed(lazy_$1(true));
+  map2.strict = map2;
+})(map || (map = {}));
+
+function meanBy_(indexed) {
+  return (array, fn) => {
+    if (array.length === 0) {
+      return Number.NaN;
+    }
+    let sum = 0;
+    for (const [index, item] of array.entries()) {
+      sum += indexed ? fn(item, index, 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 = {}));
+
+function mergeAll(items) {
+  let out = {};
+  for (const item of items) {
+    out = { ...out, ...item };
+  }
+  return out;
+}
+
+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 { [key]: destinationValue } = destination;
+    if (!isRecord(destinationValue)) {
+      continue;
+    }
+    const { [key]: sourceValue } = source;
+    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;
+}
+
+function merge(...args) {
+  return purry(merge_, args);
+}
+function merge_(data, source) {
+  return { ...data, ...source };
+}
+
+function multiply(...args) {
+  return purry(multiply_, args);
+}
+function multiply_(value, multiplicand) {
+  return value * multiplicand;
+}
+
+function noop() {
+  return void 0;
+}
+
+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.slice(),
+    0,
+    data.length - 1,
+    index,
+    compareFn
+  );
+}
+function quickSelectImplementation(data, left, right, index, compareFn) {
+  if (left === right) {
+    return data[left];
+  }
+  const pivotIndex = partition$1(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$1(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 += 1;
+    }
+  }
+  swapInPlace(data, i, right);
+  return i;
+}
+
+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
+  );
+}
+
+function omitBy(...args) {
+  return purry(omitBy_, args);
+}
+function omitBy_(object, fn) {
+  if (object === void 0 || object === null) {
+    return object;
+  }
+  const out = {};
+  for (const key of keys.strict(object)) {
+    const k = key;
+    if (!fn(object[k], k)) {
+      out[k] = object[k];
+    }
+  }
+  return out;
+}
+
+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 fromEntries(
+    Object.entries(data).filter(([key]) => !asSet.has(key))
+  );
+}
+
+function once(fn) {
+  let called = false;
+  let ret;
+  return () => {
+    if (!called) {
+      ret = fn();
+      called = true;
+    }
+    return ret;
+  };
+}
+
+function only(...args) {
+  return purry(only_, args);
+}
+function only_(array) {
+  return array.length === 1 ? array[0] : void 0;
+}
+
+function partition(...args) {
+  return purry(partition_(false), args);
+}
+function partition_(indexed) {
+  return (array, fn) => {
+    const ret = [[], []];
+    for (const [index, item] of array.entries()) {
+      const matches = indexed ? fn(item, index, array) : fn(item);
+      ret[matches ? 0 : 1].push(item);
+    }
+    return ret;
+  };
+}
+((partition2) => {
+  function indexed(...args) {
+    return purry(partition_(true), args);
+  }
+  partition2.indexed = indexed;
+})(partition || (partition = {}));
+
+function pathOr(...args) {
+  return purry(pathOr_, args);
+}
+function pathOr_(data, path, defaultValue) {
+  let current = data;
+  for (const prop of path) {
+    if (current === null || current === void 0) {
+      break;
+    }
+    current = current[prop];
+  }
+  return current ?? defaultValue;
+}
+
+function pickBy(...args) {
+  return purry(pickBy_, args);
+}
+function pickBy_(data, fn) {
+  if (data === null || data === void 0) {
+    return {};
+  }
+  const out = {};
+  for (const key of keys.strict(data)) {
+    const k = key;
+    if (fn(data[k], k)) {
+      out[k] = data[k];
+    }
+  }
+  return out;
+}
+
+function pick(...args) {
+  return purry(pick_, args);
+}
+function pick_(object, names) {
+  const out = {};
+  for (const name of names) {
+    if (name in object) {
+      out[name] = object[name];
+    }
+  }
+  return out;
+}
+
+function pipe(input, ...operations) {
+  let output = input;
+  const lazyOperations = operations.map((op) => "lazy" in op ? prepareLazyOperation(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 += 1;
+      continue;
+    }
+    const lazySequence = [];
+    for (let index = operationIndex; index < operations.length; index++) {
+      const lazyOp = lazyOperations[index];
+      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];
+    output = isSingle ? accumulator[0] : accumulator;
+    operationIndex += lazySequence.length;
+  }
+  return output;
+}
+function processItem_(item, accumulator, lazySequence) {
+  if (lazySequence.length === 0) {
+    accumulator.push(item);
+    return false;
+  }
+  let currentItem = item;
+  let lazyResult = { done: false, hasNext: false };
+  let isDone = false;
+  for (const [operationsIndex, lazyFn] of lazySequence.entries()) {
+    const { index, isIndexed, items } = lazyFn;
+    items.push(currentItem);
+    lazyResult = isIndexed ? lazyFn(currentItem, index, items) : lazyFn(currentItem);
+    lazyFn.index += 1;
+    if (lazyResult.hasNext) {
+      if (lazyResult.hasMany ?? false) {
+        for (const subItem of lazyResult.next) {
+          const subResult = processItem_(
+            subItem,
+            accumulator,
+            lazySequence.slice(operationsIndex + 1)
+          );
+          if (subResult) {
+            return true;
+          }
+        }
+        return false;
+      }
+      currentItem = lazyResult.next;
+    }
+    if (!lazyResult.hasNext) {
+      break;
+    }
+    if (lazyResult.done) {
+      isDone = true;
+    }
+  }
+  if (lazyResult.hasNext) {
+    accumulator.push(currentItem);
+  }
+  return isDone;
+}
+function prepareLazyOperation(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;
+}
+
+function piped(...operations) {
+  return (value) => pipe(
+    value,
+    ...operations
+  );
+}
+
+function prop(propName) {
+  return ({ [propName]: value }) => value;
+}
+
+function times(...args) {
+  return purry(times_, args);
+}
+function times_(count, fn) {
+  if (count < 0) {
+    throw new RangeError("n must be a non-negative number");
+  }
+  const res = [];
+  for (let i = 0; i < count; i++) {
+    res.push(fn(i));
+  }
+  return res;
+}
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function randomString(...args) {
+  return purry(randomStringImplementation, args);
+}
+function randomStringImplementation(length) {
+  return times(length, randomChar).join("");
+}
+function randomChar() {
+  return ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
+}
+
+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;
+}
+
+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 += 1;
+    }
+  }
+  return rank;
+}
+
+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 = {}));
+
+function reverse(...args) {
+  return purry(reverse_, args);
+}
+function reverse_(array) {
+  return array.slice().reverse();
+}
+
+function round(...args) {
+  return purry(_withPrecision(Math.round), args);
+}
+
+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.slice();
+  }
+  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));
+}
+
+function setPath(...args) {
+  return purry(setPath_, args);
+}
+function setPath_(data, path, value) {
+  const [current, ...rest] = path;
+  if (current === void 0) {
+    return value;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item, index) => index === current ? setPath_(item, rest, value) : item);
+  }
+  if (data === null || data === void 0) {
+    throw new Error("Path doesn't exist in object!");
+  }
+  return {
+    ...data,
+    [current]: setPath_(
+      data[current],
+      rest,
+      value
+    )
+  };
+}
+
+function set(...args) {
+  return purry(set_, args);
+}
+function set_(obj, prop, value) {
+  return {
+    ...obj,
+    [prop]: value
+  };
+}
+
+function shuffle(...args) {
+  return purry(shuffle_, args);
+}
+function shuffle_(items) {
+  const result = items.slice();
+  for (let index = 0; index < items.length; index++) {
+    const rand = index + Math.floor(Math.random() * (items.length - index));
+    const value = result[rand];
+    result[rand] = result[index];
+    result[index] = value;
+  }
+  return result;
+}
+
+function sleep(timeout) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+}
+
+function slugify(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z0-9]/g, " ").trim().replace(/\s+/g, "-");
+}
+
+function sortBy(...args) {
+  return purryOrderRules(_sortBy, args);
+}
+function _sortBy(data, compareFn) {
+  return data.slice().sort(compareFn);
+}
+((sortBy2) => {
+  sortBy2.strict = sortBy2;
+})(sortBy || (sortBy = {}));
+
+function sort(...args) {
+  return purry(sort_, args);
+}
+function sort_(items, cmp) {
+  const ret = items.slice();
+  ret.sort(cmp);
+  return ret;
+}
+((sort2) => {
+  sort2.strict = sort2;
+})(sort || (sort = {}));
+
+function _binarySearchCutoffIndex(array, predicate) {
+  let lowIndex = 0;
+  let highIndex = array.length;
+  while (lowIndex < highIndex) {
+    const pivotIndex = lowIndex + highIndex >>> 1;
+    const pivot = array[pivotIndex];
+    if (predicate(pivot, pivotIndex)) {
+      lowIndex = pivotIndex + 1;
+    } else {
+      highIndex = pivotIndex;
+    }
+  }
+  return highIndex;
+}
+
+function sortedIndexBy(...args) {
+  return purry(sortedIndexByImplementation, args);
+}
+((sortedIndexBy2) => {
+  function indexed(...args) {
+    return purry(sortedIndexByImplementation, args);
+  }
+  sortedIndexBy2.indexed = indexed;
+})(sortedIndexBy || (sortedIndexBy = {}));
+function sortedIndexByImplementation(array, item, valueFunction) {
+  const value = valueFunction(item);
+  return _binarySearchCutoffIndex(
+    array,
+    (pivot, index) => valueFunction(pivot, index) < value
+  );
+}
+
+function sortedIndexWith(...args) {
+  return purry(_binarySearchCutoffIndex, args);
+}
+((sortedIndexWith2) => {
+  function indexed(...args) {
+    return purry(_binarySearchCutoffIndex, args);
+  }
+  sortedIndexWith2.indexed = indexed;
+})(sortedIndexWith || (sortedIndexWith = {}));
+
+function sortedIndex(...args) {
+  return purry(sortedIndexImplementation, args);
+}
+function sortedIndexImplementation(array, item) {
+  return _binarySearchCutoffIndex(array, (pivot) => pivot < item);
+}
+
+function sortedLastIndexBy(...args) {
+  return purry(sortedLastIndexByImplementation, args);
+}
+((sortedLastIndexBy2) => {
+  function indexed(...args) {
+    return purry(sortedLastIndexByImplementation, args);
+  }
+  sortedLastIndexBy2.indexed = indexed;
+})(sortedLastIndexBy || (sortedLastIndexBy = {}));
+function sortedLastIndexByImplementation(array, item, valueFunction) {
+  const value = valueFunction(item);
+  return _binarySearchCutoffIndex(
+    array,
+    // The only difference between the regular implementation and the "last"
+    // variation is that we consider the pivot with equality too, so that we
+    // skip all equal values in addition to the lower ones.
+    (pivot, index) => valueFunction(pivot, index) <= value
+  );
+}
+
+function sortedLastIndex(...args) {
+  return purry(sortedLastIndexImplementation, args);
+}
+function sortedLastIndexImplementation(array, item) {
+  return _binarySearchCutoffIndex(
+    array,
+    // The only difference between the regular implementation and the "last"
+    // variation is that we consider the pivot with equality too, so that we
+    // skip all equal values in addition to the lower ones.
+    (pivot) => pivot <= item
+  );
+}
+
+function splice(...args) {
+  return purry(splice_, args);
+}
+function splice_(items, start, deleteCount, replacement) {
+  const result = items.slice();
+  result.splice(start, deleteCount, ...replacement);
+  return result;
+}
+
+function splitAt(...args) {
+  return purry(splitAt_, args);
+}
+function splitAt_(array, index) {
+  const copy = array.slice();
+  const tail = copy.splice(index);
+  return [copy, tail];
+}
+
+function splitWhen(...args) {
+  return purry(splitWhen_, args);
+}
+function splitWhen_(array, fn) {
+  for (const [index, item] of array.entries()) {
+    if (fn(item)) {
+      return splitAt(array, index);
+    }
+  }
+  return [array.slice(), []];
+}
+
+function stringToPath(path) {
+  return stringToPath_(path);
+}
+function stringToPath_(path) {
+  if (path.length === 0) {
+    return [];
+  }
+  const match = /^\[(.+?)\](.*)$/u.exec(path) ?? /^\.?([^.[\]]+)(.*)$/u.exec(path);
+  if (match !== null) {
+    const [, key, rest] = match;
+    return [key, ...stringToPath_(rest)];
+  }
+  return [path];
+}
+
+function subtract(...args) {
+  return purry(subtract_, args);
+}
+function subtract_(value, subtrahend) {
+  return value - subtrahend;
+}
+
+function sumBy_(indexed) {
+  return (array, fn) => {
+    let sum = 0;
+    for (const [index, item] of array.entries()) {
+      const summand = indexed ? fn(item, index, 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 = {}));
+
+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("");
+}
+
+function swapProps(...args) {
+  return purry(swapProps_, args);
+}
+function swapProps_(obj, key1, key2) {
+  const { [key1]: value1, [key2]: value2 } = obj;
+  return {
+    ...obj,
+    [key1]: value2,
+    [key2]: value1
+  };
+}
+
+function takeFirstBy(...args) {
+  return purryOrderRulesWithArgument(takeFirstByImplementation, args);
+}
+function takeFirstByImplementation(data, compareFn, n) {
+  if (n <= 0) {
+    return [];
+  }
+  if (n >= data.length) {
+    return data.slice();
+  }
+  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;
+}
+
+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;
+}
+
+function take(...args) {
+  return purry(take_, args, take.lazy);
+}
+function take_(array, n) {
+  return _reduceLazy(array, take.lazy(n));
+}
+((take2) => {
+  function lazy(n) {
+    if (n <= 0) {
+      return () => ({ done: true, hasNext: false });
+    }
+    let remaining = n;
+    return (value) => {
+      remaining -= 1;
+      return { done: remaining <= 0, hasNext: true, next: value };
+    };
+  }
+  take2.lazy = lazy;
+})(take || (take = {}));
+
+function uniqueBy(...args) {
+  return purry(uniqueByImplementation, args, lazyUniqueBy);
+}
+function uniqueByImplementation(data, keyFunction) {
+  return _reduceLazy(data, lazyUniqueBy(keyFunction));
+}
+function lazyUniqueBy(keyFunction) {
+  const set = /* @__PURE__ */ new Set();
+  return (value) => {
+    const key = keyFunction(value);
+    if (set.has(key)) {
+      return { done: false, hasNext: false };
+    }
+    set.add(key);
+    return { done: false, hasNext: true, next: value };
+  };
+}
+
+function uniqueWith(...args) {
+  return purry(uniqueWithImplementation, args, uniqueWith.lazy);
+}
+function uniqueWithImplementation(array, isEquals) {
+  const lazy = uniqueWith.lazy(isEquals);
+  return _reduceLazy(array, lazy, true);
+}
+function lazy_(isEquals) {
+  return (value, index, array) => array !== void 0 && array.findIndex((otherValue) => isEquals(value, otherValue)) === index ? { done: false, hasNext: true, next: value } : { done: false, hasNext: false };
+}
+((uniqueWith2) => {
+  uniqueWith2.lazy = _toLazyIndexed(lazy_);
+})(uniqueWith || (uniqueWith = {}));
+
+function unique(...args) {
+  return purry(uniqueImplementation, args, unique.lazy);
+}
+function uniqueImplementation(array) {
+  return _reduceLazy(array, unique.lazy());
+}
+((unique2) => {
+  function lazy() {
+    const set = /* @__PURE__ */ new Set();
+    return (value) => {
+      if (set.has(value)) {
+        return { done: false, hasNext: false };
+      }
+      set.add(value);
+      return { done: false, hasNext: true, next: value };
+    };
+  }
+  unique2.lazy = lazy;
+})(unique || (unique = {}));
+
+function values(source) {
+  return Object.values(source);
+}
+
+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_(first, second, fn) {
+  const resultLength = first.length > second.length ? second.length : first.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push(fn(first[i], second[i]));
+  }
+  return result;
+}
+
+function zip(...args) {
+  return purry(zip_, args);
+}
+function zip_(first, second) {
+  const resultLength = first.length > second.length ? second.length : first.length;
+  const result = [];
+  for (let i = 0; i < resultLength; i++) {
+    result.push([first[i], second[i]]);
+  }
+  return result;
+}
+((zip2) => {
+  zip2.strict = zip2;
+})(zip || (zip = {}));
+
+const isBrowser = typeof window !== "undefined";
+
+exports.KEY_CODES = KEY_CODES;
+exports.add = add;
+exports.addProp = addProp;
+exports.allPass = allPass;
+exports.anyPass = anyPass;
+exports.ceil = ceil;
+exports.chunk = chunk;
+exports.clamp = clamp;
+exports.clone = clone;
+exports.concat = concat;
+exports.conditional = conditional;
+exports.debounce = debounce;
+exports.differenceWith = differenceWith;
+exports.divide = divide;
+exports.drop = drop;
+exports.dropFirstBy = dropFirstBy;
+exports.dropLast = dropLast;
+exports.dropLastWhile = dropLastWhile;
+exports.dropWhile = dropWhile;
+exports.entries = entries;
+exports.filter = filter;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
+exports.first = first;
+exports.firstBy = firstBy;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flattenDeep = flattenDeep;
+exports.floor = floor;
+exports.forEach = forEach;
+exports.forEachObj = forEachObj;
+exports.fromEntries = fromEntries;
+exports.fromKeys = fromKeys;
+exports.groupBy = groupBy;
+exports.hasAtLeast = hasAtLeast;
+exports.hasSubObject = hasSubObject;
+exports.humanReadableFileSize = humanReadableFileSize;
+exports.identity = identity;
+exports.indexBy = indexBy;
+exports.intersectionWith = intersectionWith;
+exports.invert = invert;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isBrowser = isBrowser;
+exports.isDate = isDate;
+exports.isDeepEqual = isDeepEqual;
+exports.isDefined = isDefined;
+exports.isEmpty = isEmpty;
+exports.isError = isError;
+exports.isFunction = isFunction;
+exports.isIncludedIn = isIncludedIn;
+exports.isNonNull = isNonNull;
+exports.isNot = isNot;
+exports.isNullish = isNullish;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPromise = isPromise;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTruthy = isTruthy;
+exports.isUppercase = isUppercase;
+exports.join = join;
+exports.keys = keys;
+exports.last = last;
+exports.length = length;
+exports.map = map;
+exports.mapKeys = mapKeys;
+exports.mapToObj = mapToObj;
+exports.mapValues = mapValues;
+exports.meanBy = meanBy;
+exports.merge = merge;
+exports.mergeAll = mergeAll;
+exports.mergeDeep = mergeDeep;
+exports.multiply = multiply;
+exports.noop = noop;
+exports.nthBy = nthBy;
+exports.omit = omit;
+exports.omitBy = omitBy;
+exports.once = once;
+exports.only = only;
+exports.partition = partition;
+exports.pathOr = pathOr;
+exports.pick = pick;
+exports.pickBy = pickBy;
+exports.pipe = pipe;
+exports.piped = piped;
+exports.prop = prop;
+exports.purry = purry;
+exports.randomString = randomString;
+exports.range = range;
+exports.rankBy = rankBy;
+exports.reduce = reduce;
+exports.reverse = reverse;
+exports.round = round;
+exports.sample = sample;
+exports.set = set;
+exports.setPath = setPath;
+exports.setPath_ = setPath_;
+exports.shuffle = shuffle;
+exports.sleep = sleep;
+exports.slugify = slugify;
+exports.sort = sort;
+exports.sortBy = sortBy;
+exports.sortedIndex = sortedIndex;
+exports.sortedIndexBy = sortedIndexBy;
+exports.sortedIndexWith = sortedIndexWith;
+exports.sortedLastIndex = sortedLastIndex;
+exports.sortedLastIndexBy = sortedLastIndexBy;
+exports.splice = splice;
+exports.splitAt = splitAt;
+exports.splitByCase = splitByCase;
+exports.splitWhen = splitWhen;
+exports.stringToPath = stringToPath;
+exports.subtract = subtract;
+exports.sumBy = sumBy;
+exports.swapIndices = swapIndices;
+exports.swapProps = swapProps;
+exports.take = take;
+exports.takeFirstBy = takeFirstBy;
+exports.takeWhile = takeWhile;
+exports.times = times;
+exports.toCamelCase = toCamelCase;
+exports.toFlatCase = toFlatCase;
+exports.toKebabCase = toKebabCase;
+exports.toLowerFirst = toLowerFirst;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.toTitleCase = toTitleCase;
+exports.toTrainCase = toTrainCase;
+exports.toUpperFirst = toUpperFirst;
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;
+exports.uniqueWith = uniqueWith;
+exports.values = values;
+exports.zip = zip;
+exports.zipWith = zipWith;