@vinicunca/perkakas 0.2.1 → 0.3.3

package/README.md

@@ -0,0 +1,9 @@
+# @vinicunca/perkakas
+
+[![npm](https://img.shields.io/npm/v/@vinicunca/perkakas/latest.svg?style=flat&colorA=18181B&colorB=28CF8D)](https://npmjs.com/package/@vinicunca/perkakas)
+[![downloads](https://img.shields.io/npm/dm/@vinicunca/perkakas.svg?style=flat&colorA=18181B&colorB=28CF8D)](https://npmjs.com/package/@vinicunca/perkakas)
+[![license](https://img.shields.io/github/license/vinicunca/perkakas.svg?style=flat&colorA=18181B&colorB=28CF8D)](https://github.com/vinicunca/perkakas/blob/main/LICENSE)
+
+Utilities functions for javascript/typescript projects.
+
+[📖  Documentation](https://perkakas.vinicunca.dev/)

package/dist/commonjs/aria/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./key-codes"), exports);

package/dist/commonjs/aria/key-codes.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_CODES = void 0;
+exports.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',
+};

package/dist/commonjs/array/all-pass.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allPass = void 0;
+const purry_1 = require("../function/purry");
+function allPass(...args) {
+    return (0, purry_1.purry)(allPass_, args);
+}
+exports.allPass = allPass;
+function allPass_(data, fns) {
+    return fns.every((fn) => fn(data));
+}

package/dist/commonjs/array/any-pass.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyPass = void 0;
+const purry_1 = require("../function/purry");
+function anyPass(...args) {
+    return (0, purry_1.purry)(anyPass_, args);
+}
+exports.anyPass = anyPass;
+function anyPass_(data, fns) {
+    return fns.some((fn) => fn(data));
+}

package/dist/commonjs/array/chunk.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunk = void 0;
+const purry_1 = require("../function/purry");
+function chunk(...args) {
+    return (0, purry_1.purry)(chunk_, args);
+}
+exports.chunk = chunk;
+function chunk_(array, size) {
+    const ret = Array.from({
+        length: Math.ceil(array.length / size),
+    });
+    for (let index = 0; index < ret.length; index++) {
+        ret[index] = array.slice(index * size, (index + 1) * size);
+    }
+    return ret;
+}

package/dist/commonjs/array/compact.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compact = void 0;
+const is_truthy_1 = require("../guard/is-truthy");
+function compact(items) {
+    return items.filter(is_truthy_1.isTruthy);
+}
+exports.compact = compact;

package/dist/commonjs/array/concat.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concat = void 0;
+const purry_1 = require("../function/purry");
+function concat(...args) {
+    return (0, purry_1.purry)(concat_, args);
+}
+exports.concat = concat;
+function concat_(arr1, arr2) {
+    return arr1.concat(arr2);
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countBy = void 0;
+const purry_1 = require("../function/purry");
+function countBy_(indexed) {
+    return (array, fn) => {
+        let out = 0;
+        for (const [index, item] of array.entries()) {
+            const value = indexed ? fn(item, index, array) : fn(item);
+            out += value ? 1 : 0;
+        }
+        return out;
+    };
+}
+function countBy(...args) {
+    return (0, purry_1.purry)(countBy_(false), args);
+}
+exports.countBy = countBy;
+(function (countBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(countBy_(true), args);
+    }
+    countBy.indexed = indexed;
+})(countBy || (exports.countBy = countBy = {}));

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.differenceWith = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function differenceWith(...args) {
+    return (0, purry_1.purry)(differenceWith_, args, differenceWith.lazy);
+}
+exports.differenceWith = differenceWith;
+function differenceWith_(array, other, isEquals) {
+    const lazy = differenceWith.lazy(other, isEquals);
+    return (0, reduce_lazy_1.reduceLazy)(array, lazy);
+}
+(function (differenceWith) {
+    function lazy(other, isEquals) {
+        return (value) => other.every((otherValue) => !isEquals(value, otherValue))
+            ? { done: false, hasNext: true, next: value }
+            : { done: false, hasNext: false };
+    }
+    differenceWith.lazy = lazy;
+})(differenceWith || (exports.differenceWith = differenceWith = {}));

package/dist/commonjs/array/difference.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.difference = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function difference(...args) {
+    return (0, purry_1.purry)(difference_, args, difference.lazy);
+}
+exports.difference = difference;
+function difference_(array, other) {
+    const lazy = difference.lazy(other);
+    return (0, reduce_lazy_1.reduceLazy)(array, lazy);
+}
+(function (difference) {
+    function lazy(other) {
+        const set = new Set(other);
+        return (value) => set.has(value)
+            ? { done: false, hasNext: false }
+            : { done: false, hasNext: true, next: value };
+    }
+    difference.lazy = lazy;
+})(difference || (exports.difference = difference = {}));

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropFirstBy = void 0;
+const heap_1 = require("../utils/heap");
+const purry_order_rules_1 = require("../utils/purry-order-rules");
+function dropFirstBy(...args) {
+    return (0, purry_order_rules_1.purryOrderRulesWithArgument)(dropFirstByImplementation, args);
+}
+exports.dropFirstBy = dropFirstBy;
+function dropFirstByImplementation(data, compareFn, n) {
+    if (n >= data.length) {
+        return [];
+    }
+    if (n <= 0) {
+        return data.slice();
+    }
+    const heap = data.slice(0, n);
+    (0, heap_1.heapify)(heap, compareFn);
+    const out = [];
+    const rest = data.slice(n);
+    for (const item of rest) {
+        const previousHead = (0, heap_1.heapMaybeInsert)(heap, compareFn, item);
+        out.push(previousHead ?? item);
+    }
+    return out;
+}

package/dist/commonjs/array/drop-last-while.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropLastWhile = void 0;
+const purry_1 = require("../function/purry");
+function dropLastWhile(...args) {
+    return (0, purry_1.purry)(dropLastWhile_, args);
+}
+exports.dropLastWhile = dropLastWhile;
+function dropLastWhile_(data, predicate) {
+    for (let i = data.length - 1; i >= 0; i--) {
+        if (!predicate(data[i])) {
+            return data.slice(0, i + 1);
+        }
+    }
+    return [];
+}

package/dist/commonjs/array/drop-last.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropLast = void 0;
+const purry_1 = require("../function/purry");
+function dropLast(...args) {
+    return (0, purry_1.purry)(dropLast_, args);
+}
+exports.dropLast = dropLast;
+function dropLast_(array, n) {
+    const copy = array.slice();
+    if (n > 0) {
+        copy.splice(-n);
+    }
+    return copy;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropWhile = void 0;
+const purry_1 = require("../function/purry");
+function dropWhile(...args) {
+    return (0, purry_1.purry)(dropWhile_, args);
+}
+exports.dropWhile = dropWhile;
+function dropWhile_(data, predicate) {
+    for (let i = 0; i < data.length; i++) {
+        if (!predicate(data[i])) {
+            return data.slice(i);
+        }
+    }
+    return [];
+}

package/dist/commonjs/array/drop.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drop = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function drop(...args) {
+    return (0, purry_1.purry)(drop_, args, drop.lazy);
+}
+exports.drop = drop;
+function drop_(array, n) {
+    return (0, reduce_lazy_1.reduceLazy)(array, drop.lazy(n));
+}
+(function (drop) {
+    function lazy(n) {
+        let left = n;
+        return (value) => {
+            if (left > 0) {
+                left -= 1;
+                return { done: false, hasNext: false };
+            }
+            return { done: false, hasNext: true, next: value };
+        };
+    }
+    drop.lazy = lazy;
+})(drop || (exports.drop = drop = {}));

package/dist/commonjs/array/filter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = void 0;
+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 filter(...args) {
+    return (0, purry_1.purry)(filter_(false), args, filter.lazy);
+}
+exports.filter = filter;
+function filter_(indexed) {
+    return (array, fn) => {
+        return (0, reduce_lazy_1.reduceLazy)(array, indexed ? filter.lazyIndexed(fn) : filter.lazy(fn), indexed);
+    };
+}
+function lazy_(indexed) {
+    return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value))
+        ? { done: false, hasNext: true, next: value }
+        : { done: false, hasNext: false };
+}
+(function (filter) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(filter_(true), args, filter.lazyIndexed);
+    }
+    filter.indexed = indexed;
+    filter.lazy = lazy_(false);
+    filter.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true));
+})(filter || (exports.filter = filter = {}));

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIndex = void 0;
+const purry_1 = require("../function/purry");
+const to_lazy_indexed_1 = require("../utils/to-lazy-indexed");
+const to_single_1 = require("../utils/to-single");
+function findIndex(...args) {
+    return (0, purry_1.purry)(findIndex_(false), args, findIndex.lazy);
+}
+exports.findIndex = findIndex;
+function findIndex_(indexed) {
+    return (array, fn) => array.findIndex((item, index, input) => indexed ? fn(item, index, input) : fn(item));
+}
+function lazy_(indexed) {
+    return (fn) => {
+        let actualIndex = 0;
+        return (value, index, array) => {
+            if (indexed ? fn(value, index, array) : fn(value)) {
+                return { done: true, hasNext: true, next: actualIndex };
+            }
+            actualIndex += 1;
+            return { done: false, hasNext: false };
+        };
+    };
+}
+(function (findIndex) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(findIndex_(true), args, findIndex.lazyIndexed);
+    }
+    findIndex.indexed = indexed;
+    findIndex.lazy = (0, to_single_1.toSingle)(lazy_(false));
+    findIndex.lazyIndexed = (0, to_single_1.toSingle)((0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true)));
+})(findIndex || (exports.findIndex = findIndex = {}));

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

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

