@hpcc-js/dataflow 8.0.1 → 8.1.1

package/dist/index.js

@@ -1,500 +1,500 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = global || self, factory(global['@hpcc-js/dataflow'] = {}));
-}(this, (function (exports) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@hpcc-js/dataflow"] = {}));
+})(this, (function (exports) { 'use strict';
 
-    function isSource(source) {
-        return typeof source[Symbol.iterator] === "function" || Array.isArray(source);
+    function isSource(source) {
+        return typeof source[Symbol.iterator] === "function" || Array.isArray(source);
     }
 
-    function concatGen(concatSource) {
-        return function* (source) {
-            yield* source;
-            yield* concatSource;
-        };
-    }
-    function concat(s_or_n, concatSource) {
-        return concatSource !== undefined ? concatGen(concatSource)(s_or_n) : concatGen(s_or_n);
+    function concatGen(concatSource) {
+        return function* (source) {
+            yield* source;
+            yield* concatSource;
+        };
+    }
+    function concat(s_or_n, concatSource) {
+        return concatSource !== undefined ? concatGen(concatSource)(s_or_n) : concatGen(s_or_n);
     }
 
-    function eachGen(callbackFn) {
-        return function* (source) {
-            let i = -1;
-            for (const item of source) {
-                callbackFn(item, ++i);
-                yield item;
-            }
-        };
-    }
-    function each(s_or_cb, callbackFn) {
-        return isSource(s_or_cb) ? eachGen(callbackFn)(s_or_cb) : eachGen(s_or_cb);
+    function eachGen(callbackFn) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                callbackFn(item, ++i);
+                yield item;
+            }
+        };
+    }
+    function each(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? eachGen(callbackFn)(s_or_cb) : eachGen(s_or_cb);
     }
 
-    //  Array.entries
-    function entriesGen() {
-        return function* (source) {
-            let i = -1;
-            for (const item of source) {
-                yield [++i, item];
-            }
-        };
-    }
-    function entries(source) {
-        return source ? entriesGen()(source) : entriesGen();
+    //  Array.entries
+    function entriesGen() {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                yield [++i, item];
+            }
+        };
+    }
+    function entries(source) {
+        return source ? entriesGen()(source) : entriesGen();
     }
 
-    function filterGen(callbackFn) {
-        return function* (source) {
-            let i = -1;
-            for (const item of source) {
-                if (callbackFn(item, ++i)) {
-                    yield item;
-                }
-            }
-        };
-    }
-    function filter(s_or_cb, callbackFn) {
-        return isSource(s_or_cb) ? filterGen(callbackFn)(s_or_cb) : filterGen(s_or_cb);
+    function filterGen(callbackFn) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                if (callbackFn(item, ++i)) {
+                    yield item;
+                }
+            }
+        };
+    }
+    function filter(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? filterGen(callbackFn)(s_or_cb) : filterGen(s_or_cb);
     }
 
