@vinicunca/perkakas 0.1.0 → 0.3.1

package/dist/index.js

@@ -1,2260 +0,0 @@
-// 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/pipe.ts
-function pipe(value, ...operations) {
-  let ret = value;
-  const lazyOps = operations.map((op) => {
-    const { lazy, lazyArgs } = op;
-    if (lazy) {
-      const fn = lazy(...lazyArgs || []);
-      fn.indexed = lazy.indexed;
-      fn.single = lazy.single;
-      fn.index = 0;
-      fn.items = [];
-      return fn;
-    }
-    return null;
-  });
-  let opIdx = 0;
-  while (opIdx < operations.length) {
-    const op = operations[opIdx];
-    const lazyOp = lazyOps[opIdx];
-    if (!lazyOp) {
-      ret = op(ret);
-      opIdx++;
-      continue;
-    }
-    const lazySeq = [];
-    for (let j = opIdx; j < operations.length; j++) {
-      if (lazyOps[j]) {
-        lazySeq.push(lazyOps[j]);
-        if (lazyOps[j].single) {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    const acc = [];
-    for (const item of ret) {
-      if (_processItem({ acc, item, lazySeq })) {
-        break;
-      }
-    }
-    const lastLazySeq = lazySeq[lazySeq.length - 1];
-    if (lastLazySeq.single) {
-      ret = acc[0];
-    } else {
-      ret = acc;
-    }
-    opIdx += lazySeq.length;
-  }
-  return ret;
-}
-function _processItem({
-  acc,
-  item,
-  lazySeq
-}) {
-  if (lazySeq.length === 0) {
-    acc.push(item);
-    return false;
-  }
-  let lazyResult = { done: false, hasNext: false };
-  let isDone = false;
-  for (let i = 0; i < lazySeq.length; i++) {
-    const lazyFn = lazySeq[i];
-    const indexed = lazyFn.indexed;
-    const index = lazyFn.index;
-    const items = lazyFn.items;
-    items.push(item);
-    lazyResult = indexed ? lazyFn(item, index, items) : lazyFn(item);
-    lazyFn.index++;
-    if (lazyResult.hasNext) {
-      if (lazyResult.hasMany) {
-        const nextValues = lazyResult.next;
-        for (const subItem of nextValues) {
-          const subResult = _processItem({
-            acc,
-            item: subItem,
-            lazySeq: lazySeq.slice(i + 1)
-          });
-          if (subResult) {
-            return true;
-          }
-        }
-        return false;
-      } else {
-        item = lazyResult.next;
-      }
-    }
-    if (!lazyResult.hasNext) {
-      break;
-    }
-    if (lazyResult.done) {
-      isDone = true;
-    }
-  }
-  if (lazyResult.hasNext) {
-    acc.push(item);
-  }
-  return !!isDone;
-}
-
-// 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/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/function/sleep.ts
-function sleep(timeout) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
-  });
-}
-
-// 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-array.ts
-function isArray(data) {
-  return Array.isArray(data);
-}
-
-// src/guard/is-boolean.ts
-function isBoolean(data) {
-  return typeof data === "boolean";
-}
-
-// src/guard/is-date.ts
-function isDate(data) {
-  return data instanceof Date;
-}
-
-// src/guard/is-defined.ts
-function isDefined(data) {
-  return typeof data !== "undefined" && data !== null;
-}
-((isDefined2) => {
-  function strict(data) {
-    return data !== void 0;
-  }
-  isDefined2.strict = strict;
-})(isDefined || (isDefined = {}));
-
-// src/base.ts
-function toString(value) {
-  return Object.prototype.toString.call(value);
-}
-
-// src/guard/is-object.ts
-function isObject(data) {
-  return toString(data) === "[object Object]";
-}
-
-// src/guard/is-string.ts
-function isString(data) {
-  return typeof data === "string";
-}
-
-// src/guard/is-empty.ts
-function isEmpty(data) {
-  if (isArray(data) || isString(data)) {
-    return data.length === 0;
-  }
-  if (isObject(data)) {
-    for (const _ in data) {
-      return false;
-    }
-    return !(data instanceof RegExp);
-  }
-  return false;
-}
-
-// src/guard/is-error.ts
-function isError(data) {
-  return data instanceof Error;
-}
-
-// src/guard/is-function.ts
-function isFunction(data) {
-  return typeof data === "function";
-}
-
-// src/guard/is-nil.ts
-function isNil(data) {
-  return data == null;
-}
-
-// src/guard/is-non-null.ts
-function isNonNull(data) {
-  return data !== null;
-}
-
-// src/guard/is-not.ts
-function isNot(predicate) {
-  return (data) => {
-    return !predicate(data);
-  };
-}
-
-// src/guard/is-number.ts
-function isNumber(data) {
-  return typeof data === "number" && !Number.isNaN(data);
-}
-
-// src/guard/is-promise.ts
-function isPromise(data) {
-  return data instanceof Promise;
-}
-
-// src/guard/is-truthy.ts
-function isTruthy(data) {
-  return !!data;
-}
-
-// src/array/compact.ts
-function compact(items) {
-  return items.filter(isTruthy);
-}
-
-// src/array/concat.ts
-function concat(...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/utils/to-lazy-indexed.ts
-function toLazyIndexed(fn) {
-  fn.indexed = true;
-  return fn;
-}
-
-// 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 _lazy2(indexed) {
-  return (fn) => {
-    let i = 0;
-    return (value, index, array) => {
-      const valid = indexed ? fn(value, index, array) : fn(value);
-      if (valid) {
-        return {
-          done: true,
-          hasNext: true,
-          next: i
-        };
-      }
-      i++;
-      return {
-        done: false,
-        hasNext: false
-      };
-    };
-  };
-}
-((findIndex2) => {
-  function indexed(...args) {
-    return purry(_findIndex(true), args, findIndex2.lazyIndexed);
-  }
-  findIndex2.indexed = indexed;
-  findIndex2.lazy = toSingle(_lazy2(false));
-  findIndex2.lazyIndexed = toSingle(toLazyIndexed(_lazy2(true)));
-})(findIndex || (findIndex = {}));
-
-// src/array/find-last-index.ts
-function findLastIndex(...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];
-      }
-    }
-  };
-}
-((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 _lazy3(indexed) {
-  return (fn) => {
-    return (value, index, array) => {
-      const valid = indexed ? fn(value, index, array) : fn(value);
-      return {
-        done: valid,
-        hasNext: valid,
-        next: value
-      };
-    };
-  };
-}
-((find2) => {
-  function indexed(...args) {
-    return purry(_find(true), args, find2.lazyIndexed);
-  }
-  find2.indexed = indexed;
-  find2.lazy = toSingle(_lazy3(false));
-  find2.lazyIndexed = toSingle(toLazyIndexed(_lazy3(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/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 _lazy4(indexed) {
-  return (fn) => {
-    return (value, index, array) => {
-      if (indexed) {
-        fn(value, index, array);
-      } else {
-        fn(value);
-      }
-      return {
-        done: false,
-        hasNext: true,
-        next: value
-      };
-    };
-  };
-}
-((forEach2) => {
-  function indexed(...args) {
-    return purry(_forEach(true), args, forEach2.lazyIndexed);
-  }
-  forEach2.indexed = indexed;
-  forEach2.lazy = _lazy4(false);
-  forEach2.lazyIndexed = toLazyIndexed(_lazy4(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);
-        if (!ret[actualKey]) {
-          ret[actualKey] = [];
-        }
-        ret[actualKey].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 _lazy5(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 = _lazy5(false);
-  map2.lazyIndexed = toLazyIndexed(_lazy5(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/array/partition.ts
-function partition(...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;
-  };
-}
-((partition2) => {
-  function indexed(...args) {
-    return purry(_partition(true), args);
-  }
-  partition2.indexed = indexed;
-})(partition || (partition = {}));
-
-// 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/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 _lazy6(indexed) {
-  return (fn) => {
-    return (value, index, array) => {
-      const valid = indexed ? fn(value, index, array) : fn(value);
-      if (!valid) {
-        return {
-          done: false,
-          hasNext: true,
-          next: value
-        };
-      }
-      return {
-        done: false,
-        hasNext: false
-      };
-    };
-  };
-}
-((reject2) => {
-  function indexed(...args) {
-    return purry(_reject(true), args, reject2.lazyIndexed);
-  }
-  reject2.indexed = indexed;
-  reject2.lazy = _lazy6(false);
-  reject2.lazyIndexed = toLazyIndexed(_lazy6(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/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-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 _lazy7(isEquals) {
-  return (value, index, array) => {
-    if (array && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
-      return {
-        done: false,
-        hasNext: true,
-        next: value
-      };
-    }
-    return {
-      done: false,
-      hasNext: false
-    };
-  };
-}
-((uniqWith2) => {
-  uniqWith2.lazy = toLazyIndexed(_lazy7);
-})(uniqWith || (uniqWith = {}));
-
-// src/array/zip.ts
-function zip(...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(...args) {
-  if (typeof args[0] === "function" && args.length === 1) {
-    return function(f, s) {
-      return _zipWith(f, s, args[0]);
-    };
-  }
-  if (typeof args[0] === "function" && args.length === 2) {
-    return function(f) {
-      return _zipWith(f, args[1], args[0]);
-    };
-  }
-  if (args.length === 3) {
-    return _zipWith(args[0], args[1], args[2]);
-  }
-}
-function _zipWith(first2, second, fn) {
-  const resultLength = first2.length > second.length ? second.length : first2.length;
-  const result = [];
-  for (let i = 0; i < resultLength; i++) {
-    result.push(fn(first2[i], second[i]));
-  }
-  return result;
-}
-
-// src/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/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/map-keys.ts
-function mapKeys(arg1, arg2) {
-  if (arguments.length === 1) {
-    return (data) => _mapKeys(data, arg1);
-  }
-  return _mapKeys(arg1, arg2);
-}
-function _mapKeys(obj, fn) {
-  return Object.keys(obj).reduce((acc, key) => {
-    acc[fn(key, obj[key])] = obj[key];
-    return acc;
-  }, {});
-}
-
-// src/object/map-values.ts
-function mapValues(arg1, arg2) {
-  if (arguments.length === 1) {
-    return (data) => _mapValues(data, arg1);
-  }
-  return _mapValues(arg1, arg2);
-}
-function _mapValues(obj, fn) {
-  return Object.keys(obj).reduce((acc, key) => {
-    acc[key] = fn(obj[key], key);
-    return acc;
-  }, {});
-}
-
-// src/object/merge.ts
-function merge(...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 (propNames.length === 0) {
-    return { ...data };
-  }
-  if (propNames.length === 1) {
-    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) {
-  return Object.keys(object).reduce((acc, key) => {
-    if (!fn(object[key], key)) {
-      acc[key] = object[key];
-    }
-    return acc;
-  }, {});
-}
-
-// src/object/path-or.ts
-function pathOr(...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 Object.keys(object).reduce((acc, key) => {
-    if (fn(object[key], key)) {
-      acc[key] = object[key];
-    }
-    return acc;
-  }, {});
-}
-
-// src/object/prop.ts
-function prop(propName) {
-  return ({ [propName]: value }) => value;
-}
-
-// src/object/set.ts
-function set(...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/to-pairs.ts
-function toPairs(object) {
-  return Object.entries(object);
-}
-((toPairs2) => {
-  function strict(object) {
-    return Object.entries(object);
-  }
-  toPairs2.strict = strict;
-})(toPairs || (toPairs = {}));
-
-// src/object/values.ts
-function values(source) {
-  return Object.values(source);
-}
-
-// src/string/cases.ts
-var RE_NUMBER_CHAR = /\d/;
-var STR_SPLITTERS = ["-", "_", "/", "."];
-function isUppercase(char = "") {
-  if (RE_NUMBER_CHAR.test(char)) {
-    return void 0;
-  }
-  return char.toUpperCase() === char;
-}
-function splitByCase(string_, separators) {
-  const splitters = separators ?? STR_SPLITTERS;
-  const parts = [];
-  if (!string_ || !isString(string_)) {
-    return parts;
-  }
-  let buff = "";
-  let previousUpper;
-  let previousSplitter;
-  for (const char of string_) {
-    const isSplitter = splitters.includes(char);
-    if (isSplitter === true) {
-      parts.push(buff);
-      buff = "";
-      previousUpper = void 0;
-      continue;
-    }
-    const isUpper = isUppercase(char);
-    if (previousSplitter === false) {
-      if (previousUpper === false && isUpper === true) {
-        parts.push(buff);
-        buff = char;
-        previousUpper = isUpper;
-        continue;
-      }
-      if (previousUpper === true && isUpper === false && buff.length > 1) {
-        const lastChar = buff[buff.length - 1];
-        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
-        buff = lastChar + char;
-        previousUpper = isUpper;
-        continue;
-      }
-    }
-    buff += char;
-    previousUpper = isUpper;
-    previousSplitter = isSplitter;
-  }
-  parts.push(buff);
-  return parts;
-}
-function toUpperFirst(string_) {
-  return !string_ ? "" : string_[0].toUpperCase() + string_.slice(1);
-}
-function toLowerFirst(string_) {
-  return !string_ ? "" : string_[0].toLowerCase() + string_.slice(1);
-}
-function toPascalCase(string_) {
-  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => toUpperFirst(p)).join("");
-}
-function toCamelCase(string_) {
-  return toLowerFirst(toPascalCase(string_ || ""));
-}
-function toKebabCase(string_, joiner) {
-  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => p.toLowerCase()).join(joiner ?? "-");
-}
-function toSnakeCase(string_) {
-  return toKebabCase(string_ || "", "_");
-}
-
-// src/string/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";
-export {
-  KEY_CODES,
-  _setPath,
-  addProp,
-  allPass,
-  anyPass,
-  chunk,
-  clamp,
-  clone,
-  compact,
-  concat,
-  countBy,
-  createPipe,
-  debounce,
-  difference,
-  differenceWith,
-  drop,
-  dropLast,
-  equals,
-  filter,
-  find,
-  findIndex,
-  findLast,
-  findLastIndex,
-  first,
-  flatMap,
-  flatMapToObj,
-  flatten,
-  flattenDeep,
-  forEach,
-  forEachObj,
-  fromPairs,
-  groupBy,
-  humanReadableFileSize,
-  identity,
-  indexBy,
-  intersection,
-  intersectionWith,
-  invert,
-  isArray,
-  isBoolean,
-  isBrowser,
-  isDate,
-  isDefined,
-  isEmpty,
-  isError,
-  isFunction,
-  isNil,
-  isNonNull,
-  isNot,
-  isNumber,
-  isObject,
-  isPromise,
-  isString,
-  isTruthy,
-  isUppercase,
-  join,
-  keys,
-  last,
-  length,
-  map,
-  mapKeys,
-  mapToObj,
-  mapValues,
-  maxBy,
-  meanBy,
-  merge,
-  mergeAll,
-  mergeDeep,
-  minBy,
-  noop,
-  omit,
-  omitBy,
-  once,
-  partition,
-  pathOr,
-  pick,
-  pickBy,
-  pipe,
-  prop,
-  purry,
-  randomString,
-  range,
-  reduce,
-  reject,
-  reverse,
-  sample,
-  set,
-  setPath,
-  shuffle,
-  sleep,
-  slugify,
-  sort,
-  sortBy,
-  splitAt,
-  splitByCase,
-  splitWhen,
-  stringToPath,
-  sumBy,
-  swapIndices,
-  swapProps,
-  take,
-  takeWhile,
-  toCamelCase,
-  toKebabCase,
-  toLowerFirst,
-  toPairs,
-  toPascalCase,
-  toSnakeCase,
-  toUpperFirst,
-  type,
-  uniq,
-  uniqBy,
-  uniqWith,
-  values,
-  zip,
-  zipObj,
-  zipWith
-};