package/dist/commonjs/array/find-last.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLast = void 0;
+const purry_1 = require("../function/purry");
+function findLast(...args) {
+    return (0, purry_1.purry)(findLast_(false), args);
+}
+exports.findLast = findLast;
+function findLast_(indexed) {
+    return (array, fn) => {
+        for (let i = array.length - 1; i >= 0; i--) {
+            if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+                return array[i];
+            }
+        }
+        return undefined;
+    };
+}
+(function (findLast) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(findLast_(true), args);
+    }
+    findLast.indexed = indexed;
+})(findLast || (exports.findLast = findLast = {}));

package/dist/commonjs/array/find.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.find = void 0;
+const purry_1 = require("../function/purry");
+const to_lazy_indexed_1 = require("../utils/to-lazy-indexed");
+const to_single_1 = require("../utils/to-single");
+function find(...args) {
+    return (0, purry_1.purry)(find_(false), args, find.lazy);
+}
+exports.find = find;
+function find_(indexed) {
+    return (array, fn) => array.find((item, index, input) => indexed ? fn(item, index, input) : fn(item));
+}
+function lazy_(indexed) {
+    return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value))
+        ? { done: true, hasNext: true, next: value }
+        : { done: false, hasNext: false };
+}
+(function (find) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(find_(true), args, find.lazyIndexed);
+    }
+    find.indexed = indexed;
+    find.lazy = (0, to_single_1.toSingle)(lazy_(false));
+    find.lazyIndexed = (0, to_single_1.toSingle)((0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true)));
+})(find || (exports.find = find = {}));

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstBy = void 0;
+const purry_order_rules_1 = require("../utils/purry-order-rules");
+const has_at_least_1 = require("./has-at-least");
+function firstBy(...args) {
+    return (0, purry_order_rules_1.purryOrderRules)(firstByImplementation, args);
+}
+exports.firstBy = firstBy;
+function firstByImplementation(data, compareFn) {
+    if (!(0, has_at_least_1.hasAtLeast)(data, 2)) {
+        return data[0];
+    }
+    let [currentFirst] = data;
+    const [, ...rest] = data;
+    for (const item of rest) {
+        if (compareFn(item, currentFirst) < 0) {
+            currentFirst = item;
+        }
+    }
+    return currentFirst;
+}

