@vinicunca/perkakas 0.3.1 → 0.3.5

package/dist/commonjs/array/sort-by.js

@@ -1,51 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortBy = void 0;
-const purry_1 = require("../function/purry");
-const ALL_DIRECTIONS = ['asc', 'desc'];
-const COMPARATOR = {
-    asc: (x, y) => x > y,
-    desc: (x, y) => x < y,
-};
-function sortBy(arrayOrSortRule, ...sortRules) {
-    const args = isSortRule(arrayOrSortRule)
-        ? [[arrayOrSortRule, ...sortRules]]
-        : [arrayOrSortRule, sortRules];
-    return (0, purry_1.purry)(_sortBy, args);
+const purry_order_rules_1 = require("../utils/purry-order-rules");
+function sortBy(...args) {
+    return (0, purry_order_rules_1.purryOrderRules)(_sortBy, args);
 }
 exports.sortBy = sortBy;
-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 === undefined
-        ? undefined
-        : 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;
-    };
+function _sortBy(data, compareFn) {
+    return data.slice().sort(compareFn);
 }
 (function (sortBy) {
     sortBy.strict = sortBy;

package/dist/commonjs/array/sort.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sort = void 0;
 const purry_1 = require("../function/purry");
 function sort(...args) {
-    return (0, purry_1.purry)(_sort, args);
+    return (0, purry_1.purry)(sort_, args);
 }
 exports.sort = sort;
-function _sort(items, cmp) {
-    const ret = [...items];
+function sort_(items, cmp) {
+    const ret = items.slice();
     ret.sort(cmp);
     return ret;
 }

package/dist/commonjs/array/sorted-index-by.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortedIndexBy = void 0;
+const purry_1 = require("../function/purry");
+const binary_search_cutoff_index_1 = require("../utils/binary-search-cutoff-index");
+function sortedIndexBy(...args) {
+    return (0, purry_1.purry)(sortedIndexByImplementation, args);
+}
+exports.sortedIndexBy = sortedIndexBy;
+(function (sortedIndexBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(sortedIndexByImplementation, args);
+    }
+    sortedIndexBy.indexed = indexed;
+})(sortedIndexBy || (exports.sortedIndexBy = sortedIndexBy = {}));
+function sortedIndexByImplementation(array, item, valueFunction) {
+    const value = valueFunction(item);
+    return (0, binary_search_cutoff_index_1.binarySearchCutoffIndex)(array, (pivot, index) => valueFunction(pivot, index) < value);
+}

package/dist/commonjs/array/sorted-index-with.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortedIndexWith = void 0;
+const purry_1 = require("../function/purry");
+const binary_search_cutoff_index_1 = require("../utils/binary-search-cutoff-index");
+function sortedIndexWith(...args) {
+    return (0, purry_1.purry)(binary_search_cutoff_index_1.binarySearchCutoffIndex, args);
+}
+exports.sortedIndexWith = sortedIndexWith;
+(function (sortedIndexWith) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(binary_search_cutoff_index_1.binarySearchCutoffIndex, args);
+    }
+    sortedIndexWith.indexed = indexed;
+})(sortedIndexWith || (exports.sortedIndexWith = sortedIndexWith = {}));

package/dist/commonjs/array/sorted-index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortedIndex = void 0;
+const purry_1 = require("../function/purry");
+const binary_search_cutoff_index_1 = require("../utils/binary-search-cutoff-index");
+function sortedIndex(...args) {
+    return (0, purry_1.purry)(sortedIndexImplementation, args);
+}
+exports.sortedIndex = sortedIndex;
+function sortedIndexImplementation(array, item) {
+    return (0, binary_search_cutoff_index_1.binarySearchCutoffIndex)(array, (pivot) => pivot < item);
+}

package/dist/commonjs/array/sorted-last-index-by.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortedLastIndexBy = void 0;
+const purry_1 = require("../function/purry");
+const binary_search_cutoff_index_1 = require("../utils/binary-search-cutoff-index");
+function sortedLastIndexBy(...args) {
+    return (0, purry_1.purry)(sortedLastIndexByImplementation, args);
+}
+exports.sortedLastIndexBy = sortedLastIndexBy;
+(function (sortedLastIndexBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(sortedLastIndexByImplementation, args);
+    }
+    sortedLastIndexBy.indexed = indexed;
+})(sortedLastIndexBy || (exports.sortedLastIndexBy = sortedLastIndexBy = {}));
+function sortedLastIndexByImplementation(array, item, valueFunction) {
+    const value = valueFunction(item);
+    return (0, binary_search_cutoff_index_1.binarySearchCutoffIndex)(array, (pivot, index) => valueFunction(pivot, index) <= value);
+}