-    function firstGen(n) {
-        return function* (source) {
-            let i = 0;
-            for (const item of source) {
-                yield item;
-                if (++i >= n) {
-                    break;
-                }
-            }
-        };
-    }
-    function first(s_or_n, n) {
-        if (!isSource(s_or_n))
-            return firstGen(s_or_n);
-        return firstGen(n)(s_or_n);
+    function firstGen(n) {
+        return function* (source) {
+            let i = 0;
+            for (const item of source) {
+                yield item;
+                if (++i >= n) {
+                    break;
+                }
+            }
+        };
+    }
+    function first(s_or_n, n) {
+        if (!isSource(s_or_n))
+            return firstGen(s_or_n);
+        return firstGen(n)(s_or_n);
     }
 
-    function groupGen(groupFn) {
-        return function* (source) {
-            let i = -1;
-            const group = {};
-            for (const row of source) {
-                const key = groupFn(row, ++i);
-                if (!group[key]) {
-                    group[key] = [];
-                }
-                group[key].push(row);
-            }
-            for (const key in group) {
-                yield { key, value: group[key] };
-            }
-        };
-    }
-    function group(s_or_gbf, groupByFn) {
-        return isSource(s_or_gbf) ? groupGen(groupByFn)(s_or_gbf) : groupGen(s_or_gbf);
+    function groupGen(groupFn) {
+        return function* (source) {
+            let i = -1;
+            const group = {};
+            for (const row of source) {
+                const key = groupFn(row, ++i);
+                if (!group[key]) {
+                    group[key] = [];
+                }
+                group[key].push(row);
+            }
+            for (const key in group) {
+                yield { key, value: group[key] };
+            }
+        };
+    }
+    function group(s_or_gbf, groupByFn) {
+        return isSource(s_or_gbf) ? groupGen(groupByFn)(s_or_gbf) : groupGen(s_or_gbf);
     }
 
-    function Accessor(fof, accesor) {
-        const s = fof();
-        return {
-            observe: (_, i) => {
-                s.observe(accesor(_, i), i);
-            },
-            peek: s.peek
-        };
-    }
-    //  This is an pass through activity so a FlowObserver can be inserted into a pipeline ---
-    function sensor(s) {
-        return each((r, i) => s.observe(r, i));
-    }
-    //  This converts a FlowObserver to an Activity ---
-    function activity(s) {
-        return function* (source) {
-            let i = -1;
-            for (const row of source) {
-                s.observe(row, ++i);
-            }
-            yield s.peek();
-        };
-    }
-    //  This converts a FlowObserver to an ScalarActivity ---
-    function scalar(s) {
-        return function (source) {
-            let i = -1;
-            for (const row of source) {
-                s.observe(row, ++i);
-            }
-            return s.peek();
-        };
+    function Accessor(fof, accesor) {
+        const s = fof();
+        return {
+            observe: (_, i) => {
+                s.observe(accesor(_, i), i);
+            },
+            peek: s.peek
+        };
+    }
+    //  This is an pass through activity so a FlowObserver can be inserted into a pipeline ---
+    function sensor(s) {
+        return each((r, i) => s.observe(r, i));
+    }
+    //  This converts a FlowObserver to an Activity ---
+    function activity(s) {
+        return function* (source) {
+            let i = -1;
+            for (const row of source) {
+                s.observe(row, ++i);
+            }
+            yield s.peek();
+        };
+    }
+    //  This converts a FlowObserver to an ScalarActivity ---
+    function scalar(s) {
+        return function (source) {
+            let i = -1;
+            for (const row of source) {
+                s.observe(row, ++i);
+            }
+            return s.peek();
+        };
     }
 
-    function _max() {
-        let max;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    max = value;
-                }
-                else if (max < value) {
-                    max = value;
-                }
-            },
-            peek: () => max
-        };
-    }
-    function max(callbackFn) {
-        return callbackFn ? Accessor(_max, callbackFn) : _max();
+    function _max() {
+        let max;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    max = value;
+                }
+                else if (max < value) {
+                    max = value;
+                }
+            },
+            peek: () => max
+        };
+    }
+    function max(callbackFn) {
+        return callbackFn ? Accessor(_max, callbackFn) : _max();
     }
 
-    function _min() {
-        let min;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    min = value;
-                }
-                else if (min > value) {
-                    min = value;
-                }
-            },
-            peek: () => min
-        };
-    }
-    function min(callbackFn) {
-        return callbackFn ? Accessor(_min, callbackFn) : _min();
+    function _min() {
+        let min;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    min = value;
+                }
+                else if (min > value) {
+                    min = value;
+                }
+            },
+            peek: () => min
+        };
+    }
+    function min(callbackFn) {
+        return callbackFn ? Accessor(_min, callbackFn) : _min();
     }
 