package/dist/commonjs/array/first.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.first = void 0;
+const purry_1 = require("../function/purry");
+function first(...args) {
+    return (0, purry_1.purry)(first_, args, first.lazy);
+}
+exports.first = first;
+function first_([item]) {
+    return item;
+}
+(function (first) {
+    function lazy() {
+        return (value) => ({ done: true, hasNext: true, next: value });
+    }
+    first.lazy = lazy;
+    (function (lazy) {
+        lazy.single = true;
+    })(lazy = first.lazy || (first.lazy = {}));
+})(first || (exports.first = first = {}));

package/dist/commonjs/array/flat-map-to-obj.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatMapToObj = void 0;
+const purry_1 = require("../function/purry");
+function flatMapToObj(...args) {
+    return (0, purry_1.purry)(flatMapToObj_(false), args);
+}
+exports.flatMapToObj = flatMapToObj;
+function flatMapToObj_(indexed) {
+    return (array, fn) => {
+        const out = {};
+        for (const [index, element] of array.entries()) {
+            const items = indexed ? fn(element, index, array) : fn(element);
+            for (const [key, value] of items) {
+                out[key] = value;
+            }
+        }
+        return out;
+    };
+}
+(function (flatMapToObj) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(flatMapToObj_(true), args);
+    }
+    flatMapToObj.indexed = indexed;
+})(flatMapToObj || (exports.flatMapToObj = flatMapToObj = {}));

