lakutata 2.0.98 → 2.0.100

package/vendor/Package.internal.522.mjs

@@ -1,1033 +1,192 @@
-/* Build Date: Wed Nov 26 2025 13:02:50 GMT+0800 (China Standard Time) */
-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 i = 0;
-        var o = 0;
-        var u = 0;
-        var h;
-        var f;
-        var s;
-        for (var v = 0; v < n; v++) {
-            h = r[v];
-            f = h[0];
-            s = h[1];
-            a += f;
-            i += s;
-            o += f * f;
-            u += f * s;
-        }
-        t = (n * u - a * i) / (n * o - a * a);
-        e = i / 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;
+/* Build Date: Wed Nov 26 2025 14:26:45 GMT+0800 (China Standard Time) */
+function e(e) {
+    return typeof e === "object" && e !== null;
 }
 
-function n(r) {
-    if (r.length === 0) {
-        throw new Error("mean requires at least one data point");
-    }
-    return e(r) / r.length;
+function n(n) {
+    return e(n) && typeof n.length === "number";
 }
 
-function a(r, t) {
-    var e = n(r);
-    var a = 0;
-    var i;
-    var o;
-    if (t === 2) {
-        for (o = 0; o < r.length; o++) {
-            i = r[o] - e;
-            a += i * i;
-        }
+function i(e) {
+    if (Array.isArray(e)) {
+        return e;
+    } else if (e === undefined) {
+        return [];
+    } else if (n(e) || e instanceof Set) {
+        return Array.from(e);
     } else {
-        for (o = 0; o < r.length; o++) {
-            a += Math.pow(r[o] - e, t);
-        }
+        return [ e ];
     }
-    return a;
 }
 
-function i(r) {
-    if (r.length === 0) {
-        throw new Error("variance requires at least one data point");
-    }
-    return a(r, 2) / r.length;
+function t(e) {
+    return !isNaN(parseFloat(e));
 }
 
-function o(r) {
-    if (r.length === 1) {
-        return 0;
-    }
-    var t = i(r);
-    return Math.sqrt(t);
+function s(e) {
+    return !isNaN(parseFloat(e)) && isFinite(e);
 }
 
-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 i = 0;
-    for (var o = 0; o < r.length; o++) {
-        i += Math.pow(a - r[o][1], 2);
-    }
-    var u = 0;
-    for (var h = 0; h < r.length; h++) {
-        u += Math.pow(r[h][1] - t(r[h][0]), 2);
-    }
-    return 1 - u / i;
-}
-
-function h(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 i = 1; i < r.length + 1; i++) {
-        if (r[i] !== t) {
-            if (a > n) {
-                n = a;
-                e = t;
-            }
-            a = 1;
-            t = r[i];
-        } else {
-            a++;
-        }
-    }
-    return e;
+function r(e) {
+    return e !== null && typeof e === "object" && e.constructor === Object;
 }
 
-function f(r) {
-    return r.slice().sort(function(r, t) {
-        return r - t;
-    });
+function u(e) {
+    return f(e) && typeof e.length === "number";
 }
 
-function s(r) {
-    return h(f(r));
+function f(e) {
+    return typeof e === "object" && e !== null;
 }
 
-function v(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 o(e) {
+    return typeof e !== "undefined";
 }
 
-function l(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 c(e) {
+    return !o(e);
 }
 
-function g(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 l(e) {
+    return e === null;
 }
 
-function c(r) {
-    var t = 1;
-    for (var e = 0; e < r.length; e++) {
-        t *= r[e];
-    }
-    return t;
+function a(e) {
+    return o(e) && !l(e) && !Number.isNaN(e);
 }
 
-function w(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;
+function d(e) {
+    if (typeof e === "function") {
+        return /^class /.test(Function.prototype.toString.call(e));
     } else {
-        return r[e];
+        return false;
     }
 }
 
-function p(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 i = t - e + 1;
-            var o = Math.log(a);
-            var u = .5 * Math.exp(2 * o / 3);
-            var h = .5 * Math.sqrt(o * u * (a - u) / a);
-            if (i - a / 2 < 0) {
-                h *= -1;
-            }
-            var f = Math.max(e, Math.floor(t - i * u / a + h));
-            var s = Math.min(n, Math.floor(t + (a - i) * u / a + h));
-            p(r, t, f, s);
-        }
-        var v = r[t];
-        var l = e;
-        var g = n;
-        M(r, e, t);
-        if (r[n] > v) {
-            M(r, e, n);
-        }
-        while (l < g) {
-            M(r, l, g);
-            l++;
-            g--;
-            while (r[l] < v) {
-                l++;
-            }
-            while (r[g] > v) {
-                g--;
-            }
-        }
-        if (r[e] === v) {
-            M(r, e, g);
-        } else {
-            g++;
-            M(r, g, n);
-        }
-        if (g <= t) {
-            e = g + 1;
-        }
-        if (t <= g) {
-            n = g - 1;
-        }
-    }
-}
+function y(e) {
+    if (e === null) return true;
+    switch (typeof e) {
+      case "string":
+      case "number":
+      case "symbol":
+      case "undefined":
+      case "boolean":
+        return true;
 
-function M(r, t, e) {
-    var n = r[t];
-    r[t] = r[e];
-    r[e] = n;
-}
-
-function m(r, t) {
-    var e = r.slice();
-    if (Array.isArray(t)) {
-        d(e, t);
-        var n = [];
-        for (var a = 0; a < t.length; a++) {
-            n[a] = w(e, t[a]);
-        }
-        return n;
-    } else {
-        var i = E(e.length, t);
-        b(e, i, 0, e.length - 1);
-        return w(e, t);
+      default:
+        return false;
     }
 }
 
-function b(r, t, e, n) {
-    if (t % 1 === 0) {
-        p(r, t, e, n);
+function b(e) {
+    if (e) {
+        const n = o(Promise) && e instanceof Promise;
+        const i = e.then && typeof e.then === "function";
+        return !!(n || i);
     } else {
-        t = Math.floor(t);
-        p(r, t, e, n);
-        p(r, t + 1, t + 1, n);
+        return false;
     }
 }
 
-function d(r, t) {
-    var e = [ 0 ];
-    for (var n = 0; n < t.length; n++) {
-        e.push(E(r.length, t[n]));
-    }
-    e.push(r.length - 1);
-    e.sort(q);
-    var a = [ 0, e.length - 1 ];
-    while (a.length) {
-        var i = Math.ceil(a.pop());
-        var o = Math.floor(a.pop());
-        if (i - o <= 1) {
-            continue;
-        }
-        var u = Math.floor((o + i) / 2);
-        b(r, e[u], Math.floor(e[o]), Math.ceil(e[i]));
-        a.push(o, u, u, i);
-    }
-}
-
-function q(r, t) {
-    return r - t;
-}
-
-function E(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;
+function m(e) {
+    if (e === null || !o(e)) {
+        return false;
     } else {
-        return e;
+        return typeof e[Symbol.iterator] === "function" || typeof e[Symbol.asyncIterator] === "function";
     }
 }
 
-function y(r, t) {
-    if (t < r[0]) {
-        return 0;
-    }
-    if (t > r[r.length - 1]) {
-        return 1;
-    }
-    var e = I(r, t);
-    if (r[e] !== t) {
-        return e / r.length;
-    }
-    e++;
-    var n = N(r, t);
-    if (n === e) {
-        return e / r.length;
-    }
-    var a = n - e + 1;
-    var i = a * (n + e) / 2;
-    var o = i / a;
-    return o / r.length;
-}
-
-function I(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 p(e) {
+    return typeof e === "string";
 }
 
-function N(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 N(e) {
+    return typeof e === "function";
 }
 
-function P(r, t) {
-    var e = f(r);
-    return y(e, t);
+function D(e) {
+    return typeof e === "function" && e.constructor.name === "AsyncFunction";
 }
 
-function x(r) {
-    var t = m(r, .75);
-    var e = m(r, .25);
-    if (typeof t === "number" && typeof e === "number") {
-        return t - e;
-    }
-}
-
-function C(r) {
-    return +m(r, .5);
-}
-
-function T(r) {
-    var t = C(r);
-    var e = [];
-    for (var n = 0; n < r.length; n++) {
-        e.push(Math.abs(r[n] - t));
-    }
-    return C(e);
-}
+const k = {
+    isNumber: t,
+    isFiniteNumber: s,
+    isPlainObject: r,
+    isArrayLike: u,
+    isObject: f,
+    isDefined: o,
+    isUndefined: c,
+    isNull: l,
+    isDefinedValue: a,
+    isClass: d,
+    isPrimitive: y,
+    isPromise: b,
+    isIterable: m,
+    isString: p,
+    isFunction: N,
+    isAsyncFunction: D
+};
 
-function A(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));
-    }
+function R(e, n = {}) {
+    n = Object.assign({
+        computed: {},
+        customOrders: {},
+        nullRank: 1,
+        undefinedRank: 1,
+        nanRank: 1
+    }, n);
+    e.sort(g(n));
     return e;
 }
 
-function S(r, t, e) {
-    if (r.length === 0) {
-        return [];
-    }
-    e = e || Math.random;
-    var n = r.length;
-    var a = [];
-    for (var i = 0; i < t; i++) {
-        var o = Math.floor(e() * n);
-        a.push(r[o]);
-    }
-    return a;
-}
-
-function _(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 k(r, t) {
-    var e = r.slice();
-    return _(e, t);
-}
-
-function z(r, t, e) {
-    var n = k(r, e);
-    return n.slice(0, t);
-}
-
-function V(r, t, e) {
-    var n = r.length;
-    var a = [];
-    var i = e;
-    a[e] = r[r.length - 1];
-    while (i > 0) {
-        a[i - 1] = r[t[n][i] - 1];
-        n = t[n][i] - 1;
-        i--;
-    }
-    return a;
-}
-
-function F(r, t) {
-    var e = [];
-    var n = [];
-    var a;
-    var i;
-    var o = 0;
-    for (a = 0; a < r.length + 1; a++) {
-        var u = [];
-        var h = [];
-        for (i = 0; i < t + 1; i++) {
-            u.push(0);
-            h.push(0);
-        }
-        e.push(u);
-        n.push(h);
-    }
-    for (a = 1; a < t + 1; a++) {
-        e[1][a] = 1;
-        n[1][a] = 0;
-        for (i = 2; i < r.length + 1; i++) {
-            n[i][a] = Number.POSITIVE_INFINITY;
-        }
-    }
-    for (var f = 2; f < r.length + 1; f++) {
-        var s = 0;
-        var v = 0;
-        var l = 0;
-        var g = 0;
-        for (var c = 1; c < f + 1; c++) {
-            var w = f - c + 1;
-            var p = r[w - 1];
-            l++;
-            s += p;
-            v += p * p;
-            o = v - s * s / l;
-            g = w - 1;
-            if (g !== 0) {
-                for (i = 2; i < t + 1; i++) {
-                    if (n[f][i] >= o + n[g][i - 1]) {
-                        e[f][i] = w;
-                        n[f][i] = o + n[g][i - 1];
-                    }
-                }
-            }
+function g(e = {}) {
+    const n = i(e.by);
+    const t = i(e.order);
+    const {customOrders: s, computed: r} = e;
+    return function i(u, f, o = 0) {
+        const c = t[o] || "asc";
+        if (!(c === "asc" || c === "desc" || s[c])) {
+            return 0;
         }
-        e[f][1] = 1;
-        n[f][1] = o;
-    }
-    return {
-        lowerClassLimits: e,
-        varianceCombinations: n
-    };
-}
-
-function L(r, t) {
-    if (t > r.length) {
-        return null;
-    }
-    r = r.slice().sort(function(r, t) {
-        return r - t;
-    });
-    var e = F(r, t);
-    var n = e.lowerClassLimits;
-    return V(r, n, t);
-}
-
-function O(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 i = 0;
-    for (var o = 0; o < r.length; o++) {
-        i += (r[o] - e) * (t[o] - a);
-    }
-    var u = r.length - 1;
-    return i / u;
-}
-
-function Y(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 D(r) {
-    var t = Y(r);
-    return Math.sqrt(t);
-}
-
-function j(r, t) {
-    var e = O(r, t);
-    var n = D(r);
-    var a = D(t);
-    return e / n / a;
-}
-
-function B(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 i = 0;
-    for (var o = 0; o < r.length; o++) {
-        e = r[o] - t;
-        a += e * e;
-        i += e * e * e;
-    }
-    var u = r.length - 1;
-    var h = Math.sqrt(a / u);
-    var f = r.length;
-    var s = Math.pow(h, 3);
-    return f * i / ((f - 1) * (f - 2) * s);
-}
-
-function G(r, t) {
-    var e;
-    var n;
-    var a = [];
-    var i;
-    var o;
-    for (e = 0; e < r.length; e++) {
-        if (t === 1) {
-            a.push([ r[e] ]);
+        let l, a, d;
+        if (n.length) {
+            a = k.isDefined(u[n[o]]) ? u[n[o]] : r[n[o]] && r[n[o]](u);
+            d = k.isDefined(f[n[o]]) ? f[n[o]] : r[n[o]] && r[n[o]](f);
         } else {
-            i = G(r.slice(e + 1, r.length), t - 1);
-            for (n = 0; n < i.length; n++) {
-                o = i[n];
-                o.unshift(r[e]);
-                a.push(o);
-            }
-        }
-    }
-    return a;
-}
-
-function H(r, t) {
-    var e = [];
-    for (var n = 0; n < r.length; n++) {
-        if (t === 1) {
-            e.push([ r[n] ]);
+            a = u;
+            d = f;
+        }
+        if (s && s[c]) {
+            l = s[c].indexOf(a) - s[c].indexOf(d);
+        } else if (a === d) {
+            l = 0;
+        } else if (k.isNull(a) && k.isUndefined(d)) {
+            l = c === "asc" ? 1 : c === "desc" ? -1 : 0;
+        } else if (k.isUndefined(a) && k.isNull(d)) {
+            l = c === "asc" ? -1 : c === "desc" ? 1 : 0;
+        } else if (k.isNull(a) && k.isDefinedValue(d)) {
+            l = e.nullRank;
+        } else if (k.isUndefined(a) && k.isDefinedValue(d)) {
+            l = e.undefinedRank;
+        } else if (Number.isNaN(a) && k.isDefinedValue(d)) {
+            l = e.nanRank;
+        } else if (k.isNull(d) && k.isDefinedValue(a)) {
+            l = -e.nullRank;
+        } else if (k.isUndefined(d) && k.isDefinedValue(a)) {
+            l = -e.undefinedRank;
+        } else if (Number.isNaN(d) && k.isDefinedValue(a)) {
+            l = -e.nanRank;
         } else {
-            var a = H(r.slice(n, r.length), t - 1);
-            for (var i = 0; i < a.length; i++) {
-                e.push([ r[n] ].concat(a[i]));
-            }
-        }
-    }
-    return e;
-}
-
-function J(r, t, e) {
-    return r + (e - r) / (t + 1);
-}
-
-function K(r, t, e, n) {
-    return (r * t + e * n) / (t + n);
-}
-
-function Q(r, t, e, n, a, i) {
-    var o = K(t, e, a, i);
-    return (e * (r + Math.pow(t - o, 2)) + i * (n + Math.pow(a - o, 2))) / (e + i);
-}
-
-function R(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 U(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 W(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 X(r, t, e) {
-    return (r * t - e) / (t - 1);
-}
-
-function Z(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 $(r) {
-    return D(r) / n(r);
-}
-
-function rr(r, t) {
-    var e = n(r);
-    var a = o(r);
-    var i = Math.sqrt(r.length);
-    return (e - t) / (a / i);
-}
-
-function tr(r, t, e) {
-    var a = r.length;
-    var i = t.length;
-    if (!a || !i) {
-        return null;
-    }
-    if (!e) {
-        e = 0;
-    }
-    var o = n(r);
-    var u = n(t);
-    var h = Y(r);
-    var f = Y(t);
-    if (typeof o === "number" && typeof u === "number" && typeof h === "number" && typeof f === "number") {
-        var s = ((a - 1) * h + (i - 1) * f) / (a + i - 2);
-        return (o - u - e) / Math.sqrt(s * (1 / a + 1 / i));
-    }
-}
-
-var er = function r() {
-    this.totalCount = 0;
-    this.data = {};
-};
-
-er.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++;
-};
-
-er.prototype.score = function r(t) {
-    var e = {};
-    var n;
-    for (var a in t) {
-        var i = t[a];
-        for (n in this.data) {
-            e[n] = {};
-            if (this.data[n][a]) {
-                e[n][a + "_" + i] = (this.data[n][a][i] || 0) / this.totalCount;
-            } else {
-                e[n][a + "_" + i] = 0;
+            l = a < d ? -1 : a > d ? 1 : 0;
+            if (c === "desc") {
+                l = l * -1;
             }
         }
-    }
-    var o = {};
-    for (n in e) {
-        o[n] = 0;
-        for (var u in e[n]) {
-            o[n] += e[n][u];
+        if (l === 0 && k.isDefined(n[o + 1])) {
+            l = i(u, f, o + 1);
         }
-    }
-    return o;
-};
-
-var nr = function r() {
-    this.weights = [];
-    this.bias = 0;
-};
-
-nr.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;
-    }
-};
-
-nr.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 i = 0; i < this.weights.length; i++) {
-            this.weights[i] += a * t[i];
-        }
-        this.bias += a;
-    }
-    return this;
-};
-
-var ar = 1e-4;
-
-function ir(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 or(r) {
-    if (Number.isInteger(r)) {
-        if (r <= 0) {
-            return Number.NaN;
-        } else {
-            return ir(r - 1);
-        }
-    }
-    r--;
-    if (r < 0) {
-        return Math.PI / (Math.sin(Math.PI * -r) * or(-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 ur = [ .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 hr = 607 / 128;
-
-var fr = Math.log(Math.sqrt(2 * Math.PI));
-
-function sr(r) {
-    if (r <= 0) {
-        return Number.POSITIVE_INFINITY;
-    }
-    r--;
-    var t = ur[0];
-    for (var e = 1; e < 15; e++) {
-        t += ur[e] / (r + e);
-    }
-    var n = hr + .5 + r;
-    return fr + Math.log(t) - n + (r + .5) * Math.log(n);
-}
-
-function vr(r) {
-    if (r < 0 || r > 1) {
-        throw new Error("bernoulliDistribution requires probability to be between 0 and 1 inclusive");
-    }
-    return [ 1 - r, r ];
-}
-
-function lr(r, t) {
-    if (t < 0 || t > 1 || r <= 0 || r % 1 !== 0) {
-        return undefined;
-    }
-    var e = 0;
-    var n = 0;
-    var a = [];
-    var i = 1;
-    do {
-        a[e] = i * Math.pow(t, e) * Math.pow(1 - t, r - e);
-        n += a[e];
-        e++;
-        i = i * (r - e + 1) / e;
-    } while (n < 1 - ar);
-    return a;
-}
-
-function gr(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 - ar);
-    return n;
-}
-
-function cr(r, t, e) {
-    return (r - t) / e;
-}
-
-var wr = Math.sqrt(2 * Math.PI);
-
-function pr(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 / wr * Math.exp(-r * r / 2)) * 1e4) / 1e4;
-}
-
-var Mr = [];
-
-for (var mr = 0; mr <= 3.09; mr += .01) {
-    Mr.push(pr(mr));
-}
-
-function br(r) {
-    return 1 / (Math.exp(-r) + 1);
-}
-
-function dr(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 qr(r) {
-    if (r === 0) {
-        r = ar;
-    } else if (r >= 1) {
-        r = 1 - ar;
-    }
-    return Math.sqrt(2) * dr(2 * r - 1);
-}
-
-function Er(r) {
-    if (r <= 0 || r >= 1) {
-        throw new Error("p must be strictly between zero and one");
-    }
-    return Math.log(r / (1 - r));
-}
-
-function yr(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 Ir(r, t, e, n, a) {
-    if (typeof r !== "function") {
-        throw new TypeError("func must be a function");
-    }
-    for (var i = 0; i < n; i++) {
-        var o = (t + e) / 2;
-        if (r(o) === 0 || Math.abs((e - t) / 2) < a) {
-            return o;
-        }
-        if (yr(r(o)) === yr(r(t))) {
-            t = o;
-        } else {
-            e = o;
-        }
-    }
-    throw new Error("maximum number of iterations exceeded");
-}
-
-function Nr(r, t) {
-    if (r === 0 && t === 0) {
-        return 0;
-    }
-    return Math.abs((r - t) / t);
-}
-
-function Pr(r, t, e) {
-    if (e === void 0) e = ar;
-    return Nr(r, t) <= e;
+        return l;
+    };
 }
 
-export { p as $, t as A, k as B, S as C, z as D, vr as E, lr as F, gr as G, rr as H, tr as I, A as J, ir as K, or as L, Pr as M, Ir as N, $ as O, H as P, G as Q, K as R, Q as S, br as T, g as U, sr as V, L as W, U as X, Er as Y, qr as Z, P as _, l as a, X as a0, n as b, J as c, s as d, ar as e, C as f, R as g, W as h, B as i, Y as j, o as k, D as l, v as m, T as n, x as o, c as p, m as q, Z as r, e as s, a as t, j as u, i as v, O as w, u as x, r as y, cr as z };
+export { R as s };