@shutterstock/p-map-iterable 0.0.1

package/dist/iterable-mapper.test.js

@@ -0,0 +1,1421 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference types="jest" />
+const iterable_mapper_1 = require("./iterable-mapper");
+const util_1 = require("util");
+const sleep = (0, util_1.promisify)(setTimeout);
+function mapper({ value, ms }) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield sleep(ms);
+        return value;
+    });
+}
+class SleepIterator {
+    constructor(max) {
+        this._current = 1;
+        this._max = max;
+    }
+    [Symbol.asyncIterator]() {
+        return tslib_1.__asyncGenerator(this, arguments, function* _a() {
+            for (let i = 0; i < this._max; i++) {
+                yield tslib_1.__await(sleep(1 * (i % 10)));
+                if (this._current <= this._max) {
+                    yield yield tslib_1.__await(this._current);
+                }
+                this._current++;
+            }
+        });
+    }
+}
+class ThrowingIterator {
+    constructor(max, throwOnIndex, delayMS) {
+        this._max = max;
+        this._throwOnIndex = throwOnIndex;
+        this._delayMS = delayMS;
+    }
+    [Symbol.asyncIterator]() {
+        let index = 0;
+        const max = this._max;
+        const delayMS = this._delayMS;
+        const throwOnIndex = this._throwOnIndex;
+        return {
+            next() {
+                return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield sleep(delayMS);
+                    if (index === throwOnIndex) {
+                        throw new Error(`throwing on index ${index}`);
+                    }
+                    const item = { value: index, done: index === max };
+                    index++;
+                    return item;
+                });
+            },
+        };
+    }
+}
+describe('IterableMapper', () => {
+    const sourceNextSpy = jest.spyOn(iterable_mapper_1.IterableMapper.prototype, 'sourceNext');
+    const startAnotherRunnerSpy = jest.spyOn(iterable_mapper_1.IterableMapper.prototype, 'startAnotherRunner');
+    beforeAll(() => {
+        // nothing
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('simple tests', () => {
+        it('simple mapper works - sync mapper', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const max = 100;
+            const iterator = new SleepIterator(max);
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper(iterator, (value) => {
+                callCount++;
+                total += value;
+                return total;
+            });
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _d = true, prefetcher_1 = tslib_1.__asyncValues(prefetcher), prefetcher_1_1; prefetcher_1_1 = yield prefetcher_1.next(), _a = prefetcher_1_1.done, !_a;) {
+                    _c = prefetcher_1_1.value;
+                    _d = false;
+                    try {
+                        const item = _c;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = prefetcher_1.return)) yield _b.call(prefetcher_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            expect(callCount).toBe(max);
+            expect(loopCount).toBe(max);
+            expect(total).toBe((max * (max + 1)) / 2);
+            expect(lastTotal).toBe((max * (max + 1)) / 2);
+        }));
+        it('simple mapper works - async mapper', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _e, e_2, _f, _g;
+            const max = 100;
+            const iterator = new SleepIterator(max);
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper(iterator, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                callCount++;
+                total += value;
+                yield sleep(10 * (callCount % 6));
+                return total;
+            }));
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _h = true, prefetcher_2 = tslib_1.__asyncValues(prefetcher), prefetcher_2_1; prefetcher_2_1 = yield prefetcher_2.next(), _e = prefetcher_2_1.done, !_e;) {
+                    _g = prefetcher_2_1.value;
+                    _h = false;
+                    try {
+                        const item = _g;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _h = true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_h && !_e && (_f = prefetcher_2.return)) yield _f.call(prefetcher_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            expect(callCount).toBe(max);
+            expect(loopCount).toBe(max);
+            expect(total).toBe((max * (max + 1)) / 2);
+            expect(lastTotal).toBe((max * (max + 1)) / 2);
+        }));
+        it('async mapper works - parallel next() calls', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _j, e_3, _k, _l;
+            const max = 100;
+            const inputIterator = new SleepIterator(max);
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper(inputIterator, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                callCount++;
+                total += value;
+                yield sleep(10 * (callCount % 6));
+                return total;
+            }));
+            let lastTotal = 0;
+            let loopCount = 0;
+            const nextPromises = [];
+            const iterator = prefetcher[Symbol.asyncIterator]();
+            for (let i = 0; i < max + 1; i++) {
+                nextPromises.push(iterator.next());
+            }
+            // Wait for all the readers to resolve
+            yield Promise.all(nextPromises);
+            try {
+                for (var _m = true, nextPromises_1 = tslib_1.__asyncValues(nextPromises), nextPromises_1_1; nextPromises_1_1 = yield nextPromises_1.next(), _j = nextPromises_1_1.done, !_j;) {
+                    _l = nextPromises_1_1.value;
+                    _m = false;
+                    try {
+                        const item = _l;
+                        if (item.done === true) {
+                            break;
+                        }
+                        loopCount++;
+                        if (item.value > lastTotal) {
+                            lastTotal = item.value;
+                        }
+                    }
+                    finally {
+                        _m = true;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_m && !_j && (_k = nextPromises_1.return)) yield _k.call(nextPromises_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            expect(callCount).toBe(max);
+            expect(loopCount).toBe(max);
+            expect(total).toBe((max * (max + 1)) / 2);
+            expect(lastTotal).toBe((max * (max + 1)) / 2);
+        }));
+        it('right number run in parallel - simple', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _o, e_4, _p, _q;
+            const startTime = Date.now();
+            const max = 8;
+            const delayBetweenMs = 200;
+            const input = [
+                { value: 1, ms: delayBetweenMs },
+                { value: 2, ms: delayBetweenMs },
+                { value: 3, ms: delayBetweenMs },
+                { value: 4, ms: delayBetweenMs },
+                { value: 5, ms: delayBetweenMs },
+                { value: 6, ms: delayBetweenMs },
+                { value: 7, ms: delayBetweenMs },
+                { value: 8, ms: delayBetweenMs },
+            ];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, mapper, { concurrency: 2, maxUnread: 4 });
+            let lastSeen = 0;
+            let loopCount = 0;
+            try {
+                for (var _r = true, prefetcher_3 = tslib_1.__asyncValues(prefetcher), prefetcher_3_1; prefetcher_3_1 = yield prefetcher_3.next(), _o = prefetcher_3_1.done, !_o;) {
+                    _q = prefetcher_3_1.value;
+                    _r = false;
+                    try {
+                        const item = _q;
+                        loopCount++;
+                        if (item > lastSeen) {
+                            lastSeen = item;
+                        }
+                    }
+                    finally {
+                        _r = true;
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (!_r && !_o && (_p = prefetcher_3.return)) yield _p.call(prefetcher_3);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            expect(loopCount).toBe(max);
+            expect(lastSeen).toBe(max);
+            // Should require at least 2 batches
+            expect(Date.now() - startTime).toBeLessThan(5 * delayBetweenMs);
+            expect(Date.now() - startTime).toBeGreaterThan(4 * delayBetweenMs);
+            // The runners should never stop because the items are consumed immediately
+            expect(startAnotherRunnerSpy).toHaveBeenCalledTimes(0);
+        }));
+        // T0    - Mapping - Start 1, 2, waiting 200 ms
+        //         Q: []
+        //         Runners - 2 running
+        // T200  - Mapping - Finished 1, 2
+        //         Q: [1, 2]
+        //         Iterate - Start 1, waiting 300 ms
+        //         Q: [2]
+        //         Mapping - Start 3, 4, waiting 200 ms
+        // T400  - Mapping - Finished 3, 4
+        //         Q: [2, 3, 4]
+        //         Runners - 1 exits, 1 running
+        //         Mapping - Start 5, waiting 200 ms
+        // T500  - Iterate - Start 2, waiting 300 ms
+        //         Q: [3, 4]
+        //         Runners - ***1 starts, 2 running after
+        //         Mapping - Start 6, waiting 200 ms
+        // T600  - Mapping - Finished 5
+        //         Q: [3, 4, 5]
+        //         Runners - 1 exits, 1 running after
+        // T700  - Mapping - Finished 6
+        //         Q: [3, 4, 5, 6]
+        //         Runners - 1 exits, 0 running after
+        // T800  - Iterate - Finished 2
+        //         Iterate - Start 3, waiting 300 ms
+        //         Q: [4, 5, 6]
+        //         Runners - ***1 starts, 1 running after
+        //         Mapping - Start 7, waiting 200 ms
+        // T1000 - Mapping - Finished 7
+        //         Q: [4, 5, 6, 7]
+        //         Runners - 1 exits, 0 running after
+        // T1100 - Iterate - Finished 3
+        //         Iterate - Start 4, waiting 300 ms
+        //         Q: [5, 6, 7]
+        //         Runners - ***1 starts, 1 running after
+        // T1101 - Mapping - Iteration Done
+        //         Runners - 1 exits, 0 running after
+        //         Q: [5, 6, 7]
+        // T1400 - Iterate - Finished 4
+        //         Iterate - Start 5, waiting 300 ms
+        //         Q: [6, 7]
+        // T1700 - Iterate - Finished 5
+        //         Iterate - Start 6, waiting 300 ms
+        //         Q: [7]
+        // T2000 - Iterate - Finished 6
+        //         Iterate - Start 7, waiting 300 ms
+        //         Q: []
+        // T2300 - Iterate - Finished 7
+        //         Q: []
+        it('right number run in parallel - delay in reading', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _s, e_5, _t, _u;
+            const startTime = Date.now();
+            const max = 7;
+            const mapDelayMs = 200;
+            const readDelayMs = 300;
+            const input = [
+                { value: 1, ms: mapDelayMs },
+                { value: 2, ms: mapDelayMs },
+                { value: 3, ms: mapDelayMs },
+                { value: 4, ms: mapDelayMs },
+                { value: 5, ms: mapDelayMs },
+                { value: 6, ms: mapDelayMs },
+                { value: 7, ms: mapDelayMs },
+            ];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, mapper, { concurrency: 2, maxUnread: 4 });
+            let lastSeen = 0;
+            let loopCount = 0;
+            try {
+                for (var _v = true, prefetcher_4 = tslib_1.__asyncValues(prefetcher), prefetcher_4_1; prefetcher_4_1 = yield prefetcher_4.next(), _s = prefetcher_4_1.done, !_s;) {
+                    _u = prefetcher_4_1.value;
+                    _v = false;
+                    try {
+                        const item = _u;
+                        loopCount++;
+                        if (item > lastSeen) {
+                            lastSeen = item;
+                        }
+                        yield sleep(readDelayMs);
+                    }
+                    finally {
+                        _v = true;
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (!_v && !_s && (_t = prefetcher_4.return)) yield _t.call(prefetcher_4);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            expect(loopCount).toBe(max);
+            expect(lastSeen).toBe(max);
+            // 1st we wait 1 mapDelayMs for the 1st item to be ready
+            // Then, as we iterate the mapped items, we wait readDelayMs for "processing"
+            // This means that all the subsequent mapper calls never delay us because the
+            // prefetch queue is always full.
+            // Because of the prime numbers (2, 3, and 7) we know that we didn't accidentally
+            // cause delays of a multiple of the wrong number.
+            expect(Date.now() - startTime).toBeGreaterThan(mapDelayMs + max * readDelayMs);
+            expect(sourceNextSpy).toHaveBeenCalledTimes(max + 1);
+            expect(startAnotherRunnerSpy).toHaveBeenCalledTimes(3);
+        }));
+    });
+    describe('empty iterables', () => {
+        it('empty sync iterable works - sync mapper', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_6, _b, _c;
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper([], (value) => {
+                callCount++;
+                total += value;
+                return total;
+            });
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _d = true, prefetcher_5 = tslib_1.__asyncValues(prefetcher), prefetcher_5_1; prefetcher_5_1 = yield prefetcher_5.next(), _a = prefetcher_5_1.done, !_a;) {
+                    _c = prefetcher_5_1.value;
+                    _d = false;
+                    try {
+                        const item = _c;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = prefetcher_5.return)) yield _b.call(prefetcher_5);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            expect(callCount).toBe(0);
+            expect(loopCount).toBe(0);
+            expect(total).toBe(0);
+            expect(lastTotal).toBe(0);
+        }));
+        it('empty sync iterable works - async mapper', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _e, e_7, _f, _g;
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper([], (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                yield sleep(10);
+                callCount++;
+                total += value;
+                return total;
+            }));
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _h = true, prefetcher_6 = tslib_1.__asyncValues(prefetcher), prefetcher_6_1; prefetcher_6_1 = yield prefetcher_6.next(), _e = prefetcher_6_1.done, !_e;) {
+                    _g = prefetcher_6_1.value;
+                    _h = false;
+                    try {
+                        const item = _g;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _h = true;
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (!_h && !_e && (_f = prefetcher_6.return)) yield _f.call(prefetcher_6);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            expect(callCount).toBe(0);
+            expect(loopCount).toBe(0);
+            expect(total).toBe(0);
+            expect(lastTotal).toBe(0);
+        }));
+        it('empty async iterable works - sync mapper', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _j, e_8, _k, _l;
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper((() => {
+                return {
+                    [Symbol.asyncIterator]() {
+                        return {
+                            next() {
+                                return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                                    yield sleep(100);
+                                    return { value: undefined, done: true };
+                                });
+                            },
+                        };
+                    },
+                };
+            })(), (value) => {
+                callCount++;
+                total += value;
+                return total;
+            });
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _m = true, prefetcher_7 = tslib_1.__asyncValues(prefetcher), prefetcher_7_1; prefetcher_7_1 = yield prefetcher_7.next(), _j = prefetcher_7_1.done, !_j;) {
+                    _l = prefetcher_7_1.value;
+                    _m = false;
+                    try {
+                        const item = _l;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _m = true;
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (!_m && !_j && (_k = prefetcher_7.return)) yield _k.call(prefetcher_7);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            expect(callCount).toBe(0);
+            expect(loopCount).toBe(0);
+            expect(total).toBe(0);
+            expect(lastTotal).toBe(0);
+        }));
+        it('empty async iterable works - async mapper', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _o, e_9, _p, _q;
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper((() => {
+                return {
+                    [Symbol.asyncIterator]() {
+                        return {
+                            next() {
+                                return tslib_1.__awaiter(this, void 0, void 0, function* () {
+                                    yield sleep(100);
+                                    return { value: undefined, done: true };
+                                });
+                            },
+                        };
+                    },
+                };
+            })(), (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                yield sleep(10);
+                callCount++;
+                total += value;
+                return total;
+            }));
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _r = true, prefetcher_8 = tslib_1.__asyncValues(prefetcher), prefetcher_8_1; prefetcher_8_1 = yield prefetcher_8.next(), _o = prefetcher_8_1.done, !_o;) {
+                    _q = prefetcher_8_1.value;
+                    _r = false;
+                    try {
+                        const item = _q;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _r = true;
+                    }
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (!_r && !_o && (_p = prefetcher_8.return)) yield _p.call(prefetcher_8);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            expect(callCount).toBe(0);
+            expect(loopCount).toBe(0);
+            expect(total).toBe(0);
+            expect(lastTotal).toBe(0);
+        }));
+    });
+    describe('concurrency 1, maxUnread 1', () => {
+        const concurrency = 1;
+        const maxUnread = 1;
+        it('catches exception from mapper - 1st item - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 1) {
+                    yield sleep(100);
+                    throw new Error('throw on 1st');
+                }
+                return value;
+            }), { concurrency, maxUnread });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _a, e_10, _b, _c;
+                try {
+                    for (var _d = true, prefetcher_9 = tslib_1.__asyncValues(prefetcher), prefetcher_9_1; prefetcher_9_1 = yield prefetcher_9.next(), _a = prefetcher_9_1.done, !_a;) {
+                        _c = prefetcher_9_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = prefetcher_9.return)) yield _b.call(prefetcher_9);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+            })).rejects.toThrowError('throw on 1st');
+            yield sleep(500);
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from mapper - 2nd item - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 2) {
+                    throw new Error('throw on 2nd');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _e, e_11, _f, _g;
+                try {
+                    for (var _h = true, prefetcher_10 = tslib_1.__asyncValues(prefetcher), prefetcher_10_1; prefetcher_10_1 = yield prefetcher_10.next(), _e = prefetcher_10_1.done, !_e;) {
+                        _g = prefetcher_10_1.value;
+                        _h = false;
+                        try {
+                            const value = _g;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _h = true;
+                        }
+                    }
+                }
+                catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_e && (_f = prefetcher_10.return)) yield _f.call(prefetcher_10);
+                    }
+                    finally { if (e_11) throw e_11.error; }
+                }
+            })).rejects.toThrowError('throw on 2nd');
+            yield sleep(300);
+            expect(loopCount).toBe(1);
+            expect(mappedValues).toEqual([1, 2]);
+            expect(iteratedValues).toEqual([1]);
+        }));
+        it('catches exception from mapper - 1st item - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 1) {
+                    throw new Error('throw on 1st');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency: 1, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _j, e_12, _k, _l;
+                try {
+                    for (var _m = true, prefetcher_11 = tslib_1.__asyncValues(prefetcher), prefetcher_11_1; prefetcher_11_1 = yield prefetcher_11.next(), _j = prefetcher_11_1.done, !_j;) {
+                        _l = prefetcher_11_1.value;
+                        _m = false;
+                        try {
+                            const value = _l;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _m = true;
+                        }
+                    }
+                }
+                catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                finally {
+                    try {
+                        if (!_m && !_j && (_k = prefetcher_11.return)) yield _k.call(prefetcher_11);
+                    }
+                    finally { if (e_12) throw e_12.error; }
+                }
+            })).rejects.toThrowError('throw on 1st');
+            yield sleep(300);
+            expect(loopCount).toBe(2);
+            expect(mappedValues).toEqual([1, 2, 3]);
+            expect(iteratedValues).toEqual([2, 3]);
+        }));
+        it('catches exception from mapper - 2nd item - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 2) {
+                    throw new Error('throw on 2nd');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _o, e_13, _p, _q;
+                try {
+                    for (var _r = true, prefetcher_12 = tslib_1.__asyncValues(prefetcher), prefetcher_12_1; prefetcher_12_1 = yield prefetcher_12.next(), _o = prefetcher_12_1.done, !_o;) {
+                        _q = prefetcher_12_1.value;
+                        _r = false;
+                        try {
+                            const value = _q;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _r = true;
+                        }
+                    }
+                }
+                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                finally {
+                    try {
+                        if (!_r && !_o && (_p = prefetcher_12.return)) yield _p.call(prefetcher_12);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                }
+            })).rejects.toThrowError('throw on 2nd');
+            yield sleep(300);
+            expect(loopCount).toBe(2);
+            expect(mappedValues).toEqual([1, 2, 3]);
+            expect(iteratedValues).toEqual([1, 3]);
+        }));
+        it('catches exception from mapper - 10 of 10 items - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new SleepIterator(10);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => {
+                mappedValues.push(value);
+                throw new Error('throw on each');
+            }, { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _s, e_14, _t, _u;
+                try {
+                    for (var _v = true, prefetcher_13 = tslib_1.__asyncValues(prefetcher), prefetcher_13_1; prefetcher_13_1 = yield prefetcher_13.next(), _s = prefetcher_13_1.done, !_s;) {
+                        _u = prefetcher_13_1.value;
+                        _v = false;
+                        try {
+                            const value = _u;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _v = true;
+                        }
+                    }
+                }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (!_v && !_s && (_t = prefetcher_13.return)) yield _t.call(prefetcher_13);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
+            })).rejects.toThrowError('throw on each');
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from mapper - 10 of 10 items - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new SleepIterator(10);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => {
+                mappedValues.push(value);
+                throw new Error('throw on each');
+            }, { concurrency, maxUnread, stopOnMapperError: true });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _w, e_15, _x, _y;
+                try {
+                    for (var _z = true, prefetcher_14 = tslib_1.__asyncValues(prefetcher), prefetcher_14_1; prefetcher_14_1 = yield prefetcher_14.next(), _w = prefetcher_14_1.done, !_w;) {
+                        _y = prefetcher_14_1.value;
+                        _z = false;
+                        try {
+                            const value = _y;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _z = true;
+                        }
+                    }
+                }
+                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                finally {
+                    try {
+                        if (!_z && !_w && (_x = prefetcher_14.return)) yield _x.call(prefetcher_14);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                }
+            })).rejects.toThrowError('throw on each');
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from source iterator - 1st item', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new ThrowingIterator(100, 0, 100);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                mappedValues.push(value);
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _0, e_16, _1, _2;
+                try {
+                    for (var _3 = true, prefetcher_15 = tslib_1.__asyncValues(prefetcher), prefetcher_15_1; prefetcher_15_1 = yield prefetcher_15.next(), _0 = prefetcher_15_1.done, !_0;) {
+                        _2 = prefetcher_15_1.value;
+                        _3 = false;
+                        try {
+                            const value = _2;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _3 = true;
+                        }
+                    }
+                }
+                catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                finally {
+                    try {
+                        if (!_3 && !_0 && (_1 = prefetcher_15.return)) yield _1.call(prefetcher_15);
+                    }
+                    finally { if (e_16) throw e_16.error; }
+                }
+            })).rejects.toThrowError('throwing on index 0');
+            yield sleep(500);
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        // The 2nd iterable item throwing is distinct from the 1st when concurrency is 1 because
+        // it means that the sourceNext() is invoked from next() or sourceNext() and not from
+        // the constructor
+        it('catches exception from source iterator - 2nd item', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new ThrowingIterator(100, 1, 100);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                mappedValues.push(value);
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _4, e_17, _5, _6;
+                try {
+                    for (var _7 = true, prefetcher_16 = tslib_1.__asyncValues(prefetcher), prefetcher_16_1; prefetcher_16_1 = yield prefetcher_16.next(), _4 = prefetcher_16_1.done, !_4;) {
+                        _6 = prefetcher_16_1.value;
+                        _7 = false;
+                        try {
+                            const value = _6;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _7 = true;
+                        }
+                    }
+                }
+                catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                finally {
+                    try {
+                        if (!_7 && !_4 && (_5 = prefetcher_16.return)) yield _5.call(prefetcher_16);
+                    }
+                    finally { if (e_17) throw e_17.error; }
+                }
+            })).rejects.toThrowError('throwing on index 1');
+            yield sleep(500);
+            expect(loopCount).toBe(1);
+            expect(mappedValues).toEqual([0]);
+            expect(iteratedValues).toEqual([0]);
+        }));
+    });
+    describe('concurrency 2, maxUnread 4', () => {
+        const concurrency = 2;
+        const maxUnread = 4;
+        it('catches exception from mapper - 1st item - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 1) {
+                    yield sleep(100);
+                    throw new Error('throw on 1st');
+                }
+                return value;
+            }), { concurrency, maxUnread });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _a, e_18, _b, _c;
+                try {
+                    for (var _d = true, prefetcher_17 = tslib_1.__asyncValues(prefetcher), prefetcher_17_1; prefetcher_17_1 = yield prefetcher_17.next(), _a = prefetcher_17_1.done, !_a;) {
+                        _c = prefetcher_17_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = prefetcher_17.return)) yield _b.call(prefetcher_17);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+            })).rejects.toThrowError('throw on 1st');
+            yield sleep(500);
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1, 2]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from mapper - 2nd item - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 2) {
+                    throw new Error('throw on 2nd');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _e, e_19, _f, _g;
+                try {
+                    for (var _h = true, prefetcher_18 = tslib_1.__asyncValues(prefetcher), prefetcher_18_1; prefetcher_18_1 = yield prefetcher_18.next(), _e = prefetcher_18_1.done, !_e;) {
+                        _g = prefetcher_18_1.value;
+                        _h = false;
+                        try {
+                            const value = _g;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _h = true;
+                        }
+                    }
+                }
+                catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_e && (_f = prefetcher_18.return)) yield _f.call(prefetcher_18);
+                    }
+                    finally { if (e_19) throw e_19.error; }
+                }
+            })).rejects.toThrowError('throw on 2nd');
+            yield sleep(300);
+            expect(loopCount).toBe(2);
+            expect(mappedValues).toEqual([1, 3, 2]);
+            expect(iteratedValues).toEqual([1, 3]);
+        }));
+        it('catches exception from mapper - 1st item - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 1) {
+                    throw new Error('throw on 1st');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _j, e_20, _k, _l;
+                try {
+                    for (var _m = true, prefetcher_19 = tslib_1.__asyncValues(prefetcher), prefetcher_19_1; prefetcher_19_1 = yield prefetcher_19.next(), _j = prefetcher_19_1.done, !_j;) {
+                        _l = prefetcher_19_1.value;
+                        _m = false;
+                        try {
+                            const value = _l;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _m = true;
+                        }
+                    }
+                }
+                catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                finally {
+                    try {
+                        if (!_m && !_j && (_k = prefetcher_19.return)) yield _k.call(prefetcher_19);
+                    }
+                    finally { if (e_20) throw e_20.error; }
+                }
+            })).rejects.toThrowError('throw on 1st');
+            yield sleep(300);
+            expect(loopCount).toBe(2);
+            expect(mappedValues).toEqual([1, 3, 2]);
+            expect(iteratedValues).toEqual([3, 2]);
+        }));
+        it('catches exception from mapper - 2nd item - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 2) {
+                    throw new Error('throw on 2nd');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _o, e_21, _p, _q;
+                try {
+                    for (var _r = true, prefetcher_20 = tslib_1.__asyncValues(prefetcher), prefetcher_20_1; prefetcher_20_1 = yield prefetcher_20.next(), _o = prefetcher_20_1.done, !_o;) {
+                        _q = prefetcher_20_1.value;
+                        _r = false;
+                        try {
+                            const value = _q;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _r = true;
+                        }
+                    }
+                }
+                catch (e_21_1) { e_21 = { error: e_21_1 }; }
+                finally {
+                    try {
+                        if (!_r && !_o && (_p = prefetcher_20.return)) yield _p.call(prefetcher_20);
+                    }
+                    finally { if (e_21) throw e_21.error; }
+                }
+            })).rejects.toThrowError('throw on 2nd');
+            yield sleep(300);
+            expect(loopCount).toBe(2);
+            expect(mappedValues).toEqual([1, 3, 2]);
+            expect(iteratedValues).toEqual([1, 3]);
+        }));
+        it('catches exception from mapper - 10 of 10 items - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new SleepIterator(10);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => {
+                mappedValues.push(value);
+                throw new Error('throw on each');
+            }, { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _s, e_22, _t, _u;
+                try {
+                    for (var _v = true, prefetcher_21 = tslib_1.__asyncValues(prefetcher), prefetcher_21_1; prefetcher_21_1 = yield prefetcher_21.next(), _s = prefetcher_21_1.done, !_s;) {
+                        _u = prefetcher_21_1.value;
+                        _v = false;
+                        try {
+                            const value = _u;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _v = true;
+                        }
+                    }
+                }
+                catch (e_22_1) { e_22 = { error: e_22_1 }; }
+                finally {
+                    try {
+                        if (!_v && !_s && (_t = prefetcher_21.return)) yield _t.call(prefetcher_21);
+                    }
+                    finally { if (e_22) throw e_22.error; }
+                }
+            })).rejects.toThrowError('throw on each');
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from mapper - 10 of 10 items - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new SleepIterator(10);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => {
+                mappedValues.push(value);
+                throw new Error('throw on each');
+            }, { concurrency, maxUnread, stopOnMapperError: true });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _w, e_23, _x, _y;
+                try {
+                    for (var _z = true, prefetcher_22 = tslib_1.__asyncValues(prefetcher), prefetcher_22_1; prefetcher_22_1 = yield prefetcher_22.next(), _w = prefetcher_22_1.done, !_w;) {
+                        _y = prefetcher_22_1.value;
+                        _z = false;
+                        try {
+                            const value = _y;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _z = true;
+                        }
+                    }
+                }
+                catch (e_23_1) { e_23 = { error: e_23_1 }; }
+                finally {
+                    try {
+                        if (!_z && !_w && (_x = prefetcher_22.return)) yield _x.call(prefetcher_22);
+                    }
+                    finally { if (e_23) throw e_23.error; }
+                }
+            })).rejects.toThrowError('throw on each');
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from source iterator - 1st item', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new ThrowingIterator(100, 0, 100);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                mappedValues.push(value);
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _0, e_24, _1, _2;
+                try {
+                    for (var _3 = true, prefetcher_23 = tslib_1.__asyncValues(prefetcher), prefetcher_23_1; prefetcher_23_1 = yield prefetcher_23.next(), _0 = prefetcher_23_1.done, !_0;) {
+                        _2 = prefetcher_23_1.value;
+                        _3 = false;
+                        try {
+                            const value = _2;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _3 = true;
+                        }
+                    }
+                }
+                catch (e_24_1) { e_24 = { error: e_24_1 }; }
+                finally {
+                    try {
+                        if (!_3 && !_0 && (_1 = prefetcher_23.return)) yield _1.call(prefetcher_23);
+                    }
+                    finally { if (e_24) throw e_24.error; }
+                }
+            })).rejects.toThrowError('throwing on index 0');
+            yield sleep(500);
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        // The 2nd iterable item throwing is distinct from the 1st when concurrency is 1 because
+        // it means that the sourceNext() is invoked from next() or sourceNext() and not from
+        // the constructor
+        it('catches exception from source iterator - 2nd item', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new ThrowingIterator(100, 1, 100);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                mappedValues.push(value);
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _4, e_25, _5, _6;
+                try {
+                    for (var _7 = true, prefetcher_24 = tslib_1.__asyncValues(prefetcher), prefetcher_24_1; prefetcher_24_1 = yield prefetcher_24.next(), _4 = prefetcher_24_1.done, !_4;) {
+                        _6 = prefetcher_24_1.value;
+                        _7 = false;
+                        try {
+                            const value = _6;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _7 = true;
+                        }
+                    }
+                }
+                catch (e_25_1) { e_25 = { error: e_25_1 }; }
+                finally {
+                    try {
+                        if (!_7 && !_4 && (_5 = prefetcher_24.return)) yield _5.call(prefetcher_24);
+                    }
+                    finally { if (e_25) throw e_25.error; }
+                }
+            })).rejects.toThrowError('throwing on index 1');
+            yield sleep(500);
+            expect(loopCount).toBe(1);
+            expect(mappedValues).toEqual([0]);
+            expect(iteratedValues).toEqual([0]);
+        }));
+    });
+    describe('concurrency Number.POSITIVE_INFINITY, maxUnread Number.POSITIVE_INFINITY', () => {
+        const concurrency = Number.POSITIVE_INFINITY;
+        const maxUnread = Number.POSITIVE_INFINITY;
+        it('catches exception from mapper - 1st item - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 1) {
+                    yield sleep(100);
+                    throw new Error('throw on 1st');
+                }
+                return value;
+            }), { concurrency, maxUnread });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _a, e_26, _b, _c;
+                try {
+                    for (var _d = true, prefetcher_25 = tslib_1.__asyncValues(prefetcher), prefetcher_25_1; prefetcher_25_1 = yield prefetcher_25.next(), _a = prefetcher_25_1.done, !_a;) {
+                        _c = prefetcher_25_1.value;
+                        _d = false;
+                        try {
+                            const value = _c;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_26_1) { e_26 = { error: e_26_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = prefetcher_25.return)) yield _b.call(prefetcher_25);
+                    }
+                    finally { if (e_26) throw e_26.error; }
+                }
+            })).rejects.toThrowError('throw on 1st');
+            yield sleep(500);
+            expect(loopCount).toBe(1);
+            expect(mappedValues).toEqual([1, 3, 2]);
+            // NOTE: This seems wrong - Item 2 succeeds at being mapped, but after the 1st item throws.
+            // Since item 2 was mapped you would think it should be iterated with the exception for
+            // item 1 delayed until all items are read.
+            // However, since the mapper for 2 could throw, this could lead to 2 exceptions wanting to
+            // throw if we waited like this... so we would have to throw an AggregateError... and
+            // that just leads to guidance that the caller should catch exceptions in their mapper
+            // and return them as part of their NewElement object type.
+            // If a consumer catches and returns the exception then re-throws in their `for await`
+            // then this behavior would match their results exactly (the 1st item would cause the iteration
+            // loop to break out).
+            expect(iteratedValues).toEqual([3]);
+        }));
+        it('catches exception from mapper - 2nd item - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = [1, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return sleep(300, 2); }), 3];
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                value = typeof value === 'function' ? yield value() : value;
+                mappedValues.push(value);
+                if (value === 2) {
+                    throw new Error('throw on 2nd');
+                }
+                yield sleep(100);
+                return value;
+            }), { concurrency, maxUnread });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _e, e_27, _f, _g;
+                try {
+                    for (var _h = true, prefetcher_26 = tslib_1.__asyncValues(prefetcher), prefetcher_26_1; prefetcher_26_1 = yield prefetcher_26.next(), _e = prefetcher_26_1.done, !_e;) {
+                        _g = prefetcher_26_1.value;
+                        _h = false;
+                        try {
+                            const value = _g;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _h = true;
+                        }
+                    }
+                }
+                catch (e_27_1) { e_27 = { error: e_27_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_e && (_f = prefetcher_26.return)) yield _f.call(prefetcher_26);
+                    }
+                    finally { if (e_27) throw e_27.error; }
+                }
+            })).rejects.toThrowError('throw on 2nd');
+            yield sleep(300);
+            expect(loopCount).toBe(2);
+            expect(mappedValues).toEqual([1, 3, 2]);
+            expect(iteratedValues).toEqual([1, 3]);
+        }));
+        it('async mapper works', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            var _j, e_28, _k, _l;
+            const max = 100;
+            const iterator = new SleepIterator(max);
+            let total = 0;
+            let callCount = 0;
+            const prefetcher = new iterable_mapper_1.IterableMapper(iterator, (value) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                callCount++;
+                total += value;
+                yield sleep(10 * (callCount % 6));
+                return total;
+            }), { concurrency, maxUnread });
+            let lastTotal = 0;
+            let loopCount = 0;
+            try {
+                for (var _m = true, prefetcher_27 = tslib_1.__asyncValues(prefetcher), prefetcher_27_1; prefetcher_27_1 = yield prefetcher_27.next(), _j = prefetcher_27_1.done, !_j;) {
+                    _l = prefetcher_27_1.value;
+                    _m = false;
+                    try {
+                        const item = _l;
+                        loopCount++;
+                        if (item > lastTotal) {
+                            lastTotal = item;
+                        }
+                    }
+                    finally {
+                        _m = true;
+                    }
+                }
+            }
+            catch (e_28_1) { e_28 = { error: e_28_1 }; }
+            finally {
+                try {
+                    if (!_m && !_j && (_k = prefetcher_27.return)) yield _k.call(prefetcher_27);
+                }
+                finally { if (e_28) throw e_28.error; }
+            }
+            expect(callCount).toBe(max);
+            expect(loopCount).toBe(max);
+            expect(total).toBe((max * (max + 1)) / 2);
+            expect(lastTotal).toBe((max * (max + 1)) / 2);
+        }));
+        it('catches exception from mapper - 10 of 10 items - stopOnMapperError true', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new SleepIterator(10);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => {
+                mappedValues.push(value);
+                throw new Error('throw on each');
+            }, { concurrency, maxUnread, stopOnMapperError: true });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _o, e_29, _p, _q;
+                try {
+                    for (var _r = true, prefetcher_28 = tslib_1.__asyncValues(prefetcher), prefetcher_28_1; prefetcher_28_1 = yield prefetcher_28.next(), _o = prefetcher_28_1.done, !_o;) {
+                        _q = prefetcher_28_1.value;
+                        _r = false;
+                        try {
+                            const value = _q;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _r = true;
+                        }
+                    }
+                }
+                catch (e_29_1) { e_29 = { error: e_29_1 }; }
+                finally {
+                    try {
+                        if (!_r && !_o && (_p = prefetcher_28.return)) yield _p.call(prefetcher_28);
+                    }
+                    finally { if (e_29) throw e_29.error; }
+                }
+            })).rejects.toThrowError('throw on each');
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1]);
+            expect(iteratedValues).toEqual([]);
+        }));
+        it('catches exception from mapper - 10 of 10 items - stopOnMapperError false', () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const input = new SleepIterator(10);
+            const mappedValues = [];
+            const iteratedValues = [];
+            const prefetcher = new iterable_mapper_1.IterableMapper(input, (value) => {
+                mappedValues.push(value);
+                throw new Error('throw on each');
+            }, { concurrency, maxUnread, stopOnMapperError: false });
+            let loopCount = 0;
+            yield expect(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                var _s, e_30, _t, _u;
+                try {
+                    for (var _v = true, prefetcher_29 = tslib_1.__asyncValues(prefetcher), prefetcher_29_1; prefetcher_29_1 = yield prefetcher_29.next(), _s = prefetcher_29_1.done, !_s;) {
+                        _u = prefetcher_29_1.value;
+                        _v = false;
+                        try {
+                            const value = _u;
+                            loopCount++;
+                            iteratedValues.push(value);
+                        }
+                        finally {
+                            _v = true;
+                        }
+                    }
+                }
+                catch (e_30_1) { e_30 = { error: e_30_1 }; }
+                finally {
+                    try {
+                        if (!_v && !_s && (_t = prefetcher_29.return)) yield _t.call(prefetcher_29);
+                    }
+                    finally { if (e_30) throw e_30.error; }
+                }
+            })).rejects.toThrowError('throw on each');
+            expect(loopCount).toBe(0);
+            expect(mappedValues).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+            expect(iteratedValues).toEqual([]);
+        }));
+    });
+});
+//# sourceMappingURL=iterable-mapper.test.js.map