-    function _extent() {
-        const minFO = min();
-        const maxFO = max();
-        return {
-            observe: (value, idx) => {
-                minFO.observe(value, idx);
-                maxFO.observe(value, idx);
-            },
-            peek: () => [minFO.peek(), maxFO.peek()]
-        };
-    }
-    function extent(callbackFn) {
-        return callbackFn ? Accessor(_extent, callbackFn) : _extent();
+    function _extent() {
+        const minFO = min();
+        const maxFO = max();
+        return {
+            observe: (value, idx) => {
+                minFO.observe(value, idx);
+                maxFO.observe(value, idx);
+            },
+            peek: () => [minFO.peek(), maxFO.peek()]
+        };
+    }
+    function extent(callbackFn) {
+        return callbackFn ? Accessor(_extent, callbackFn) : _extent();
     }
 
-    function isOptionA(_) {
-        return _.buckets !== undefined;
-    }
-    function histogramGen(callbackFn, options) {
-        return function* (_source) {
-            let min;
-            let bucketSize;
-            let source;
-            if (isOptionA(options)) {
-                source = Array.isArray(_source) ? _source : [..._source];
-                const minMax = scalar(extent(callbackFn))(source);
-                if (minMax === undefined) {
-                    return undefined;
-                }
-                min = minMax[0];
-                const max = minMax[1];
-                const buckets = options.buckets;
-                bucketSize = (max - min) / buckets;
-            }
-            else {
-                source = _source;
-                min = options.min;
-                bucketSize = options.range;
-            }
-            const histogram = {};
-            let maxBucketID = 0;
-            for (const row of source) {
-                const value = callbackFn(row);
-                const bucketID = Math.floor((value - min) / bucketSize);
-                if (maxBucketID < bucketID) {
-                    maxBucketID = bucketID;
-                }
-                if (histogram[bucketID] === undefined) {
-                    histogram[bucketID] = [];
-                }
-                histogram[bucketID].push(row);
-            }
-            const lastBucket = histogram[maxBucketID];
-            const from = min + maxBucketID * bucketSize;
-            for (let i = 0; i <= maxBucketID; ++i) {
-                //  If all items in the last bucket match the "to" of the previous bucket, put them in there...
-                if (i === maxBucketID - 1 && lastBucket.every(row => from === callbackFn(row))) {
-                    yield {
-                        from: min + i * bucketSize,
-                        to: min + (i + 1) * bucketSize,
-                        value: [...(histogram[i] || []), ...lastBucket]
-                    };
-                    break;
-                }
-                yield {
-                    from: min + i * bucketSize,
-                    to: min + (i + 1) * bucketSize,
-                    value: histogram[i] || []
-                };
-            }
-        };
-    }
-    function histogram(s_or_hf, hf_or_b, options) {
-        return isSource(s_or_hf) ? histogramGen(hf_or_b, options)(s_or_hf) : histogramGen(s_or_hf, hf_or_b);
+    function isOptionA(_) {
+        return _.buckets !== undefined;
+    }
+    function histogramGen(callbackFn, options) {
+        return function* (_source) {
+            let min;
+            let bucketSize;
+            let source;
+            if (isOptionA(options)) {
+                source = Array.isArray(_source) ? _source : [..._source];
+                const minMax = scalar(extent(callbackFn))(source);
+                if (minMax === undefined) {
+                    return undefined;
+                }
+                min = minMax[0];
+                const max = minMax[1];
+                const buckets = options.buckets;
+                bucketSize = (max - min) / buckets;
+            }
+            else {
+                source = _source;
+                min = options.min;
+                bucketSize = options.range;
+            }
+            const histogram = {};
+            let maxBucketID = 0;
+            for (const row of source) {
+                const value = callbackFn(row);
+                const bucketID = Math.floor((value - min) / bucketSize);
+                if (maxBucketID < bucketID) {
+                    maxBucketID = bucketID;
+                }
+                if (histogram[bucketID] === undefined) {
+                    histogram[bucketID] = [];
+                }
+                histogram[bucketID].push(row);
+            }
+            const lastBucket = histogram[maxBucketID];
+            const from = min + maxBucketID * bucketSize;
+            for (let i = 0; i <= maxBucketID; ++i) {
+                //  If all items in the last bucket match the "to" of the previous bucket, put them in there...
+                if (i === maxBucketID - 1 && lastBucket.every(row => from === callbackFn(row))) {
+                    yield {
+                        from: min + i * bucketSize,
+                        to: min + (i + 1) * bucketSize,
+                        value: [...(histogram[i] || []), ...lastBucket]
+                    };
+                    break;
+                }
+                yield {
+                    from: min + i * bucketSize,
+                    to: min + (i + 1) * bucketSize,
+                    value: histogram[i] || []
+                };
+            }
+        };
+    }
+    function histogram(s_or_hf, hf_or_b, options) {
+        return isSource(s_or_hf) ? histogramGen(hf_or_b, options)(s_or_hf) : histogramGen(s_or_hf, hf_or_b);
     }
 
-    function mapGen(callbackFn) {
-        return function* (source) {
-            let i = -1;
-            for (const item of source) {
-                yield callbackFn(item, ++i);
-            }
-        };
-    }
-    function map(s_or_cb, callbackFn) {
-        return isSource(s_or_cb) ? mapGen(callbackFn)(s_or_cb) : mapGen(s_or_cb);
+    function mapGen(callbackFn) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                yield callbackFn(item, ++i);
+            }
+        };
+    }
+    function map(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? mapGen(callbackFn)(s_or_cb) : mapGen(s_or_cb);
     }
 