package/dist/commonjs/array/flat-map.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatMap = void 0;
+const purry_1 = require("../function/purry");
+const flatten_1 = require("./flatten");
+function flatMap(...args) {
+    return (0, purry_1.purry)(flatMap_, args, flatMap.lazy);
+}
+exports.flatMap = flatMap;
+function flatMap_(array, fn) {
+    return (0, flatten_1.flatten)(array.map((item) => fn(item)));
+}
+(function (flatMap) {
+    function lazy(fn) {
+        return (value) => {
+            const next = fn(value);
+            return Array.isArray(next)
+                ? { done: false, hasMany: true, hasNext: true, next }
+                : { done: false, hasNext: true, next };
+        };
+    }
+    flatMap.lazy = lazy;
+})(flatMap || (exports.flatMap = flatMap = {}));

package/dist/commonjs/array/flatten-deep.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenDeep = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function flattenDeep(...args) {
+    return (0, purry_1.purry)(flattenDeep_, args, flattenDeep.lazy);
+}
+exports.flattenDeep = flattenDeep;
+function flattenDeep_(items) {
+    return (0, reduce_lazy_1.reduceLazy)(items, flattenDeep.lazy());
+}
+function flattenDeepValue_(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    const ret = [];
+    for (const item of value) {
+        if (Array.isArray(item)) {
+            ret.push(...flattenDeep(item));
+        }
+        else {
+            ret.push(item);
+        }
+    }
+    return ret;
+}
+(function (flattenDeep) {
+    function lazy() {
+        return (value) => {
+            const next = flattenDeepValue_(value);
+            return Array.isArray(next)
+                ? { done: false, hasMany: true, hasNext: true, next }
+                : { done: false, hasNext: true, next };
+        };
+    }
+    flattenDeep.lazy = lazy;
+})(flattenDeep || (exports.flattenDeep = flattenDeep = {}));

package/dist/commonjs/array/flatten.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function flatten(...args) {
+    return (0, purry_1.purry)(flatten_, args, flatten.lazy);
+}
+exports.flatten = flatten;
+function flatten_(items) {
+    return (0, reduce_lazy_1.reduceLazy)(items, flatten.lazy());
+}
+(function (flatten) {
+    function lazy() {
+        return (item) => Array.isArray(item)
+            ? { done: false, hasMany: true, hasNext: true, next: item }
+            : { done: false, hasNext: true, next: item };
+    }
+    flatten.lazy = lazy;
+})(flatten || (exports.flatten = flatten = {}));

package/dist/commonjs/array/for-each.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEach = void 0;
+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 forEach(...args) {
+    return (0, purry_1.purry)(forEach_(false), args, forEach.lazy);
+}
+exports.forEach = forEach;
+function forEach_(indexed) {
+    return (array, fn) => (0, reduce_lazy_1.reduceLazy)(array, indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn), indexed);
+}
+function lazy_(indexed) {
+    return (fn) => (value, index, array) => {
+        if (indexed) {
+            fn(value, index, array);
+        }
+        else {
+            fn(value);
+        }
+        return {
+            done: false,
+            hasNext: true,
+            next: value,
+        };
+    };
+}
+(function (forEach) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(forEach_(true), args, forEach.lazyIndexed);
+    }
+    forEach.indexed = indexed;
+    forEach.lazy = lazy_(false);
+    forEach.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true));
+})(forEach || (exports.forEach = forEach = {}));

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = void 0;
+const purry_1 = require("../function/purry");
+function groupBy(...args) {
+    return (0, purry_1.purry)(groupBy_(false), args);
+}
+exports.groupBy = groupBy;
+function groupBy_(indexed) {
+    return (array, fn) => {
+        const ret = {};
+        for (const [index, item] of array.entries()) {
+            const key = indexed ? fn(item, index, array) : fn(item);
+            if (key !== undefined) {
+                const actualKey = String(key);
+                let items = ret[actualKey];
+                if (items === undefined) {
+                    items = [];
+                    ret[actualKey] = items;
+                }
+                items.push(item);
+            }
+        }
+        return ret;
+    };
+}
+(function (groupBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(groupBy_(true), args);
+    }
+    groupBy.indexed = indexed;
+    groupBy.strict = groupBy;
+})(groupBy || (exports.groupBy = groupBy = {}));