@hpcc-js/dataflow 9.1.0 → 9.3.0

package/dist/index.js

@@ -1,558 +1,398 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@hpcc-js/dataflow"] = {}));
-})(this, (function (exports) { 'use strict';
-
-    function isSource(source) {
-        return source && (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 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();
-    }
-
-    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 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 _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 _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 isSource(source) {
+  return source && (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 !== void 0 ? 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 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)
+      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)
+      if (yield item, ++i >= n)
+        break;
+  };
+}
+function first(s_or_n, n) {
+  return isSource(s_or_n) ? firstGen(n)(s_or_n) : firstGen(s_or_n);
+}
+function groupGen(groupFn) {
+  return function* (source) {
+    let i = -1;
+    const group2 = {};
+    for (const row of source) {
+      const key = groupFn(row, ++i);
+      group2[key] || (group2[key] = []), group2[key].push(row);
+    }
+    for (const key in group2)
+      yield { key, value: group2[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
+  };
+}
+function sensor(s) {
+  return each((r, i) => s.observe(r, i));
+}
+function activity(s) {
+  return function* (source) {
+    let i = -1;
+    for (const row of source)
+      s.observe(row, ++i);
+    yield s.peek();
+  };
+}
+function scalar(s) {
+  return function(source) {
+    let i = -1;
+    for (const row of source)
+      s.observe(row, ++i);
+    return s.peek();
+  };
+}
+function _max() {
+  let max2;
+  return {
+    observe: (value, idx) => {
+      (idx === 0 || max2 < value) && (max2 = value);
+    },
+    peek: () => max2
+  };
+}
+function max(callbackFn) {
+  return callbackFn ? Accessor(_max, callbackFn) : _max();
+}
+function _min() {
+  let min2;
+  return {
+    observe: (value, idx) => {
+      (idx === 0 || min2 > value) && (min2 = value);
+    },
+    peek: () => min2
+  };
+}
+function min(callbackFn) {
+  return callbackFn ? Accessor(_min, callbackFn) : _min();
+}
+function _extent() {
+  const minFO = min(), 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 !== void 0;
+}
+function histogramGen(callbackFn, options) {
+  return function* (_source) {
+    let min2, bucketSize, source;
+    if (isOptionA(options)) {
+      source = Array.isArray(_source) ? _source : [..._source];
+      const minMax = scalar(extent(callbackFn))(source);
+      if (minMax === void 0)
+        return;
+      min2 = minMax[0];
+      const max2 = minMax[1], buckets = options.buckets;
+      bucketSize = (max2 - min2) / buckets;
+    } else
+      source = _source, min2 = options.min, bucketSize = options.range;
+    const histogram2 = {};
+    let maxBucketID = 0;
+    for (const row of source) {
+      const value = callbackFn(row), bucketID = Math.floor((value - min2) / bucketSize);
+      maxBucketID < bucketID && (maxBucketID = bucketID), histogram2[bucketID] === void 0 && (histogram2[bucketID] = []), histogram2[bucketID].push(row);
+    }
+    const lastBucket = histogram2[maxBucketID], from = min2 + maxBucketID * bucketSize;
+    for (let i = 0; i <= maxBucketID; ++i) {
+      if (i === maxBucketID - 1 && lastBucket.every((row) => from === callbackFn(row))) {
+        yield {
+          from: min2 + i * bucketSize,
+          to: min2 + (i + 1) * bucketSize,
+          value: [...histogram2[i] || [], ...lastBucket]
         };
-    }
-    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 joinGen(_sourceU, callbackFn) {
-        const sourceB = Array.isArray(_sourceU) ? _sourceU[Symbol.iterator]() : _sourceU;
-        return function* (sourceT) {
-            let i = -1;
-            for (const item of sourceT) {
-                yield callbackFn(item, sourceB.next().value, ++i);
-            }
-        };
-    }
-    function join(sT_or_sU, sU_or_cb, callbackFn) {
-        return isSource(sU_or_cb) ? joinGen(sU_or_cb, callbackFn)(sT_or_sU) : joinGen(sT_or_sU, sU_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 normalizeGen() {
-        const calcExtent = scalar(extent());
-        return function* (_source) {
-            const source = Array.isArray(_source) ? _source : [..._source];
-            const range = calcExtent(source);
-            const divisor = (range[1] - range[0]) || 1;
-            const normalizeMap = map((row) => (row - range[0]) / divisor);
-            return yield* normalizeMap(source);
-        };
-    }
-    function normalize(s_or_undef) {
-        return isSource(s_or_undef) ? normalizeGen()(s_or_undef) : normalizeGen();
-    }
-
-    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) {
-        return isSource(s_or_n) ? skipGen(n)(s_or_n) : skipGen(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 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 _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 _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 _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* 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 chain = pipe;
-
-    exports.Accessor = Accessor;
-    exports.activity = activity;
-    exports.chain = chain;
-    exports.concat = concat;
-    exports.count = count;
-    exports.deviation = deviation;
-    exports.distribution = distribution;
-    exports.each = each;
-    exports.entries = entries;
-    exports.extent = extent;
-    exports.filter = filter;
-    exports.first = first;
-    exports.generate = generate;
-    exports.group = group;
-    exports.histogram = histogram;
-    exports.isSource = isSource;
-    exports.join = join;
-    exports.map = map;
-    exports.max = max;
-    exports.mean = mean;
-    exports.median = median;
-    exports.min = min;
-    exports.normalize = normalize;
-    exports.pipe = pipe;
-    exports.quartile = quartile;
-    exports.reduce = reduce;
-    exports.scalar = scalar;
-    exports.sensor = sensor;
-    exports.skip = skip;
-    exports.sort = sort;
-    exports.variance = variance;
-
-}));
+        break;
+      }
+      yield {
+        from: min2 + i * bucketSize,
+        to: min2 + (i + 1) * bucketSize,
+        value: histogram2[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 joinGen(_sourceU, callbackFn) {
+  const sourceB = Array.isArray(_sourceU) ? _sourceU[Symbol.iterator]() : _sourceU;
+  return function* (sourceT) {
+    let i = -1;
+    for (const item of sourceT)
+      yield callbackFn(item, sourceB.next().value, ++i);
+  };
+}
+function join(sT_or_sU, sU_or_cb, callbackFn) {
+  return isSource(sU_or_cb) ? joinGen(sU_or_cb, callbackFn)(sT_or_sU) : joinGen(sT_or_sU, sU_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 normalizeGen() {
+  const calcExtent = scalar(extent());
+  return function* (_source) {
+    const source = Array.isArray(_source) ? _source : [..._source], range = calcExtent(source), divisor = range[1] - range[0] || 1;
+    return yield* map((row) => (row - range[0]) / divisor)(source);
+  };
+}
+function normalize(s_or_undef) {
+  return isSource(s_or_undef) ? normalizeGen()(s_or_undef) : normalizeGen();
+}
+function skipGen(n) {
+  return function* (source) {
+    let i = -1;
+    for (const item of source)
+      ++i >= n && (yield item);
+  };
+}
+function skip(s_or_n, n) {
+  return isSource(s_or_n) ? skipGen(n)(s_or_n) : skipGen(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 count() {
+  let count2;
+  return {
+    observe: (value, idx) => {
+      idx === 0 && (count2 = 0), ++count2;
+    },
+    peek: () => count2
+  };
+}
+function _variance() {
+  let count2, mean2, sum;
+  return {
+    observe: (value, idx) => {
+      idx === 0 && (count2 = 0, mean2 = 0, sum = 0);
+      const delta = value - mean2;
+      mean2 += delta / ++count2, sum += delta * (value - mean2);
+    },
+    peek: () => count2 > 1 ? sum / (count2 - 1) : void 0
+  };
+}
+function variance(callbackFn) {
+  return callbackFn ? Accessor(_variance, callbackFn) : _variance();
+}
+function _deviation() {
+  const v = variance();
+  return {
+    observe: (value, idx) => {
+      v.observe(value, idx);
+    },
+    peek: () => {
+      const variance2 = v.peek();
+      return variance2 !== void 0 ? Math.sqrt(variance2) : variance2;
+    }
+  };
+}
+function deviation(callbackFn) {
+  return callbackFn ? Accessor(_deviation, callbackFn) : _deviation();
+}
+function _mean() {
+  let total, count2;
+  return {
+    observe: (value, idx) => {
+      idx === 0 ? total = value : total += value, count2 = idx;
+    },
+    peek: () => total / (count2 + 1)
+  };
+}
+function mean(callbackFn) {
+  return callbackFn ? Accessor(_mean, callbackFn) : _mean();
+}
+function _distribution() {
+  const minFO = min(), maxFO = max(), meanFO = mean(), 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 === void 0) return;
+      const varianceResult = varianceFO.peek();
+      return {
+        min: minResult,
+        max: maxFO.peek(),
+        mean: meanFO.peek(),
+        variance: varianceResult,
+        deviation: varianceResult !== void 0 ? Math.sqrt(varianceResult) : void 0
+      };
+    }
+  };
+}
+function distribution(callbackFn) {
+  return callbackFn ? Accessor(_distribution, callbackFn) : _distribution();
+}
+function _median() {
+  let values;
+  return {
+    observe: (value, idx) => {
+      idx === 0 && (values = []), values.push(value);
+    },
+    peek: () => {
+      const sorted = values.sort((l, r) => l - r), mid = sorted.length / 2;
+      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[Math.floor(mid)];
+    }
+  };
+}
+function median(callbackFn) {
+  return callbackFn ? Accessor(_median, callbackFn) : _median();
+}
+function _quartile() {
+  let values;
+  return {
+    observe: (value, idx) => {
+      idx === 0 && (values = []), values.push(value);
+    },
+    peek: () => {
+      const sorted = values.sort((l, r) => l - r), mid = sorted.length / 2;
+      let medianVal, lower, upper;
+      if (!(sorted.length < 2))
+        return sorted.length % 2 === 0 ? (medianVal = (sorted[mid - 1] + sorted[mid]) / 2, lower = sorted.slice(0, mid), upper = sorted.slice(mid)) : (medianVal = sorted[Math.floor(mid)], lower = sorted.slice(0, Math.floor(mid)), upper = sorted.slice(Math.ceil(mid))), [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) => {
+      idx === 0 ? reduced = initialValue === void 0 ? value : callback(initialValue, value, idx) : reduced = callback(reduced, value, idx);
+    },
+    peek: () => reduced
+  };
+}
+function reduce(callbackFn, initialValue) {
+  return _reduce(callbackFn, initialValue);
+}
+function* generate(generatorFn, maxLen) {
+  let i = -1;
+  for (; maxLen === void 0 || ++i < maxLen; )
+    yield generatorFn();
+}
+const GeneratorFunction = (function* () {
+}).constructor;
+function chainGen(...items) {
+  return items[items.length - 1] instanceof GeneratorFunction ? function* (source) {
+    let tail = source;
+    for (const activity2 of items)
+      tail = activity2(tail);
+    yield* tail;
+  } : function(source) {
+    let tail = source;
+    for (const activity2 of items)
+      tail = activity2(tail);
+    return tail;
+  };
+}
+function pipe(s_or_ia, ...items) {
+  return isSource(s_or_ia) ? chainGen(...items)(s_or_ia) : chainGen(s_or_ia, ...items);
+}
+const chain = pipe;
+export {
+  Accessor,
+  activity,
+  chain,
+  concat,
+  count,
+  deviation,
+  distribution,
+  each,
+  entries,
+  extent,
+  filter,
+  first,
+  generate,
+  group,
+  histogram,
+  isSource,
+  join,
+  map,
+  max,
+  mean,
+  median,
+  min,
+  normalize,
+  pipe,
+  quartile,
+  reduce,
+  scalar,
+  sensor,
+  skip,
+  sort,
+  variance
+};
 //# sourceMappingURL=index.js.map