-    function skipGen(n) {
-        return function* (source) {
-            let i = -1;
-            for (const item of source) {
-                if (++i >= n) {
-                    yield item;
-                }
-            }
-        };
-    }
-    function skip(s_or_n, n) {
-        if (!isSource(s_or_n))
-            return skipGen(s_or_n);
-        return skipGen(n)(s_or_n);
+    function skipGen(n) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                if (++i >= n) {
+                    yield item;
+                }
+            }
+        };
+    }
+    function skip(s_or_n, n) {
+        if (!isSource(s_or_n))
+            return skipGen(s_or_n);
+        return skipGen(n)(s_or_n);
     }
 
-    function sortGen(compareFn) {
-        return function* (source) {
-            yield* (Array.isArray(source) ? source : [...source]).sort(compareFn);
-        };
-    }
-    function sort(s_or_cb, callbackFn) {
-        return isSource(s_or_cb) ? sortGen(callbackFn)(s_or_cb) : sortGen(s_or_cb);
+    function sortGen(compareFn) {
+        return function* (source) {
+            yield* (Array.isArray(source) ? source : [...source]).sort(compareFn);
+        };
+    }
+    function sort(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? sortGen(callbackFn)(s_or_cb) : sortGen(s_or_cb);
     }
 
-    function count() {
-        let count;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    count = 0;
-                }
-                ++count;
-            },
-            peek: () => count
-        };
+    function count() {
+        let count;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    count = 0;
+                }
+                ++count;
+            },
+            peek: () => count
+        };
     }
 
-    function _variance() {
-        let count;
-        let mean;
-        let sum;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    count = 0;
-                    mean = 0;
-                    sum = 0;
-                }
-                const delta = value - mean;
-                mean += delta / ++count;
-                sum += delta * (value - mean);
-            },
-            peek: () => count > 1 ? sum / (count - 1) : undefined
-        };
-    }
-    function variance(callbackFn) {
-        return callbackFn ? Accessor(_variance, callbackFn) : _variance();
+    function _variance() {
+        let count;
+        let mean;
+        let sum;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    count = 0;
+                    mean = 0;
+                    sum = 0;
+                }
+                const delta = value - mean;
+                mean += delta / ++count;
+                sum += delta * (value - mean);
+            },
+            peek: () => count > 1 ? sum / (count - 1) : undefined
+        };
+    }
+    function variance(callbackFn) {
+        return callbackFn ? Accessor(_variance, callbackFn) : _variance();
     }
 
-    function _deviation() {
-        const v = variance();
-        return {
-            observe: (value, idx) => {
-                v.observe(value, idx);
-            },
-            peek: () => {
-                const variance = v.peek();
-                return variance !== undefined ? Math.sqrt(variance) : variance;
-            }
-        };
-    }
-    function deviation(callbackFn) {
-        return callbackFn ? Accessor(_deviation, callbackFn) : _deviation();
+    function _deviation() {
+        const v = variance();
+        return {
+            observe: (value, idx) => {
+                v.observe(value, idx);
+            },
+            peek: () => {
+                const variance = v.peek();
+                return variance !== undefined ? Math.sqrt(variance) : variance;
+            }
+        };
+    }
+    function deviation(callbackFn) {
+        return callbackFn ? Accessor(_deviation, callbackFn) : _deviation();
     }
 
-    function _mean() {
-        let total;
-        let count;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    total = value;
-                }
-                else {
-                    total += value;
-                }
-                count = idx;
-            },
-            peek: () => total / (count + 1)
-        };
-    }
-    function mean(callbackFn) {
-        return callbackFn ? Accessor(_mean, callbackFn) : _mean();
+    function _mean() {
+        let total;
+        let count;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    total = value;
+                }
+                else {
+                    total += value;
+                }
+                count = idx;
+            },
+            peek: () => total / (count + 1)
+        };
+    }
+    function mean(callbackFn) {
+        return callbackFn ? Accessor(_mean, callbackFn) : _mean();
     }
 