package/dist/commonjs/array/sorted-last-index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortedLastIndex = void 0;
+const purry_1 = require("../function/purry");
+const binary_search_cutoff_index_1 = require("../utils/binary-search-cutoff-index");
+function sortedLastIndex(...args) {
+    return (0, purry_1.purry)(sortedLastIndexImplementation, args);
+}
+exports.sortedLastIndex = sortedLastIndex;
+function sortedLastIndexImplementation(array, item) {
+    return (0, binary_search_cutoff_index_1.binarySearchCutoffIndex)(array, (pivot) => pivot <= item);
+}

package/dist/commonjs/array/splice.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splice = void 0;
 const purry_1 = require("../function/purry");
 function splice(...args) {
-    return (0, purry_1.purry)(_splice, args);
+    return (0, purry_1.purry)(splice_, args);
 }
 exports.splice = splice;
-function _splice(items, start, deleteCount, replacement) {
-    const result = [...items];
+function splice_(items, start, deleteCount, replacement) {
+    const result = items.slice();
     result.splice(start, deleteCount, ...replacement);
     return result;
 }

package/dist/commonjs/array/split-at.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitAt = void 0;
 const purry_1 = require("../function/purry");
 function splitAt(...args) {
-    return (0, purry_1.purry)(_splitAt, args);
+    return (0, purry_1.purry)(splitAt_, args);
 }
 exports.splitAt = splitAt;
-function _splitAt(array, index) {
-    const copy = [...array];
+function splitAt_(array, index) {
+    const copy = array.slice();
     const tail = copy.splice(index);
     return [copy, tail];
 }

package/dist/commonjs/array/split-when.js

@@ -4,14 +4,14 @@ exports.splitWhen = void 0;
 const purry_1 = require("../function/purry");
 const split_at_1 = require("./split-at");
 function splitWhen(...args) {
-    return (0, purry_1.purry)(_splitWhen, args);
+    return (0, purry_1.purry)(splitWhen_, args);
 }
 exports.splitWhen = splitWhen;
-function _splitWhen(array, fn) {
-    for (let i = 0; i < array.length; i++) {
-        if (fn(array[i])) {
-            return (0, split_at_1.splitAt)(array, i);
+function splitWhen_(array, fn) {
+    for (const [index, item] of array.entries()) {
+        if (fn(item)) {
+            return (0, split_at_1.splitAt)(array, index);
         }
     }
-    return [array, []];
+    return [array.slice(), []];
 }

package/dist/commonjs/array/sum-by.js

@@ -2,23 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sumBy = void 0;
 const purry_1 = require("../function/purry");
-function _sumBy(indexed) {
+function sumBy_(indexed) {
     return (array, fn) => {
         let sum = 0;
-        array.forEach((item, i) => {
-            const summand = indexed ? fn(item, i, array) : fn(item);
+        for (const [index, item] of array.entries()) {
+            const summand = indexed ? fn(item, index, array) : fn(item);
             sum += summand;
-        });
+        }
         return sum;
     };
 }
 function sumBy(...args) {
-    return (0, purry_1.purry)(_sumBy(false), args);
+    return (0, purry_1.purry)(sumBy_(false), args);
 }
 exports.sumBy = sumBy;
 (function (sumBy) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_sumBy(true), args);
+        return (0, purry_1.purry)(sumBy_(true), args);
     }
     sumBy.indexed = indexed;
 })(sumBy || (exports.sumBy = sumBy = {}));

package/dist/commonjs/array/swap-indices.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.swapIndices = void 0;
 const purry_1 = require("../function/purry");
 function swapIndices(...args) {
-    return (0, purry_1.purry)(_swapIndices, args);
+    return (0, purry_1.purry)(swapIndices_, args);
 }
 exports.swapIndices = swapIndices;
-function _swapIndices(item, index1, index2) {
+function swapIndices_(item, index1, index2) {
     return typeof item === 'string'
-        ? _swapString(item, index1, index2)
-        : _swapArray(item, index1, index2);
+        ? swapString_(item, index1, index2)
+        : swapArray_(item, index1, index2);
 }
-function _swapArray(item, index1, index2) {
+function swapArray_(item, index1, index2) {
     const result = item.slice();
     if (Number.isNaN(index1) || Number.isNaN(index2)) {
         return result;
@@ -28,7 +28,7 @@ function _swapArray(item, index1, index2) {
     result[positiveIndexB] = item[positiveIndexA];
     return result;
 }
-function _swapString(item, index1, index2) {
-    const result = _swapArray(item.split(''), index1, index2);
+function swapString_(item, index1, index2) {
+    const result = swapArray_(item.split(''), index1, index2);
     return result.join('');
 }

package/dist/commonjs/array/take-first-by.js

@@ -12,7 +12,7 @@ function takeFirstByImplementation(data, compareFn, n) {
         return [];
     }
     if (n >= data.length) {
-        return [...data];
+        return data.slice();
     }
     const heap = data.slice(0, n);
     (0, heap_1.heapify)(heap, compareFn);

package/dist/commonjs/array/take-while.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.takeWhile = void 0;
 const purry_1 = require("../function/purry");
 function takeWhile(...args) {
-    return (0, purry_1.purry)(_takeWhile, args);
+    return (0, purry_1.purry)(takeWhile_, args);
 }
 exports.takeWhile = takeWhile;
-function _takeWhile(array, fn) {
+function takeWhile_(array, fn) {
     const ret = [];
     for (const item of array) {
         if (!fn(item)) {

package/dist/commonjs/array/take.js

@@ -4,34 +4,21 @@ exports.take = void 0;
 const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 function take(...args) {
-    return (0, purry_1.purry)(_take, args, take.lazy);
+    return (0, purry_1.purry)(take_, args, take.lazy);
 }
 exports.take = take;
-function _take(array, n) {
+function take_(array, n) {
     return (0, reduce_lazy_1.reduceLazy)(array, take.lazy(n));
 }
 (function (take) {
     function lazy(n) {
+        if (n <= 0) {
+            return () => ({ done: true, hasNext: false });
+        }
+        let remaining = 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,
-            };
+            remaining -= 1;
+            return { done: remaining <= 0, hasNext: true, next: value };
         };
     }
     take.lazy = lazy;

package/dist/commonjs/array/uniq-by.js

@@ -4,10 +4,10 @@ exports.uniqBy = void 0;
 const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 function uniqBy(...args) {
-    return (0, purry_1.purry)(_uniqBy, args, lazyUniqBy);
+    return (0, purry_1.purry)(uniqBy_, args, lazyUniqBy);
 }
 exports.uniqBy = uniqBy;
-function _uniqBy(array, transformer) {
+function uniqBy_(array, transformer) {
     return (0, reduce_lazy_1.reduceLazy)(array, lazyUniqBy(transformer));
 }
 function lazyUniqBy(transformer) {
@@ -15,16 +15,9 @@ function lazyUniqBy(transformer) {
     return (value) => {
         const appliedItem = transformer(value);
         if (set.has(appliedItem)) {
-            return {
-                done: false,
-                hasNext: false,
-            };
+            return { done: false, hasNext: false };
         }
         set.add(appliedItem);
-        return {
-            done: false,
-            hasNext: true,
-            next: value,
-        };
+        return { done: false, hasNext: true, next: value };
     };
 }

package/dist/commonjs/array/uniq-with.js

@@ -5,29 +5,19 @@ const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 const to_lazy_indexed_1 = require("../utils/to-lazy-indexed");
 function uniqWith(...args) {
-    return (0, purry_1.purry)(_uniqWith, args, uniqWith.lazy);
+    return (0, purry_1.purry)(uniqWith_, args, uniqWith.lazy);
 }
 exports.uniqWith = uniqWith;
-function _uniqWith(array, isEquals) {
+function uniqWith_(array, isEquals) {
     const lazy = uniqWith.lazy(isEquals);
     return (0, reduce_lazy_1.reduceLazy)(array, lazy, true);
 }
-function _lazy(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,
-        };
-    };
+function lazy_(isEquals) {
+    return (value, index, array) => array !== undefined
+        && array.findIndex((otherValue) => isEquals(value, otherValue)) === index
+        ? { done: false, hasNext: true, next: value }
+        : { done: false, hasNext: false };
 }
 (function (uniqWith) {
-    uniqWith.lazy = (0, to_lazy_indexed_1.toLazyIndexed)(_lazy);
+    uniqWith.lazy = (0, to_lazy_indexed_1.toLazyIndexed)(lazy_);
 })(uniqWith || (exports.uniqWith = uniqWith = {}));

package/dist/commonjs/array/uniq.js

@@ -4,10 +4,10 @@ exports.uniq = void 0;
 const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 function uniq(...args) {
-    return (0, purry_1.purry)(_uniq, args, uniq.lazy);
+    return (0, purry_1.purry)(uniq_, args, uniq.lazy);
 }
 exports.uniq = uniq;
-function _uniq(array) {
+function uniq_(array) {
     return (0, reduce_lazy_1.reduceLazy)(array, uniq.lazy());
 }
 (function (uniq) {
@@ -15,17 +15,10 @@ function _uniq(array) {
         const set = new Set();
         return (value) => {
             if (set.has(value)) {
-                return {
-                    done: false,
-                    hasNext: false,
-                };
+                return { done: false, hasNext: false };
             }
             set.add(value);
-            return {
-                done: false,
-                hasNext: true,
-                next: value,
-            };
+            return { done: false, hasNext: true, next: value };
         };
     }
     uniq.lazy = lazy;

package/dist/commonjs/array/zip-obj.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zipObj = void 0;
 const purry_1 = require("../function/purry");
 function zipObj(...args) {
-    return (0, purry_1.purry)(_zipObj, args);
+    return (0, purry_1.purry)(zipObj_, args);
 }
 exports.zipObj = zipObj;
-function _zipObj(first, second) {
+function zipObj_(first, second) {
     const resultLength = first.length > second.length ? second.length : first.length;
     const result = {};
     for (let i = 0; i < resultLength; i++) {

package/dist/commonjs/array/zip-with.js

@@ -4,16 +4,16 @@ exports.zipWith = void 0;
 function zipWith(arg0, arg1, arg2) {
     if (typeof arg0 === 'function') {
         return arg1 === undefined
-            ? (f, s) => _zipWith(f, s, arg0)
-            : (f) => _zipWith(f, arg1, arg0);
+            ? (f, s) => zipWith_(f, s, arg0)
+            : (f) => zipWith_(f, arg1, arg0);
     }
     if (arg1 === undefined || arg2 === undefined) {
         throw new Error('zipWith: Missing arguments in dataFirst function call');
     }
-    return _zipWith(arg0, arg1, arg2);
+    return zipWith_(arg0, arg1, arg2);
 }
 exports.zipWith = zipWith;
-function _zipWith(first, second, fn) {
+function zipWith_(first, second, fn) {
     const resultLength = first.length > second.length ? second.length : first.length;
     const result = [];
     for (let i = 0; i < resultLength; i++) {

package/dist/commonjs/array/zip.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zip = void 0;
 const purry_1 = require("../function/purry");
 function zip(...args) {
-    return (0, purry_1.purry)(_zip, args);
+    return (0, purry_1.purry)(zip_, args);
 }
 exports.zip = zip;
-function _zip(first, second) {
+function zip_(first, second) {
     const resultLength = first.length > second.length ? second.length : first.length;
     const result = [];
     for (let i = 0; i < resultLength; i++) {

package/dist/commonjs/function/create-pipe.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPipe = void 0;
 const pipe_1 = require("./pipe");
 function createPipe(...operations) {
-    return (value) => pipe_1.pipe(value, ...operations);
+    return (value) => (0, pipe_1.pipe)(value, ...operations);
 }
 exports.createPipe = createPipe;

package/dist/commonjs/function/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./debounce"), exports);
 __exportStar(require("./pipe"), exports);
 __exportStar(require("./purry"), exports);
 __exportStar(require("./sleep"), exports);
+__exportStar(require("./times"), exports);

package/dist/commonjs/function/pipe.js

@@ -3,19 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipe = void 0;
 function pipe(input, ...operations) {
     let output = input;
-    const lazyOperations = operations.map((op) => 'lazy' in op ? toPipedLazy(op) : undefined);
+    const lazyOperations = operations.map((op) => 'lazy' in op ? prepareLazyOperation(op) : undefined);
     let operationIndex = 0;
     while (operationIndex < operations.length) {
         const lazyOperation = lazyOperations[operationIndex];
         if (lazyOperation === undefined || !isIterable(output)) {
             const operation = operations[operationIndex];
             output = operation(output);
-            operationIndex++;
+            operationIndex += 1;
             continue;
         }
         const lazySequence = [];
-        for (let j = operationIndex; j < operations.length; j++) {
-            const lazyOp = lazyOperations[j];
+        for (let index = operationIndex; index < operations.length; index++) {
+            const lazyOp = lazyOperations[index];
             if (lazyOp === undefined) {
                 break;
             }
@@ -37,12 +37,7 @@ function pipe(input, ...operations) {
             }
         }
         const { isSingle } = lazySequence[lazySequence.length - 1];
-        if (isSingle) {
-            output = accumulator[0];
-        }
-        else {
-            output = accumulator;
-        }
+        output = isSingle ? accumulator[0] : accumulator;
         operationIndex += lazySequence.length;
     }
     return output;
@@ -53,28 +48,27 @@ function processItem_(item, accumulator, lazySequence) {
         accumulator.push(item);
         return false;
     }
+    let currentItem = item;
     let lazyResult = { done: false, hasNext: false };
     let isDone = false;
-    for (let i = 0; i < lazySequence.length; i++) {
-        const lazyFn = lazySequence[i];
+    for (const [operationsIndex, lazyFn] of lazySequence.entries()) {
         const { index, isIndexed, items } = lazyFn;
-        items.push(item);
-        lazyResult = isIndexed ? lazyFn(item, index, items) : lazyFn(item);
-        lazyFn.index++;
+        items.push(currentItem);
+        lazyResult = isIndexed
+            ? lazyFn(currentItem, index, items)
+            : lazyFn(currentItem);
+        lazyFn.index += 1;
         if (lazyResult.hasNext) {
-            if (lazyResult.hasMany) {
-                const nextValues = lazyResult.next;
-                for (const subItem of nextValues) {
-                    const subResult = processItem_(subItem, accumulator, lazySequence.slice(i + 1));
+            if (lazyResult.hasMany ?? false) {
+                for (const subItem of lazyResult.next) {
+                    const subResult = processItem_(subItem, accumulator, lazySequence.slice(operationsIndex + 1));
                     if (subResult) {
                         return true;
                     }
                 }
                 return false;
             }
-            else {
-                item = lazyResult.next;
-            }
+            currentItem = lazyResult.next;
         }
         if (!lazyResult.hasNext) {
             break;
@@ -84,11 +78,11 @@ function processItem_(item, accumulator, lazySequence) {
         }
     }
     if (lazyResult.hasNext) {
-        accumulator.push(item);
+        accumulator.push(currentItem);
     }
     return isDone;
 }
-function toPipedLazy(op) {
+function prepareLazyOperation(op) {
     const { lazy, lazyArgs } = op;
     const fn = lazy(...(lazyArgs ?? []));
     return Object.assign(fn, {

package/dist/commonjs/function/purry.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.purry = void 0;
-function purry(fn, args, lazy) {
+function purry(fn, args, lazyFactory) {
+    const callArgs = Array.from(args);
     const diff = fn.length - args.length;
-    const arrayArgs = Array.from(args);
     if (diff === 0) {
-        return fn(...arrayArgs);
+        return fn(...callArgs);
     }
     if (diff === 1) {
-        const ret = (data) => fn(data, ...arrayArgs);
-        if (lazy || fn.lazy) {
-            ret.lazy = lazy || fn.lazy;
-            ret.lazyArgs = args;
-        }
-        return ret;
+        const ret = (data) => fn(data, ...callArgs);
+        const lazy = lazyFactory ?? fn.lazy;
+        return lazy === undefined
+            ? ret
+            : Object.assign(ret, { lazy, lazyArgs: args });
     }
     throw new Error('Wrong number of arguments');
 }

package/dist/commonjs/function/times.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.times = void 0;
+const purry_1 = require("./purry");
+function times(...args) {
+    return (0, purry_1.purry)(times_, args);
+}
+exports.times = times;
+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;
+}