@softwareventures/async-iterable/index.js

Pure functional AsyncIterable traversal

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.asyncContains = exports.asyncIndexFn = exports.asyncIndex = exports.asyncFold1Fn = exports.asyncFold1 = exports.asyncFoldFn = exports.asyncFold = exports.asyncRemoveFirstFn = exports.asyncRemoveFirst = exports.asyncRemoveFn = exports.asyncRemove = exports.asyncExcludeFirstFn = exports.asyncExcludeFirst = exports.asyncExcludeNull = exports.asyncExcludeFn = exports.asyncExclude = exports.asyncFilterFn = exports.asyncFilter = exports.asyncMapFn = exports.asyncMap = exports.asyncPrefixMatchFn = exports.asyncPrefixMatch = exports.asyncNotEqualFn = exports.asyncNotEqual = exports.asyncEqualFn = exports.asyncEqual = exports.asyncDropUntilFn = exports.asyncDropUntil = exports.asyncDropWhile = exports.asyncTakeUntilFn = exports.asyncTakeUntil = exports.asyncTakeWhileFn = exports.asyncTakeWhile = exports.asyncDropFn = exports.asyncDrop = exports.asyncTakeFn = exports.asyncTake = exports.asyncNotEmpty = exports.asyncEmpty = exports.asyncOnly = exports.asyncLast = exports.asyncInitial = exports.asyncUnshiftFn = exports.asyncUnshift = exports.asyncPushFn = exports.asyncPush = exports.asyncTail = exports.asyncFirst = exports.asyncToSet = exports.asyncToArray = void 0;
exports.asyncMapKeyLastByFn = exports.asyncMapKeyLastBy = exports.asyncMapKeyFirstByFn = exports.asyncMapKeyFirstBy = exports.asyncMapKeyByFn = exports.asyncMapKeyBy = exports.asyncKeyLastByFn = exports.asyncKeyLastBy = exports.asyncKeyFirstByFn = exports.asyncKeyFirstBy = exports.asyncKeyByFn = exports.asyncKeyBy = exports.asyncZipStrict = exports.asyncZipFn = exports.asyncZip = exports.asyncScan1 = exports.asyncScanFn = exports.asyncScan = exports.asyncNoneNull = exports.asyncConcatMapFn = exports.asyncConcatMap = exports.asyncAppend = exports.asyncPrepend = exports.asyncConcat = exports.asyncAll = exports.asyncAny = exports.asyncOr = exports.asyncAnd = exports.asyncAverage = exports.asyncProduct = exports.asyncSum = exports.asyncMinimumByFn = exports.asyncMinimumBy = exports.asyncMinimumFn = exports.asyncMinimum = exports.asyncMaximumByFn = exports.asyncMaximumBy = exports.asyncMaximumFn = exports.asyncMaximum = exports.asyncFindFn = exports.asyncFind = exports.asyncFindIndexFn = exports.asyncFindIndex = exports.asyncIndexOfFn = exports.asyncIndexOf = exports.asyncContainsFn = void 0;
exports.asyncIterable = asyncIterable;
exports.asyncIterator = asyncIterator;
exports.isAsyncIterable = isAsyncIterable;
exports.toArray = toArray;
exports.toSet = toSet;
exports.first = first;
exports.tail = tail;
exports.push = push;
exports.pushFn = pushFn;
exports.unshift = unshift;
exports.unshiftFn = unshiftFn;
exports.initial = initial;
exports.last = last;
exports.only = only;
exports.empty = empty;
exports.notEmpty = notEmpty;
exports.slice = slice;
exports.take = take;
exports.takeFn = takeFn;
exports.drop = drop;
exports.dropFn = dropFn;
exports.takeWhile = takeWhile;
exports.takeWhileFn = takeWhileFn;
exports.takeUntil = takeUntil;
exports.takeUntilFn = takeUntilFn;
exports.dropWhile = dropWhile;
exports.dropWhileFn = dropWhileFn;
exports.dropUntil = dropUntil;
exports.dropUntilFn = dropUntilFn;
exports.equal = equal;
exports.equalFn = equalFn;
exports.notEqual = notEqual;
exports.notEqualFn = notEqualFn;
exports.prefixMatch = prefixMatch;
exports.prefixMatchFn = prefixMatchFn;
exports.map = map;
exports.mapFn = mapFn;
exports.filter = filter;
exports.filterFn = filterFn;
exports.exclude = exclude;
exports.excludeFn = excludeFn;
exports.excludeNull = excludeNull;
exports.excludeFirst = excludeFirst;
exports.excludeFirstFn = excludeFirstFn;
exports.remove = remove;
exports.removeFn = removeFn;
exports.removeFirst = removeFirst;
exports.removeFirstFn = removeFirstFn;
exports.fold = fold;
exports.foldFn = foldFn;
exports.fold1 = fold1;
exports.fold1Fn = fold1Fn;
exports.index = index;
exports.indexFn = indexFn;
exports.contains = contains;
exports.containsFn = containsFn;
exports.indexOf = indexOf;
exports.indexOfFn = indexOfFn;
exports.findIndex = findIndex;
exports.findIndexFn = findIndexFn;
exports.find = find;
exports.findFn = findFn;
exports.maximum = maximum;
exports.maximumFn = maximumFn;
exports.maximumBy = maximumBy;
exports.maximumByFn = maximumByFn;
exports.minimum = minimum;
exports.minimumFn = minimumFn;
exports.minimumBy = minimumBy;
exports.minimumByFn = minimumByFn;
exports.sum = sum;
exports.product = product;
exports.average = average;
exports.and = and;
exports.or = or;
exports.any = any;
exports.all = all;
exports.concat = concat;
exports.prepend = prepend;
exports.append = append;
exports.concatMap = concatMap;
exports.concatMapFn = concatMapFn;
exports.noneNull = noneNull;
exports.scan = scan;
exports.scanFn = scanFn;
exports.scan1 = scan1;
exports.scan1Fn = scan1Fn;
exports.pairwise = pairwise;
exports.zip = zip;
exports.zipFn = zipFn;
exports.zipStrict = zipStrict;
exports.zipStrictFn = zipStrictFn;
exports.keyBy = keyBy;
exports.keyByFn = keyByFn;
exports.keyFirstBy = keyFirstBy;
exports.keyFirstByFn = keyFirstByFn;
exports.keyLastBy = keyLastBy;
exports.keyLastByFn = keyLastByFn;
exports.mapKeyBy = mapKeyBy;
exports.mapKeyByFn = mapKeyByFn;
exports.mapKeyFirstBy = mapKeyFirstBy;
exports.mapKeyFirstByFn = mapKeyFirstByFn;
exports.mapKeyLastBy = mapKeyLastBy;
exports.mapKeyLastByFn = mapKeyLastByFn;
const ordered_1 = require("@softwareventures/ordered");
const nullable_1 = require("@softwareventures/nullable");
async function* asyncIterable(iterable) {
    for await (const element of await iterable) {
        yield element;
    }
}
function asyncIterator(iterable) {
    return asyncIterable(iterable)[Symbol.asyncIterator]();
}
function isAsyncIterable(value) {
    return typeof value === "object" && value != null && Symbol.asyncIterator in value;
}
async function toArray(iterable) {
    const array = [];
    for await (const element of await iterable) {
        array.push(element);
    }
    return array;
}
exports.asyncToArray = toArray;
async function toSet(iterable) {
    const set = new Set();
    for await (const element of await iterable) {
        set.add(element);
    }
    return set;
}
exports.asyncToSet = toSet;
async function first(iterable) {
    const result = await asyncIterator(iterable).next();
    return result.done === true ? null : result.value;
}
exports.asyncFirst = first;
async function* tail(iterable) {
    const iterator = asyncIterator(iterable);
    await iterator.next();
    let element = await iterator.next();
    while (element.done !== true) {
        yield element.value;
        element = await iterator.next();
    }
}
exports.asyncTail = tail;
async function* push(iterable, value) {
    for await (const element of await iterable) {
        yield element;
    }
    yield await value;
}
exports.asyncPush = push;
function pushFn(value) {
    return iterable => push(iterable, value);
}
exports.asyncPushFn = pushFn;
async function* unshift(iterable, value) {
    yield await value;
    for await (const element of await iterable) {
        yield element;
    }
}
exports.asyncUnshift = unshift;
function unshiftFn(value) {
    return iterable => unshift(iterable, value);
}
exports.asyncUnshiftFn = unshiftFn;
async function* initial(iterable) {
    const iterator = asyncIterator(iterable);
    let prev = await iterator.next();
    let element = prev.done === true ? prev : await iterator.next();
    while (element.done !== true) {
        yield prev.value;
        prev = element;
        element = await iterator.next();
    }
}
exports.asyncInitial = initial;
async function last(iterable) {
    let last = null;
    for await (const element of await iterable) {
        last = element;
    }
    return last;
}
exports.asyncLast = last;
async function only(iterable) {
    const iterator = asyncIterator(iterable);
    const first = await iterator.next();
    return !(first.done ?? false) && ((await iterator.next()).done ?? false) ? first.value : null;
}
exports.asyncOnly = only;
async function empty(iterable) {
    return (await asyncIterator(iterable).next()).done === true;
}
exports.asyncEmpty = empty;
async function notEmpty(iterable) {
    return !(await empty(iterable));
}
exports.asyncNotEmpty = notEmpty;
async function* slice(iterable, start = 0, end = Infinity) {
    const s = await start;
    const e = await end;
    if (e === s) {
        return;
    }
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    for (let i = 0; i < s && element.done !== true; ++i) {
        element = await iterator.next();
    }
    for (let i = s; i < e && element.done !== true; ++i) {
        yield element.value;
        element = await iterator.next();
    }
}
async function* take(iterable, count) {
    const c = await count;
    if (c === 0) {
        return;
    }
    let i = 0;
    for await (const element of await iterable) {
        yield element;
        if (++i >= c) {
            return;
        }
    }
}
exports.asyncTake = take;
function takeFn(count) {
    return iterable => take(iterable, count);
}
exports.asyncTakeFn = takeFn;
async function* drop(iterable, count) {
    const iterator = asyncIterator(iterable);
    const c = await count;
    let element = await iterator.next();
    for (let i = 0; i < c && element.done !== true; ++i) {
        element = await iterator.next();
    }
    while (element.done !== true) {
        yield element.value;
        element = await iterator.next();
    }
}
exports.asyncDrop = drop;
function dropFn(count) {
    return iterable => drop(iterable, count);
}
exports.asyncDropFn = dropFn;
async function* takeWhile(iterable, predicate) {
    let i = 0;
    for await (const element of await iterable) {
        if (!(await predicate(element, i))) {
            return;
        }
        yield element;
        ++i;
    }
}
exports.asyncTakeWhile = takeWhile;
function takeWhileFn(predicate) {
    return iterable => takeWhile(iterable, predicate);
}
exports.asyncTakeWhileFn = takeWhileFn;
function takeUntil(iterable, predicate) {
    return takeWhile(iterable, async (element, index) => !(await predicate(element, index)));
}
exports.asyncTakeUntil = takeUntil;
function takeUntilFn(predicate) {
    return iterable => takeUntil(iterable, predicate);
}
exports.asyncTakeUntilFn = takeUntilFn;
async function* dropWhile(iterable, predicate) {
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    for (let i = 0; element.done !== true && (await predicate(element.value, i)); ++i) {
        element = await iterator.next();
    }
    while (element.done !== true) {
        yield element.value;
        element = await iterator.next();
    }
}
exports.asyncDropWhile = dropWhile;
function dropWhileFn(predicate) {
    return iterable => dropWhile(iterable, predicate);
}
function dropUntil(iterable, predicate) {
    return dropWhile(iterable, async (element, index) => !(await predicate(element, index)));
}
exports.asyncDropUntil = dropUntil;
function dropUntilFn(predicate) {
    return iterable => dropUntil(iterable, predicate);
}
exports.asyncDropUntilFn = dropUntilFn;
async function equal(a, b, elementsEqual = ordered_1.equal) {
    const ait = asyncIterator(a);
    const bit = asyncIterator(b);
    let ar = await ait.next();
    let br = await bit.next();
    while (ar.done !== true && br.done !== true) {
        if (!(await elementsEqual(ar.value, br.value))) {
            return false;
        }
        ar = await ait.next();
        br = await bit.next();
    }
    return (ar.done ?? false) && (br.done ?? false);
}
exports.asyncEqual = equal;
function equalFn(b, elementsEqual = ordered_1.equal) {
    return async (a) => equal(a, b, elementsEqual);
}
exports.asyncEqualFn = equalFn;
async function notEqual(a, b, elementsEqual = ordered_1.equal) {
    return !(await equal(a, b, elementsEqual));
}
exports.asyncNotEqual = notEqual;
function notEqualFn(b, elementsEqual = ordered_1.equal) {
    return async (a) => notEqual(a, b, elementsEqual);
}
exports.asyncNotEqualFn = notEqualFn;
async function prefixMatch(a, b, elementsEqual = ordered_1.equal) {
    const ait = asyncIterator(a);
    const bit = asyncIterator(b);
    let ar = await ait.next();
    let br = await bit.next();
    while (ar.done !== true && br.done !== true) {
        if (!(await elementsEqual(ar.value, br.value))) {
            return false;
        }
        ar = await ait.next();
        br = await bit.next();
    }
    return br.done ?? false;
}
exports.asyncPrefixMatch = prefixMatch;
function prefixMatchFn(b, elementsEqual = ordered_1.equal) {
    return async (a) => prefixMatch(a, b, elementsEqual);
}
exports.asyncPrefixMatchFn = prefixMatchFn;
async function* map(iterable, f) {
    let i = 0;
    for await (const element of await iterable) {
        yield await f(element, i++);
    }
}
exports.asyncMap = map;
function mapFn(f) {
    return iterable => map(iterable, f);
}
exports.asyncMapFn = mapFn;
async function* filter(iterable, predicate) {
    let i = 0;
    for await (const element of await iterable) {
        if (await predicate(element, i++)) {
            yield element;
        }
    }
}
exports.asyncFilter = filter;
function filterFn(predicate) {
    return iterable => filter(iterable, predicate);
}
exports.asyncFilterFn = filterFn;
function exclude(iterable, predicate) {
    return filter(iterable, async (element, index) => !(await predicate(element, index)));
}
exports.asyncExclude = exclude;
function excludeFn(predicate) {
    return iterable => exclude(iterable, predicate);
}
exports.asyncExcludeFn = exclude;
function excludeNull(iterable) {
    return filter(iterable, nullable_1.isNotNull);
}
exports.asyncExcludeNull = excludeNull;
async function* excludeFirst(iterable, predicate) {
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    for (let i = 0; element.done !== true; ++i) {
        if (await predicate(element.value, i)) {
            break;
        }
        yield element.value;
        element = await iterator.next();
    }
    if (element.done !== true) {
        element = await iterator.next();
    }
    while (element.done !== true) {
        yield element.value;
        element = await iterator.next();
    }
}
exports.asyncExcludeFirst = excludeFirst;
function excludeFirstFn(predicate) {
    return iterable => excludeFirst(iterable, predicate);
}
exports.asyncExcludeFirstFn = excludeFirstFn;
function remove(iterable, value) {
    return exclude(iterable, element => element === value);
}
exports.asyncRemove = remove;
function removeFn(value) {
    return iterable => remove(iterable, value);
}
exports.asyncRemoveFn = removeFn;
function removeFirst(iterable, value) {
    return excludeFirst(iterable, element => element === value);
}
exports.asyncRemoveFirst = removeFirst;
function removeFirstFn(value) {
    return iterable => removeFirst(iterable, value);
}
exports.asyncRemoveFirstFn = removeFirstFn;
async function fold(iterable, f, initial) {
    let accumulator = initial;
    let i = 0;
    for await (const element of await iterable) {
        accumulator = await f(accumulator, element, i++);
    }
    return accumulator;
}
exports.asyncFold = fold;
function foldFn(f, initial) {
    return async (iterable) => fold(iterable, f, initial);
}
exports.asyncFoldFn = foldFn;
async function fold1(iterable, f) {
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    if (element.done === true) {
        throw new TypeError("fold1: empty AsyncIterable");
    }
    let accumulator = element.value;
    let i = 1;
    element = await iterator.next();
    while (element.done !== true) {
        accumulator = await f(accumulator, element.value, i++);
        element = await iterator.next();
    }
    return accumulator;
}
exports.asyncFold1 = fold1;
function fold1Fn(f) {
    return async (iterable) => fold1(iterable, f);
}
exports.asyncFold1Fn = fold1Fn;
async function index(iterable, index) {
    if (index < 0 || !isFinite(index) || Math.floor(index) !== index) {
        throw new RangeError("illegal index");
    }
    let i = 0;
    for await (const element of await iterable) {
        if (i++ === index) {
            return element;
        }
    }
    return null;
}
exports.asyncIndex = index;
function indexFn(index) {
    return async (iterable) => (0, exports.asyncIndex)(iterable, index);
}
exports.asyncIndexFn = indexFn;
async function contains(iterable, value) {
    for await (const element of await iterable) {
        if (element === value) {
            return true;
        }
    }
    return false;
}
exports.asyncContains = contains;
function containsFn(value) {
    return async (iterable) => contains(iterable, value);
}
exports.asyncContainsFn = containsFn;
async function indexOf(iterable, value) {
    let i = 0;
    for await (const element of await iterable) {
        if (element === value) {
            return i;
        }
        ++i;
    }
    return null;
}
exports.asyncIndexOf = indexOf;
function indexOfFn(value) {
    return async (iterable) => indexOf(iterable, value);
}
exports.asyncIndexOfFn = indexOfFn;
async function findIndex(iterable, predicate) {
    let i = 0;
    for await (const element of await iterable) {
        if (await predicate(element, i)) {
            return i;
        }
        ++i;
    }
    return null;
}
exports.asyncFindIndex = findIndex;
function findIndexFn(predicate) {
    return async (iterable) => findIndex(iterable, predicate);
}
exports.asyncFindIndexFn = findIndexFn;
async function find(iterable, predicate) {
    let i = 0;
    for await (const element of await iterable) {
        if (await predicate(element, i++)) {
            return element;
        }
    }
    return null;
}
exports.asyncFind = find;
function findFn(predicate) {
    return async (iterable) => find(iterable, predicate);
}
exports.asyncFindFn = findFn;
async function maximum(iterable, compare) {
    return internalMaximum(iterable, compare ?? ordered_1.compare);
}
exports.asyncMaximum = maximum;
function maximumFn(compare) {
    return async (iterable) => maximum(iterable, compare);
}
exports.asyncMaximumFn = maximumFn;
async function internalMaximum(iterable, compare) {
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    if (element.done === true) {
        return null;
    }
    let max = element.value;
    element = await iterator.next();
    while (element.done !== true) {
        if (compare(element.value, max) > ordered_1.Comparison.equal) {
            max = element.value;
        }
        element = await iterator.next();
    }
    return max;
}
async function maximumBy(iterable, select) {
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    if (element.done === true) {
        return null;
    }
    let max = element.value;
    let maxBy = await select(element.value, 0);
    let i = 0;
    element = await iterator.next();
    while (element.done !== true) {
        const by = await select(element.value, i++);
        if (by > maxBy) {
            max = element.value;
            maxBy = by;
        }
        element = await iterator.next();
    }
    return max;
}
exports.asyncMaximumBy = maximumBy;
function maximumByFn(select) {
    return async (iterable) => maximumBy(iterable, select);
}
exports.asyncMaximumByFn = maximumByFn;
async function minimum(iterable, compare) {
    return internalMaximum(iterable, (0, ordered_1.reverse)(compare ?? ordered_1.compare));
}
exports.asyncMinimum = minimum;
function minimumFn(compare) {
    return async (iterable) => minimum(iterable, compare);
}
exports.asyncMinimumFn = minimumFn;
async function minimumBy(iterable, select) {
    return maximumBy(iterable, async (element, index) => -(await select(element, index)));
}
exports.asyncMinimumBy = minimumBy;
function minimumByFn(select) {
    return async (iterable) => minimumBy(iterable, select);
}
exports.asyncMinimumByFn = minimumByFn;
async function sum(iterable) {
    return fold(iterable, (sum, element) => sum + element, 0);
}
exports.asyncSum = sum;
async function product(iterable) {
    return fold(iterable, (product, element) => product * element, 1);
}
exports.asyncProduct = product;
async function average(iterable) {
    const [sum, count] = await fold(iterable, ([sum], element, index) => [sum + element, index + 1], [0, 0]);
    return count === 0 ? null : sum / count;
}
exports.asyncAverage = average;
async function and(iterable) {
    return (await findIndex(iterable, element => !element)) == null;
}
exports.asyncAnd = and;
async function or(iterable) {
    return (await findIndex(iterable, Boolean)) != null;
}
exports.asyncOr = or;
async function any(iterable, predicate) {
    return (await findIndex(iterable, predicate)) != null;
}
exports.asyncAny = any;
async function all(iterable, predicate) {
    return ((await findIndex(iterable, async (element, index) => !(await predicate(element, index)))) ==
        null);
}
exports.asyncAll = all;
async function* concat(iterables) {
    for await (const iterable of await iterables) {
        for await (const element of iterable) {
            yield element;
        }
    }
}
exports.asyncConcat = concat;
function prepend(a) {
    return b => concat([a, b]);
}
exports.asyncPrepend = prepend;
function append(b) {
    return a => concat([a, b]);
}
exports.asyncAppend = append;
function concatMap(iterable, f) {
    return concat(map(iterable, f));
}
exports.asyncConcatMap = concatMap;
function concatMapFn(f) {
    return iterable => concatMap(iterable, f);
}
exports.asyncConcatMapFn = concatMapFn;
async function noneNull(iterable) {
    const result = [];
    for await (const element of await iterable) {
        if (element == null) {
            return null;
        }
        result.push(element);
    }
    return result;
}
exports.asyncNoneNull = noneNull;
async function* scan(iterable, f, initial) {
    let i = 0;
    let accumulator = initial;
    for await (const element of await iterable) {
        yield (accumulator = await f(accumulator, element, i++));
    }
}
exports.asyncScan = scan;
function scanFn(f, initial) {
    return iterable => scan(iterable, f, initial);
}
exports.asyncScanFn = scanFn;
async function* scan1(iterable, f) {
    const iterator = asyncIterator(iterable);
    let element = await iterator.next();
    if (element.done === true) {
        return;
    }
    let accumulator = element.value;
    yield accumulator;
    let i = 1;
    element = await iterator.next();
    while (element.done !== true) {
        yield (accumulator = await f(accumulator, element.value, i++));
        element = await iterator.next();
    }
}
exports.asyncScan1 = scan1;
function scan1Fn(f) {
    return iterable => scan1(iterable, f);
}
async function* pairwise(iterable) {
    const iterator = asyncIterator(iterable);
    let prev = await iterator.next();
    if (prev.done === true) {
        return;
    }
    let element = await iterator.next();
    while (element.done !== true) {
        yield [prev.value, element.value];
        prev = element;
        element = await iterator.next();
    }
}
function zip(a, b) {
    return zipInternal(a, b);
}
exports.asyncZip = zip;
function zipFn(b) {
    return a => zip(a, b);
}
exports.asyncZipFn = zipFn;
function zipStrict(a, b) {
    return zipInternal(a, b, true);
}
exports.asyncZipStrict = zipStrict;
function zipStrictFn(b) {
    return a => zipStrict(a, b);
}
async function* zipInternal(a, b, strict = false) {
    const ait = asyncIterator(a);
    const bit = asyncIterator(b);
    let ar = await ait.next();
    let br = await bit.next();
    while (ar.done !== true && br.done !== true) {
        yield [ar.value, br.value];
        ar = await ait.next();
        br = await bit.next();
    }
    if (strict && (ar.done !== true || br.done !== true)) {
        throw new RangeError("zipStrict: Iterables have different lengths");
    }
}
async function keyBy(iterable, f) {
    const map = new Map();
    let i = 0;
    for await (const element of await iterable) {
        const key = f(element, i++);
        const group = map.get(key) ?? [];
        group.push(element);
        map.set(key, group);
    }
    return map;
}
exports.asyncKeyBy = keyBy;
function keyByFn(f) {
    return async (iterable) => keyBy(iterable, f);
}
exports.asyncKeyByFn = keyByFn;
async function keyFirstBy(iterable, f) {
    const map = new Map();
    let i = 0;
    for await (const element of await iterable) {
        const key = f(element, i++);
        if (!map.has(key)) {
            map.set(key, element);
        }
    }
    return map;
}
exports.asyncKeyFirstBy = keyFirstBy;
function keyFirstByFn(f) {
    return async (iterable) => keyFirstBy(iterable, f);
}
exports.asyncKeyFirstByFn = keyFirstByFn;
async function keyLastBy(iterable, f) {
    const map = new Map();
    let i = 0;
    for await (const element of await iterable) {
        map.set(f(element, i++), element);
    }
    return map;
}
exports.asyncKeyLastBy = keyLastBy;
function keyLastByFn(f) {
    return async (iterable) => keyLastBy(iterable, f);
}
exports.asyncKeyLastByFn = keyLastByFn;
async function mapKeyBy(iterable, f) {
    const map = new Map();
    let i = 0;
    for await (const element of await iterable) {
        const [key, value] = await f(element, i++);
        const group = map.get(key) ?? [];
        group.push(value);
        map.set(key, group);
    }
    return map;
}
exports.asyncMapKeyBy = mapKeyBy;
function mapKeyByFn(f) {
    return async (iterable) => mapKeyBy(iterable, f);
}
exports.asyncMapKeyByFn = mapKeyByFn;
async function mapKeyFirstBy(iterable, f) {
    const map = new Map();
    let i = 0;
    for await (const element of await iterable) {
        const [key, value] = await f(element, i++);
        if (!map.has(key)) {
            map.set(key, value);
        }
    }
    return map;
}
exports.asyncMapKeyFirstBy = mapKeyFirstBy;
function mapKeyFirstByFn(f) {
    return async (iterable) => mapKeyFirstBy(iterable, f);
}
exports.asyncMapKeyFirstByFn = mapKeyFirstByFn;
async function mapKeyLastBy(iterable, f) {
    const map = new Map();
    let i = 0;
    for await (const element of await iterable) {
        const [key, value] = await f(element, i++);
        map.set(key, value);
    }
    return map;
}
exports.asyncMapKeyLastBy = mapKeyLastBy;
function mapKeyLastByFn(f) {
    return async (iterable) => mapKeyLastBy(iterable, f);
}
exports.asyncMapKeyLastByFn = mapKeyLastByFn;
//# sourceMappingURL=index.js.map