-    function _distribution() {
-        const minFO = min();
-        const maxFO = max();
-        const meanFO = mean();
-        const varianceFO = variance();
-        return {
-            observe: (value, idx) => {
-                minFO.observe(value, idx);
-                maxFO.observe(value, idx);
-                meanFO.observe(value, idx);
-                varianceFO.observe(value, idx);
-            },
-            peek: () => {
-                const minResult = minFO.peek();
-                if (minResult === undefined)
-                    return undefined;
-                const varianceResult = varianceFO.peek();
-                return {
-                    min: minResult,
-                    max: maxFO.peek(),
-                    mean: meanFO.peek(),
-                    variance: varianceResult,
-                    deviation: varianceResult !== undefined ? Math.sqrt(varianceResult) : undefined
-                };
-            }
-        };
-    }
-    function distribution(callbackFn) {
-        return callbackFn ? Accessor(_distribution, callbackFn) : _distribution();
+    function _distribution() {
+        const minFO = min();
+        const maxFO = max();
+        const meanFO = mean();
+        const varianceFO = variance();
+        return {
+            observe: (value, idx) => {
+                minFO.observe(value, idx);
+                maxFO.observe(value, idx);
+                meanFO.observe(value, idx);
+                varianceFO.observe(value, idx);
+            },
+            peek: () => {
+                const minResult = minFO.peek();
+                if (minResult === undefined)
+                    return undefined;
+                const varianceResult = varianceFO.peek();
+                return {
+                    min: minResult,
+                    max: maxFO.peek(),
+                    mean: meanFO.peek(),
+                    variance: varianceResult,
+                    deviation: varianceResult !== undefined ? Math.sqrt(varianceResult) : undefined
+                };
+            }
+        };
+    }
+    function distribution(callbackFn) {
+        return callbackFn ? Accessor(_distribution, callbackFn) : _distribution();
     }
 
-    function _median() {
-        let values;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    values = [];
-                }
-                values.push(value);
-            },
-            peek: () => {
-                const sorted = values.sort((l, r) => l - r);
-                const mid = sorted.length / 2;
-                if (sorted.length % 2 === 0) {
-                    return (sorted[mid - 1] + sorted[mid]) / 2;
-                }
-                else {
-                    return sorted[Math.floor(mid)];
-                }
-            }
-        };
-    }
-    function median(callbackFn) {
-        return callbackFn ? Accessor(_median, callbackFn) : _median();
+    function _median() {
+        let values;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    values = [];
+                }
+                values.push(value);
+            },
+            peek: () => {
+                const sorted = values.sort((l, r) => l - r);
+                const mid = sorted.length / 2;
+                if (sorted.length % 2 === 0) {
+                    return (sorted[mid - 1] + sorted[mid]) / 2;
+                }
+                else {
+                    return sorted[Math.floor(mid)];
+                }
+            }
+        };
+    }
+    function median(callbackFn) {
+        return callbackFn ? Accessor(_median, callbackFn) : _median();
     }
 
