@rimbu/common 0.12.3 → 1.0.0-alpha.2

package/dist/main/async-reducer.js

@@ -1,872 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncReducer = void 0;
-var tslib_1 = require("tslib");
-var internal_1 = require("./internal");
-function identity(value) {
-    return value;
-}
-var AsyncReducer;
-(function (AsyncReducer) {
-    var _this = this;
-    /**
-     * A base class that can be used to easily create `AsyncReducer` instances.
-     * @typeparam I - the input value type
-     * @typeparam O - the output value type
-     * @typeparam S - the internal state type
-     */
-    var Base = /** @class */ (function () {
-        function Base(init, next, stateToResult, onClose) {
-            this.init = init;
-            this.next = next;
-            this.stateToResult = stateToResult;
-            this.onClose = onClose;
-        }
-        Base.prototype.filterInput = function (pred) {
-            var _this = this;
-            return create(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                var _a;
-                return tslib_1.__generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _a = {
-                                nextIndex: 0
-                            };
-                            return [4 /*yield*/, internal_1.AsyncOptLazy.toMaybePromise(this.init)];
-                        case 1: return [2 /*return*/, (_a.state = _b.sent(),
-                                _a)];
-                    }
-                });
-            }); }, function (state, elem, index, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                var _a;
-                return tslib_1.__generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            if (!pred(elem, index, halt)) return [3 /*break*/, 2];
-                            _a = state;
-                            return [4 /*yield*/, this.next(state.state, elem, state.nextIndex++, halt)];
-                        case 1:
-                            _a.state = _b.sent();
-                            _b.label = 2;
-                        case 2: return [2 /*return*/, state];
-                    }
-                });
-            }); }, function (state) { return _this.stateToResult(state.state); }, function (state, error) { var _a; return (_a = _this.onClose) === null || _a === void 0 ? void 0 : _a.call(_this, state.state, error); });
-        };
-        Base.prototype.mapInput = function (mapFun) {
-            var _this = this;
-            return create(this.init, function (state, elem, index, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () { var _a, _b; return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = this.next;
-                        _b = [state];
-                        return [4 /*yield*/, mapFun(elem, index)];
-                    case 1: return [2 /*return*/, _a.apply(this, _b.concat([_c.sent(), index, halt]))];
-                }
-            }); }); }, this.stateToResult, this.onClose);
-        };
-        Base.prototype.collectInput = function (collectFun) {
-            var _this = this;
-            return create(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                var _a;
-                return tslib_1.__generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _a = {
-                                nextIndex: 0
-                            };
-                            return [4 /*yield*/, internal_1.AsyncOptLazy.toMaybePromise(this.init)];
-                        case 1: return [2 /*return*/, (_a.state = _b.sent(),
-                                _a)];
-                    }
-                });
-            }); }, function (state, elem, index, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                var nextElem, _a;
-                return tslib_1.__generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0: return [4 /*yield*/, collectFun(elem, index, internal_1.CollectFun.Skip, halt)];
-                        case 1:
-                            nextElem = _b.sent();
-                            if (!(internal_1.CollectFun.Skip !== nextElem)) return [3 /*break*/, 3];
-                            _a = state;
-                            return [4 /*yield*/, this.next(state.state, nextElem, state.nextIndex++, halt)];
-                        case 2:
-                            _a.state = _b.sent();
-                            _b.label = 3;
-                        case 3: return [2 /*return*/, state];
-                    }
-                });
-            }); }, function (state) { return _this.stateToResult(state.state); }, function (state, error) { var _a; return (_a = _this.onClose) === null || _a === void 0 ? void 0 : _a.call(_this, state.state, error); });
-        };
-        Base.prototype.mapOutput = function (mapFun) {
-            var _this = this;
-            return create(this.init, this.next, function (state) { return tslib_1.__awaiter(_this, void 0, void 0, function () { var _a; return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = mapFun;
-                        return [4 /*yield*/, this.stateToResult(state)];
-                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
-                }
-            }); }); }, this.onClose);
-        };
-        Base.prototype.takeInput = function (amount) {
-            if (amount <= 0) {
-                return create(this.init, identity, this.stateToResult);
-            }
-            return this.filterInput(function (_, i, halt) {
-                var more = i < amount;
-                if (!more)
-                    halt();
-                return more;
-            });
-        };
-        Base.prototype.dropInput = function (amount) {
-            if (amount <= 0)
-                return this;
-            return this.filterInput(function (_, i) { return i >= amount; });
-        };
-        Base.prototype.sliceInput = function (from, amount) {
-            if (from === void 0) { from = 0; }
-            if (undefined === amount)
-                return this.dropInput(from);
-            if (amount <= 0)
-                return create(this.init, identity, this.stateToResult);
-            if (from <= 0)
-                return this.takeInput(amount);
-            return this.takeInput(amount).dropInput(from);
-        };
-        return Base;
-    }());
-    AsyncReducer.Base = Base;
-    /**
-     * Returns an `AsyncReducer` with the given options:
-     * @param init - the optionally lazy and/or promised initial state value
-     * @param next - returns (potentially asynchronously) the next state value based on the given inputs:<br/>
-     * - current: the current state<br/>
-     * - next: the current input value<br/>
-     * - index: the input index value<br/>
-     * - halt: function that, when called, ensures no more elements are passed to the reducer
-     * @param stateToResult - a potentially asynchronous function that converts the current state to an output value
-     * @param onClose - (optional) a function that will be called when the reducer will no longer receive values
-     * @typeparam I - the input value type
-     * @typeparam O - the output value type
-     * @typeparam S - the internal state type
-     */
-    function create(init, next, stateToResult, onClose) {
-        return new AsyncReducer.Base(init, next, stateToResult, onClose);
-    }
-    AsyncReducer.create = create;
-    /**
-     * Returns an `AsyncReducer` of which the input, state, and output types are the same.
-     * @param init - the optionally lazy and/or promised initial state value
-     * @param next - returns (potentially asynchronously) the next state value based on the given inputs:<br/>
-     * - current: the current state<br/>
-     * - next: the current input value<br/>
-     * - index: the input index value<br/>
-     * - halt: function that, when called, ensures no more elements are passed to the reducer
-     * @param stateToResult - a potentially asynchronous function that converts the current state to an output value
-     * @param onClose - (optional) a function that will be called when the reducer will no longer receive values
-     * @typeparam I - the input value type
-     * @typeparam O - the output value type
-     * @typeparam S - the internal state type
-     */
-    function createMono(init, next, stateToResult, onClose) {
-        return create(init, next, stateToResult !== null && stateToResult !== void 0 ? stateToResult : identity, onClose);
-    }
-    AsyncReducer.createMono = createMono;
-    /**
-     * Returns an `AsyncReducer` of which the state and output types are the same.
-     * @param init - the optionally lazy and/or promised initial state value
-     * @param next - returns (potentially asynchronously) the next state value based on the given inputs:<br/>
-     * - current: the current state<br/>
-     * - next: the current input value<br/>
-     * - index: the input index value<br/>
-     * - halt: function that, when called, ensures no more elements are passed to the reducer
-     * @param stateToResult - a potentially asynchronous function that converts the current state to an output value
-     * @param onClose - (optional) a function that will be called when the reducer will no longer receive values
-     * @typeparam I - the input value type
-     * @typeparam O - the output value type
-     * @typeparam S - the internal state type
-     */
-    function createOutput(init, next, stateToResult, onClose) {
-        return create(init, next, stateToResult !== null && stateToResult !== void 0 ? stateToResult : identity, onClose);
-    }
-    AsyncReducer.createOutput = createOutput;
-    function from(reducer) {
-        return AsyncReducer.create(reducer.init, reducer.next, reducer.stateToResult);
-    }
-    AsyncReducer.from = from;
-    /**
-     * A `Reducer` that sums all given numeric input values.
-     * @example
-     * ```ts
-     * console.log(Stream.range({ amount: 5 }).reduce(Reducer.sum))
-     * // => 10
-     * ```
-     */
-    AsyncReducer.sum = createMono(0, function (state, next) { return state + next; });
-    /**
-     * A `Reducer` that calculates the product of all given numeric input values.
-     * @example
-     * ```ts
-     * console.log(Stream.range({ start: 1, amount: 5 }).reduce(product))
-     * // => 120
-     * ```
-     */
-    AsyncReducer.product = createMono(1, function (state, next, _, halt) {
-        if (0 === next)
-            halt();
-        return state * next;
-    });
-    /**
-     * A `Reducer` that calculates the average of all given numberic input values.
-     * @example
-     * ```ts
-     * console.log(Stream.range({ amount: 5 }).reduce(Reducer.average));
-     * // => 2
-     * ```
-     */
-    AsyncReducer.average = createMono(0, function (avg, value, index) { return avg + (value - avg) / (index + 1); });
-    /**
-     * Returns a `Reducer` that remembers the minimum value of the inputs using the given `compFun` to compare input values
-     * @param compFun - a comparison function for two input values, returning 0 when equal, positive when greater, negetive when smaller
-     * @param otherwise - (default: undefineds) a fallback value when there were no input values given
-     * @example
-     * ```ts
-     * const stream = Stream.of('abc', 'a', 'abcde', 'ab')
-     * console.log(stream.minBy((s1, s2) => s1.length - s2.length))
-     * // 'a'
-     * ```
-     */
-    AsyncReducer.minBy = function (compFun, otherwise) {
-        var token = Symbol();
-        return create(token, function (state, next) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (token === state)
-                            return [2 /*return*/, next];
-                        return [4 /*yield*/, compFun(state, next)];
-                    case 1: return [2 /*return*/, (_a.sent()) < 0 ? state : next];
-                }
-            });
-        }); }, function (state) {
-            return token === state ? internal_1.AsyncOptLazy.toMaybePromise(otherwise) : state;
-        });
-    };
-    /**
-     * Returns a `Reducer` that remembers the minimum value of the numberic inputs.
-     * @param otherwise - (default: undefined) a fallback value when there were no input values given
-     * @example
-     * ```ts
-     * console.log(Stream.of(5, 3, 7, 4).reduce(Reducer.min()))
-     * // => 3
-     * ```
-     */
-    AsyncReducer.min = function (otherwise) {
-        return create(undefined, function (state, next) {
-            return undefined !== state && state < next ? state : next;
-        }, function (state) {
-            return state !== null && state !== void 0 ? state : internal_1.AsyncOptLazy.toMaybePromise(otherwise);
-        });
-    };
-    /**
-     * Returns a `Reducer` that remembers the maximum value of the inputs using the given `compFun` to compare input values
-     * @param compFun - a comparison function for two input values, returning 0 when equal, positive when greater, negetive when smaller
-     * @param otherwise - (default: undefined) a fallback value when there were no input values given
-     * @example
-     * ```ts
-     * const stream = Stream.of('abc', 'a', 'abcde', 'ab')
-     * console.log(stream.maxBy((s1, s2) => s1.length - s2.length))
-     * // 'abcde'
-     * ```
-     */
-    AsyncReducer.maxBy = function (compFun, otherwise) {
-        var token = Symbol();
-        return create(token, function (state, next) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (token === state)
-                            return [2 /*return*/, next];
-                        return [4 /*yield*/, compFun(state, next)];
-                    case 1: return [2 /*return*/, (_a.sent()) > 0 ? state : next];
-                }
-            });
-        }); }, function (state) {
-            return token === state ? internal_1.AsyncOptLazy.toMaybePromise(otherwise) : state;
-        });
-    };
-    /**
-     * Returns a `Reducer` that remembers the maximum value of the numberic inputs.
-     * @param otherwise - (default: undefined) a fallback value when there were no input values given
-     * @example
-     * ```ts
-     * console.log(Stream.of(5, 3, 7, 4).reduce(Reducer.max()))
-     * // => 7
-     * ```
-     */
-    AsyncReducer.max = function (otherwise) {
-        return create(undefined, function (state, next) {
-            return undefined !== state && state > next ? state : next;
-        }, function (state) {
-            return state !== null && state !== void 0 ? state : internal_1.AsyncOptLazy.toMaybePromise(otherwise);
-        });
-    };
-    /**
-     * Returns a `Reducer` that joins the given input values into a string using the given options.
-     * @param options - an object containing:<br/>
-     * - sep: (optional) a seperator string value between values in the output<br/>
-     * - start: (optional) a start string to prepend to the output<br/>
-     * - end: (optional) an end string to append to the output<br/>
-     * @example
-     * ```ts
-     * console.log(Stream.of(1, 2, 3).reduce(Reducer.join({ sep: '-' })))
-     * // => '1-2-3'
-     * ```
-     */
-    function join(_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.sep, sep = _c === void 0 ? '' : _c, _d = _b.start, start = _d === void 0 ? '' : _d, _e = _b.end, end = _e === void 0 ? '' : _e, _f = _b.valueToString, valueToString = _f === void 0 ? String : _f;
-        var curSep = '';
-        var curStart = start;
-        return create('', function (state, next) {
-            var result = curStart.concat(state, curSep, valueToString(next));
-            curSep = sep;
-            curStart = '';
-            return result;
-        }, function (state) { return state.concat(end); });
-    }
-    AsyncReducer.join = join;
-    /**
-     * Returns an `AsyncReducer` that remembers the amount of input items provided.
-     * @param pred - (optional) a predicate that returns false if the item should not be counted given:<br/>
-     * - value: the current input value<br/>
-     * - index: the input value index
-     * @example
-     * ```ts
-     * const stream = AsyncStream.from(Stream.range({ amount: 10 }))
-     * console.log(await stream.reduce(AsyncReducer.count()))
-     * // => 10
-     * console.log(await stream.reduce(AsyncReducer.count(async v => v < 5)))
-     * // => 5
-     * ```
-     */
-    AsyncReducer.count = function (pred) {
-        if (undefined === pred)
-            return createOutput(0, function (_, __, i) { return i + 1; });
-        return createOutput(0, function (state, next, i) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, (pred === null || pred === void 0 ? void 0 : pred(next, i))];
-                    case 1:
-                        if (_a.sent())
-                            return [2 /*return*/, state + 1];
-                        return [2 /*return*/, state];
-                }
-            });
-        }); });
-    };
-    /**
-     * Returns an `AsyncReducer` that remembers the first input value for which the given `pred` function returns true.
-     * @param pred - a function taking an input value and its index, and returning true if the value should be remembered
-     * @param otherwise - (default: undefined) a fallback value to output if no input value yet has satisfied the given predicate
-     * @typeparam T - the input value type
-     * @typeparam O - the fallback value type
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range({ amount: 10 })).reduce(AsyncReducer.firstWhere(async v => v > 5)))
-     * // => 6
-     * ```
-     */
-    AsyncReducer.firstWhere = function (pred, otherwise) {
-        var token = Symbol();
-        return create(token, function (state, next, i, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = token === state;
-                        if (!_a) return [3 /*break*/, 2];
-                        return [4 /*yield*/, pred(next, i)];
-                    case 1:
-                        _a = (_b.sent());
-                        _b.label = 2;
-                    case 2:
-                        if (_a) {
-                            halt();
-                            return [2 /*return*/, next];
-                        }
-                        return [2 /*return*/, state];
-                }
-            });
-        }); }, function (state) {
-            return token === state ? internal_1.AsyncOptLazy.toMaybePromise(otherwise) : state;
-        });
-    };
-    /**
-     * Returns an `AsyncReducer` that remembers the first input value.
-     * @param otherwise - (default: undefined) a fallback value to output if no input value has been provided
-     * @typeparam T - the input value type
-     * @typeparam O - the fallback value type
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range{ amount: 10 })).reduce(AsyncReducer.first())
-     * // => 0
-     * ```
-     */
-    AsyncReducer.first = function (otherwise) {
-        var token = Symbol();
-        return create(token, function (state, next, _, halt) {
-            halt();
-            if (token === state)
-                return next;
-            return state;
-        }, function (state) {
-            return token === state ? internal_1.AsyncOptLazy.toMaybePromise(otherwise) : state;
-        });
-    };
-    /**
-     * Returns an `AsyncReducer` that remembers the last input value for which the given `pred` function returns true.
-     * @param pred - a function taking an input value and its index, and returning true if the value should be remembered
-     * @param otherwise - (default: undefined) a fallback value to output if no input value yet has satisfied the given predicate
-     * @typeparam T - the input value type
-     * @typeparam O - the fallback value type
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range({ amount: 10 })).reduce(AsyncReducer.lastWhere(async v => v > 5)))
-     * // => 9
-     * ```
-     */
-    AsyncReducer.lastWhere = function (pred, otherwise) {
-        var token = Symbol();
-        return create(token, function (state, next, i) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, pred(next, i)];
-                    case 1:
-                        if (_a.sent())
-                            return [2 /*return*/, next];
-                        return [2 /*return*/, state];
-                }
-            });
-        }); }, function (state) {
-            return token === state ? internal_1.AsyncOptLazy.toMaybePromise(otherwise) : state;
-        });
-    };
-    /**
-     * Returns an `AsyncReducer` that remembers the last input value.
-     * @param otherwise - (default: undefined) a fallback value to output if no input value has been provided
-     * @typeparam T - the input value type
-     * @typeparam O - the fallback value type
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range{ amount: 10 })).reduce(AsyncReducer.last())
-     * // => 9
-     * ```
-     */
-    AsyncReducer.last = function (otherwise) {
-        var token = Symbol();
-        return create(function () { return token; }, function (_, next) { return next; }, function (state) {
-            return token === state ? internal_1.AsyncOptLazy.toMaybePromise(otherwise) : state;
-        });
-    };
-    /**
-     * Returns a `Reducer` that ouputs false as long as no input value satisfies given `pred`, true otherwise.
-     * @typeparam T - the element type
-     * @param pred - a function taking an input value and its index, and returning true if the value satisfies the predicate
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range{ amount: 10 })).reduce(AsyncReducer.some(async v => v > 5))
-     * // => true
-     * ```
-     */
-    function some(pred) {
-        var _this = this;
-        return createOutput(false, function (state, next, i, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var satisfies;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (state)
-                            return [2 /*return*/, state];
-                        return [4 /*yield*/, pred(next, i)];
-                    case 1:
-                        satisfies = _a.sent();
-                        if (satisfies) {
-                            halt();
-                        }
-                        return [2 /*return*/, satisfies];
-                }
-            });
-        }); });
-    }
-    AsyncReducer.some = some;
-    /**
-     * Returns an `AsyncReducer` that ouputs true as long as all input values satisfy the given `pred`, false otherwise.
-     * @typeparam T - the element type
-     * @param pred - a function taking an input value and its index, and returning true if the value satisfies the predicate
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range{ amount: 10 })).reduce(AsyncReducer.every(async v => v < 5))
-     * // => false
-     * ```
-     */
-    function every(pred) {
-        var _this = this;
-        return createOutput(true, function (state, next, i, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var satisfies;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!state)
-                            return [2 /*return*/, state];
-                        return [4 /*yield*/, pred(next, i)];
-                    case 1:
-                        satisfies = _a.sent();
-                        if (!satisfies) {
-                            halt();
-                        }
-                        return [2 /*return*/, satisfies];
-                }
-            });
-        }); });
-    }
-    AsyncReducer.every = every;
-    /**
-     * Returns an `AsyncReducer` that outputs false as long as the given `elem` has not been encountered in the input values, true otherwise.
-     * @typeparam T - the element type
-     * @param elem - the element to search for
-     * @param eq - (optional) a comparison function that returns true if te two given input values are considered equal
-     * @example
-     * ```ts
-     * await AsyncStream.from(Stream.range({ amount: 10 })).reduce(AsyncReducer.contains(5)))
-     * // => true
-     * ```
-     */
-    function contains(elem, eq) {
-        if (eq === void 0) { eq = Object.is; }
-        return createOutput(false, function (state, next, _, halt) {
-            if (state)
-                return state;
-            var satisfies = eq(next, elem);
-            if (satisfies) {
-                halt();
-            }
-            return satisfies;
-        });
-    }
-    AsyncReducer.contains = contains;
-    /**
-     * Returns an `AsyncReducer` that takes boolean values and outputs true if all input values are true, and false otherwise.
-     * @example
-     * ```ts
-     * await AsyncStream.of(true, false, true)).reduce(AsyncReducer.and))
-     * // => false
-     * ```
-     */
-    AsyncReducer.and = createMono(true, function (state, next, _, halt) {
-        if (!state)
-            return state;
-        if (!next)
-            halt();
-        return next;
-    });
-    /**
-     * Returns an `AsyncReducer` that takes boolean values and outputs true if one or more input values are true, and false otherwise.
-     * @example
-     * ```ts
-     * await AsyncStream.of(true, false, true)).reduce(AsyncReducer.or))
-     * // => true
-     * ```
-     */
-    AsyncReducer.or = createMono(false, function (state, next, _, halt) {
-        if (state)
-            return state;
-        if (next)
-            halt();
-        return next;
-    });
-    /**
-     * Returns an `AsyncReducer` that outputs true if no input values are received, false otherwise.
-     * @example
-     * ```ts
-     * await AsyncStream.of(1, 2, 3).reduce(AsyncReducer.isEmpty))
-     * // => false
-     * ```
-     */
-    AsyncReducer.isEmpty = createOutput(true, function (_, __, ___, halt) {
-        halt();
-        return false;
-    });
-    /**
-     * Returns an `AsyncReducer` that outputs true if one or more input values are received, false otherwise.
-     * @example
-     * ```ts
-     * await AsyncStream.of(1, 2, 3).reduce(AsyncReducer.nonEmpty))
-     * // => true
-     * ```
-     */
-    AsyncReducer.nonEmpty = createOutput(false, function (_, __, ___, halt) {
-        halt();
-        return true;
-    });
-    /**
-     * Returns an `AsyncReducer` that collects received input values in an array, and returns a copy of that array as an output value when requested.
-     * @typeparam T - the element type
-     * @example
-     * ```ts
-     * await AsyncStream.of(1, 2, 3).reduce(AsyncReducer.toArray()))
-     * // => [1, 2, 3]
-     * ```
-     */
-    function toArray() {
-        return create(function () { return []; }, function (state, next) {
-            state.push(next);
-            return state;
-        }, function (state) { return state.slice(); });
-    }
-    AsyncReducer.toArray = toArray;
-    /**
-     * Returns a `AsyncReducer` that collects received input tuples into a mutable JS Map, and returns
-     * a copy of that map when output is requested.
-     * @typeparam K - the map key type
-     * @typeparam V - the map value type
-     * @example
-     * ```ts
-     * await AsyncStream.of([1, 'a'], [2, 'b']).reduce(AsyncReducer.toJSMap()))
-     * // Map { 1 => 'a', 2 => 'b' }
-     * ```
-     */
-    function toJSMap() {
-        return create(function () { return new Map(); }, function (state, next) {
-            state.set(next[0], next[1]);
-            return state;
-        }, function (s) { return new Map(s); });
-    }
-    AsyncReducer.toJSMap = toJSMap;
-    /**
-     * Returns an `AsyncReducer` that collects received input values into a mutable JS Set, and returns
-     * a copy of that map when output is requested.
-     * @typeparam T - the element type
-     * @example
-     * ```ts
-     * await AsyncStream.of(1, 2, 3).reduce(AsyncReducer.toJSSet()))
-     * // Set {1, 2, 3}
-     * ```
-     */
-    function toJSSet() {
-        return create(function () { return new Set(); }, function (state, next) {
-            state.add(next);
-            return state;
-        }, function (s) { return new Set(s); });
-    }
-    AsyncReducer.toJSSet = toJSSet;
-    /**
-     * Returns an `AsyncReducer` that collects 2-tuples containing keys and values into a plain JS object, and
-     * returns a copy of that object when output is requested.
-     * @typeparam K - the result object key type
-     * @typeparam V - the result object value type
-     * @example
-     * ```ts
-     * await AsyncStream.of(['a', 1], ['b', true]).reduce(AsyncReducer.toJSObject()))
-     * // { a: 1, b: true }
-     * ```
-     */
-    function toJSObject() {
-        return create(function () { return ({}); }, function (state, entry) {
-            state[entry[0]] = entry[1];
-            return state;
-        }, function (s) { return (tslib_1.__assign({}, s)); });
-    }
-    AsyncReducer.toJSObject = toJSObject;
-    /**
-     * Returns an `AsyncReducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in an array.
-     * @param reducers - 2 or more reducers to combine
-     * @example
-     * ```ts
-     * const red = AsyncReducer.combineArr(AsyncReducer.sum, AsyncReducer.average)
-     *
-     * await AsyncStream.from(Stream.range({ amount: 9 }))
-     *  .reduce(red)
-     * // => [36, 4]
-     * ```
-     */
-    function combineArr() {
-        var _this = this;
-        var reducers = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            reducers[_i] = arguments[_i];
-        }
-        var createState = function () {
-            return Promise.all(reducers.map(function (reducer) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                var result;
-                var _a;
-                return tslib_1.__generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _a = {
-                                reducer: reducer,
-                                halted: false,
-                                halt: function () {
-                                    result.halted = true;
-                                }
-                            };
-                            return [4 /*yield*/, internal_1.AsyncOptLazy.toMaybePromise(reducer.init)];
-                        case 1:
-                            result = (_a.state = _b.sent(),
-                                _a);
-                            return [2 /*return*/, result];
-                    }
-                });
-            }); }));
-        };
-        return create(createState, function (allState, next, index, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var anyNotHalted;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        anyNotHalted = false;
-                        return [4 /*yield*/, Promise.all(allState.map(function (red) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var _a;
-                                return tslib_1.__generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            if (red.halted)
-                                                return [2 /*return*/];
-                                            _a = red;
-                                            return [4 /*yield*/, red.reducer.next(red.state, next, index, red.halt)];
-                                        case 1:
-                                            _a.state = _b.sent();
-                                            if (!red.halted)
-                                                anyNotHalted = true;
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        _a.sent();
-                        if (!anyNotHalted)
-                            halt();
-                        return [2 /*return*/, allState];
-                }
-            });
-        }); }, function (allState) {
-            return Promise.all(allState.map(function (st) { return st.reducer.stateToResult(st.state); }));
-        });
-    }
-    AsyncReducer.combineArr = combineArr;
-    /**
-     * Returns an `AsyncReducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in the shape of the given object.
-     * @typeparam T - the input type for all the reducers
-     * @typeparam R - the result object shape
-     * @param reducerObj - an object of keys, and reducers corresponding to those keys
-     * @example
-     * ```ts
-     * const red = AsyncReducer.combineObj({
-     *   theSum: Reducer.sum,
-     *   theAverage: Reducer.average
-     * });
-     *
-     * await AsyncStream.from(Stream.range({ amount: 9 }))
-     *   .reduce(red));
-     * // => { theSum: 36, theAverage: 4 }
-     * ```
-     */
-    function combineObj(reducerObj) {
-        var _this = this;
-        var createState = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var entries;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all(Object.entries(reducerObj).map(function (_a) {
-                            var _b = tslib_1.__read(_a, 2), key = _b[0], reducer = _b[1];
-                            return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var result;
-                                var _c;
-                                return tslib_1.__generator(this, function (_d) {
-                                    switch (_d.label) {
-                                        case 0:
-                                            _c = {
-                                                reducer: reducer,
-                                                halted: false,
-                                                halt: function () {
-                                                    result.halted = true;
-                                                }
-                                            };
-                                            return [4 /*yield*/, internal_1.AsyncOptLazy.toMaybePromise(reducer.init)];
-                                        case 1:
-                                            result = (_c.state = _d.sent(),
-                                                _c);
-                                            return [2 /*return*/, [key, result]];
-                                    }
-                                });
-                            });
-                        }))];
-                    case 1:
-                        entries = _a.sent();
-                        return [2 /*return*/, Object.fromEntries(entries)];
-                }
-            });
-        }); };
-        return create(createState, function (allState, next, index, halt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var anyNotHalted;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        anyNotHalted = false;
-                        return [4 /*yield*/, Promise.all(Object.values(allState).map(function (red) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var _a;
-                                return tslib_1.__generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            if (red.halted) {
-                                                return [2 /*return*/];
-                                            }
-                                            _a = red;
-                                            return [4 /*yield*/, red.reducer.next(red.state, next, index, red.halt)];
-                                        case 1:
-                                            _a.state = _b.sent();
-                                            if (!red.halted) {
-                                                anyNotHalted = true;
-                                            }
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        _a.sent();
-                        if (!anyNotHalted) {
-                            halt();
-                        }
-                        return [2 /*return*/, allState];
-                }
-            });
-        }); }, function (allState) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var entries;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all(Object.entries(allState).map(function (_a) {
-                            var _b = tslib_1.__read(_a, 2), key = _b[0], st = _b[1];
-                            return tslib_1.__awaiter(_this, void 0, void 0, function () { var _c; return tslib_1.__generator(this, function (_d) {
-                                switch (_d.label) {
-                                    case 0:
-                                        _c = [key];
-                                        return [4 /*yield*/, st.reducer.stateToResult(st.state)];
-                                    case 1: return [2 /*return*/, _c.concat([_d.sent()])];
-                                }
-                            }); });
-                        }))];
-                    case 1:
-                        entries = _a.sent();
-                        return [2 /*return*/, Object.fromEntries(entries)];
-                }
-            });
-        }); });
-    }
-    AsyncReducer.combineObj = combineObj;
-})(AsyncReducer = exports.AsyncReducer || (exports.AsyncReducer = {}));
-//# sourceMappingURL=async-reducer.js.map