@vinicunca/perkakas 0.0.5 → 0.0.9

package/dist/index.js

@@ -172,25 +172,32 @@ function purry(fn, args, lazy) {
   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() {
-  return purry(_allPass, arguments);
+function allPass(...args) {
+  return purry(_allPass, args);
 }
 function _allPass(data, fns) {
   return fns.every((fn) => fn(data));
 }
 
 // src/array/any-pass.ts
-function anyPass() {
-  return purry(_anyPass, arguments);
+function anyPass(...args) {
+  return purry(_anyPass, args);
 }
 function _anyPass(data, fns) {
   return fns.some((fn) => fn(data));
 }
 
 // src/array/chunk.ts
-function chunk() {
-  return purry(_chunk, arguments);
+function chunk(...args) {
+  return purry(_chunk, args);
 }
 function _chunk(array, size) {
   const ret = Array.from({
@@ -305,8 +312,8 @@ function compact(items) {
 }
 
 // src/array/concat.ts
-function concat() {
-  return purry(_concat, arguments);
+function concat(...args) {
+  return purry(_concat, args);
 }
 function _concat(arr1, arr2) {
   return arr1.concat(arr2);
@@ -321,12 +328,12 @@ function _countBy(indexed) {
     }, 0);
   };
 }
-function countBy() {
-  return purry(_countBy(false), arguments);
+function countBy(...args) {
+  return purry(_countBy(false), args);
 }
 ((countBy2) => {
-  function indexed() {
-    return purry(_countBy(true), arguments);
+  function indexed(...args) {
+    return purry(_countBy(true), args);
   }
   countBy2.indexed = indexed;
 })(countBy || (countBy = {}));
@@ -347,8 +354,8 @@ function _reduceLazy(array, lazy, indexed) {
 }
 
 // src/array/difference-with.ts
-function differenceWith() {
-  return purry(_differenceWith, arguments, differenceWith.lazy);
+function differenceWith(...args) {
+  return purry(_differenceWith, args, differenceWith.lazy);
 }
 function _differenceWith(array, other, isEquals) {
   const lazy = differenceWith.lazy(other, isEquals);
@@ -374,8 +381,8 @@ function _differenceWith(array, other, isEquals) {
 })(differenceWith || (differenceWith = {}));
 
 // src/array/difference.ts
-function difference() {
-  return purry(_difference, arguments, difference.lazy);
+function difference(...args) {
+  return purry(_difference, args, difference.lazy);
 }
 function _difference(array, other) {
   const lazy = difference.lazy(other);
@@ -402,8 +409,8 @@ function _difference(array, other) {
 })(difference || (difference = {}));
 
 // src/array/drop-last.ts
-function dropLast() {
-  return purry(_dropLast, arguments);
+function dropLast(...args) {
+  return purry(_dropLast, args);
 }
 function _dropLast(array, n) {
   const copy = [...array];
@@ -414,8 +421,8 @@ function _dropLast(array, n) {
 }
 
 // src/array/drop.ts
-function drop() {
-  return purry(_drop, arguments, drop.lazy);
+function drop(...args) {
+  return purry(_drop, args, drop.lazy);
 }
 function _drop(array, n) {
   return _reduceLazy(array, drop.lazy(n));
@@ -448,8 +455,8 @@ function toLazyIndexed(fn) {
 }
 
 // src/array/filter.ts
-function filter() {
-  return purry(_filter(false), arguments, filter.lazy);
+function filter(...args) {
+  return purry(_filter(false), args, filter.lazy);
 }
 function _filter(indexed) {
   return (array, fn) => {
@@ -479,8 +486,8 @@ function _lazy(indexed) {
   };
 }
 ((filter2) => {
-  function indexed() {
-    return purry(_filter(true), arguments, filter2.lazyIndexed);
+  function indexed(...args) {
+    return purry(_filter(true), args, filter2.lazyIndexed);
   }
   filter2.indexed = indexed;
   filter2.lazy = _lazy(false);
@@ -494,8 +501,8 @@ function toSingle(fn) {
 }
 
 // src/array/find-index.ts
-function findIndex() {
-  return purry(_findIndex(false), arguments, findIndex.lazy);
+function findIndex(...args) {
+  return purry(_findIndex(false), args, findIndex.lazy);
 }
 function _findIndex(indexed) {
   return (array, fn) => {
@@ -526,8 +533,8 @@ function _lazy2(indexed) {
   };
 }
 ((findIndex2) => {
-  function indexed() {
-    return purry(_findIndex(true), arguments, findIndex2.lazyIndexed);
+  function indexed(...args) {
+    return purry(_findIndex(true), args, findIndex2.lazyIndexed);
   }
   findIndex2.indexed = indexed;
   findIndex2.lazy = toSingle(_lazy2(false));
@@ -535,8 +542,8 @@ function _lazy2(indexed) {
 })(findIndex || (findIndex = {}));
 
 // src/array/find-last-index.ts
-function findLastIndex() {
-  return purry(_findLastIndex(false), arguments);
+function findLastIndex(...args) {
+  return purry(_findLastIndex(false), args);
 }
 function _findLastIndex(indexed) {
   return (array, fn) => {
@@ -549,15 +556,15 @@ function _findLastIndex(indexed) {
   };
 }
 ((findLastIndex2) => {
-  function indexed() {
-    return purry(_findLastIndex(true), arguments);
+  function indexed(...args) {
+    return purry(_findLastIndex(true), args);
   }
   findLastIndex2.indexed = indexed;
 })(findLastIndex || (findLastIndex = {}));
 
 // src/array/find-last.ts
-function findLast() {
-  return purry(_findLast(false), arguments);
+function findLast(...args) {
+  return purry(_findLast(false), args);
 }
 function _findLast(indexed) {
   return (array, fn) => {
@@ -569,15 +576,15 @@ function _findLast(indexed) {
   };
 }
 ((findLast2) => {
-  function indexed() {
-    return purry(_findLast(true), arguments);
+  function indexed(...args) {
+    return purry(_findLast(true), args);
   }
   findLast2.indexed = indexed;
 })(findLast || (findLast = {}));
 
 // src/array/find.ts
-function find() {
-  return purry(_find(false), arguments, find.lazy);
+function find(...args) {
+  return purry(_find(false), args, find.lazy);
 }
 function _find(indexed) {
   return (array, fn) => {
@@ -600,8 +607,8 @@ function _lazy3(indexed) {
   };
 }
 ((find2) => {
-  function indexed() {
-    return purry(_find(true), arguments, find2.lazyIndexed);
+  function indexed(...args) {
+    return purry(_find(true), args, find2.lazyIndexed);
   }
   find2.indexed = indexed;
   find2.lazy = toSingle(_lazy3(false));
@@ -609,8 +616,8 @@ function _lazy3(indexed) {
 })(find || (find = {}));
 
 // src/array/first.ts
-function first() {
-  return purry(_first, arguments, first.lazy);
+function first(...args) {
+  return purry(_first, args, first.lazy);
 }
 function _first([first2]) {
   return first2;
@@ -632,8 +639,8 @@ function _first([first2]) {
 })(first || (first = {}));
 
 // src/array/flat-map-to-obj.ts
-function flatMapToObj() {
-  return purry(_flatMapToObj(false), arguments);
+function flatMapToObj(...args) {
+  return purry(_flatMapToObj(false), args);
 }
 function _flatMapToObj(indexed) {
   return (array, fn) => {
@@ -647,15 +654,15 @@ function _flatMapToObj(indexed) {
   };
 }
 ((flatMapToObj2) => {
-  function indexed() {
-    return purry(_flatMapToObj(true), arguments);
+  function indexed(...args) {
+    return purry(_flatMapToObj(true), args);
   }
   flatMapToObj2.indexed = indexed;
 })(flatMapToObj || (flatMapToObj = {}));
 
 // src/array/flatten.ts
-function flatten() {
-  return purry(_flatten, arguments, flatten.lazy);
+function flatten(...args) {
+  return purry(_flatten, args, flatten.lazy);
 }
 function _flatten(items) {
   return _reduceLazy(items, flatten.lazy());
@@ -682,8 +689,8 @@ function _flatten(items) {
 })(flatten || (flatten = {}));
 
 // src/array/flat-map.ts
-function flatMap() {
-  return purry(_flatMap, arguments, flatMap.lazy);
+function flatMap(...args) {
+  return purry(_flatMap, args, flatMap.lazy);
 }
 function _flatMap(array, fn) {
   return flatten(array.map((item) => fn(item)));
@@ -711,8 +718,8 @@ function _flatMap(array, fn) {
 })(flatMap || (flatMap = {}));
 
 // src/array/flatten-deep.ts
-function flattenDeep() {
-  return purry(_flattenDeep, arguments, flattenDeep.lazy);
+function flattenDeep(...args) {
+  return purry(_flattenDeep, args, flattenDeep.lazy);
 }
 function _flattenDeep(items) {
   return _reduceLazy(items, flattenDeep.lazy());
@@ -754,8 +761,8 @@ function _flattenDeepValue(value) {
 })(flattenDeep || (flattenDeep = {}));
 
 // src/array/for-each.ts
-function forEach() {
-  return purry(_forEach(false), arguments, forEach.lazy);
+function forEach(...args) {
+  return purry(_forEach(false), args, forEach.lazy);
 }
 function _forEach(indexed) {
   return (array, fn) => {
@@ -783,8 +790,8 @@ function _lazy4(indexed) {
   };
 }
 ((forEach2) => {
-  function indexed() {
-    return purry(_forEach(true), arguments, forEach2.lazyIndexed);
+  function indexed(...args) {
+    return purry(_forEach(true), args, forEach2.lazyIndexed);
   }
   forEach2.indexed = indexed;
   forEach2.lazy = _lazy4(false);
@@ -792,8 +799,8 @@ function _lazy4(indexed) {
 })(forEach || (forEach = {}));
 
 // src/array/group-by.ts
-function groupBy() {
-  return purry(_groupBy(false), arguments);
+function groupBy(...args) {
+  return purry(_groupBy(false), args);
 }
 function _groupBy(indexed) {
   return (array, fn) => {
@@ -812,16 +819,16 @@ function _groupBy(indexed) {
   };
 }
 ((groupBy2) => {
-  function indexed() {
-    return purry(_groupBy(true), arguments);
+  function indexed(...args) {
+    return purry(_groupBy(true), args);
   }
   groupBy2.indexed = indexed;
   groupBy2.strict = groupBy2;
 })(groupBy || (groupBy = {}));
 
 // src/array/index-by.ts
-function indexBy() {
-  return purry(_indexBy(false), arguments);
+function indexBy(...args) {
+  return purry(_indexBy(false), args);
 }
 function _indexBy(indexed) {
   return (array, fn) => {
@@ -834,15 +841,15 @@ function _indexBy(indexed) {
   };
 }
 ((indexBy2) => {
-  function indexed() {
-    return purry(_indexBy(true), arguments);
+  function indexed(...args) {
+    return purry(_indexBy(true), args);
   }
   indexBy2.indexed = indexed;
 })(indexBy || (indexBy = {}));
 
 // src/array/intersection.ts
-function intersection() {
-  return purry(_intersection, arguments, intersection.lazy);
+function intersection(...args) {
+  return purry(_intersection, args, intersection.lazy);
 }
 function _intersection(array, other) {
   const lazy = intersection.lazy(other);
@@ -869,8 +876,8 @@ function _intersection(array, other) {
 })(intersection || (intersection = {}));
 
 // src/array/intersection-with.ts
-function intersectionWith() {
-  return purry(_intersectionWith, arguments, intersectionWith.lazy);
+function intersectionWith(...args) {
+  return purry(_intersectionWith, args, intersectionWith.lazy);
 }
 function _intersectionWith(array, other, comparator) {
   const lazy = intersectionWith.lazy(other, comparator);
@@ -896,32 +903,32 @@ function _intersectionWith(array, other, comparator) {
 })(intersectionWith || (intersectionWith = {}));
 
 // src/array/join.ts
-function join() {
-  return purry(joinImplementation, arguments);
+function join(...args) {
+  return purry(joinImplementation, args);
 }
 function joinImplementation(data, glue) {
   return data.join(glue);
 }
 
 // src/array/last.ts
-function last() {
-  return purry(_last, arguments);
+function last(...args) {
+  return purry(_last, args);
 }
 function _last(array) {
   return array[array.length - 1];
 }
 
 // src/array/length.ts
-function length() {
-  return purry(_length, arguments);
+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() {
-  return purry(_map(false), arguments, map.lazy);
+function map(...args) {
+  return purry(_map(false), args, map.lazy);
 }
 function _map(indexed) {
   return (array, fn) => {
@@ -944,8 +951,8 @@ function _lazy5(indexed) {
   };
 }
 ((map2) => {
-  function indexed() {
-    return purry(_map(true), arguments, map2.lazyIndexed);
+  function indexed(...args) {
+    return purry(_map(true), args, map2.lazyIndexed);
   }
   map2.indexed = indexed;
   map2.lazy = _lazy5(false);
@@ -954,8 +961,8 @@ function _lazy5(indexed) {
 })(map || (map = {}));
 
 // src/array/map-to-obj.ts
-function mapToObj() {
-  return purry(_mapToObj(false), arguments);
+function mapToObj(...args) {
+  return purry(_mapToObj(false), args);
 }
 function _mapToObj(indexed) {
   return (array, fn) => {
@@ -967,8 +974,8 @@ function _mapToObj(indexed) {
   };
 }
 ((mapToObj2) => {
-  function indexed() {
-    return purry(_mapToObj(true), arguments);
+  function indexed(...args) {
+    return purry(_mapToObj(true), args);
   }
   mapToObj2.indexed = indexed;
 })(mapToObj || (mapToObj = {}));
@@ -988,12 +995,12 @@ function _maxBy(indexed) {
     return ret;
   };
 }
-function maxBy() {
-  return purry(_maxBy(false), arguments);
+function maxBy(...args) {
+  return purry(_maxBy(false), args);
 }
 ((maxBy2) => {
-  function indexed() {
-    return purry(_maxBy(true), arguments);
+  function indexed(...args) {
+    return purry(_maxBy(true), args);
   }
   maxBy2.indexed = indexed;
 })(maxBy || (maxBy = {}));
@@ -1011,12 +1018,12 @@ function _meanBy(indexed) {
     return sum / array.length;
   };
 }
-function meanBy() {
-  return purry(_meanBy(false), arguments);
+function meanBy(...args) {
+  return purry(_meanBy(false), args);
 }
 ((meanBy2) => {
-  function indexed() {
-    return purry(_meanBy(true), arguments);
+  function indexed(...args) {
+    return purry(_meanBy(true), args);
   }
   meanBy2.indexed = indexed;
 })(meanBy || (meanBy = {}));
@@ -1041,19 +1048,19 @@ function _minBy(indexed) {
     return ret;
   };
 }
-function minBy() {
-  return purry(_minBy(false), arguments);
+function minBy(...args) {
+  return purry(_minBy(false), args);
 }
 ((minBy2) => {
-  function indexed() {
-    return purry(_minBy(true), arguments);
+  function indexed(...args) {
+    return purry(_minBy(true), args);
   }
   minBy2.indexed = indexed;
 })(minBy || (minBy = {}));
 
 // src/array/partition.ts
-function partition() {
-  return purry(_partition(false), arguments);
+function partition(...args) {
+  return purry(_partition(false), args);
 }
 function _partition(indexed) {
   return (array, fn) => {
@@ -1066,15 +1073,15 @@ function _partition(indexed) {
   };
 }
 ((partition2) => {
-  function indexed() {
-    return purry(_partition(true), arguments);
+  function indexed(...args) {
+    return purry(_partition(true), args);
   }
   partition2.indexed = indexed;
 })(partition || (partition = {}));
 
 // src/array/range.ts
-function range() {
-  return purry(_range, arguments);
+function range(...args) {
+  return purry(_range, args);
 }
 function _range(start, end) {
   const ret = [];
@@ -1085,8 +1092,8 @@ function _range(start, end) {
 }
 
 // src/array/reduce.ts
-function reduce() {
-  return purry(_reduce(false), arguments);
+function reduce(...args) {
+  return purry(_reduce(false), args);
 }
 function _reduce(indexed) {
   return (items, fn, initialValue) => {
@@ -1097,15 +1104,15 @@ function _reduce(indexed) {
   };
 }
 ((reduce2) => {
-  function indexed() {
-    return purry(_reduce(true), arguments);
+  function indexed(...args) {
+    return purry(_reduce(true), args);
   }
   reduce2.indexed = indexed;
 })(reduce || (reduce = {}));
 
 // src/array/reject.ts
-function reject() {
-  return purry(_reject(false), arguments, reject.lazy);
+function reject(...args) {
+  return purry(_reject(false), args, reject.lazy);
 }
 function _reject(indexed) {
   return (array, fn) => {
@@ -1135,8 +1142,8 @@ function _lazy6(indexed) {
   };
 }
 ((reject2) => {
-  function indexed() {
-    return purry(_reject(true), arguments, reject2.lazyIndexed);
+  function indexed(...args) {
+    return purry(_reject(true), args, reject2.lazyIndexed);
   }
   reject2.indexed = indexed;
   reject2.lazy = _lazy6(false);
@@ -1144,8 +1151,8 @@ function _lazy6(indexed) {
 })(reject || (reject = {}));
 
 // src/array/reverse.ts
-function reverse() {
-  return purry(_reverse, arguments);
+function reverse(...args) {
+  return purry(_reverse, args);
 }
 function _reverse(array) {
   return array.slice().reverse();
@@ -1181,8 +1188,8 @@ function sampleImplementation(data, sampleSize) {
 }
 
 // src/array/shuffle.ts
-function shuffle() {
-  return purry(_shuffle, arguments);
+function shuffle(...args) {
+  return purry(_shuffle, args);
 }
 function _shuffle(items) {
   const result = items.slice();
@@ -1196,8 +1203,8 @@ function _shuffle(items) {
 }
 
 // src/array/sort.ts
-function sort() {
-  return purry(_sort, arguments);
+function sort(...args) {
+  return purry(_sort, args);
 }
 function _sort(items, cmp) {
   const ret = [...items];
@@ -1215,17 +1222,7 @@ var COMPARATOR = {
   desc: (x, y) => x < y
 };
 function sortBy(arrayOrSortRule, ...sortRules) {
-  const args = isSortRule(arrayOrSortRule) ? (
-    // *data-last invocation*: put all sort rules into a single array to be
-    // passed as the first param.
-    [[arrayOrSortRule, ...sortRules]]
-  ) : (
-    // *data-first invocation*: put the arrayOrSort (which is array now) as
-    // the first param, and all the sorts (as an array) into the second param.
-    // `purry` would pick the right "flavour" based on the length of the
-    // params tuple.
-    [arrayOrSortRule, sortRules]
-  );
+  const args = isSortRule(arrayOrSortRule) ? [[arrayOrSortRule, ...sortRules]] : [arrayOrSortRule, sortRules];
   return purry(_sortBy, args);
 }
 function isSortRule(x) {
@@ -1263,8 +1260,8 @@ function comparer(primaryRule, secondaryRule, ...otherRules) {
 })(sortBy || (sortBy = {}));
 
 // src/array/split-at.ts
-function splitAt() {
-  return purry(_splitAt, arguments);
+function splitAt(...args) {
+  return purry(_splitAt, args);
 }
 function _splitAt(array, index) {
   const copy = [...array];
@@ -1273,8 +1270,8 @@ function _splitAt(array, index) {
 }
 
 // src/array/split-when.ts
-function splitWhen() {
-  return purry(_splitWhen, arguments);
+function splitWhen(...args) {
+  return purry(_splitWhen, args);
 }
 function _splitWhen(array, fn) {
   for (let i = 0; i < array.length; i++) {
@@ -1296,12 +1293,12 @@ function _sumBy(indexed) {
     return sum;
   };
 }
-function sumBy() {
-  return purry(_sumBy(false), arguments);
+function sumBy(...args) {
+  return purry(_sumBy(false), args);
 }
 ((sumBy2) => {
-  function indexed() {
-    return purry(_sumBy(true), arguments);
+  function indexed(...args) {
+    return purry(_sumBy(true), args);
   }
   sumBy2.indexed = indexed;
 })(sumBy || (sumBy = {}));
@@ -1336,8 +1333,8 @@ function _swapString(item, index1, index2) {
 }
 
 // src/array/take.ts
-function take() {
-  return purry(_take, arguments, take.lazy);
+function take(...args) {
+  return purry(_take, args, take.lazy);
 }
 function _take(array, n) {
   return _reduceLazy(array, take.lazy(n));
@@ -1370,8 +1367,8 @@ function _take(array, n) {
 })(take || (take = {}));
 
 // src/array/take-while.ts
-function takeWhile() {
-  return purry(_takeWhile, arguments);
+function takeWhile(...args) {
+  return purry(_takeWhile, args);
 }
 function _takeWhile(array, fn) {
   const ret = [];
@@ -1385,8 +1382,8 @@ function _takeWhile(array, fn) {
 }
 
 // src/array/uniq.ts
-function uniq() {
-  return purry(_uniq, arguments, uniq.lazy);
+function uniq(...args) {
+  return purry(_uniq, args, uniq.lazy);
 }
 function _uniq(array) {
   return _reduceLazy(array, uniq.lazy());
@@ -1413,8 +1410,8 @@ function _uniq(array) {
 })(uniq || (uniq = {}));
 
 // src/array/uniq-by.ts
-function uniqBy() {
-  return purry(_uniqBy, arguments, lazyUniqBy);
+function uniqBy(...args) {
+  return purry(_uniqBy, args, lazyUniqBy);
 }
 function _uniqBy(array, transformer) {
   return _reduceLazy(array, lazyUniqBy(transformer));
@@ -1439,8 +1436,8 @@ function lazyUniqBy(transformer) {
 }
 
 // src/array/uniq-with.ts
-function uniqWith() {
-  return purry(_uniqWith, arguments, uniqWith.lazy);
+function uniqWith(...args) {
+  return purry(_uniqWith, args, uniqWith.lazy);
 }
 function _uniqWith(array, isEquals) {
   const lazy = uniqWith.lazy(isEquals);
@@ -1466,8 +1463,8 @@ function _lazy7(isEquals) {
 })(uniqWith || (uniqWith = {}));
 
 // src/array/zip.ts
-function zip() {
-  return purry(_zip, arguments);
+function zip(...args) {
+  return purry(_zip, args);
 }
 function _zip(first2, second) {
   const resultLength = first2.length > second.length ? second.length : first2.length;
@@ -1479,8 +1476,8 @@ function _zip(first2, second) {
 }
 
 // src/array/zip-obj.ts
-function zipObj() {
-  return purry(_zipObj, arguments);
+function zipObj(...args) {
+  return purry(_zipObj, args);
 }
 function _zipObj(first2, second) {
   const resultLength = first2.length > second.length ? second.length : first2.length;
@@ -1492,8 +1489,7 @@ function _zipObj(first2, second) {
 }
 
 // src/array/zip-with.ts
-function zipWith() {
-  const args = Array.from(arguments);
+function zipWith(...args) {
   if (typeof args[0] === "function" && args.length === 1) {
     return function(f, s) {
       return _zipWith(f, s, args[0]);
@@ -1517,51 +1513,9 @@ function _zipWith(first2, second, fn) {
   return result;
 }
 
-// src/helpers/index.ts
-function convertToUnit(str, unit = "px") {
-  if (isNil(str) || str === "") {
-    return void 0;
-  } else if (Number.isNaN(+str)) {
-    return String(str);
-  } else if (!Number.isFinite(+str)) {
-    return void 0;
-  } else {
-    return `${Number(str)}${unit}`;
-  }
-}
-function increaseWithUnit({ target, delta }) {
-  if (isNumber(target)) {
-    return target + delta;
-  }
-  const value = target.match(/^-?[0-9]+\.?[0-9]*/)?.[0] || "";
-  const unit = target.slice(value.length);
-  const result = Number.parseFloat(value) + delta;
-  if (Number.isNaN(result)) {
-    return target;
-  }
-  return result + unit;
-}
-function humanReadableFileSize(bytes, base = 1e3) {
-  if (bytes < base) {
-    return `${bytes} B`;
-  }
-  const prefix = base === 1024 ? ["Ki", "Mi", "Gi"] : ["k", "M", "G"];
-  let unit = -1;
-  while (Math.abs(bytes) >= base && unit < prefix.length - 1) {
-    bytes /= base;
-    ++unit;
-  }
-  return `${bytes.toFixed(1)} ${prefix[unit]}B`;
-}
-function sleep(timeout) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
-  });
-}
-
 // src/number/clamp.ts
-function clamp() {
-  return purry(_clamp, arguments);
+function clamp(...args) {
+  return purry(_clamp, args);
 }
 function _clamp(value, limits) {
   if (limits.min != null && limits.min > value) {
@@ -1586,7 +1540,13 @@ function _addProp(obj, prop2, value) {
 
 // src/type/type.ts
 function type(val) {
-  return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
+  if (val === null) {
+    return "Null";
+  }
+  if (val === void 0) {
+    return "Undefined";
+  }
+  return Object.prototype.toString.call(val).slice(8, -1);
 }
 
 // src/object/clone.ts
@@ -1633,8 +1593,8 @@ function clone(value) {
 // src/object/equals.ts
 var isArray2 = Array.isArray;
 var keyList = Object.keys;
-function equals() {
-  return purry(_equals, arguments);
+function equals(...args) {
+  return purry(_equals, args);
 }
 function _equals(a, b) {
   if (a === b) {
@@ -1699,8 +1659,8 @@ function _equals(a, b) {
 }
 
 // src/object/for-each-obj.ts
-function forEachObj() {
-  return purry(_forEachObj(false), arguments);
+function forEachObj(...args) {
+  return purry(_forEachObj(false), args);
 }
 function _forEachObj(indexed) {
   return (object, fn) => {
@@ -1718,8 +1678,8 @@ function _forEachObj(indexed) {
   };
 }
 ((forEachObj2) => {
-  function indexed() {
-    return purry(_forEachObj(true), arguments);
+  function indexed(...args) {
+    return purry(_forEachObj(true), args);
   }
   forEachObj2.indexed = indexed;
 })(forEachObj || (forEachObj = {}));
@@ -1737,8 +1697,8 @@ function fromPairs(entries) {
 })(fromPairs || (fromPairs = {}));
 
 // src/object/invert.ts
-function invert() {
-  return purry(_invert, arguments);
+function invert(...args) {
+  return purry(_invert, args);
 }
 function _invert(object) {
   const result = {};
@@ -1785,16 +1745,16 @@ function _mapValues(obj, fn) {
 }
 
 // src/object/merge.ts
-function merge() {
-  return purry(_merge, arguments);
+function merge(...args) {
+  return purry(_merge, args);
 }
 function _merge(a, b) {
   return Object.assign({}, a, b);
 }
 
 // src/object/omit.ts
-function omit() {
-  return purry(_omit, arguments);
+function omit(...args) {
+  return purry(_omit, args);
 }
 function _omit(data, propNames) {
   if (propNames.length === 0) {
@@ -1803,7 +1763,6 @@ function _omit(data, propNames) {
   if (propNames.length === 1) {
     const [propName] = propNames;
     const {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- use destructuring to remove a single key, letting JS optimize here...
       [propName]: omitted,
       ...remaining
     } = data;
@@ -1819,8 +1778,8 @@ function _omit(data, propNames) {
 }
 
 // src/object/omit-by.ts
-function omitBy() {
-  return purry(_omitBy, arguments);
+function omitBy(...args) {
+  return purry(_omitBy, args);
 }
 function _omitBy(object, fn) {
   return Object.keys(object).reduce((acc, key) => {
@@ -1832,8 +1791,8 @@ function _omitBy(object, fn) {
 }
 
 // src/object/path-or.ts
-function pathOr() {
-  return purry(_pathOr, arguments);
+function pathOr(...args) {
+  return purry(_pathOr, args);
 }
 function _pathOr(object, path, defaultValue) {
   let current = object;
@@ -1847,8 +1806,8 @@ function _pathOr(object, path, defaultValue) {
 }
 
 // src/object/pick.ts
-function pick() {
-  return purry(_pick, arguments);
+function pick(...args) {
+  return purry(_pick, args);
 }
 function _pick(object, names) {
   if (object == null) {
@@ -1863,8 +1822,8 @@ function _pick(object, names) {
 }
 
 // src/object/pick-by.ts
-function pickBy() {
-  return purry(_pickBy, arguments);
+function pickBy(...args) {
+  return purry(_pickBy, args);
 }
 function _pickBy(object, fn) {
   if (object == null) {
@@ -1884,8 +1843,8 @@ function prop(propName) {
 }
 
 // src/object/set.ts
-function set() {
-  return purry(_set, arguments);
+function set(...args) {
+  return purry(_set, args);
 }
 function _set(obj, prop2, value) {
   return {
@@ -1895,8 +1854,8 @@ function _set(obj, prop2, value) {
 }
 
 // src/object/set-path.ts
-function setPath() {
-  return purry(_setPath, arguments);
+function setPath(...args) {
+  return purry(_setPath, args);
 }
 function _setPath(object, path, defaultValue) {
   if (path.length === 0) {
@@ -1917,8 +1876,8 @@ function _setPath(object, path, defaultValue) {
 }
 
 // src/object/swap-props.ts
-function swapProps() {
-  return purry(_swapProps, arguments);
+function swapProps(...args) {
+  return purry(_swapProps, args);
 }
 function _swapProps(obj, key1, key2) {
   const { [key1]: value1, [key2]: value2 } = obj;
@@ -2013,6 +1972,20 @@ 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";
@@ -2020,6 +1993,11 @@ function randomString(length2) {
   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);
@@ -2049,7 +2027,6 @@ export {
   clone,
   compact,
   concat,
-  convertToUnit,
   countBy,
   createPipe,
   difference,
@@ -2073,7 +2050,6 @@ export {
   groupBy,
   humanReadableFileSize,
   identity,
-  increaseWithUnit,
   indexBy,
   intersection,
   intersectionWith,
@@ -2129,6 +2105,7 @@ export {
   setPath,
   shuffle,
   sleep,
+  slugify,
   sort,
   sortBy,
   splitAt,