-    function _quartile() {
-        let values;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    values = [];
-                }
-                values.push(value);
-            },
-            peek: () => {
-                const sorted = values.sort((l, r) => l - r);
-                const mid = sorted.length / 2;
-                let medianVal;
-                let lower;
-                let upper;
-                if (sorted.length < 2) {
-                    return undefined;
-                }
-                else if (sorted.length % 2 === 0) {
-                    medianVal = (sorted[mid - 1] + sorted[mid]) / 2;
-                    lower = sorted.slice(0, mid);
-                    upper = sorted.slice(mid);
-                }
-                else {
-                    medianVal = sorted[Math.floor(mid)];
-                    lower = sorted.slice(0, Math.floor(mid));
-                    upper = sorted.slice(Math.ceil(mid));
-                }
-                return [sorted[0], scalar(median())(lower), medianVal, scalar(median())(upper), sorted[sorted.length - 1]];
-            }
-        };
-    }
-    function quartile(callbackFn) {
-        return callbackFn ? Accessor(_quartile, callbackFn) : _quartile();
+    function _quartile() {
+        let values;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    values = [];
+                }
+                values.push(value);
+            },
+            peek: () => {
+                const sorted = values.sort((l, r) => l - r);
+                const mid = sorted.length / 2;
+                let medianVal;
+                let lower;
+                let upper;
+                if (sorted.length < 2) {
+                    return undefined;
+                }
+                else if (sorted.length % 2 === 0) {
+                    medianVal = (sorted[mid - 1] + sorted[mid]) / 2;
+                    lower = sorted.slice(0, mid);
+                    upper = sorted.slice(mid);
+                }
+                else {
+                    medianVal = sorted[Math.floor(mid)];
+                    lower = sorted.slice(0, Math.floor(mid));
+                    upper = sorted.slice(Math.ceil(mid));
+                }
+                return [sorted[0], scalar(median())(lower), medianVal, scalar(median())(upper), sorted[sorted.length - 1]];
+            }
+        };
+    }
+    function quartile(callbackFn) {
+        return callbackFn ? Accessor(_quartile, callbackFn) : _quartile();
     }
 
-    function _reduce(callback, initialValue) {
-        let reduced;
-        return {
-            observe: (value, idx) => {
-                if (idx === 0) {
-                    reduced = initialValue === undefined ? value : callback(initialValue, value, idx);
-                }
-                else {
-                    reduced = callback(reduced, value, idx);
-                }
-            },
-            peek: () => reduced
-        };
-    }
-    function reduce(callbackFn, initialValue) {
-        return _reduce(callbackFn, initialValue);
+    function _reduce(callback, initialValue) {
+        let reduced;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    reduced = initialValue === undefined ? value : callback(initialValue, value, idx);
+                }
+                else {
+                    reduced = callback(reduced, value, idx);
+                }
+            },
+            peek: () => reduced
+        };
+    }
+    function reduce(callbackFn, initialValue) {
+        return _reduce(callbackFn, initialValue);
     }
 
-    function* generate(generatorFn, maxLen) {
-        let i = -1;
-        while (maxLen === undefined || ++i < maxLen) {
-            yield generatorFn();
-        }
+    function* generate(generatorFn, maxLen) {
+        let i = -1;
+        while (maxLen === undefined || ++i < maxLen) {
+            yield generatorFn();
+        }
     }
 
-    const GeneratorFunction = (function* () { }).constructor;
-    function chainGen(...items) {
-        if (items[items.length - 1] instanceof GeneratorFunction) {
-            return function* (source) {
-                // @ts-ignore
-                let tail = source;
-                for (const activity of items) {
-                    // @ts-ignore
-                    tail = activity(tail);
-                }
-                yield* tail;
-            };
-        }
-        else {
-            return function (source) {
-                // @ts-ignore
-                let tail = source;
-                for (const activity of items) {
-                    // @ts-ignore
-                    tail = activity(tail);
-                }
-                return tail;
-            };
-        }
-    }
-    function pipe(s_or_ia, ...items) {
-        return isSource(s_or_ia) ? chainGen(...items)(s_or_ia) : chainGen(s_or_ia, ...items);
-    }
-    //  Maintain backward compatibility
+    const GeneratorFunction = (function* () { }).constructor;
+    function chainGen(...items) {
+        if (items[items.length - 1] instanceof GeneratorFunction) {
+            return function* (source) {
+                // @ts-ignore
+                let tail = source;
+                for (const activity of items) {
+                    // @ts-ignore
+                    tail = activity(tail);
+                }
+                yield* tail;
+            };
+        }
+        else {
+            return function (source) {
+                // @ts-ignore
+                let tail = source;
+                for (const activity of items) {
+                    // @ts-ignore
+                    tail = activity(tail);
+                }
+                return tail;
+            };
+        }
+    }
+    function pipe(s_or_ia, ...items) {
+        return isSource(s_or_ia) ? chainGen(...items)(s_or_ia) : chainGen(s_or_ia, ...items);
+    }
+    //  Maintain backward compatibility
     const chain = pipe;
 
     exports.Accessor = Accessor;
@@ -529,5 +529,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=index.js.map