lakutata 2.0.77 → 2.0.78

package/vendor/Package.16.cjs

@@ -1,3 +1,2249 @@
 "use strict";
 
-require("assert");
+function r(r) {
+    var t;
+    var e;
+    var n = r.length;
+    if (n === 1) {
+        t = 0;
+        e = r[0][1];
+    } else {
+        var a = 0;
+        var o = 0;
+        var i = 0;
+        var u = 0;
+        var f;
+        var v;
+        var h;
+        for (var s = 0; s < n; s++) {
+            f = r[s];
+            v = f[0];
+            h = f[1];
+            a += v;
+            o += h;
+            i += v * v;
+            u += v * h;
+        }
+        t = (n * u - a * o) / (n * i - a * a);
+        e = o / n - t * a / n;
+    }
+    return {
+        m: t,
+        b: e
+    };
+}
+
+function t(r) {
+    return function(t) {
+        return r.b + r.m * t;
+    };
+}
+
+function e(r) {
+    if (r.length === 0) {
+        return 0;
+    }
+    var t = r[0];
+    var e = 0;
+    var n;
+    if (typeof t !== "number") {
+        return Number.NaN;
+    }
+    for (var a = 1; a < r.length; a++) {
+        if (typeof r[a] !== "number") {
+            return Number.NaN;
+        }
+        n = t + r[a];
+        if (Math.abs(t) >= Math.abs(r[a])) {
+            e += t - n + r[a];
+        } else {
+            e += r[a] - n + t;
+        }
+        t = n;
+    }
+    return t + e;
+}
+
+function n(r) {
+    if (r.length === 0) {
+        throw new Error("mean requires at least one data point");
+    }
+    return e(r) / r.length;
+}
+
+function a(r, t) {
+    var e = n(r);
+    var a = 0;
+    var o;
+    var i;
+    if (t === 2) {
+        for (i = 0; i < r.length; i++) {
+            o = r[i] - e;
+            a += o * o;
+        }
+    } else {
+        for (i = 0; i < r.length; i++) {
+            a += Math.pow(r[i] - e, t);
+        }
+    }
+    return a;
+}
+
+function o(r) {
+    if (r.length === 0) {
+        throw new Error("variance requires at least one data point");
+    }
+    return a(r, 2) / r.length;
+}
+
+function i(r) {
+    if (r.length === 1) {
+        return 0;
+    }
+    var t = o(r);
+    return Math.sqrt(t);
+}
+
+function u(r, t) {
+    if (r.length < 2) {
+        return 1;
+    }
+    var e = 0;
+    for (var n = 0; n < r.length; n++) {
+        e += r[n][1];
+    }
+    var a = e / r.length;
+    var o = 0;
+    for (var i = 0; i < r.length; i++) {
+        o += Math.pow(a - r[i][1], 2);
+    }
+    var u = 0;
+    for (var f = 0; f < r.length; f++) {
+        u += Math.pow(r[f][1] - t(r[f][0]), 2);
+    }
+    return 1 - u / o;
+}
+
+function f(r) {
+    if (r.length === 0) {
+        throw new Error("mode requires at least one data point");
+    }
+    if (r.length === 1) {
+        return r[0];
+    }
+    var t = r[0];
+    var e = Number.NaN;
+    var n = 0;
+    var a = 1;
+    for (var o = 1; o < r.length + 1; o++) {
+        if (r[o] !== t) {
+            if (a > n) {
+                n = a;
+                e = t;
+            }
+            a = 1;
+            t = r[o];
+        } else {
+            a++;
+        }
+    }
+    return e;
+}
+
+function v(r) {
+    return r.slice().sort((function(r, t) {
+        return r - t;
+    }));
+}
+
+function h(r) {
+    return f(v(r));
+}
+
+function s(r) {
+    var t = new Map;
+    var e;
+    var n = 0;
+    for (var a = 0; a < r.length; a++) {
+        var o = t.get(r[a]);
+        if (o === undefined) {
+            o = 1;
+        } else {
+            o++;
+        }
+        if (o > n) {
+            e = r[a];
+            n = o;
+        }
+        t.set(r[a], o);
+    }
+    if (n === 0) {
+        throw new Error("mode requires at last one data point");
+    }
+    return e;
+}
+
+function l(r) {
+    if (r.length === 0) {
+        throw new Error("min requires at least one data point");
+    }
+    var t = r[0];
+    for (var e = 1; e < r.length; e++) {
+        if (r[e] < t) {
+            t = r[e];
+        }
+    }
+    return t;
+}
+
+function c(r) {
+    if (r.length === 0) {
+        throw new Error("max requires at least one data point");
+    }
+    var t = r[0];
+    for (var e = 1; e < r.length; e++) {
+        if (r[e] > t) {
+            t = r[e];
+        }
+    }
+    return t;
+}
+
+function p(r) {
+    if (r.length === 0) {
+        throw new Error("extent requires at least one data point");
+    }
+    var t = r[0];
+    var e = r[0];
+    for (var n = 1; n < r.length; n++) {
+        if (r[n] > e) {
+            e = r[n];
+        }
+        if (r[n] < t) {
+            t = r[n];
+        }
+    }
+    return [ t, e ];
+}
+
+function g(r) {
+    return r[0];
+}
+
+function w(r) {
+    return r[r.length - 1];
+}
+
+function M(r) {
+    return [ r[0], r[r.length - 1] ];
+}
+
+function m(r) {
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        if (typeof r[e] !== "number") {
+            return Number.NaN;
+        }
+        t += r[e];
+    }
+    return t;
+}
+
+function d(r) {
+    var t = 1;
+    for (var e = 0; e < r.length; e++) {
+        t *= r[e];
+    }
+    return t;
+}
+
+function b(r, t) {
+    var e = r.length * t;
+    if (r.length === 0) {
+        throw new Error("quantile requires at least one data point.");
+    } else if (t < 0 || t > 1) {
+        throw new Error("quantiles must be between 0 and 1");
+    } else if (t === 1) {
+        return r[r.length - 1];
+    } else if (t === 0) {
+        return r[0];
+    } else if (e % 1 !== 0) {
+        return r[Math.ceil(e) - 1];
+    } else if (r.length % 2 === 0) {
+        return (r[e - 1] + r[e]) / 2;
+    } else {
+        return r[e];
+    }
+}
+
+function x(r, t, e, n) {
+    e = e || 0;
+    n = n || r.length - 1;
+    while (n > e) {
+        if (n - e > 600) {
+            var a = n - e + 1;
+            var o = t - e + 1;
+            var i = Math.log(a);
+            var u = .5 * Math.exp(2 * i / 3);
+            var f = .5 * Math.sqrt(i * u * (a - u) / a);
+            if (o - a / 2 < 0) {
+                f *= -1;
+            }
+            var v = Math.max(e, Math.floor(t - o * u / a + f));
+            var h = Math.min(n, Math.floor(t + (a - o) * u / a + f));
+            x(r, t, v, h);
+        }
+        var s = r[t];
+        var l = e;
+        var c = n;
+        q(r, e, t);
+        if (r[n] > s) {
+            q(r, e, n);
+        }
+        while (l < c) {
+            q(r, l, c);
+            l++;
+            c--;
+            while (r[l] < s) {
+                l++;
+            }
+            while (r[c] > s) {
+                c--;
+            }
+        }
+        if (r[e] === s) {
+            q(r, e, c);
+        } else {
+            c++;
+            q(r, c, n);
+        }
+        if (c <= t) {
+            e = c + 1;
+        }
+        if (t <= c) {
+            n = c - 1;
+        }
+    }
+}
+
+function q(r, t, e) {
+    var n = r[t];
+    r[t] = r[e];
+    r[e] = n;
+}
+
+function E(r, t) {
+    var e = r.slice();
+    if (Array.isArray(t)) {
+        N(e, t);
+        var n = [];
+        for (var a = 0; a < t.length; a++) {
+            n[a] = b(e, t[a]);
+        }
+        return n;
+    } else {
+        var o = k(e.length, t);
+        y(e, o, 0, e.length - 1);
+        return b(e, t);
+    }
+}
+
+function y(r, t, e, n) {
+    if (t % 1 === 0) {
+        x(r, t, e, n);
+    } else {
+        t = Math.floor(t);
+        x(r, t, e, n);
+        x(r, t + 1, t + 1, n);
+    }
+}
+
+function N(r, t) {
+    var e = [ 0 ];
+    for (var n = 0; n < t.length; n++) {
+        e.push(k(r.length, t[n]));
+    }
+    e.push(r.length - 1);
+    e.sort(I);
+    var a = [ 0, e.length - 1 ];
+    while (a.length) {
+        var o = Math.ceil(a.pop());
+        var i = Math.floor(a.pop());
+        if (o - i <= 1) {
+            continue;
+        }
+        var u = Math.floor((i + o) / 2);
+        y(r, e[u], Math.floor(e[i]), Math.ceil(e[o]));
+        a.push(i, u, u, o);
+    }
+}
+
+function I(r, t) {
+    return r - t;
+}
+
+function k(r, t) {
+    var e = r * t;
+    if (t === 1) {
+        return r - 1;
+    } else if (t === 0) {
+        return 0;
+    } else if (e % 1 !== 0) {
+        return Math.ceil(e) - 1;
+    } else if (r % 2 === 0) {
+        return e - .5;
+    } else {
+        return e;
+    }
+}
+
+function A(r, t) {
+    if (t < r[0]) {
+        return 0;
+    }
+    if (t > r[r.length - 1]) {
+        return 1;
+    }
+    var e = P(r, t);
+    if (r[e] !== t) {
+        return e / r.length;
+    }
+    e++;
+    var n = S(r, t);
+    if (n === e) {
+        return e / r.length;
+    }
+    var a = n - e + 1;
+    var o = a * (n + e) / 2;
+    var i = o / a;
+    return i / r.length;
+}
+
+function P(r, t) {
+    var e = 0;
+    var n = 0;
+    var a = r.length;
+    while (n < a) {
+        e = n + a >>> 1;
+        if (t <= r[e]) {
+            a = e;
+        } else {
+            n = -~e;
+        }
+    }
+    return n;
+}
+
+function S(r, t) {
+    var e = 0;
+    var n = 0;
+    var a = r.length;
+    while (n < a) {
+        e = n + a >>> 1;
+        if (t >= r[e]) {
+            n = -~e;
+        } else {
+            a = e;
+        }
+    }
+    return n;
+}
+
+function C(r, t) {
+    var e = v(r);
+    return A(e, t);
+}
+
+function _(r) {
+    var t = E(r, .75);
+    var e = E(r, .25);
+    if (typeof t === "number" && typeof e === "number") {
+        return t - e;
+    }
+}
+
+function T(r) {
+    return +E(r, .5);
+}
+
+function V(r) {
+    var t = T(r);
+    var e = [];
+    for (var n = 0; n < r.length; n++) {
+        e.push(Math.abs(r[n] - t));
+    }
+    return T(e);
+}
+
+function D(r, t) {
+    var e = [];
+    if (t < 1) {
+        throw new Error("chunk size must be a positive number");
+    }
+    if (Math.floor(t) !== t) {
+        throw new Error("chunk size must be an integer");
+    }
+    for (var n = 0; n < r.length; n += t) {
+        e.push(r.slice(n, n + t));
+    }
+    return e;
+}
+
+function L(r, t, e) {
+    if (r.length === 0) {
+        return [];
+    }
+    e = e || Math.random;
+    var n = r.length;
+    var a = [];
+    for (var o = 0; o < t; o++) {
+        var i = Math.floor(e() * n);
+        a.push(r[i]);
+    }
+    return a;
+}
+
+function R(r, t) {
+    t = t || Math.random;
+    var e = r.length;
+    var n;
+    var a;
+    while (e > 0) {
+        a = Math.floor(t() * e--);
+        n = r[e];
+        r[e] = r[a];
+        r[a] = n;
+    }
+    return r;
+}
+
+function U(r, t) {
+    var e = r.slice();
+    return R(e, t);
+}
+
+function z(r, t, e) {
+    var n = U(r, e);
+    return n.slice(0, t);
+}
+
+function F(r, t) {
+    var e = [];
+    for (var n = 0; n < r; n++) {
+        var a = [];
+        for (var o = 0; o < t; o++) {
+            a.push(0);
+        }
+        e.push(a);
+    }
+    return e;
+}
+
+function O(r) {
+    var t = 0;
+    var e;
+    for (var n = 0; n < r.length; n++) {
+        if (n === 0 || r[n] !== e) {
+            e = r[n];
+            t++;
+        }
+    }
+    return t;
+}
+
+function X(r, t, e, n) {
+    var a;
+    if (r > 0) {
+        var o = (e[t] - e[r - 1]) / (t - r + 1);
+        a = n[t] - n[r - 1] - (t - r + 1) * o * o;
+    } else {
+        a = n[t] - e[t] * e[t] / (t + 1);
+    }
+    if (a < 0) {
+        return 0;
+    }
+    return a;
+}
+
+function Y(r, t, e, n, a, o, i) {
+    if (r > t) {
+        return;
+    }
+    var u = Math.floor((r + t) / 2);
+    n[e][u] = n[e - 1][u - 1];
+    a[e][u] = u;
+    var f = e;
+    if (r > e) {
+        f = Math.max(f, a[e][r - 1] || 0);
+    }
+    f = Math.max(f, a[e - 1][u] || 0);
+    var v = u - 1;
+    if (t < n[0].length - 1) {
+        v = Math.min(v, a[e][t + 1] || 0);
+    }
+    var h;
+    var s;
+    var l;
+    var c;
+    for (var p = v; p >= f; --p) {
+        h = X(p, u, o, i);
+        if (h + n[e - 1][f - 1] >= n[e][u]) {
+            break;
+        }
+        s = X(f, u, o, i);
+        l = s + n[e - 1][f - 1];
+        if (l < n[e][u]) {
+            n[e][u] = l;
+            a[e][u] = f;
+        }
+        f++;
+        c = h + n[e - 1][p - 1];
+        if (c < n[e][u]) {
+            n[e][u] = c;
+            a[e][u] = p;
+        }
+    }
+    Y(r, u - 1, e, n, a, o, i);
+    Y(u + 1, t, e, n, a, o, i);
+}
+
+function j(r, t, e) {
+    var n = t[0].length;
+    var a = r[Math.floor(n / 2)];
+    var o = [];
+    var i = [];
+    for (var u = 0, f = void 0; u < n; ++u) {
+        f = r[u] - a;
+        if (u === 0) {
+            o.push(f);
+            i.push(f * f);
+        } else {
+            o.push(o[u - 1] + f);
+            i.push(i[u - 1] + f * f);
+        }
+        t[0][u] = X(0, u, o, i);
+        e[0][u] = 0;
+    }
+    var v;
+    for (var h = 1; h < t.length; ++h) {
+        if (h < t.length - 1) {
+            v = h;
+        } else {
+            v = n - 1;
+        }
+        Y(v, n - 1, h, t, e, o, i);
+    }
+}
+
+function K(r, t) {
+    if (t > r.length) {
+        throw new Error("cannot generate more classes than there are data values");
+    }
+    var e = v(r);
+    var n = O(e);
+    if (n === 1) {
+        return [ e ];
+    }
+    var a = F(t, e.length);
+    var o = F(t, e.length);
+    j(e, a, o);
+    var i = [];
+    var u = o[0].length - 1;
+    for (var f = o.length - 1; f >= 0; f--) {
+        var h = o[f][u];
+        i[f] = e.slice(h, u + 1);
+        if (f > 0) {
+            u = h - 1;
+        }
+    }
+    return i;
+}
+
+function W(r, t, e) {
+    var n = r.length;
+    var a = [];
+    var o = e;
+    a[e] = r[r.length - 1];
+    while (o > 0) {
+        a[o - 1] = r[t[n][o] - 1];
+        n = t[n][o] - 1;
+        o--;
+    }
+    return a;
+}
+
+function B(r, t) {
+    var e = [];
+    var n = [];
+    var a;
+    var o;
+    var i = 0;
+    for (a = 0; a < r.length + 1; a++) {
+        var u = [];
+        var f = [];
+        for (o = 0; o < t + 1; o++) {
+            u.push(0);
+            f.push(0);
+        }
+        e.push(u);
+        n.push(f);
+    }
+    for (a = 1; a < t + 1; a++) {
+        e[1][a] = 1;
+        n[1][a] = 0;
+        for (o = 2; o < r.length + 1; o++) {
+            n[o][a] = Number.POSITIVE_INFINITY;
+        }
+    }
+    for (var v = 2; v < r.length + 1; v++) {
+        var h = 0;
+        var s = 0;
+        var l = 0;
+        var c = 0;
+        for (var p = 1; p < v + 1; p++) {
+            var g = v - p + 1;
+            var w = r[g - 1];
+            l++;
+            h += w;
+            s += w * w;
+            i = s - h * h / l;
+            c = g - 1;
+            if (c !== 0) {
+                for (o = 2; o < t + 1; o++) {
+                    if (n[v][o] >= i + n[c][o - 1]) {
+                        e[v][o] = g;
+                        n[v][o] = i + n[c][o - 1];
+                    }
+                }
+            }
+        }
+        e[v][1] = 1;
+        n[v][1] = i;
+    }
+    return {
+        lowerClassLimits: e,
+        varianceCombinations: n
+    };
+}
+
+function G(r, t) {
+    if (t > r.length) {
+        return null;
+    }
+    r = r.slice().sort((function(r, t) {
+        return r - t;
+    }));
+    var e = B(r, t);
+    var n = e.lowerClassLimits;
+    return W(r, n, t);
+}
+
+function H(r, t) {
+    if (r.length < 2) {
+        return r;
+    }
+    var e = l(r);
+    var n = c(r);
+    var a = [ e ];
+    var o = (n - e) / t;
+    for (var i = 1; i < t; i++) {
+        a.push(a[0] + o * i);
+    }
+    a.push(n);
+    return a;
+}
+
+function J(r, t) {
+    if (r.length !== t.length) {
+        throw new Error("sampleCovariance requires samples with equal lengths");
+    }
+    if (r.length < 2) {
+        throw new Error("sampleCovariance requires at least two data points in each sample");
+    }
+    var e = n(r);
+    var a = n(t);
+    var o = 0;
+    for (var i = 0; i < r.length; i++) {
+        o += (r[i] - e) * (t[i] - a);
+    }
+    var u = r.length - 1;
+    return o / u;
+}
+
+function Q(r) {
+    if (r.length < 2) {
+        throw new Error("sampleVariance requires at least two data points");
+    }
+    var t = a(r, 2);
+    var e = r.length - 1;
+    return t / e;
+}
+
+function Z(r) {
+    var t = Q(r);
+    return Math.sqrt(t);
+}
+
+function $(r, t) {
+    var e = J(r, t);
+    var n = Z(r);
+    var a = Z(t);
+    return e / n / a;
+}
+
+function rr(r, t) {
+    var e = r.map((function(r, t) {
+        return [ r, t ];
+    })).sort((function(r, t) {
+        return r[0] - t[0];
+    })).map((function(r) {
+        return r[1];
+    }));
+    var n = t.map((function(r, t) {
+        return [ r, t ];
+    })).sort((function(r, t) {
+        return r[0] - t[0];
+    })).map((function(r) {
+        return r[1];
+    }));
+    var a = Array(e.length);
+    var o = Array(e.length);
+    for (var i = 0; i < e.length; i++) {
+        a[e[i]] = i;
+        o[n[i]] = i;
+    }
+    return $(a, o);
+}
+
+function tr(r) {
+    if (r.length < 3) {
+        throw new Error("sampleSkewness requires at least three data points");
+    }
+    var t = n(r);
+    var e;
+    var a = 0;
+    var o = 0;
+    for (var i = 0; i < r.length; i++) {
+        e = r[i] - t;
+        a += e * e;
+        o += e * e * e;
+    }
+    var u = r.length - 1;
+    var f = Math.sqrt(a / u);
+    var v = r.length;
+    var h = Math.pow(f, 3);
+    return v * o / ((v - 1) * (v - 2) * h);
+}
+
+function er(r) {
+    var t = r.length;
+    if (t < 4) {
+        throw new Error("sampleKurtosis requires at least four data points");
+    }
+    var e = n(r);
+    var a;
+    var o = 0;
+    var i = 0;
+    for (var u = 0; u < t; u++) {
+        a = r[u] - e;
+        o += a * a;
+        i += a * a * a * a;
+    }
+    return (t - 1) / ((t - 2) * (t - 3)) * (t * (t + 1) * i / (o * o) - 3 * (t - 1));
+}
+
+function nr(r) {
+    var t = new Array(r.length);
+    var e = [ r.slice() ];
+    for (var n = 0; n < r.length; n++) {
+        t[n] = 0;
+    }
+    for (var a = 0; a < r.length; ) {
+        if (t[a] < a) {
+            var o = 0;
+            if (a % 2 !== 0) {
+                o = t[a];
+            }
+            var i = r[o];
+            r[o] = r[a];
+            r[a] = i;
+            e.push(r.slice());
+            t[a]++;
+            a = 0;
+        } else {
+            t[a] = 0;
+            a++;
+        }
+    }
+    return e;
+}
+
+function ar(r, t) {
+    var e;
+    var n;
+    var a = [];
+    var o;
+    var i;
+    for (e = 0; e < r.length; e++) {
+        if (t === 1) {
+            a.push([ r[e] ]);
+        } else {
+            o = ar(r.slice(e + 1, r.length), t - 1);
+            for (n = 0; n < o.length; n++) {
+                i = o[n];
+                i.unshift(r[e]);
+                a.push(i);
+            }
+        }
+    }
+    return a;
+}
+
+function or(r, t) {
+    var e = [];
+    for (var n = 0; n < r.length; n++) {
+        if (t === 1) {
+            e.push([ r[n] ]);
+        } else {
+            var a = or(r.slice(n, r.length), t - 1);
+            for (var o = 0; o < a.length; o++) {
+                e.push([ r[n] ].concat(a[o]));
+            }
+        }
+    }
+    return e;
+}
+
+function ir(r, t, e) {
+    return r + (e - r) / (t + 1);
+}
+
+function ur(r, t, e, n) {
+    return (r * t + e * n) / (t + n);
+}
+
+function fr(r, t, e, n, a, o) {
+    var i = ur(t, e, a, o);
+    return (e * (r + Math.pow(t - i, 2)) + o * (n + Math.pow(a - i, 2))) / (e + o);
+}
+
+function vr(r) {
+    if (r.length === 0) {
+        throw new Error("geometricMean requires at least one data point");
+    }
+    var t = 1;
+    for (var e = 0; e < r.length; e++) {
+        if (r[e] < 0) {
+            throw new Error("geometricMean requires only non-negative numbers as input");
+        }
+        t *= r[e];
+    }
+    return Math.pow(t, 1 / r.length);
+}
+
+function hr(r) {
+    if (r.length === 0) {
+        throw new Error("logAverage requires at least one data point");
+    }
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        if (r[e] < 0) {
+            throw new Error("logAverage requires only non-negative numbers as input");
+        }
+        t += Math.log(r[e]);
+    }
+    return Math.exp(t / r.length);
+}
+
+function sr(r) {
+    if (r.length === 0) {
+        throw new Error("harmonicMean requires at least one data point");
+    }
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        if (r[e] <= 0) {
+            throw new Error("harmonicMean requires only positive numbers as input");
+        }
+        t += 1 / r[e];
+    }
+    return r.length / t;
+}
+
+function lr(r) {
+    if (r.length === 0) {
+        throw new Error("meanSimple requires at least one data point");
+    }
+    return m(r) / r.length;
+}
+
+function cr(r) {
+    return b(r, .5);
+}
+
+function pr(r, t, e) {
+    return (r * t - e) / (t - 1);
+}
+
+function gr(r) {
+    if (r.length === 0) {
+        throw new Error("rootMeanSquare requires at least one data point");
+    }
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        t += Math.pow(r[e], 2);
+    }
+    return Math.sqrt(t / r.length);
+}
+
+function wr(r) {
+    return Z(r) / n(r);
+}
+
+function Mr(r, t) {
+    var e = n(r);
+    var a = i(r);
+    var o = Math.sqrt(r.length);
+    return (e - t) / (a / o);
+}
+
+function mr(r, t, e) {
+    var a = r.length;
+    var o = t.length;
+    if (!a || !o) {
+        return null;
+    }
+    if (!e) {
+        e = 0;
+    }
+    var i = n(r);
+    var u = n(t);
+    var f = Q(r);
+    var v = Q(t);
+    if (typeof i === "number" && typeof u === "number" && typeof f === "number" && typeof v === "number") {
+        var h = ((a - 1) * f + (o - 1) * v) / (a + o - 2);
+        return (i - u - e) / Math.sqrt(h * (1 / a + 1 / o));
+    }
+}
+
+function dr(r, t) {
+    if (!r.length || !t.length) {
+        throw new Error("Neither sample can be empty");
+    }
+    var e = r.map((function(r) {
+        return {
+            label: "x",
+            value: r
+        };
+    })).concat(t.map((function(r) {
+        return {
+            label: "y",
+            value: r
+        };
+    }))).sort((function(r, t) {
+        return r.value - t.value;
+    }));
+    for (var n = 0; n < e.length; n++) {
+        e[n].rank = n;
+    }
+    var a = [ e[0].rank ];
+    for (var o = 1; o < e.length; o++) {
+        if (e[o].value === e[o - 1].value) {
+            a.push(e[o].rank);
+            if (o === e.length - 1) {
+                i(e, a);
+            }
+        } else if (a.length > 1) {
+            i(e, a);
+        } else {
+            a = [ e[o].rank ];
+        }
+    }
+    function i(r, t) {
+        var e = (t[0] + t[t.length - 1]) / 2;
+        for (var n = 0; n < t.length; n++) {
+            r[t[n]].rank = e;
+        }
+    }
+    var u = 0;
+    for (var f = 0; f < e.length; f++) {
+        var v = e[f];
+        if (v.label === "x") {
+            u += v.rank + 1;
+        }
+    }
+    return u;
+}
+
+var br = function r() {
+    this.totalCount = 0;
+    this.data = {};
+};
+
+br.prototype.train = function r(t, e) {
+    if (!this.data[e]) {
+        this.data[e] = {};
+    }
+    for (var n in t) {
+        var a = t[n];
+        if (this.data[e][n] === undefined) {
+            this.data[e][n] = {};
+        }
+        if (this.data[e][n][a] === undefined) {
+            this.data[e][n][a] = 0;
+        }
+        this.data[e][n][a]++;
+    }
+    this.totalCount++;
+};
+
+br.prototype.score = function r(t) {
+    var e = {};
+    var n;
+    for (var a in t) {
+        var o = t[a];
+        for (n in this.data) {
+            e[n] = {};
+            if (this.data[n][a]) {
+                e[n][a + "_" + o] = (this.data[n][a][o] || 0) / this.totalCount;
+            } else {
+                e[n][a + "_" + o] = 0;
+            }
+        }
+    }
+    var i = {};
+    for (n in e) {
+        i[n] = 0;
+        for (var u in e[n]) {
+            i[n] += e[n][u];
+        }
+    }
+    return i;
+};
+
+var xr = function r() {
+    this.weights = [];
+    this.bias = 0;
+};
+
+xr.prototype.predict = function r(t) {
+    if (t.length !== this.weights.length) {
+        return null;
+    }
+    var e = 0;
+    for (var n = 0; n < this.weights.length; n++) {
+        e += this.weights[n] * t[n];
+    }
+    e += this.bias;
+    if (e > 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+};
+
+xr.prototype.train = function r(t, e) {
+    if (e !== 0 && e !== 1) {
+        return null;
+    }
+    if (t.length !== this.weights.length) {
+        this.weights = t;
+        this.bias = 1;
+    }
+    var n = this.predict(t);
+    if (typeof n === "number" && n !== e) {
+        var a = e - n;
+        for (var o = 0; o < this.weights.length; o++) {
+            this.weights[o] += a * t[o];
+        }
+        this.bias += a;
+    }
+    return this;
+};
+
+var qr = 1e-4;
+
+function Er(r) {
+    if (r < 0) {
+        throw new Error("factorial requires a non-negative value");
+    }
+    if (Math.floor(r) !== r) {
+        throw new Error("factorial requires an integer input");
+    }
+    var t = 1;
+    for (var e = 2; e <= r; e++) {
+        t *= e;
+    }
+    return t;
+}
+
+function yr(r) {
+    if (Number.isInteger(r)) {
+        if (r <= 0) {
+            return Number.NaN;
+        } else {
+            return Er(r - 1);
+        }
+    }
+    r--;
+    if (r < 0) {
+        return Math.PI / (Math.sin(Math.PI * -r) * yr(-r));
+    } else {
+        var t = Math.pow(r / Math.E, r) * Math.sqrt(2 * Math.PI * (r + 1 / 6));
+        var e = r + 1 / 4;
+        var n = 1 + 1 / 144 / Math.pow(e, 2) - 1 / 12960 / Math.pow(e, 3) - 257 / 207360 / Math.pow(e, 4) - 52 / 2612736 / Math.pow(e, 5) + 5741173 / 9405849600 / Math.pow(e, 6) + 37529 / 18811699200 / Math.pow(e, 7);
+        return t * n;
+    }
+}
+
+var Nr = [ .9999999999999971, 57.15623566586292, -59.59796035547549, 14.136097974741746, -.4919138160976202, 3399464998481189e-20, 4652362892704858e-20, -9837447530487956e-20, .0001580887032249125, -.00021026444172410488, .00021743961811521265, -.0001643181065367639, 8441822398385275e-20, -26190838401581408e-21, 36899182659531625e-22 ];
+
+var Ir = 607 / 128;
+
+var kr = Math.log(Math.sqrt(2 * Math.PI));
+
+function Ar(r) {
+    if (r <= 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    r--;
+    var t = Nr[0];
+    for (var e = 1; e < 15; e++) {
+        t += Nr[e] / (r + e);
+    }
+    var n = Ir + .5 + r;
+    return kr + Math.log(t) - n + (r + .5) * Math.log(n);
+}
+
+function Pr(r) {
+    if (r < 0 || r > 1) {
+        throw new Error("bernoulliDistribution requires probability to be between 0 and 1 inclusive");
+    }
+    return [ 1 - r, r ];
+}
+
+function Sr(r, t) {
+    if (t < 0 || t > 1 || r <= 0 || r % 1 !== 0) {
+        return undefined;
+    }
+    var e = 0;
+    var n = 0;
+    var a = [];
+    var o = 1;
+    do {
+        a[e] = o * Math.pow(t, e) * Math.pow(1 - t, r - e);
+        n += a[e];
+        e++;
+        o = o * (r - e + 1) / e;
+    } while (n < 1 - qr);
+    return a;
+}
+
+function Cr(r) {
+    if (r <= 0) {
+        return undefined;
+    }
+    var t = 0;
+    var e = 0;
+    var n = [];
+    var a = 1;
+    do {
+        n[t] = Math.exp(-r) * Math.pow(r, t) / a;
+        e += n[t];
+        t++;
+        a *= t;
+    } while (e < 1 - qr);
+    return n;
+}
+
+var _r = {
+    1: {
+        .995: 0,
+        .99: 0,
+        .975: 0,
+        .95: 0,
+        .9: .02,
+        .5: .45,
+        .1: 2.71,
+        .05: 3.84,
+        .025: 5.02,
+        .01: 6.63,
+        .005: 7.88
+    },
+    2: {
+        .995: .01,
+        .99: .02,
+        .975: .05,
+        .95: .1,
+        .9: .21,
+        .5: 1.39,
+        .1: 4.61,
+        .05: 5.99,
+        .025: 7.38,
+        .01: 9.21,
+        .005: 10.6
+    },
+    3: {
+        .995: .07,
+        .99: .11,
+        .975: .22,
+        .95: .35,
+        .9: .58,
+        .5: 2.37,
+        .1: 6.25,
+        .05: 7.81,
+        .025: 9.35,
+        .01: 11.34,
+        .005: 12.84
+    },
+    4: {
+        .995: .21,
+        .99: .3,
+        .975: .48,
+        .95: .71,
+        .9: 1.06,
+        .5: 3.36,
+        .1: 7.78,
+        .05: 9.49,
+        .025: 11.14,
+        .01: 13.28,
+        .005: 14.86
+    },
+    5: {
+        .995: .41,
+        .99: .55,
+        .975: .83,
+        .95: 1.15,
+        .9: 1.61,
+        .5: 4.35,
+        .1: 9.24,
+        .05: 11.07,
+        .025: 12.83,
+        .01: 15.09,
+        .005: 16.75
+    },
+    6: {
+        .995: .68,
+        .99: .87,
+        .975: 1.24,
+        .95: 1.64,
+        .9: 2.2,
+        .5: 5.35,
+        .1: 10.65,
+        .05: 12.59,
+        .025: 14.45,
+        .01: 16.81,
+        .005: 18.55
+    },
+    7: {
+        .995: .99,
+        .99: 1.25,
+        .975: 1.69,
+        .95: 2.17,
+        .9: 2.83,
+        .5: 6.35,
+        .1: 12.02,
+        .05: 14.07,
+        .025: 16.01,
+        .01: 18.48,
+        .005: 20.28
+    },
+    8: {
+        .995: 1.34,
+        .99: 1.65,
+        .975: 2.18,
+        .95: 2.73,
+        .9: 3.49,
+        .5: 7.34,
+        .1: 13.36,
+        .05: 15.51,
+        .025: 17.53,
+        .01: 20.09,
+        .005: 21.96
+    },
+    9: {
+        .995: 1.73,
+        .99: 2.09,
+        .975: 2.7,
+        .95: 3.33,
+        .9: 4.17,
+        .5: 8.34,
+        .1: 14.68,
+        .05: 16.92,
+        .025: 19.02,
+        .01: 21.67,
+        .005: 23.59
+    },
+    10: {
+        .995: 2.16,
+        .99: 2.56,
+        .975: 3.25,
+        .95: 3.94,
+        .9: 4.87,
+        .5: 9.34,
+        .1: 15.99,
+        .05: 18.31,
+        .025: 20.48,
+        .01: 23.21,
+        .005: 25.19
+    },
+    11: {
+        .995: 2.6,
+        .99: 3.05,
+        .975: 3.82,
+        .95: 4.57,
+        .9: 5.58,
+        .5: 10.34,
+        .1: 17.28,
+        .05: 19.68,
+        .025: 21.92,
+        .01: 24.72,
+        .005: 26.76
+    },
+    12: {
+        .995: 3.07,
+        .99: 3.57,
+        .975: 4.4,
+        .95: 5.23,
+        .9: 6.3,
+        .5: 11.34,
+        .1: 18.55,
+        .05: 21.03,
+        .025: 23.34,
+        .01: 26.22,
+        .005: 28.3
+    },
+    13: {
+        .995: 3.57,
+        .99: 4.11,
+        .975: 5.01,
+        .95: 5.89,
+        .9: 7.04,
+        .5: 12.34,
+        .1: 19.81,
+        .05: 22.36,
+        .025: 24.74,
+        .01: 27.69,
+        .005: 29.82
+    },
+    14: {
+        .995: 4.07,
+        .99: 4.66,
+        .975: 5.63,
+        .95: 6.57,
+        .9: 7.79,
+        .5: 13.34,
+        .1: 21.06,
+        .05: 23.68,
+        .025: 26.12,
+        .01: 29.14,
+        .005: 31.32
+    },
+    15: {
+        .995: 4.6,
+        .99: 5.23,
+        .975: 6.27,
+        .95: 7.26,
+        .9: 8.55,
+        .5: 14.34,
+        .1: 22.31,
+        .05: 25,
+        .025: 27.49,
+        .01: 30.58,
+        .005: 32.8
+    },
+    16: {
+        .995: 5.14,
+        .99: 5.81,
+        .975: 6.91,
+        .95: 7.96,
+        .9: 9.31,
+        .5: 15.34,
+        .1: 23.54,
+        .05: 26.3,
+        .025: 28.85,
+        .01: 32,
+        .005: 34.27
+    },
+    17: {
+        .995: 5.7,
+        .99: 6.41,
+        .975: 7.56,
+        .95: 8.67,
+        .9: 10.09,
+        .5: 16.34,
+        .1: 24.77,
+        .05: 27.59,
+        .025: 30.19,
+        .01: 33.41,
+        .005: 35.72
+    },
+    18: {
+        .995: 6.26,
+        .99: 7.01,
+        .975: 8.23,
+        .95: 9.39,
+        .9: 10.87,
+        .5: 17.34,
+        .1: 25.99,
+        .05: 28.87,
+        .025: 31.53,
+        .01: 34.81,
+        .005: 37.16
+    },
+    19: {
+        .995: 6.84,
+        .99: 7.63,
+        .975: 8.91,
+        .95: 10.12,
+        .9: 11.65,
+        .5: 18.34,
+        .1: 27.2,
+        .05: 30.14,
+        .025: 32.85,
+        .01: 36.19,
+        .005: 38.58
+    },
+    20: {
+        .995: 7.43,
+        .99: 8.26,
+        .975: 9.59,
+        .95: 10.85,
+        .9: 12.44,
+        .5: 19.34,
+        .1: 28.41,
+        .05: 31.41,
+        .025: 34.17,
+        .01: 37.57,
+        .005: 40
+    },
+    21: {
+        .995: 8.03,
+        .99: 8.9,
+        .975: 10.28,
+        .95: 11.59,
+        .9: 13.24,
+        .5: 20.34,
+        .1: 29.62,
+        .05: 32.67,
+        .025: 35.48,
+        .01: 38.93,
+        .005: 41.4
+    },
+    22: {
+        .995: 8.64,
+        .99: 9.54,
+        .975: 10.98,
+        .95: 12.34,
+        .9: 14.04,
+        .5: 21.34,
+        .1: 30.81,
+        .05: 33.92,
+        .025: 36.78,
+        .01: 40.29,
+        .005: 42.8
+    },
+    23: {
+        .995: 9.26,
+        .99: 10.2,
+        .975: 11.69,
+        .95: 13.09,
+        .9: 14.85,
+        .5: 22.34,
+        .1: 32.01,
+        .05: 35.17,
+        .025: 38.08,
+        .01: 41.64,
+        .005: 44.18
+    },
+    24: {
+        .995: 9.89,
+        .99: 10.86,
+        .975: 12.4,
+        .95: 13.85,
+        .9: 15.66,
+        .5: 23.34,
+        .1: 33.2,
+        .05: 36.42,
+        .025: 39.36,
+        .01: 42.98,
+        .005: 45.56
+    },
+    25: {
+        .995: 10.52,
+        .99: 11.52,
+        .975: 13.12,
+        .95: 14.61,
+        .9: 16.47,
+        .5: 24.34,
+        .1: 34.28,
+        .05: 37.65,
+        .025: 40.65,
+        .01: 44.31,
+        .005: 46.93
+    },
+    26: {
+        .995: 11.16,
+        .99: 12.2,
+        .975: 13.84,
+        .95: 15.38,
+        .9: 17.29,
+        .5: 25.34,
+        .1: 35.56,
+        .05: 38.89,
+        .025: 41.92,
+        .01: 45.64,
+        .005: 48.29
+    },
+    27: {
+        .995: 11.81,
+        .99: 12.88,
+        .975: 14.57,
+        .95: 16.15,
+        .9: 18.11,
+        .5: 26.34,
+        .1: 36.74,
+        .05: 40.11,
+        .025: 43.19,
+        .01: 46.96,
+        .005: 49.65
+    },
+    28: {
+        .995: 12.46,
+        .99: 13.57,
+        .975: 15.31,
+        .95: 16.93,
+        .9: 18.94,
+        .5: 27.34,
+        .1: 37.92,
+        .05: 41.34,
+        .025: 44.46,
+        .01: 48.28,
+        .005: 50.99
+    },
+    29: {
+        .995: 13.12,
+        .99: 14.26,
+        .975: 16.05,
+        .95: 17.71,
+        .9: 19.77,
+        .5: 28.34,
+        .1: 39.09,
+        .05: 42.56,
+        .025: 45.72,
+        .01: 49.59,
+        .005: 52.34
+    },
+    30: {
+        .995: 13.79,
+        .99: 14.95,
+        .975: 16.79,
+        .95: 18.49,
+        .9: 20.6,
+        .5: 29.34,
+        .1: 40.26,
+        .05: 43.77,
+        .025: 46.98,
+        .01: 50.89,
+        .005: 53.67
+    },
+    40: {
+        .995: 20.71,
+        .99: 22.16,
+        .975: 24.43,
+        .95: 26.51,
+        .9: 29.05,
+        .5: 39.34,
+        .1: 51.81,
+        .05: 55.76,
+        .025: 59.34,
+        .01: 63.69,
+        .005: 66.77
+    },
+    50: {
+        .995: 27.99,
+        .99: 29.71,
+        .975: 32.36,
+        .95: 34.76,
+        .9: 37.69,
+        .5: 49.33,
+        .1: 63.17,
+        .05: 67.5,
+        .025: 71.42,
+        .01: 76.15,
+        .005: 79.49
+    },
+    60: {
+        .995: 35.53,
+        .99: 37.48,
+        .975: 40.48,
+        .95: 43.19,
+        .9: 46.46,
+        .5: 59.33,
+        .1: 74.4,
+        .05: 79.08,
+        .025: 83.3,
+        .01: 88.38,
+        .005: 91.95
+    },
+    70: {
+        .995: 43.28,
+        .99: 45.44,
+        .975: 48.76,
+        .95: 51.74,
+        .9: 55.33,
+        .5: 69.33,
+        .1: 85.53,
+        .05: 90.53,
+        .025: 95.02,
+        .01: 100.42,
+        .005: 104.22
+    },
+    80: {
+        .995: 51.17,
+        .99: 53.54,
+        .975: 57.15,
+        .95: 60.39,
+        .9: 64.28,
+        .5: 79.33,
+        .1: 96.58,
+        .05: 101.88,
+        .025: 106.63,
+        .01: 112.33,
+        .005: 116.32
+    },
+    90: {
+        .995: 59.2,
+        .99: 61.75,
+        .975: 65.65,
+        .95: 69.13,
+        .9: 73.29,
+        .5: 89.33,
+        .1: 107.57,
+        .05: 113.14,
+        .025: 118.14,
+        .01: 124.12,
+        .005: 128.3
+    },
+    100: {
+        .995: 67.33,
+        .99: 70.06,
+        .975: 74.22,
+        .95: 77.93,
+        .9: 82.36,
+        .5: 99.33,
+        .1: 118.5,
+        .05: 124.34,
+        .025: 129.56,
+        .01: 135.81,
+        .005: 140.17
+    }
+};
+
+function Tr(r, t, e) {
+    var a = n(r);
+    var o = 0;
+    var i = 1;
+    var u = t(a);
+    var f = [];
+    var v = [];
+    for (var h = 0; h < r.length; h++) {
+        if (f[r[h]] === undefined) {
+            f[r[h]] = 0;
+        }
+        f[r[h]]++;
+    }
+    for (var s = 0; s < f.length; s++) {
+        if (f[s] === undefined) {
+            f[s] = 0;
+        }
+    }
+    for (var l in u) {
+        if (l in f) {
+            v[+l] = u[l] * r.length;
+        }
+    }
+    for (var c = v.length - 1; c >= 0; c--) {
+        if (v[c] < 3) {
+            v[c - 1] += v[c];
+            v.pop();
+            f[c - 1] += f[c];
+            f.pop();
+        }
+    }
+    for (var p = 0; p < f.length; p++) {
+        o += Math.pow(f[p] - v[p], 2) / v[p];
+    }
+    var g = f.length - i - 1;
+    return _r[g][e] < o;
+}
+
+var Vr = Math.sqrt(2 * Math.PI);
+
+var Dr = {
+    gaussian: function(r) {
+        return Math.exp(-.5 * r * r) / Vr;
+    }
+};
+
+var Lr = {
+    nrd: function(r) {
+        var t = Z(r);
+        var e = _(r);
+        if (typeof e === "number") {
+            t = Math.min(t, e / 1.34);
+        }
+        return 1.06 * t * Math.pow(r.length, -.2);
+    }
+};
+
+function Rr(r, t, e) {
+    var n;
+    if (t === undefined) {
+        n = Dr.gaussian;
+    } else if (typeof t === "string") {
+        if (!Dr[t]) {
+            throw new Error('Unknown kernel "' + t + '"');
+        }
+        n = Dr[t];
+    } else {
+        n = t;
+    }
+    var a;
+    if (typeof e === "undefined") {
+        a = Lr.nrd(r);
+    } else if (typeof e === "string") {
+        if (!Lr[e]) {
+            throw new Error('Unknown bandwidth method "' + e + '"');
+        }
+        a = Lr[e](r);
+    } else {
+        a = e;
+    }
+    return function(t) {
+        var e = 0;
+        var o = 0;
+        for (e = 0; e < r.length; e++) {
+            o += n((t - r[e]) / a);
+        }
+        return o / a / r.length;
+    };
+}
+
+function Ur(r, t, e) {
+    return (r - t) / e;
+}
+
+var zr = Math.sqrt(2 * Math.PI);
+
+function Fr(r) {
+    var t = r;
+    var e = r;
+    for (var n = 1; n < 15; n++) {
+        e *= r * r / (2 * n + 1);
+        t += e;
+    }
+    return Math.round((.5 + t / zr * Math.exp(-r * r / 2)) * 1e4) / 1e4;
+}
+
+var Or = [];
+
+for (var Xr = 0; Xr <= 3.09; Xr += .01) {
+    Or.push(Fr(Xr));
+}
+
+function Yr(r) {
+    var t = Math.abs(r);
+    var e = Math.min(Math.round(t * 100), Or.length - 1);
+    if (r >= 0) {
+        return Or[e];
+    } else {
+        return Math.round((1 - Or[e]) * 1e4) / 1e4;
+    }
+}
+
+function jr(r) {
+    return 1 / (Math.exp(-r) + 1);
+}
+
+function Kr(r) {
+    var t = 1 / (1 + .5 * Math.abs(r));
+    var e = t * Math.exp(-r * r + ((((((((.17087277 * t - .82215223) * t + 1.48851587) * t - 1.13520398) * t + .27886807) * t - .18628806) * t + .09678418) * t + .37409196) * t + 1.00002368) * t - 1.26551223);
+    if (r >= 0) {
+        return 1 - e;
+    } else {
+        return e - 1;
+    }
+}
+
+function Wr(r) {
+    var t = 8 * (Math.PI - 3) / (3 * Math.PI * (4 - Math.PI));
+    var e = Math.sqrt(Math.sqrt(Math.pow(2 / (Math.PI * t) + Math.log(1 - r * r) / 2, 2) - Math.log(1 - r * r) / t) - (2 / (Math.PI * t) + Math.log(1 - r * r) / 2));
+    if (r >= 0) {
+        return e;
+    } else {
+        return -e;
+    }
+}
+
+function Br(r) {
+    if (r === 0) {
+        r = qr;
+    } else if (r >= 1) {
+        r = 1 - qr;
+    }
+    return Math.sqrt(2) * Wr(2 * r - 1);
+}
+
+function Gr(r) {
+    if (r <= 0 || r >= 1) {
+        throw new Error("p must be strictly between zero and one");
+    }
+    return Math.log(r / (1 - r));
+}
+
+function Hr(r, t, e, a, o) {
+    if (a === undefined) {
+        a = 1e4;
+    }
+    if (e === undefined) {
+        e = "two_side";
+    }
+    if (e !== "two_side" && e !== "greater" && e !== "less") {
+        throw new Error("`alternative` must be either 'two_side', 'greater', or 'less'.");
+    }
+    var i = n(r);
+    var u = n(t);
+    var f = i - u;
+    var v = new Array(a);
+    var h = r.concat(t);
+    var s = Math.floor(h.length / 2);
+    for (var l = 0; l < a; l++) {
+        R(h, o);
+        var c = h.slice(0, s);
+        var p = h.slice(s, h.length);
+        var g = n(c) - n(p);
+        v[l] = g;
+    }
+    var w = 0;
+    if (e === "two_side") {
+        for (var M = 0; M <= a; M++) {
+            if (Math.abs(v[M]) >= Math.abs(f)) {
+                w += 1;
+            }
+        }
+    } else if (e === "greater") {
+        for (var m = 0; m <= a; m++) {
+            if (v[m] >= f) {
+                w += 1;
+            }
+        }
+    } else {
+        for (var d = 0; d <= a; d++) {
+            if (v[d] <= f) {
+                w += 1;
+            }
+        }
+    }
+    return w / a;
+}
+
+function Jr(r) {
+    if (typeof r === "number") {
+        if (r < 0) {
+            return -1;
+        } else if (r === 0) {
+            return 0;
+        } else {
+            return 1;
+        }
+    } else {
+        throw new TypeError("not a number");
+    }
+}
+
+function Qr(r, t, e, n, a) {
+    if (typeof r !== "function") {
+        throw new TypeError("func must be a function");
+    }
+    for (var o = 0; o < n; o++) {
+        var i = (t + e) / 2;
+        if (r(i) === 0 || Math.abs((e - t) / 2) < a) {
+            return i;
+        }
+        if (Jr(r(i)) === Jr(r(t))) {
+            t = i;
+        } else {
+            e = i;
+        }
+    }
+    throw new Error("maximum number of iterations exceeded");
+}
+
+function Zr(r, t) {
+    var e = 0;
+    for (var n = 0; n < r.length; n++) {
+        var a = r[n] - t[n];
+        e += a * a;
+    }
+    return Math.sqrt(e);
+}
+
+function $r(r, t, e) {
+    if (e === void 0) e = Math.random;
+    var n = null;
+    var a = z(r, t, e);
+    var o = null;
+    var i = Number.MAX_VALUE;
+    while (i !== 0) {
+        o = rt(r, a);
+        n = a;
+        a = tt(r, o, t);
+        i = et(a, n);
+    }
+    return {
+        labels: o,
+        centroids: a
+    };
+}
+
+function rt(r, t) {
+    return r.map((function(r) {
+        var e = Number.MAX_VALUE;
+        var n = -1;
+        for (var a = 0; a < t.length; a++) {
+            var o = Zr(r, t[a]);
+            if (o < e) {
+                e = o;
+                n = a;
+            }
+        }
+        return n;
+    }));
+}
+
+function tt(r, t, e) {
+    var n = r[0].length;
+    var a = F(e, n);
+    var o = Array(e).fill(0);
+    var i = r.length;
+    for (var u = 0; u < i; u++) {
+        var f = r[u];
+        var v = t[u];
+        var h = a[v];
+        for (var s = 0; s < n; s++) {
+            h[s] += f[s];
+        }
+        o[v] += 1;
+    }
+    for (var l = 0; l < e; l++) {
+        if (o[l] === 0) {
+            throw new Error("Centroid " + l + " has no friends");
+        }
+        var c = a[l];
+        for (var p = 0; p < n; p++) {
+            c[p] /= o[l];
+        }
+    }
+    return a;
+}
+
+function et(r, t) {
+    var e = 0;
+    for (var n = 0; n < r.length; n++) {
+        e += Zr(r[n], t[n]);
+    }
+    return e;
+}
+
+function nt(r, t) {
+    if (r.length !== t.length) {
+        throw new Error("must have exactly as many labels as points");
+    }
+    var e = at(t);
+    var n = ot(r);
+    var a = [];
+    for (var o = 0; o < r.length; o++) {
+        var i = 0;
+        if (e[t[o]].length > 1) {
+            var u = ut(o, e[t[o]], n);
+            var f = it(o, t, e, n);
+            i = (f - u) / Math.max(u, f);
+        }
+        a.push(i);
+    }
+    return a;
+}
+
+function at(r) {
+    var t = 1 + c(r);
+    var e = Array(t);
+    for (var n = 0; n < r.length; n++) {
+        var a = r[n];
+        if (e[a] === undefined) {
+            e[a] = [];
+        }
+        e[a].push(n);
+    }
+    return e;
+}
+
+function ot(r) {
+    var t = r.length;
+    var e = F(t, t);
+    for (var n = 0; n < t; n++) {
+        for (var a = 0; a < n; a++) {
+            e[n][a] = Zr(r[n], r[a]);
+            e[a][n] = e[n][a];
+        }
+    }
+    return e;
+}
+
+function it(r, t, e, n) {
+    var a = t[r];
+    var o = Number.MAX_VALUE;
+    for (var i = 0; i < e.length; i++) {
+        if (i !== a) {
+            var u = ut(r, e[i], n);
+            if (u < o) {
+                o = u;
+            }
+        }
+    }
+    return o;
+}
+
+function ut(r, t, e) {
+    var n = 0;
+    for (var a = 0; a < t.length; a++) {
+        n += e[r][t[a]];
+    }
+    return n / t.length;
+}
+
+function ft(r, t) {
+    var e = nt(r, t);
+    return c(e);
+}
+
+function vt(r, t) {
+    if (r === 0 && t === 0) {
+        return 0;
+    }
+    return Math.abs((r - t) / t);
+}
+
+function ht(r, t, e) {
+    if (e === void 0) e = qr;
+    return vt(r, t) <= e;
+}
+
+exports.addToMean = ir;
+
+exports.approxEqual = ht;
+
+exports.bernoulliDistribution = Pr;
+
+exports.binomialDistribution = Sr;
+
+exports.bisect = Qr;
+
+exports.chunk = D;
+
+exports.coefficientOfVariation = wr;
+
+exports.combinations = ar;
+
+exports.combinationsReplacement = or;
+
+exports.combineMeans = ur;
+
+exports.combineVariances = fr;
+
+exports.cumulativeStdLogisticProbability = jr;
+
+exports.epsilon = qr;
+
+exports.extent = p;
+
+exports.factorial = Er;
+
+exports.gamma = yr;
+
+exports.gammaln = Ar;
+
+exports.geometricMean = vr;
+
+exports.harmonicMean = sr;
+
+exports.interquartileRange = _;
+
+exports.jenks = G;
+
+exports.linearRegression = r;
+
+exports.linearRegressionLine = t;
+
+exports.logAverage = hr;
+
+exports.logit = Gr;
+
+exports.max = c;
+
+exports.mean = n;
+
+exports.median = T;
+
+exports.medianAbsoluteDeviation = V;
+
+exports.min = l;
+
+exports.mode = h;
+
+exports.poissonDistribution = Cr;
+
+exports.probit = Br;
+
+exports.product = d;
+
+exports.quantile = E;
+
+exports.quantileRank = C;
+
+exports.quickselect = x;
+
+exports.rSquared = u;
+
+exports.rootMeanSquare = gr;
+
+exports.sample = z;
+
+exports.sampleCorrelation = $;
+
+exports.sampleCovariance = J;
+
+exports.sampleSkewness = tr;
+
+exports.sampleStandardDeviation = Z;
+
+exports.sampleVariance = Q;
+
+exports.sampleWithReplacement = L;
+
+exports.shuffle = U;
+
+exports.standardDeviation = i;
+
+exports.subtractFromMean = pr;
+
+exports.sum = e;
+
+exports.sumNthPowerDeviations = a;
+
+exports.tTest = Mr;
+
+exports.tTestTwoSample = mr;
+
+exports.variance = o;
+
+exports.zScore = Ur;