qntjs-lib 1.0.0

package/dist/bundle/index.js

@@ -0,0 +1,3169 @@
+function H(t, n) {
+  if (typeof n == "number") {
+    const l = t.length, s = new Float64Array(l);
+    for (let i = 0; i < l; i++)
+      s[i] = t[i] + n;
+    return s;
+  }
+  const r = n, o = Math.min(t.length, r.length), e = new Float64Array(o);
+  for (let l = 0; l < o; l++)
+    e[l] = t[l] + r[l];
+  return e;
+}
+function ft(t, n) {
+  if (typeof n == "number") {
+    const l = t.length, s = new Float64Array(l);
+    for (let i = 0; i < l; i++)
+      s[i] = t[i] - n;
+    return s;
+  }
+  const r = n, o = Math.min(t.length, r.length), e = new Float64Array(o);
+  for (let l = 0; l < o; l++)
+    e[l] = t[l] - r[l];
+  return e;
+}
+function U(t, n) {
+  if (typeof n == "number") {
+    const l = t.length, s = new Float64Array(l);
+    for (let i = 0; i < l; i++)
+      s[i] = t[i] * n;
+    return s;
+  }
+  const r = n, o = Math.min(t.length, r.length), e = new Float64Array(o);
+  for (let l = 0; l < o; l++)
+    e[l] = t[l] * r[l];
+  return e;
+}
+function It(t, n) {
+  if (typeof n == "number") {
+    const l = t.length, s = new Float64Array(l);
+    for (let i = 0; i < l; i++)
+      s[i] = t[i] / n;
+    return s;
+  }
+  const r = n, o = Math.min(t.length, r.length), e = new Float64Array(o);
+  for (let l = 0; l < o; l++)
+    e[l] = t[l] / r[l];
+  return e;
+}
+function st(t, n) {
+  if (typeof n == "number") {
+    const l = t.length, s = new Float64Array(l);
+    for (let i = 0; i < l; i++)
+      s[i] = (t[i] + n) / 2;
+    return s;
+  }
+  const r = n, o = Math.min(t.length, r.length), e = new Float64Array(o);
+  for (let l = 0; l < o; l++)
+    e[l] = (t[l] + r[l]) / 2;
+  return e;
+}
+function Lt(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  for (let e = 0; e < r; e++)
+    o[e] = t[e] * n;
+  return o;
+}
+function St(t, n, r) {
+  const o = t.length, e = new Float64Array(o);
+  for (let l = 0; l < o; l++) {
+    let s = t[l];
+    if (s !== s) {
+      e[l] = NaN;
+      continue;
+    }
+    s < n ? s = n : s > r && (s = r), e[l] = s;
+  }
+  return e;
+}
+function Vt(t) {
+  const n = t.length, r = new Float64Array(n);
+  for (let o = 0; o < n; o++)
+    r[o] = Math.abs(t[o]);
+  return r;
+}
+function _t(t) {
+  const n = t.length, r = new Float64Array(n);
+  for (let o = 0; o < n; o++)
+    r[o] = Math.sign(t[o]);
+  return r;
+}
+function jt(t) {
+  const n = t.length, r = new Float64Array(n);
+  for (let o = 0; o < n; o++) {
+    const e = t[o];
+    e >= 0 ? r[o] = Math.floor(e + 0.5) : r[o] = Math.ceil(e - 0.5);
+  }
+  return r;
+}
+function kt(t) {
+  const n = t.length, r = new Float64Array(n);
+  for (let o = 0; o < n; o++)
+    r[o] = Math.floor(t[o]);
+  return r;
+}
+function qt(t) {
+  const n = t.length, r = new Float64Array(n);
+  for (let o = 0; o < n; o++)
+    r[o] = Math.ceil(t[o]);
+  return r;
+}
+function Ot(t) {
+  const n = t.length;
+  if (n === 0)
+    return new Float64Array(0);
+  const r = new Float64Array(n);
+  r[0] = NaN;
+  for (let o = 1; o < n; o++)
+    r[o] = t[o] - t[o - 1];
+  return r;
+}
+function Ct(t, n) {
+  const r = t.length, o = n;
+  for (let e = 0; e < r; e++)
+    t[e] = o(t[e], e);
+}
+function P(t, n, r) {
+  const o = t.length, e = new Uint8Array(o);
+  if (typeof n == "number") {
+    const i = n;
+    for (let f = 0; f < o; f++)
+      e[f] = r(t[f], i) ? 1 : 0;
+    return e;
+  }
+  const l = n, s = Math.min(o, l.length);
+  for (let i = 0; i < s; i++)
+    e[i] = r(t[i], l[i]) ? 1 : 0;
+  return e;
+}
+function Pt(t, n) {
+  return P(t, n, (o, e) => o < e);
+}
+function Ut(t, n) {
+  return P(t, n, (o, e) => o < e || Math.abs(o - e) < Number.EPSILON);
+}
+function Dt(t, n) {
+  return P(t, n, (o, e) => o > e);
+}
+function Tt(t, n) {
+  return P(t, n, (o, e) => o > e || Math.abs(o - e) < Number.EPSILON);
+}
+function Bt(t, n) {
+  return P(t, n, (o, e) => Math.abs(o - e) < Number.EPSILON);
+}
+function Xt(t, n) {
+  return P(t, n, (o, e) => o !== e);
+}
+function Yt(t, n) {
+  return P(t, n, (r, o) => r !== 0 && o !== 0);
+}
+function zt(t, n) {
+  return P(t, n, (r, o) => r !== 0 || o !== 0);
+}
+function Ht(t) {
+  const n = t.length, r = new Uint8Array(n);
+  for (let o = 0; o < n; o++)
+    r[o] = t[o] === 0 ? 1 : 0;
+  return r;
+}
+function Rt(t) {
+  let n = 1, r = 0;
+  for (let o = 0; o < t.length; o++) {
+    const e = t[o];
+    e === e && (n *= e, r++);
+  }
+  return r === 0 ? NaN : n;
+}
+function Kt(t) {
+  const n = t.length, r = new Float64Array(n);
+  let o = 1;
+  for (let e = 0; e < n; e++) {
+    const l = t[e];
+    l === l ? (o *= l, r[e] = o) : r[e] = NaN;
+  }
+  return r;
+}
+function Wt(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  if (n <= 0)
+    throw new Error("period must be positive");
+  if (r < n)
+    return o.fill(NaN);
+  o.fill(NaN, 0, n - 1);
+  let e = 1, l = 0, s = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    f === f && (s++, f === 0 ? l++ : e *= f);
+  }
+  o[n - 1] = s > 0 ? l > 0 ? 0 : e : NaN;
+  for (let i = n; i < r; i++) {
+    const f = t[i - n], a = t[i];
+    if (f === f) {
+      if (s--, f === 0)
+        l--;
+      else if (e !== 0)
+        e /= f;
+      else if (l === 0) {
+        e = 1;
+        for (let c = i - n + 1; c < i; c++) {
+          const u = t[c];
+          u === u && u !== 0 && (e *= u);
+        }
+      }
+    }
+    a === a && (s++, a === 0 ? l++ : e *= a), o[i] = s > 0 ? l > 0 ? 0 : e : NaN;
+  }
+  return o;
+}
+function S() {
+  return typeof process > "u" || typeof process.env > "u" ? !1 : process?.env?.SKIP_DENSE_OPTIMIZATION === "true";
+}
+function at(t, n, r, o = !0) {
+  if (n <= 0)
+    throw new Error("Length must be positive");
+  const e = t.length, l = new Uint8Array(e);
+  if (e === 0)
+    return l;
+  const s = r === "rising", i = new Int32Array(e);
+  let f = 0, a = 0;
+  if (!o) {
+    f = 0, a = 0;
+    const N = Math.min(e, n);
+    for (let h = 1; h < N; h++) {
+      const w = h - 1, m = t[w];
+      if (s)
+        for (; a > f && t[i[a - 1]] <= m; )
+          a--;
+      else
+        for (; a > f && t[i[a - 1]] >= m; )
+          a--;
+      i[a++] = w;
+      const g = h - n;
+      for (; a > f && i[f] < g; )
+        f++;
+    }
+    for (let h = Math.max(n, 1); h < e; h++) {
+      const w = h - 1, m = t[w];
+      if (s)
+        for (; a > f && t[i[a - 1]] <= m; )
+          a--;
+      else
+        for (; a > f && t[i[a - 1]] >= m; )
+          a--;
+      i[a++] = w;
+      const g = h - n;
+      for (; a > f && i[f] < g; )
+        f++;
+      const v = a > f ? i[f] : -1;
+      v >= 0 ? l[h] = s ? t[h] > t[v] ? 1 : 0 : t[h] < t[v] ? 1 : 0 : l[h] = 0;
+    }
+    return l;
+  }
+  f = 0, a = 0;
+  let c = -1;
+  const u = Math.min(e, n);
+  if (e > 0) {
+    const N = t[0];
+    N !== N ? (l[0] = 0, c = -1) : (c = 0, l[0] = 0);
+  }
+  for (let N = 1; N < u; N++) {
+    const h = t[N];
+    if (h !== h) {
+      l[N] = l[N - 1];
+      continue;
+    }
+    const w = c;
+    if (w >= 0) {
+      const g = t[w];
+      if (s)
+        for (; a > f && t[i[a - 1]] <= g; )
+          a--;
+      else
+        for (; a > f && t[i[a - 1]] >= g; )
+          a--;
+      i[a++] = w;
+    }
+    c = N;
+    const m = N - n;
+    for (; a > f && i[f] < m; )
+      f++;
+  }
+  for (let N = Math.max(n, 1); N < e; N++) {
+    const h = t[N];
+    if (h !== h) {
+      l[N] = l[N - 1];
+      continue;
+    }
+    const w = c;
+    if (w >= 0) {
+      const v = t[w];
+      if (s)
+        for (; a > f && t[i[a - 1]] <= v; )
+          a--;
+      else
+        for (; a > f && t[i[a - 1]] >= v; )
+          a--;
+      i[a++] = w;
+    }
+    c = N;
+    const m = N - n;
+    for (; a > f && i[f] < m; )
+      f++;
+    const g = a > f ? i[f] : -1;
+    g >= 0 ? l[N] = s ? t[N] > t[g] ? 1 : 0 : t[N] < t[g] ? 1 : 0 : l[N] = 0;
+  }
+  return l;
+}
+function Gt(t, n, r = !0) {
+  return at(t, n, "rising", r);
+}
+function $t(t, n, r = !0) {
+  return at(t, n, "falling", r);
+}
+function ot(t, n, r) {
+  return Zt(t, n, r ?? ((e, l, s, i) => e > s && l <= i || e < s && l >= i));
+}
+function Jt(t, n) {
+  return ot(t, n, (o, e, l, s) => o > l && e <= s);
+}
+function Qt(t, n) {
+  return ot(t, n, (o, e, l, s) => o < l && e >= s);
+}
+function Zt(t, n, r) {
+  const o = t.length, e = new Uint8Array(o);
+  if (o === 0)
+    return e;
+  if (typeof n == "number") {
+    const i = n;
+    for (let f = 1; f < o; f++) {
+      const a = t[f], c = t[f - 1];
+      a !== a || c !== c || r(a, c, i, i) && (e[f] = 1);
+    }
+    return e;
+  }
+  const l = n, s = Math.min(o, l.length);
+  for (let i = 1; i < s; i++) {
+    const f = t[i], a = t[i - 1], c = l[i], u = l[i - 1];
+    f !== f || a !== a || c !== c || u !== u || r(f, a, c, u) && (e[i] = 1);
+  }
+  return e;
+}
+function pt(t, n, r) {
+  if (t.length !== n.length)
+    return !1;
+  for (let o = 0; o < t.length; o++) {
+    const e = t[o], l = n[o];
+    if (e !== e && l === l || e === e && l !== l)
+      return !1;
+    if (!(e !== e && l !== l)) {
+      if (r !== void 0) {
+        if (Math.abs(e - l) > Math.pow(10, -r))
+          return !1;
+      } else if (e !== l)
+        return !1;
+    }
+  }
+  return !0;
+}
+function tn(t) {
+  for (let n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (r === r)
+      return !1;
+  }
+  return !0;
+}
+function nn(t) {
+  let n = 0;
+  for (let r = 0; r < t.length; r++) {
+    const o = t[r];
+    o !== o && n++;
+  }
+  return n;
+}
+function L(...t) {
+  if (t.length === 0)
+    return !1;
+  const n = t[0].length;
+  for (let r = 0; r < n; r++)
+    for (let o = 0; o < t.length; o++) {
+      const e = t[o][r];
+      if (e !== e)
+        return !0;
+    }
+  return !1;
+}
+function ct(t) {
+  const n = t.length, r = new Float64Array(n);
+  for (let o = 0; o < n; o++) {
+    const e = t[o];
+    r[o] = e !== e ? 1 : 0;
+  }
+  return r;
+}
+function en(t) {
+  const n = ct(t), r = n.length;
+  for (let o = 0; o < r; o++)
+    n[o] = n[o] ? 0 : 1;
+  return n;
+}
+function W(t, n) {
+  if (n && t instanceof Float64Array)
+    return t;
+  const r = new Float64Array(t.length);
+  for (let o = 0; o < t.length; o++)
+    r[o] = t[o];
+  return r;
+}
+function on(t, n, r = !1) {
+  const o = W(t, r);
+  for (let e = 0; e < o.length; e++) {
+    const l = o[e];
+    l !== l && (o[e] = n);
+  }
+  return o;
+}
+function ln(t, n = !1) {
+  const r = W(t, n);
+  let o;
+  for (let e = 0; e < r.length; e++) {
+    const l = r[e];
+    l === l ? o = l : o !== void 0 && (r[e] = o);
+  }
+  return r;
+}
+function rn(t, n = !1) {
+  const r = W(t, n);
+  let o;
+  for (let e = r.length - 1; e >= 0; e--) {
+    const l = r[e];
+    l === l ? o = l : o !== void 0 && (r[e] = o);
+  }
+  return r;
+}
+function ut(t, n = 1) {
+  const r = t.length, o = new Float64Array(r);
+  if (n === 0) {
+    for (let l = 0; l < r; l++)
+      o[l] = t[l];
+    return o;
+  }
+  if (n > 0) {
+    for (let l = 0; l < r; l++) {
+      const s = l - n;
+      o[l] = s >= 0 ? t[s] : NaN;
+    }
+    return o;
+  }
+  const e = -n;
+  for (let l = 0; l < r; l++) {
+    const s = l + e;
+    o[l] = s < r ? t[s] : NaN;
+  }
+  return o;
+}
+function fn(t, n, r, o = !1) {
+  const e = W(t, o), l = n !== n;
+  for (let s = 0; s < e.length; s++) {
+    const i = e[s];
+    l ? i !== i && (e[s] = r) : i === n && (e[s] = r);
+  }
+  return e;
+}
+function sn(t) {
+  const n = t.length, r = new Float64Array(n);
+  let o = 0;
+  for (let e = 0; e < n; e++) {
+    const l = t[e];
+    l === l && (r[o++] = l);
+  }
+  return o === n ? r : r.slice(0, o);
+}
+const Ze = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  allna: tn,
+  bfill: rn,
+  countna: nn,
+  dropna: sn,
+  equals: pt,
+  ffill: ln,
+  fillna: on,
+  havena: L,
+  isna: ct,
+  lag: ut,
+  notna: en,
+  replace: fn
+}, Symbol.toStringTag, { value: "Module" }));
+function Z(t, n = !0) {
+  let r = 0, o = 0;
+  if (!S() && n && (L(t) || (n = !1)), n)
+    for (let e = 0; e < t.length; e++) {
+      const l = t[e];
+      l === l && (r += l, o++);
+    }
+  else {
+    o = t.length;
+    for (let e = 0; e < t.length; e++)
+      r += t[e];
+  }
+  return o === 0 ? NaN : r;
+}
+function an(t) {
+  const n = t.length, r = new Float64Array(n);
+  let o = 0;
+  for (let e = 0; e < n; e++) {
+    const l = t[e];
+    l === l && (o += l), r[e] = o;
+  }
+  return r;
+}
+function cn(t, n, r = !0) {
+  const o = t.length, e = new Float64Array(o);
+  if (n <= 0)
+    throw new Error("period must be positive");
+  if (o < n)
+    return e.fill(NaN);
+  if (S() || r && !L(t) && (r = !1), !r) {
+    let i = 0;
+    for (let f = 0; f < n; f++)
+      i += t[f];
+    e[n - 1] = i;
+    for (let f = n; f < o; f++)
+      i += t[f] - t[f - n], e[f] = i;
+    return e;
+  }
+  let l = 0, s = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    f === f && (l += f, s++);
+  }
+  e[n - 1] = s > 0 ? l : NaN;
+  for (let i = n; i < o; i++) {
+    const f = t[i], a = t[i - n];
+    f === f && (l += f, s++), a === a && (l -= a, s--), e[i] = s > 0 ? l : NaN;
+  }
+  return e;
+}
+function Nt(t, n, r) {
+  const o = t.length, e = new Float64Array(o);
+  if (n <= 0)
+    throw new Error("period must be positive");
+  if (o < n)
+    return e;
+  const l = new Int32Array(o);
+  let s = 0, i = 0;
+  for (let f = 0; f < n - 1; f++) {
+    const a = t[f];
+    if (a === a) {
+      for (; i > s && (r ? t[l[i - 1]] < a : t[l[i - 1]] > a); )
+        i--;
+      l[i++] = f;
+    }
+  }
+  for (let f = n - 1; f < o; f++) {
+    const a = t[f];
+    for (; i > s && l[s] <= f - n; )
+      s++;
+    if (a === a) {
+      for (; i > s && (r ? t[l[i - 1]] < a : t[l[i - 1]] > a); )
+        i--;
+      l[i++] = f;
+    }
+    e[f] = i > s ? t[l[s]] : NaN;
+  }
+  return e;
+}
+function un(t, n) {
+  return Nt(t, n, !1);
+}
+function Nn(t, n) {
+  return Nt(t, n, !0);
+}
+function lt(t, n, r, o) {
+  const e = t.length;
+  if (n.length !== e)
+    throw new Error("minSource and maxSource must have equal length");
+  const l = new Float64Array(e), s = new Float64Array(e);
+  if (r <= 0)
+    throw new Error("period must be positive");
+  if (e < r)
+    return { min: l, max: s };
+  const i = new Int32Array(e), f = new Int32Array(e);
+  let a = 0, c = 0, u = 0, N = 0;
+  for (let h = 0; h < r - 1; h++) {
+    const w = t[h], m = n[h];
+    for (; c > a && t[i[c - 1]] > w; )
+      c--;
+    for (; N > u && n[f[N - 1]] < m; )
+      N--;
+    w === w && (i[c++] = h), m === m && (f[N++] = h);
+  }
+  for (let h = r - 1; h < e; h++) {
+    const w = t[h], m = n[h];
+    for (; c > a && i[a] <= h - r; )
+      a++;
+    for (; c > a && t[i[c - 1]] > w; )
+      c--;
+    for (; N > u && f[u] <= h - r; )
+      u++;
+    for (; N > u && n[f[N - 1]] < m; )
+      N--;
+    w === w && (i[c++] = h), m === m && (f[N++] = h);
+    const g = c > a ? t[i[a]] : NaN, v = N > u ? n[f[u]] : NaN;
+    l[h] = g, s[h] = v, o && o(g, v, h);
+  }
+  return { min: l, max: s };
+}
+function hn(t) {
+  let n = 1 / 0, r = !1;
+  for (let o = 0; o < t.length; o++) {
+    const e = t[o];
+    e === e && (e < n && (n = e), r = !0);
+  }
+  return r ? n : NaN;
+}
+function wn(t) {
+  let n = -1 / 0, r = !1;
+  for (let o = 0; o < t.length; o++) {
+    const e = t[o];
+    e === e && (e > n && (n = e), r = !0);
+  }
+  return r ? n : NaN;
+}
+function mn(t) {
+  let n = -1, r = 1 / 0;
+  for (let o = 0; o < t.length; o++) {
+    const e = t[o];
+    e === e && e < r && (r = e, n = o);
+  }
+  return n;
+}
+function vn(t) {
+  let n = -1, r = -1 / 0;
+  for (let o = 0; o < t.length; o++) {
+    const e = t[o];
+    e === e && e > r && (r = e, n = o);
+  }
+  return n;
+}
+function gn(t) {
+  const n = t.length, r = new Float64Array(n);
+  let o = -1 / 0;
+  for (let e = 0; e < n; e++) {
+    const l = t[e];
+    l !== l ? r[e] = NaN : (e === 0 ? o = l : o = Math.max(o, l), r[e] = o);
+  }
+  return r;
+}
+function yn(t) {
+  const n = t.length, r = new Float64Array(n);
+  let o = 1 / 0;
+  for (let e = 0; e < n; e++) {
+    const l = t[e];
+    l !== l ? r[e] = NaN : (e === 0 ? o = l : o = Math.min(o, l), r[e] = o);
+  }
+  return r;
+}
+function ht(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  if (n <= 0)
+    throw new Error("period must be positive");
+  if (r < n)
+    return o.fill(NaN);
+  o.fill(NaN, 0, n - 1);
+  const e = new Int32Array(r);
+  let l = 0, s = 0;
+  for (let i = 0; i < r; i++) {
+    const f = t[i];
+    for (; s > l && e[l] <= i - n; )
+      l++;
+    if (f === f) {
+      for (; s > l && t[e[s - 1]] > f; )
+        s--;
+      e[s++] = i;
+    }
+    i >= n - 1 && (o[i] = s > l ? e[l] : NaN);
+  }
+  return o;
+}
+function wt(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  if (n <= 0)
+    throw new Error("period must be positive");
+  if (r < n)
+    return o.fill(NaN);
+  o.fill(NaN, 0, n - 1);
+  const e = new Int32Array(r);
+  let l = 0, s = 0;
+  for (let i = 0; i < r; i++) {
+    const f = t[i];
+    for (; s > l && e[l] <= i - n; )
+      l++;
+    if (f === f) {
+      for (; s > l && t[e[s - 1]] < f; )
+        s--;
+      e[s++] = i;
+    }
+    i >= n - 1 && (o[i] = s > l ? e[l] : NaN);
+  }
+  return o;
+}
+function An(t, n) {
+  const r = n?.lo ?? 0, o = n?.hi ?? 1, e = new Float64Array(t);
+  for (let l = 0; l < t; l++)
+    e[l] = r + Math.random() * (o - r);
+  return e;
+}
+function bn(t, n) {
+  const r = n?.mean ?? 0, o = n?.sd ?? 1, e = new Float64Array(t);
+  for (let l = 0; l < t; l += 2) {
+    const s = Math.random(), i = Math.random(), f = Math.sqrt(-2 * Math.log(s)), a = 2 * Math.PI * i;
+    e[l] = r + o * f * Math.cos(a), l + 1 < t && (e[l + 1] = r + o * f * Math.sin(a));
+  }
+  return e;
+}
+function Fn(t, n) {
+  const r = Math.min(t.length, n.length);
+  let o = 0;
+  for (let e = 0; e < r; e++)
+    o += t[e] * n[e];
+  return o;
+}
+function Mn(t, n = 2, r = !0) {
+  const o = t.length;
+  if (o === 0)
+    return NaN;
+  if (r) {
+    let e = 0, l = 0;
+    if (n === 2) {
+      for (let s = 0; s < o; s++) {
+        const i = t[s];
+        i === i && (e += i * i, l++);
+      }
+      return l === 0 ? NaN : Math.sqrt(e);
+    } else {
+      for (let s = 0; s < o; s++) {
+        const i = t[s];
+        i === i && (e += Math.pow(Math.abs(i), n), l++);
+      }
+      return l === 0 ? NaN : Math.pow(e, 1 / n);
+    }
+  } else if (n === 2) {
+    let e = 0;
+    for (let l = 0; l < o; l++) {
+      const s = t[l];
+      e += s * s;
+    }
+    return Math.sqrt(e);
+  } else if (n === 1) {
+    let e = 0;
+    for (let l = 0; l < o; l++)
+      e += Math.abs(t[l]);
+    return e;
+  } else if (n === 1 / 0) {
+    let e = 0;
+    for (let l = 0; l < o; l++) {
+      const s = Math.abs(t[l]);
+      s > e && (e = s);
+    }
+    return e;
+  } else {
+    let e = 0;
+    for (let l = 0; l < o; l++)
+      e += Math.pow(Math.abs(t[l]), n);
+    return Math.pow(e, 1 / n);
+  }
+}
+function xn(t, n) {
+  const r = Math.min(t.length, n.length);
+  let o = 0, e = 0, l = 0, s = 0, i = 0;
+  for (let u = 0; u < r; u++) {
+    const N = t[u], h = n[u];
+    N === N && h === h && (o += N, e += h, l += N * N, s += N * h, i++);
+  }
+  if (i === 0)
+    return { intercept: NaN, slope: NaN };
+  const f = i * l - o * o;
+  if (f === 0)
+    return { intercept: NaN, slope: NaN };
+  const a = (i * s - o * e) / f;
+  return { intercept: (e - a * o) / i, slope: a };
+}
+function En(t) {
+  const n = t.length, r = new Array(n);
+  for (let e = 0; e < n; e++)
+    r[e] = t[e].slice();
+  const o = new Array(n);
+  for (let e = 0; e < n; e++)
+    o[e] = new Array(n).fill(0), o[e][e] = 1;
+  for (let e = 0; e < n; e++) {
+    let l = e;
+    for (let u = e; u < n; u++)
+      Math.abs(r[u][e]) > Math.abs(r[l][e]) && (l = u);
+    if (Math.abs(r[l][e]) < 1e-12)
+      return null;
+    const s = r[e], i = r[l];
+    r[e] = i, r[l] = s;
+    const f = o[e], a = o[l];
+    o[e] = a, o[l] = f;
+    const c = r[e][e];
+    for (let u = 0; u < n; u++)
+      r[e][u] /= c, o[e][u] /= c;
+    for (let u = 0; u < n; u++)
+      if (u !== e) {
+        const N = r[u][e];
+        for (let h = 0; h < n; h++)
+          r[u][h] -= N * r[e][h], o[u][h] -= N * o[e][h];
+      }
+  }
+  return o;
+}
+function dn(t, n) {
+  const r = t.length;
+  if (r === 0)
+    return null;
+  const o = t[0].length, e = o + 1, l = Array.from({ length: e }, function() {
+    return new Array(e).fill(0);
+  }), s = new Array(e).fill(0);
+  for (let a = 0; a < r; a++) {
+    const c = t[a], u = n[a], N = [1];
+    for (let h = 0; h < o; h++)
+      N.push(c[h]);
+    for (let h = 0; h < e; h++)
+      for (let w = 0; w < e; w++)
+        l[h][w] += N[h] * N[w];
+    for (let h = 0; h < e; h++)
+      s[h] += N[h] * u;
+  }
+  const i = En(l);
+  if (!i)
+    return null;
+  const f = new Array(e).fill(0);
+  for (let a = 0; a < e; a++)
+    for (let c = 0; c < e; c++)
+      f[a] += i[a][c] * s[c];
+  return f;
+}
+const pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  abs: Vt,
+  add: H,
+  and: Yt,
+  argmax: vn,
+  argmin: mn,
+  avg: st,
+  ceil: qt,
+  clamp: St,
+  cummax: gn,
+  cummin: yn,
+  cumprod: Kt,
+  cumsum: an,
+  diff: Ot,
+  div: It,
+  dot: Fn,
+  eq: Bt,
+  floor: kt,
+  gt: Dt,
+  gte: Tt,
+  lt: Pt,
+  lte: Ut,
+  max: wn,
+  min: hn,
+  mul: U,
+  neq: Xt,
+  norm: Mn,
+  not: Ht,
+  ols: xn,
+  olsMulti: dn,
+  or: zt,
+  prod: Rt,
+  randnormal: bn,
+  randuniform: An,
+  rollargmax: wt,
+  rollargmin: ht,
+  rollmax: Nn,
+  rollmin: un,
+  rollminmax: lt,
+  rollprod: Wt,
+  rollsum: cn,
+  round: jt,
+  scale: Lt,
+  sign: _t,
+  sub: ft,
+  sum: Z
+}, Symbol.toStringTag, { value: "Module" }));
+function In(t, n, r, o) {
+  let e = 0;
+  for (let l = 0; l < n; l++)
+    e += t[l], o[l] = NaN;
+  o[n - 1] = e / n;
+  for (let l = n; l < r; l++)
+    e += t[l] - t[l - n], o[l] = e / n;
+  return o;
+}
+function Ln(t, n, r, o) {
+  let e = 0, l = 0;
+  for (let s = 0; s < n; s++) {
+    const i = t[s];
+    i === i && (e += i, l++), o[s] = NaN;
+  }
+  o[n - 1] = l > 0 ? e / l : NaN;
+  for (let s = n; s < r; s++) {
+    const i = t[s], f = t[s - n];
+    i === i && (e += i, l++), f === f && (e -= f, l--), o[s] = l > 0 ? e / l : NaN;
+  }
+  return o;
+}
+function _(t, n, r = !0) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = new Float64Array(o);
+  return o < n ? e.fill(NaN) : (r && !S() && !L(t) && (r = !1), r ? Ln(t, n, o, e) : In(t, n, o, e));
+}
+function mt(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r);
+  if (r < n)
+    return o.fill(NaN);
+  const e = 2 / (n + 1);
+  let l = 0;
+  for (; l < r && t[l] !== t[l]; )
+    l++;
+  if (l === r)
+    return o.fill(NaN);
+  if (n === 1) {
+    for (let a = 0; a < r; a++)
+      o[a] = t[a];
+    return o;
+  }
+  let s = t[l], i = 1;
+  for (l++; l < r && i < n; ) {
+    const a = t[l];
+    l++, a === a && (s = s + e * (a - s), i++);
+  }
+  if (i < n)
+    return o.fill(NaN);
+  const f = l - 1;
+  o[f] = s, o.fill(NaN, 0, f);
+  for (let a = l; a < r; a++) {
+    const c = t[a];
+    if (c !== c) {
+      o[a] = NaN;
+      continue;
+    }
+    s = s + e * (c - s), o[a] = s;
+  }
+  return o;
+}
+function R(t, n, r = !0) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = new Float64Array(o);
+  return o < n ? e.fill(NaN) : (r && !S() && !L(t) && (r = !1), r ? Vn(t, n, e) : Sn(t, n, e));
+}
+function Sn(t, n, r) {
+  const o = t.length, e = n * (n + 1) / 2;
+  let l = 0, s = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    l += f, s += f * (i + 1), r[i] = NaN;
+  }
+  r[n - 1] = s / e;
+  for (let i = n; i < o; i++) {
+    const f = t[i], a = t[i - n];
+    l += f - a, s = s - l + (n + 1) * f - a, r[i] = s / e;
+  }
+  return r;
+}
+function Vn(t, n, r) {
+  const o = t.length, e = n, l = new Float64Array(e);
+  for (let N = 0; N < e; N++)
+    l[N] = NaN;
+  let s = 0, i = 0, f = 0, a = 0;
+  const c = Math.min(o, e);
+  for (let N = 0; N < c; N++) {
+    const h = t[N];
+    if (l[N] = h, h === h) {
+      const w = N + 1;
+      s += h, i += h * w, f += w, a++;
+    }
+    r[N] = NaN;
+  }
+  a > 0 ? r[e - 1] = i / f : r[e - 1] = NaN;
+  let u = 0;
+  for (let N = e; N < o; N++) {
+    const h = t[N], w = l[u], m = w === w, g = h === h, v = s;
+    m && (s -= w), g && (s += h), i = i - v + (g ? h * e : 0), f = f - a + (g ? e : 0), m && a--, g && a++, l[u] = h, u = (u + 1) % e, f > 0 ? r[N] = i / f : r[N] = NaN;
+  }
+  return r;
+}
+function _n(t, n, r, o = !0) {
+  const e = t.length;
+  if (n.length !== e)
+    throw new Error("price and volume must have equal length");
+  if (r <= 0)
+    throw new Error("Period must be positive");
+  const l = new Float64Array(e);
+  if (e < r)
+    return l.fill(NaN);
+  for (let s = 0; s < r; s++)
+    l[s] = NaN;
+  return o && !S() && !L(t, n) && (o = !1), o ? jn(t, n, r, l) : kn(t, n, r, l);
+}
+function jn(t, n, r, o) {
+  const e = t.length, l = r;
+  if (e < l)
+    return o.fill(NaN);
+  const s = new Float64Array(l), i = new Float64Array(l);
+  for (let u = 0; u < l; u++)
+    s[u] = NaN, i[u] = NaN;
+  let f = 0, a = 0;
+  for (let u = 0; u < l; u++) {
+    const N = t[u], h = n[u];
+    if (N === N && h === h) {
+      const w = N * h;
+      s[u] = w, i[u] = h, f += w, a += h;
+    } else
+      s[u] = NaN, i[u] = NaN;
+  }
+  o[l - 1] = a !== 0 ? f / a : NaN;
+  let c = 0;
+  for (let u = l; u < e; u++) {
+    const N = t[u], h = n[u], w = s[c], m = i[c];
+    if (m === m && (f -= w, a -= m), N === N && h === h) {
+      const g = N * h;
+      s[c] = g, i[c] = h, f += g, a += h;
+    } else
+      s[c] = NaN, i[c] = NaN;
+    c++, c === l && (c = 0), o[u] = a !== 0 ? f / a : NaN;
+  }
+  return o;
+}
+function kn(t, n, r, o) {
+  const e = t.length;
+  let l = 0, s = 0;
+  for (let i = 0; i < r; i++) {
+    const f = t[i], a = n[i];
+    l += f * a, s += a;
+  }
+  o[r - 1] = s !== 0 ? l / s : NaN;
+  for (let i = r; i < e; i++) {
+    const f = t[i], a = n[i], c = t[i - r], u = n[i - r];
+    l += f * a - c * u, s += a - u, o[i] = s !== 0 ? l / s : NaN;
+  }
+  return o;
+}
+function qn(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r);
+  if (r < n)
+    return o.fill(NaN);
+  const e = 2 / (n + 1);
+  let l = 0;
+  for (; l < r && t[l] !== t[l]; )
+    l++;
+  if (l === r)
+    return o.fill(NaN);
+  let s = t[l], i = 1;
+  for (l++; l < r && i < n; ) {
+    const u = t[l];
+    l++, u === u && (s = s + e * (u - s), i++);
+  }
+  if (i < n)
+    return o.fill(NaN);
+  let f = s, a = 1;
+  for (; l < r && a < n; ) {
+    const u = t[l];
+    l++, u === u && (s = s + e * (u - s), i++, f = f + e * (s - f), a++);
+  }
+  if (a < n)
+    return o.fill(NaN);
+  const c = l - 1;
+  o[c] = 2 * s - f, o.fill(NaN, 0, c);
+  for (let u = l; u < r; u++) {
+    const N = t[u];
+    if (N !== N) {
+      o[u] = NaN;
+      continue;
+    }
+    s = s + e * (N - s), f = f + e * (s - f), o[u] = 2 * s - f;
+  }
+  return o;
+}
+function On(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length;
+  if (r < n)
+    return new Float64Array(r).fill(NaN);
+  const o = Math.floor((n + 1) / 2);
+  return _(_(t, o, !1), n + 1 - o, !1);
+}
+function Cn(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r);
+  if (r < n)
+    return o.fill(NaN);
+  const e = 2 / (n + 1);
+  let l = 0;
+  for (; l < r && t[l] !== t[l]; )
+    l++;
+  if (l === r)
+    return o.fill(NaN);
+  let s = t[l], i = 1;
+  for (l++; l < r && i < n; ) {
+    const h = t[l];
+    l++, h === h && (s = s + e * (h - s), i++);
+  }
+  if (i < n)
+    return o.fill(NaN);
+  let f = s, a = 1;
+  for (; l < r && a < n; ) {
+    const h = t[l];
+    l++, h === h && (s = s + e * (h - s), i++, f = f + e * (s - f), a++);
+  }
+  if (a < n)
+    return o.fill(NaN);
+  let c = f, u = 1;
+  for (; l < r && u < n; ) {
+    const h = t[l];
+    l++, h === h && (s = s + e * (h - s), f = f + e * (s - f), c = c + e * (f - c), u++);
+  }
+  if (u < n)
+    return o.fill(NaN);
+  const N = l - 1;
+  o[N] = 3 * s - 3 * f + c, N > 0 && o.fill(NaN, 0, N);
+  for (let h = l; h < r; h++) {
+    const w = t[h];
+    if (w !== w) {
+      o[h] = NaN;
+      continue;
+    }
+    s = s + e * (w - s), f = f + e * (s - f), c = c + e * (f - c), o[h] = 3 * s - 3 * f + c;
+  }
+  return o;
+}
+function Pn(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  if (r < n)
+    return o.fill(NaN);
+  const e = Math.floor(n / 2), l = Math.floor(Math.sqrt(n)), s = new Float64Array(r);
+  for (let a = 0; a < n - 1; a++)
+    s[a] = NaN;
+  const i = R(t, e), f = R(t, n);
+  for (let a = n - 1; a < r; a++)
+    s[a] = 2 * i[a] - f[a];
+  return R(s, l, !1);
+}
+function Un(t, n, r = 2, o = 30, e = !0) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const l = t.length, s = new Float64Array(l);
+  return l < n ? (s.fill(NaN), s) : (e && !S() && !L(t) && (e = !1), e ? Dn(t, n, r, o) : p(t, n, r, o));
+}
+function p(t, n, r, o) {
+  const e = t.length, l = new Float64Array(e);
+  if (l.fill(NaN), e < n + 1)
+    return l;
+  const s = 2 / (r + 1), i = 2 / (o + 1), f = Math.abs;
+  let a = 0;
+  for (let u = 1; u <= n; u++)
+    a += f(t[u] - t[u - 1]);
+  let c = t[n - 1];
+  l[n - 1] = c;
+  for (let u = n; u < e; u++) {
+    const N = f(t[u] - t[u - n]), w = (a !== 0 ? N / a : 0) * (s - i) + i, m = w * w;
+    if (c = c + m * (t[u] - c), l[u] = c, u + 1 < e) {
+      const g = f(t[u + 1] - t[u]), v = f(t[u - n + 1] - t[u - n]);
+      a += g - v;
+    }
+  }
+  return l;
+}
+function Dn(t, n, r, o) {
+  const e = t.length, l = new Float64Array(e);
+  l.fill(NaN);
+  let s = !1;
+  for (let c = 0; c < e; c++)
+    if (t[c] !== t[c]) {
+      s = !0;
+      break;
+    }
+  if (!s)
+    return p(t, n, r, o);
+  const i = [], f = [];
+  for (let c = 0; c < e; c++) {
+    const u = t[c];
+    u === u && (i.push(c), f.push(u));
+  }
+  if (f.length < n + 1)
+    return l;
+  const a = p(f, n, r, o);
+  for (let c = 0; c < a.length; c++) {
+    const u = i[c];
+    l[u] = a[c];
+  }
+  return l;
+}
+function Tn(t, n, r, o) {
+  for (let s = 0; s < n; s++)
+    o[s] = NaN;
+  if (n === 1) {
+    for (let s = 0; s < r; s++)
+      o[s] = t[s];
+    return o;
+  }
+  let e = 0;
+  for (let s = 0; s < n; s++)
+    e += t[s];
+  let l = e / n;
+  o[n - 1] = l;
+  for (let s = n; s < r; s++) {
+    const i = t[s];
+    l = (l * (n - 1) + i) / n, o[s] = l;
+  }
+  return o;
+}
+function Bn(t, n, r, o) {
+  o.fill(NaN);
+  let e = 0, l = 0, s, i = !1;
+  for (let f = 0; f < r; f++) {
+    const a = t[f];
+    if (a === a) {
+      if (!i) {
+        e += a, l++, l === n && (s = e / n, o[f] = s, i = !0);
+        continue;
+      }
+      s = (s * (n - 1) + a) / n, o[f] = s;
+    }
+  }
+  return o;
+}
+function tt(t, n, r = !0) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = new Float64Array(o);
+  return o < n ? (e.fill(NaN), e) : (r && !S() && !L(t) && (r = !1), r ? Bn(t, n, o, e) : Tn(t, n, o, e));
+}
+function Xn(t, n, r) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = new Float64Array(o);
+  if (e.fill(NaN), o < n)
+    return e;
+  const l = 6 * (n - 1);
+  if (o <= l)
+    return e;
+  const s = 2 / (n + 1), i = 1 - s;
+  let f = 0, a = 0, c = 0;
+  for (; f < o && c < n; ) {
+    const M = t[f++];
+    M === M && (a += M, c++);
+  }
+  if (c < n)
+    return e;
+  let u = a / n;
+  for (a = u, c = 1; f < o && c < n; ) {
+    const M = t[f++];
+    M === M && (u = s * M + i * u, a += u, c++);
+  }
+  if (c < n)
+    return e;
+  let N = a / n;
+  for (a = N, c = 1; f < o && c < n; ) {
+    const M = t[f++];
+    M === M && (u = s * M + i * u, N = s * u + i * N, a += N, c++);
+  }
+  if (c < n)
+    return e;
+  let h = a / n;
+  for (a = h, c = 1; f < o && c < n; ) {
+    const M = t[f++];
+    M === M && (u = s * M + i * u, N = s * u + i * N, h = s * N + i * h, a += h, c++);
+  }
+  if (c < n)
+    return e;
+  let w = a / n;
+  for (a = w, c = 1; f < o && c < n; ) {
+    const M = t[f++];
+    M === M && (u = s * M + i * u, N = s * u + i * N, h = s * N + i * h, w = s * h + i * w, a += w, c++);
+  }
+  if (c < n)
+    return e;
+  let m = a / n;
+  for (a = m, c = 1; f < o && c < n; ) {
+    const M = t[f++];
+    M === M && (u = s * M + i * u, N = s * u + i * N, h = s * N + i * h, w = s * h + i * w, m = s * w + i * m, a += m, c++);
+  }
+  if (c < n)
+    return e;
+  let g = a / n;
+  const v = l;
+  f = v + 1;
+  const A = r * r, b = -(A * r), y = 3 * (A - b), F = -6 * A - 3 * (r - b), x = 1 + 3 * r - b + 3 * A;
+  let d = v;
+  e[d++] = b * g + y * m + F * w + x * h;
+  for (let M = f; M < o; M++) {
+    const E = t[M];
+    u = s * E + i * u, N = s * u + i * N, h = s * N + i * h, w = s * h + i * w, m = s * w + i * m, g = s * m + i * g, e[d++] = b * g + y * m + F * w + x * h;
+  }
+  return e;
+}
+function vt(t, n = { ddof: 1, skipna: !0 }) {
+  const r = n?.ddof ?? 1;
+  let o = n?.skipna ?? !0;
+  const e = t.length;
+  let l = 0, s = 0, i = 0;
+  if (o) {
+    !S() && o && !L(t) && (o = !1);
+    for (let c = 0; c < e; c++) {
+      const u = t[c];
+      u === u && (l += u, s += u * u, i++);
+    }
+  } else {
+    i = e;
+    for (let c = 0; c < e; c++) {
+      const u = t[c];
+      l += u, s += u * u;
+    }
+  }
+  if (i === 0)
+    return NaN;
+  const f = l / i;
+  if (r < 0 || !Number.isFinite(r))
+    throw new Error("ddof must be a finite non-negative number");
+  const a = i - r;
+  return a <= 0 ? NaN : (s - i * f * f) / a;
+}
+function gt(t, n = { ddof: 1, skipna: !0 }) {
+  const r = vt(t, n);
+  return Math.sqrt(r);
+}
+function Yn(t, n, r = { ddof: 1 }) {
+  if (t.length !== n.length)
+    throw new Error("x and y must have same length");
+  const o = t.length, e = r?.ddof ?? 1;
+  let l = 0, s = 0, i = 0, f = 0;
+  for (let N = 0; N < o; N++) {
+    const h = t[N], w = n[N];
+    h === h && w === w && (l += h, s += w, i += h * w, f++);
+  }
+  if (f === 0)
+    return NaN;
+  const a = l / f, c = s / f;
+  if (e < 0 || !Number.isFinite(e))
+    throw new Error("ddof must be a finite non-negative number");
+  const u = f - e;
+  return u <= 0 ? NaN : (i - f * a * c) / u;
+}
+function rt(t, n, r) {
+  const o = t.length, e = new Float64Array(o);
+  if (e.fill(NaN), n <= 0)
+    throw new Error("period must be positive");
+  if (o < n)
+    return e;
+  let l = 0, s = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    l += f, s += f * f;
+  }
+  {
+    const i = n, f = i - r;
+    if (f > 0) {
+      const a = l / i;
+      e[n - 1] = (s - i * a * a) / f;
+    } else
+      e[n - 1] = NaN;
+  }
+  for (let i = n; i < o; i++) {
+    const f = t[i], a = t[i - n];
+    l += f - a, s += f * f - a * a;
+    const c = n, u = c - r;
+    if (u > 0) {
+      const N = l / c;
+      e[i] = (s - c * N * N) / u;
+    } else
+      e[i] = NaN;
+  }
+  return e;
+}
+function yt(t, n, r = { skipna: !0, ddof: 1 }) {
+  let o = r.skipna ?? !0, e = r.ddof ?? 1;
+  return o ? !S() && !L(t) ? rt(t, n, e) : zn(t, n, e) : rt(t, n, e);
+}
+function zn(t, n, r) {
+  const o = t.length, e = new Float64Array(o);
+  if (e.fill(NaN), n <= 0)
+    throw new Error("period must be positive");
+  if (o < n)
+    return e;
+  let l = 0, s = 0, i = 0;
+  for (let f = 0; f < n; f++) {
+    const a = t[f];
+    a === a && (l += a, s += a * a, i++);
+  }
+  {
+    const f = i - r;
+    e[n - 1] = f > 0 ? (s - i * (l / i) * (l / i)) / f : NaN;
+  }
+  for (let f = n; f < o; f++) {
+    const a = t[f], c = t[f - n];
+    a === a && (l += a, s += a * a, i++), c === c && (l -= c, s -= c * c, i--);
+    const u = i - r;
+    e[f] = u > 0 ? (s - i * (l / i) * (l / i)) / u : NaN;
+  }
+  return e;
+}
+function At(t, n, r, o = { ddof: 1 }) {
+  const e = o?.ddof ?? 1;
+  if (t.length !== n.length)
+    throw new Error("x and y must have same length");
+  const l = t.length, s = new Float64Array(l);
+  let i = 0, f = 0, a = 0, c = 0;
+  for (let N = 0; N < r; N++) {
+    const h = t[N], w = n[N];
+    h === h && w === w && (i += h, f += w, a += h * w, c++);
+  }
+  const u = e + 1;
+  if (c >= u) {
+    const N = 1 / c, h = i * N, w = f * N, m = c - e;
+    s[r - 1] = m > 0 ? (a - c * h * w) / m : NaN;
+  } else
+    s[r - 1] = NaN;
+  for (let N = r; N < l; N++) {
+    const h = t[N], w = n[N], m = t[N - r], g = n[N - r];
+    h === h && w === w && (i += h, f += w, a += h * w, c++), m === m && g === g && (i -= m, f -= g, a -= m * g, c--);
+    const v = e + 1;
+    if (c >= v) {
+      const A = 1 / c, b = i * A, y = f * A, F = c - e;
+      s[N] = F > 0 ? (a - c * b * y) / F : NaN;
+    } else
+      s[N] = NaN;
+  }
+  return s;
+}
+function K(t, n, r = { skipna: !0, ddof: 1 }) {
+  const o = yt(t, n, r), e = new Float64Array(o.length);
+  for (let l = 0; l < o.length; l++)
+    e[l] = Math.sqrt(o[l]);
+  return e;
+}
+function B(t, n = { skipna: !0 }) {
+  const r = n?.weights;
+  let o = n?.skipna ?? !0;
+  if (r && r.length !== t.length)
+    throw new Error("source and weights must have same length");
+  if (!S() && o && (r ? L(t, r) || (o = !1) : L(t) || (o = !1)), !r) {
+    if (!o) {
+      const f = Z(t, !1);
+      return f !== f ? NaN : f / t.length;
+    }
+    const s = Z(t, !0);
+    if (s !== s)
+      return NaN;
+    let i = 0;
+    for (let f = 0; f < t.length; f++)
+      t[f] === t[f] && i++;
+    return s / i;
+  }
+  if (!o) {
+    let s = 0, i = 0;
+    for (let f = 0; f < t.length; f++) {
+      const a = t[f], c = r[f];
+      s += a * c, i += c;
+    }
+    return i === 0 ? NaN : s / i;
+  }
+  let e = 0, l = 0;
+  for (let s = 0; s < t.length; s++) {
+    const i = t[s], f = r[s];
+    i === i && f === f && (e += i * f, l += f);
+  }
+  return l === 0 ? NaN : e / l;
+}
+function Hn(t, n, r = !0) {
+  const o = t.length, e = new Float64Array(o);
+  if (e.fill(NaN), n <= 0)
+    throw new Error("period must be positive");
+  if (o < n)
+    return e;
+  if (!S() && r && !L(t)) {
+    let i = 0;
+    for (let f = 0; f < n; f++)
+      i += t[f];
+    e[n - 1] = i / n;
+    for (let f = n; f < o; f++)
+      i += t[f] - t[f - n], e[f] = i / n;
+    return e;
+  }
+  let l = 0, s = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    f === f && (l += f, s++);
+  }
+  e[n - 1] = s > 0 ? l / s : NaN;
+  for (let i = n; i < o; i++) {
+    const f = t[i], a = t[i - n];
+    f === f && (l += f, s++), a === a && (l -= a, s--), e[i] = s > 0 ? l / s : NaN;
+  }
+  return e;
+}
+function Rn(t, n = { skipna: !0 }) {
+  const r = n?.weights;
+  let o = n?.skipna ?? !0;
+  if (r && r.length !== t.length)
+    throw new Error("source and weights must have same length");
+  if (!S() && o && (r ? L(t, r) || (o = !1) : L(t) || (o = !1)), !r) {
+    if (!o) {
+      let f = 0;
+      for (let a = 0; a < t.length; a++) {
+        const c = t[a];
+        if (c <= 0 || c !== c)
+          return NaN;
+        f += 1 / c;
+      }
+      return t.length === 0 ? NaN : t.length / f;
+    }
+    let s = 0, i = 0;
+    for (let f = 0; f < t.length; f++) {
+      const a = t[f];
+      if (a === a) {
+        if (a <= 0)
+          return NaN;
+        s += 1 / a, i++;
+      }
+    }
+    return i === 0 ? NaN : i / s;
+  }
+  if (!o) {
+    let s = 0, i = 0;
+    for (let f = 0; f < t.length; f++) {
+      const a = t[f], c = r[f];
+      if (a <= 0 || a !== a || c !== c)
+        return NaN;
+      s += c / a, i += c;
+    }
+    return i === 0 ? NaN : i / s;
+  }
+  let e = 0, l = 0;
+  for (let s = 0; s < t.length; s++) {
+    const i = t[s], f = r[s];
+    if (i === i && f === f) {
+      if (i <= 0)
+        return NaN;
+      e += f / i, l += f;
+    }
+  }
+  return l === 0 ? NaN : l / e;
+}
+function Kn(t, n = { skipna: !0 }) {
+  const r = n?.weights;
+  let o = n?.skipna ?? !0;
+  if (r && r.length !== t.length)
+    throw new Error("source and weights must have same length");
+  if (!S() && o && (r ? L(t, r) || (o = !1) : L(t) || (o = !1)), !r) {
+    if (!o) {
+      let f = 0;
+      for (let a = 0; a < t.length; a++) {
+        const c = t[a];
+        if (c <= 0 || c !== c)
+          return NaN;
+        f += Math.log(c);
+      }
+      return t.length === 0 ? NaN : Math.exp(f / t.length);
+    }
+    let s = 0, i = 0;
+    for (let f = 0; f < t.length; f++) {
+      const a = t[f];
+      if (a === a) {
+        if (a <= 0)
+          return NaN;
+        s += Math.log(a), i++;
+      }
+    }
+    return i === 0 ? NaN : Math.exp(s / i);
+  }
+  if (!o) {
+    let s = 0, i = 0;
+    for (let f = 0; f < t.length; f++) {
+      const a = t[f], c = r[f];
+      if (a <= 0 || a !== a || c !== c)
+        return NaN;
+      s += c * Math.log(a), i += c;
+    }
+    return i === 0 ? NaN : Math.exp(s / i);
+  }
+  let e = 0, l = 0;
+  for (let s = 0; s < t.length; s++) {
+    const i = t[s], f = r[s];
+    if (i === i && f === f) {
+      if (i <= 0)
+        return NaN;
+      e += f * Math.log(i), l += f;
+    }
+  }
+  return l === 0 ? NaN : Math.exp(e / l);
+}
+function Wn(t, n = !0) {
+  if (t.length === 0)
+    return NaN;
+  const r = B(t, { skipna: n });
+  if (r !== r)
+    return NaN;
+  if (!S() && n && !L(t)) {
+    let l = 0;
+    for (let s = 0; s < t.length; s++)
+      l += Math.abs(t[s] - r);
+    return l / t.length;
+  }
+  let o = 0, e = 0;
+  if (!n) {
+    for (let l = 0; l < t.length; l++)
+      o += Math.abs(t[l] - r);
+    return o / t.length;
+  }
+  for (let l = 0; l < t.length; l++) {
+    const s = t[l];
+    s === s && (o += Math.abs(s - r), e++);
+  }
+  return e === 0 ? NaN : o / e;
+}
+function J(t, n, r) {
+  const o = t[n];
+  t[n] = t[r], t[r] = o;
+}
+function Gn(t, n, r, o) {
+  const e = t[o];
+  J(t, o, r);
+  let l = n;
+  for (let s = n; s < r; s++)
+    t[s] < e && (J(t, l, s), l++);
+  return J(t, l, r), l;
+}
+function nt(t, n, r, o) {
+  for (; o > r; ) {
+    const e = o - r + 1;
+    if (e > 600) {
+      const i = n - r + 1, f = Math.log(e), a = Math.floor(0.5 * Math.exp(2 * f / 3)), c = Math.floor(0.5 * Math.sqrt(f * a * (e - a) / e) * (i - e / 2 >= 0 ? 1 : -1)), u = Math.max(r, Math.floor(n - i * a / e + c)), N = Math.min(o, Math.floor(n + (e - i) * a / e + c));
+      nt(t, n, u, N), r = u, o = N;
+    }
+    const l = (() => {
+      const i = r + (o - r >> 1), f = t[r], a = t[i], c = t[o];
+      return f <= a && a <= c || c <= a && a <= f ? i : a <= f && f <= c || c <= f && f <= a ? r : o;
+    })(), s = Gn(t, r, o, l);
+    if (n === s)
+      return t[n];
+    n < s ? o = s - 1 : r = s + 1;
+  }
+  return t[r];
+}
+function z(t, n, r, o) {
+  let e = n;
+  for (; e > 0; ) {
+    const l = e - 1 >> 1, s = t[e], i = t[l], f = o[s], a = o[i];
+    if (r && f < a || !r && f > a || f === a && s < i)
+      t[e] = i, t[l] = s, e = l;
+    else
+      break;
+  }
+}
+function $n(t, n, r, o, e) {
+  let l = r;
+  for (; ; ) {
+    const s = l * 2 + 1, i = s + 1;
+    let f = l;
+    if (s < n) {
+      const a = t[s], c = t[f], u = e[a], N = e[c];
+      (o ? u < N || u === N && a < c : u > N || u === N && a < c) && (f = s);
+    }
+    if (i < n) {
+      const a = t[i], c = t[f], u = e[a], N = e[c];
+      (o ? u < N || u === N && a < c : u > N || u === N && a < c) && (f = i);
+    }
+    if (f !== l) {
+      const a = t[l];
+      t[l] = t[f], t[f] = a, l = f;
+    } else
+      break;
+  }
+}
+function et(t, n, r, o, e) {
+  if (n === 0)
+    return { top: void 0, len: 0 };
+  const l = t[0], s = t[--n];
+  return t[0] = s, $n(t, n, 0, r, o), e[l] = 0, { top: l, len: n };
+}
+function C(t, n, r, o, e, l) {
+  for (; n > 0; ) {
+    const s = t[0];
+    if (o[s])
+      n = et(t, n, r, l, e).len, o[s] = 0;
+    else
+      break;
+  }
+  return n;
+}
+function Jn(t) {
+  return T(t, 0.5);
+}
+function bt(t, n, r) {
+  const o = t.length, e = new Float64Array(o);
+  if (n <= 0)
+    throw new Error("period must be positive");
+  if (o < n) {
+    const m = new Float64Array(o);
+    return m.fill(NaN), m;
+  }
+  const l = Math.min(o, n - 1);
+  for (let m = 0; m < l; m++)
+    e[m] = NaN;
+  if (r < 0 || r > 1)
+    throw new Error("q must be in [0,1]");
+  const s = new Int32Array(n), i = new Int32Array(n), f = new Uint8Array(o), a = new Uint8Array(o);
+  let c = 0, u = 0, N = 0, h = 0;
+  const w = t;
+  for (let m = 0; m < o; m++) {
+    const g = m, v = w[g];
+    if (v === v) {
+      const b = c === 0 ? void 0 : s[0];
+      b === void 0 || v <= w[b] ? (s[c] = g, z(s, c, !1, w), c++, N++, a[g] = 1) : (i[u] = g, z(i, u, !0, w), u++, h++, a[g] = 2);
+    }
+    if (m >= n) {
+      const b = m - n;
+      a[b] === 1 ? (N--, f[b] = 1, a[b] = 0) : a[b] === 2 && (h--, f[b] = 1, a[b] = 0);
+    }
+    const A = N + h;
+    if (A !== 0) {
+      const y = Math.floor((A - 1) * r) + 1;
+      for (c = C(s, c, !1, f, a, w), u = C(i, u, !0, f, a, w); N > y; ) {
+        c = C(s, c, !1, f, a, w);
+        const F = et(s, c, !1, w, a), x = F.top;
+        c = F.len, N--, i[u] = x, z(i, u, !0, w), u++, h++;
+      }
+      for (; N < y; ) {
+        u = C(i, u, !0, f, a, w);
+        const F = et(i, u, !0, w, a), x = F.top;
+        u = F.len, h--, s[c] = x, z(s, c, !1, w), c++, N++;
+      }
+      c = C(s, c, !1, f, a, w), u = C(i, u, !0, f, a, w);
+    }
+    if (m >= n - 1) {
+      c = C(s, c, !1, f, a, w), u = C(i, u, !0, f, a, w);
+      const b = N + h;
+      if (b === 0)
+        e[m] = NaN;
+      else if ((b & 1) === 1) {
+        const y = s[0];
+        e[m] = w[y];
+      } else {
+        const y = s[0], F = i[0];
+        e[m] = (w[y] + w[F]) / 2;
+      }
+    }
+  }
+  return e;
+}
+function Qn(t, n) {
+  return t.length, bt(t, n, 0.5);
+}
+function Ft(t, n, r) {
+  const o = (n - 1) * r, e = Math.floor(o), l = Math.ceil(o);
+  if (e === l)
+    return nt(t, e, 0, n - 1);
+  const s = nt(t, e, 0, n - 1);
+  let i = 1 / 0;
+  for (let a = e + 1; a < n; a++) {
+    const c = t[a];
+    c < i && (i = c);
+  }
+  const f = o - e;
+  return s * (1 - f) + i * f;
+}
+function T(t, n) {
+  if (n < 0 || n > 1)
+    throw new Error("q must be in [0,1]");
+  const r = t.length;
+  if (r === 0)
+    return NaN;
+  const o = new Float64Array(r);
+  let e = 0;
+  for (let l = 0; l < r; l++) {
+    const s = t[l];
+    s === s && (o[e++] = s);
+  }
+  return e === 0 ? NaN : Ft(o, e, n);
+}
+function Zn(t, n) {
+  if (n.length === 0)
+    return [];
+  if (n.length === 1)
+    return [T(t, n[0])];
+  const r = t.length, o = new Float64Array(r);
+  let e = 0;
+  for (let f = 0; f < r; f++) {
+    const a = t[f];
+    a === a && (o[e++] = a);
+  }
+  if (e === 0)
+    return n.map(() => NaN);
+  const l = new Array(n.length);
+  if (n.length <= 10) {
+    for (let f = 0; f < n.length; f++) {
+      const a = n[f];
+      if (a < 0 || a > 1) {
+        l[f] = NaN;
+        continue;
+      }
+      l[f] = Ft(o, e, a);
+    }
+    return l;
+  }
+  const s = o.subarray(0, e);
+  s.sort();
+  const i = e;
+  for (let f = 0; f < n.length; f++) {
+    const a = n[f];
+    if (a < 0 || a > 1) {
+      l[f] = NaN;
+      continue;
+    }
+    const c = (i - 1) * a, u = Math.floor(c), N = Math.ceil(c);
+    if (u === N)
+      l[f] = s[u];
+    else {
+      const h = c - u;
+      l[f] = s[u] * (1 - h) + s[N] * h;
+    }
+  }
+  return l;
+}
+function pn(t, n, r) {
+  return t.length, bt(t, n, r);
+}
+function te(t, n = !0) {
+  const r = t.length, o = new Float64Array(r);
+  if (r === 0)
+    return o;
+  !S() && n && (L(t) || (n = !1));
+  const e = B(t, { skipna: n }), l = gt(t, { ddof: 1, skipna: n });
+  if (l === 0 || l !== l)
+    return o.fill(NaN), o;
+  for (let s = 0; s < r; s++)
+    o[s] = (t[s] - e) / l;
+  return o;
+}
+function ne(t, n = !0) {
+  const r = t.length, o = new Float64Array(r);
+  if (r === 0)
+    return o;
+  if (n) {
+    let e = 1 / 0, l = -1 / 0;
+    for (let i = 0; i < r; i++) {
+      const f = t[i];
+      f === f && (f < e && (e = f), f > l && (l = f));
+    }
+    if (e !== e || l !== l || l === e)
+      return o.fill(NaN), o;
+    const s = l - e;
+    for (let i = 0; i < r; i++) {
+      const f = t[i];
+      o[i] = f === f ? (f - e) / s : NaN;
+    }
+    return o;
+  } else {
+    let e = t[0], l = t[0];
+    for (let i = 1; i < r; i++) {
+      const f = t[i];
+      f < e && (e = f), f > l && (l = f);
+    }
+    if (l === e)
+      return o.fill(NaN), o;
+    const s = l - e;
+    for (let i = 0; i < r; i++)
+      o[i] = (t[i] - e) / s;
+    return o;
+  }
+}
+function ee(t, n, r = !0) {
+  if (t.length !== n.length)
+    throw new Error("x and y must have same length");
+  const o = t.length;
+  if (o === 0)
+    return NaN;
+  if (!S() && r && (L(t, n) || (r = !1)), r) {
+    let e = 0, l = 0, s = 0, i = 0, f = 0, a = 0;
+    for (let v = 0; v < o; v++) {
+      const A = t[v], b = n[v];
+      A === A && b === b && (e += A, l += b, s += A * b, i += A * A, f += b * b, a++);
+    }
+    if (a === 0)
+      return NaN;
+    const c = 1;
+    if (!Number.isFinite(c))
+      throw new Error("ddof must be a finite non-negative number");
+    const u = a - c;
+    if (u <= 0)
+      return NaN;
+    const N = e / a, h = l / a, w = (s - a * N * h) / u, m = (i - a * N * N) / u, g = (f - a * h * h) / u;
+    return m === 0 || g === 0 ? NaN : w / Math.sqrt(m * g);
+  } else {
+    let e = 0, l = 0;
+    for (let u = 0; u < o; u++)
+      e += t[u], l += n[u];
+    const s = e / o, i = l / o;
+    let f = 0, a = 0, c = 0;
+    for (let u = 0; u < o; u++) {
+      const N = t[u] - s, h = n[u] - i;
+      f += N * h, a += N * N, c += h * h;
+    }
+    return a === 0 || c === 0 ? NaN : f / Math.sqrt(a * c);
+  }
+}
+function oe(t, n, r, o) {
+  const l = (o?.outLength ?? "min") === "max" ? Math.max(t.length, n.length) : Math.min(t.length, n.length), s = o?.skipna ?? !0;
+  let i, f;
+  if (t.length === l && n.length === l)
+    i = t instanceof Float64Array ? t : Float64Array.from(t), f = n instanceof Float64Array ? n : Float64Array.from(n);
+  else {
+    i = new Float64Array(l), f = new Float64Array(l);
+    for (let h = 0; h < l; h++)
+      i[h] = h < t.length ? t[h] : NaN, f[h] = h < n.length ? n[h] : NaN;
+  }
+  const a = At(i, f, r), c = K(i, r, { skipna: s }), u = K(f, r, { skipna: s }), N = new Float64Array(l);
+  for (let h = 0; h < l; h++) {
+    const w = c[h] * u[h];
+    w > 1e-12 ? N[h] = a[h] / w : N[h] = NaN;
+  }
+  return N;
+}
+function le(t, n) {
+  let r = n?.lower ?? 0.05, o = n?.upper ?? 0.95, e = n?.skipna ?? !0;
+  const l = t.length, s = new Float64Array(l);
+  if (l === 0)
+    return s;
+  if (r < 0 || o < 0 || r > 1 || o > 1 || r > o)
+    throw new Error("invalid quantile bounds");
+  !S() && e && (L(t) || (e = !1));
+  const i = T(t, r), f = T(t, o);
+  if (i !== i || f !== f)
+    return s.fill(NaN), s;
+  if (e)
+    for (let a = 0; a < l; a++) {
+      const c = t[a];
+      c !== c ? s[a] = NaN : c < i ? s[a] = i : c > f ? s[a] = f : s[a] = c;
+    }
+  else
+    for (let a = 0; a < l; a++) {
+      const c = t[a];
+      c < i ? s[a] = i : c > f ? s[a] = f : s[a] = c;
+    }
+  return s;
+}
+function re(t) {
+  const n = t.length, r = B(t);
+  if (r !== r)
+    return NaN;
+  let o = 0, e = 0, l = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    if (f === f) {
+      const a = f - r;
+      o += a * a, e += a * a * a, l++;
+    }
+  }
+  if (l < 3)
+    return NaN;
+  const s = Math.sqrt(o / l);
+  return s === 0 ? 0 : e / l / (s * s * s);
+}
+function ie(t) {
+  const n = t.length, r = B(t);
+  if (r !== r)
+    return NaN;
+  let o = 0, e = 0, l = 0;
+  for (let i = 0; i < n; i++) {
+    const f = t[i];
+    if (f === f) {
+      const a = f - r, c = a * a;
+      o += c, e += c * c, l++;
+    }
+  }
+  if (l < 4)
+    return NaN;
+  const s = o / l;
+  return s === 0 ? 0 : e / l / (s * s) - 3;
+}
+function fe(t, n) {
+  const r = t.length, o = new Float64Array(r).fill(NaN);
+  if (r < n)
+    return o;
+  let e = 0, l = 0, s = 0, i = 0;
+  for (let f = 0; f < n; f++) {
+    const a = t[f];
+    a === a && (i++, e += a, l += a * a, s += a * a * a);
+  }
+  if (i >= 3) {
+    const f = e / i, a = l / i - f * f;
+    if (a > 1e-12) {
+      const c = Math.sqrt(a);
+      o[n - 1] = (s / i - 3 * f * a - f * f * f) / (c * c * c);
+    } else
+      o[n - 1] = 0;
+  }
+  for (let f = n; f < r; f++) {
+    const a = t[f - n];
+    a === a && (i--, e -= a, l -= a * a, s -= a * a * a);
+    const c = t[f];
+    if (c === c && (i++, e += c, l += c * c, s += c * c * c), i >= 3) {
+      const u = e / i, N = l / i - u * u;
+      if (N > 1e-12) {
+        const h = Math.sqrt(N);
+        o[f] = (s / i - 3 * u * N - u * u * u) / (h * h * h);
+      } else
+        o[f] = 0;
+    }
+  }
+  return o;
+}
+function se(t, n) {
+  const r = t.length, o = new Float64Array(r).fill(NaN);
+  if (r < n)
+    return o;
+  let e = 0, l = 0, s = 0, i = 0, f = 0;
+  for (let a = 0; a < n; a++) {
+    const c = t[a];
+    if (c === c) {
+      f++, e += c;
+      const u = c * c;
+      l += u, s += u * c, i += u * u;
+    }
+  }
+  if (f >= 4) {
+    const a = e / f, c = l / f - a * a;
+    if (c > 1e-12) {
+      const u = l / f, N = s / f, h = i / f;
+      o[n - 1] = (h - 4 * a * N + 6 * a * a * u - 3 * a * a * a * a) / (c * c) - 3;
+    } else
+      o[n - 1] = 0;
+  }
+  for (let a = n; a < r; a++) {
+    const c = t[a - n];
+    if (c === c) {
+      f--, e -= c;
+      const N = c * c;
+      l -= N, s -= N * c, i -= N * N;
+    }
+    const u = t[a];
+    if (u === u) {
+      f++, e += u;
+      const N = u * u;
+      l += N, s += N * u, i += N * N;
+    }
+    if (f >= 4) {
+      const N = e / f, h = l / f - N * N;
+      if (h > 1e-12) {
+        const w = l / f, m = s / f, g = i / f;
+        o[a] = (g - 4 * N * m + 6 * N * N * w - 3 * N * N * N * N) / (h * h) - 3;
+      } else
+        o[a] = 0;
+    }
+  }
+  return o;
+}
+function ae(t) {
+  for (let n = t.length - 1; n > 0; n--) {
+    const r = Math.floor(Math.random() * (n + 1)), o = t[n];
+    t[n] = t[r], t[r] = o;
+  }
+  return t;
+}
+function ce(t, n) {
+  if (n <= 0)
+    return [];
+  const r = t.length;
+  if (n >= r)
+    return t.slice();
+  const o = [], e = t.slice();
+  for (let l = 0; l < n; l++) {
+    const s = Math.floor(Math.random() * e.length);
+    o.push(e[s]), e.splice(s, 1);
+  }
+  return o;
+}
+function ue(t, n) {
+  const r = [];
+  for (let o = 0; o < n; o++) {
+    const e = Math.floor(Math.random() * t.length);
+    r.push(t[e]);
+  }
+  return r;
+}
+const to = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bootstrap: ue,
+  corr: ee,
+  covar: Yn,
+  gmean: Kn,
+  hmean: Rn,
+  kurtosis: ie,
+  mad: Wn,
+  mean: B,
+  median: Jn,
+  norminmax: ne,
+  percentiles: Zn,
+  quantile: T,
+  rollcorr: oe,
+  rollcovar: At,
+  rollkurtosis: se,
+  rollmean: Hn,
+  rollmedian: Qn,
+  rollquantile: pn,
+  rollskew: fe,
+  rollstdev: K,
+  rollvar: yt,
+  sample: ce,
+  shuffle: ae,
+  skew: re,
+  stdev: gt,
+  var: vt,
+  winsorize: le,
+  zscore: te
+}, Symbol.toStringTag, { value: "Module" }));
+function Ne(t, n, r = 5, o = 34, e = !0) {
+  if (r <= 0 || o <= 0)
+    throw new Error("Periods must be positive");
+  if (r >= o)
+    throw new Error("shortPeriod should be less than longPeriod");
+  const l = t.length;
+  if (n.length !== l)
+    throw new Error("high and low must have same length");
+  const s = new Float64Array(l);
+  if (l < o)
+    return s.fill(NaN);
+  let i = e;
+  if (i && !S() && (L(t, n) || (i = !0)), !i) {
+    const u = new Float64Array(o), N = new Float64Array(r);
+    let h = 0, w = 0, m = 0, g = 0;
+    for (let v = 0; v < l; v++) {
+      const A = (t[v] + n[v]) / 2;
+      h += A, w += A;
+      const b = u[m];
+      h -= b, u[m] = A, m++, m === o && (m = 0);
+      const y = N[g];
+      w -= y, N[g] = A, g++, g === r && (g = 0), v >= o - 1 && (v >= r - 1 ? s[v] = w / r - h / o : s[v] = NaN);
+    }
+    return s;
+  }
+  const f = st(t, n), a = _(f, r), c = _(f, o);
+  return ft(a, c);
+}
+function he(t, n, r) {
+  if (n <= 0 || r <= 0)
+    throw new Error("Periods must be positive");
+  if (n >= r)
+    throw new Error("shortPeriod should be less than longPeriod");
+  const o = t.length, e = new Float64Array(o);
+  if (e.fill(NaN), o < r)
+    return e;
+  const l = 2 / (n + 1), s = 2 / (r + 1);
+  let i = NaN, f = NaN, a = 0, c = 0;
+  for (let u = 0; u < o; u++) {
+    const N = t[u];
+    if (N === N) {
+      if (a === 0) {
+        i = N, f = N, a = 1, c = 1;
+        continue;
+      }
+      i = i + l * (N - i), f = f + s * (N - f), a++, c++, c >= r && a >= n && (e[u] = i - f);
+    }
+  }
+  return e;
+}
+function we(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r);
+  if (r === 0)
+    return o;
+  if (r < n + 1)
+    return o.fill(NaN), o;
+  for (let f = 0; f < n; f++)
+    o[f] = NaN;
+  let e = 0, l = 0, s = 0;
+  for (let f = 1; f <= n; f++) {
+    const a = t[f - 1], u = t[f] - a;
+    u === u && (s++, u > 0 ? e += u : u < 0 && (l += -u));
+  }
+  const i = e + l;
+  o[n] = s === 0 ? NaN : i !== 0 ? 100 * (e - l) / i : 0;
+  for (let f = n + 1; f < r; f++) {
+    const a = t[f - 1], u = t[f] - a, N = t[f - n - 1], w = t[f - n] - N, m = w === w, g = u === u;
+    if (m && (w > 0 ? e -= w : w < 0 && (l -= -w), s--), g && (u > 0 ? e += u : u < 0 && (l += -u), s++), s === 0) {
+      o[f] = NaN;
+      continue;
+    }
+    const v = e + l;
+    o[f] = v !== 0 ? 100 * (e - l) / v : 0;
+  }
+  return o;
+}
+function me(t, n, r, o) {
+  if (n <= 0 || r <= 0 || o <= 0)
+    throw new Error("Periods must be positive");
+  const e = t.length, l = new Float64Array(e), s = new Float64Array(e), i = new Float64Array(e);
+  l.fill(NaN), s.fill(NaN), i.fill(NaN);
+  const f = r + o - 1;
+  if (e < f)
+    return [l, s, i];
+  const a = 2 / (n + 1), c = 2 / (r + 1), u = 2 / (o + 1);
+  let N = !1, h = NaN, w = NaN, m = NaN, g = 0, v = 0;
+  for (let A = 0; A < e; A++) {
+    const b = t[A];
+    if (b === b) {
+      if (g === 0) {
+        h = b, w = b, g = 1, v = 1;
+        continue;
+      }
+      if (h = h + a * (b - h), w = w + c * (b - w), g++, v++, v >= r && g >= n) {
+        const y = h - w;
+        l[A] = y, N ? (m = m + u * (y - m), s[A] = m, i[A] = y - m) : (m = y, N = !0, s[A] = m, i[A] = 0);
+      }
+    }
+  }
+  return [l, s, i];
+}
+function ve(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r).fill(NaN, 0, Math.min(r, n));
+  if (r <= n)
+    return o;
+  for (let e = n; e < r; e++)
+    o[e] = t[e] - t[e - n];
+  return o;
+}
+function ge(t, n, r) {
+  if (n <= 0 || r <= 0)
+    throw new Error("Periods must be positive");
+  if (n >= r)
+    throw new Error("shortPeriod should be less than longPeriod");
+  const o = t.length, e = new Float64Array(o);
+  for (let u = 0; u < o; u++)
+    e[u] = NaN;
+  if (o === 0)
+    return e;
+  const l = 2 / (n + 1), s = 2 / (r + 1);
+  let i = 0;
+  for (; i < o && t[i] !== t[i]; )
+    i++;
+  if (i === o)
+    return e;
+  let f = t[i], a = t[i], c = 1;
+  for (i = i + 1; i < o; i++) {
+    const u = t[i];
+    u === u && (f = f + l * (u - f), a = a + s * (u - a), c++, c >= r && (a === 0 ? e[i] = 0 : e[i] = 100 * (f - a) / a));
+  }
+  return e;
+}
+function Mt(t, n, r = 1) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = new Float64Array(o);
+  for (let l = 0; l < n; l++)
+    e[l] = NaN;
+  if (o <= n)
+    return e;
+  for (let l = n; l < o; l++) {
+    const s = t[l], i = t[l - n];
+    e[l] = r * (s - i) / i;
+  }
+  return e;
+}
+function ye(t, n) {
+  return Mt(t, n, 1);
+}
+function D(t, n) {
+  return Mt(t, n, 100);
+}
+function Ae(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  if (o.fill(NaN, 0, n), r < n + 1)
+    return o;
+  let e = 0, l = 0;
+  for (let f = 1; f <= n; f++) {
+    const a = t[f] - t[f - 1];
+    a > 0 ? e += a : l += -a;
+  }
+  let s = e / n, i = l / n;
+  o[n] = i === 0 ? 100 : 100 - 100 / (1 + s / i);
+  for (let f = n + 1; f < r; f++) {
+    const a = t[f] - t[f - 1], c = Math.max(a, 0), u = Math.max(-a, 0);
+    s = (s * (n - 1) + c) / n, i = (i * (n - 1) + u) / n, o[f] = i === 0 ? 100 : 100 - 100 / (1 + s / i);
+  }
+  return o;
+}
+function be(t, n) {
+  const r = t.length, o = new Float64Array(r);
+  if (o.fill(NaN), r < n + 1)
+    return o;
+  let e = 0, l = 0, s = 0, i = NaN, f = NaN, a = NaN;
+  for (let c = 0; c < r; c++) {
+    const u = t[c];
+    if (u !== u)
+      continue;
+    if (a !== a) {
+      a = u;
+      continue;
+    }
+    const N = u - a, h = Math.max(N, 0), w = Math.max(-N, 0);
+    s < n ? (e += h, l += w, s++, s === n ? (i = e / n, f = l / n, o[c] = f === 0 ? 100 : 100 - 100 / (1 + i / f)) : o[c] = NaN) : (i = (i * (n - 1) + h) / n, f = (f * (n - 1) + w) / n, o[c] = f === 0 ? 100 : 100 - 100 / (1 + i / f)), a = u;
+  }
+  return o;
+}
+function xt(t, n, r = !0) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length;
+  if (r && !S()) {
+    let e = !1;
+    for (let l = 0; l < o; l++)
+      if (t[l] !== t[l]) {
+        e = !0;
+        break;
+      }
+    e || (r = !1);
+  }
+  return r ? be(t, n) : Ae(t, n);
+}
+function Fe(t, n, r, o, e, l) {
+  if (o <= 0 || e <= 0 || l <= 0)
+    throw new Error("Periods must be positive");
+  const s = r.length;
+  if (t.length !== s || n.length !== s)
+    throw new Error("high, low and close must have equal length");
+  const i = new Float64Array(s), f = new Float64Array(s);
+  if (s === 0)
+    return [i, f];
+  const a = o + e + l - 2;
+  if (s < a)
+    return [i.fill(NaN), f.fill(NaN)];
+  const c = new Float64Array(s).fill(NaN);
+  lt(n, t, o, (w, m, g) => {
+    const v = r[g], A = m - w;
+    c[g] = A === 0 ? 0 : (v - w) / A * 100;
+  });
+  const N = _(c, e, !1), h = _(N, l, !1);
+  return [N, h];
+}
+function Me(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r);
+  o.fill(NaN);
+  const e = xt(t, n);
+  if (r === 0)
+    return o;
+  const l = new Int32Array(r), s = new Int32Array(r), i = new Int32Array(r), f = new Int32Array(r);
+  let a = 0, c = 0, u = 0, N = 0, h = -1;
+  for (let w = 0; w < r; w++) {
+    const m = e[w];
+    if (m !== m) {
+      o[w] = NaN;
+      continue;
+    }
+    for (h++; c > a && e[l[c - 1]] >= m; )
+      c--;
+    l[c] = w, i[c] = h, c++;
+    const g = h - n;
+    for (; c > a && i[a] <= g; )
+      a++;
+    for (; N > u && e[s[N - 1]] <= m; )
+      N--;
+    s[N] = w, f[N] = h, N++;
+    const v = h - n;
+    for (; N > u && f[u] <= v; )
+      u++;
+    if (h >= n - 1) {
+      const A = e[l[a]], y = e[s[u]] - A;
+      o[w] = y === 0 ? 0 : (m - A) / y;
+    } else
+      o[w] = NaN;
+  }
+  return o;
+}
+const Q = { s1: 7, s2: 14, s3: 28 };
+function xe(t, n, r, o) {
+  const e = o?.s1 ?? Q.s1, l = o?.s2 ?? Q.s2, s = o?.s3 ?? Q.s3;
+  if (e <= 0 || l <= 0 || s <= 0)
+    throw new Error("Periods must be positive");
+  const i = r.length;
+  if (t.length !== i || n.length !== i)
+    throw new Error("high, low and close must have equal length");
+  const f = new Float64Array(i);
+  for (let v = 0; v < i; v++)
+    f[v] = NaN;
+  if (i === 0)
+    return f;
+  const a = new Float64Array(i + 1), c = new Float64Array(i + 1);
+  {
+    const v = t[0], A = n[0], y = r[0] - A, F = v - A;
+    a[1] = y, c[1] = F;
+  }
+  for (let v = 1; v < i; v++) {
+    const A = t[v], b = n[v], y = r[v], F = r[v - 1], x = Math.min(b, F), d = Math.max(A, F), M = y - x, E = d - x;
+    a[v + 1] = a[v] + M, c[v + 1] = c[v] + E;
+  }
+  const u = 4, N = 2, h = 1, w = u + N + h, m = Math.max(e, l, s);
+  if (i < m)
+    return f;
+  const g = m;
+  for (let v = g; v < i; v++) {
+    const A = v - e + 1, b = v - l + 1, y = v - s + 1, F = a[v + 1] - a[A], x = c[v + 1] - c[A], d = x === 0 ? 0 : F / x, M = a[v + 1] - a[b], E = c[v + 1] - c[b], I = E === 0 ? 0 : M / E, V = a[v + 1] - a[y], k = c[v + 1] - c[y], O = k === 0 ? 0 : V / k;
+    f[v] = 100 * ((u * d + N * I + h * O) / w);
+  }
+  return f;
+}
+function Ee(t, n, r, o) {
+  if (o <= 0)
+    throw new Error("Period must be positive");
+  const e = r.length;
+  if (t.length !== e || n.length !== e)
+    throw new Error("high, low and close must have equal length");
+  const l = new Float64Array(e);
+  return l.fill(NaN), lt(n, t, o, (i, f, a) => {
+    const c = r[a], u = f - i;
+    l[a] = u === 0 ? 0 : (f - c) / u * -100;
+  }), l;
+}
+function de(t, n, r, o = !0) {
+  if (r <= 0)
+    throw new Error("Period must be positive");
+  const e = t.length;
+  if (n.length !== e)
+    throw new Error("high and low must have same length");
+  const l = new Float64Array(e), s = new Float64Array(e);
+  if (l.fill(NaN), s.fill(NaN), e < r)
+    return [l, s];
+  if (L(t, n))
+    return [l, s];
+  let i = o;
+  if (i && !S()) {
+    let c = !1;
+    for (let u = 0; u < e; u++)
+      if (t[u] !== t[u] || n[u] !== n[u]) {
+        c = !0;
+        break;
+      }
+    c || (i = !0);
+  }
+  if (!i) {
+    let c = -1, u = NaN, N = -1, h = NaN;
+    for (let w = r; w < e; w++) {
+      const m = w - r + 1;
+      if (c < m) {
+        c = -1, u = NaN;
+        for (let A = m; A <= w; A++) {
+          const b = t[A];
+          b === b && (c === -1 || b > u) && (c = A, u = b);
+        }
+      } else {
+        const A = t[w];
+        A === A && (c === -1 || A > u) && (c = w, u = A);
+      }
+      const g = c === -1 ? NaN : w - c;
+      if (l[w - 1] = g === g ? (r - g) / r * 100 : NaN, N < m) {
+        N = -1, h = NaN;
+        for (let A = m; A <= w; A++) {
+          const b = n[A];
+          b === b && (N === -1 || b < h) && (N = A, h = b);
+        }
+      } else {
+        const A = n[w];
+        A === A && (N === -1 || A < h) && (N = w, h = A);
+      }
+      const v = N === -1 ? NaN : w - N;
+      s[w - 1] = v === v ? (r - v) / r * 100 : NaN;
+    }
+    return [l, s];
+  }
+  const f = wt(t, r), a = ht(n, r);
+  for (let c = r; c < e; c++) {
+    const u = f[c];
+    l[c - 1] = u !== u ? NaN : (r - (c - u)) / r * 100;
+    const N = a[c];
+    s[c - 1] = N !== N ? NaN : (r - (c - N)) / r * 100;
+  }
+  return [l, s];
+}
+const j = {
+  r1: 10,
+  r2: 15,
+  r3: 20,
+  r4: 30,
+  n1: 10,
+  n2: 10,
+  n3: 10,
+  n4: 15,
+  w1: 1,
+  w2: 2,
+  w3: 3,
+  w4: 4
+};
+function Ie(t, n) {
+  let r = n?.r1 ?? j.r1, o = n?.r2 ?? j.r2, e = n?.r3 ?? j.r3, l = n?.r4 ?? j.r4, s = n?.n1 ?? j.n1, i = n?.n2 ?? j.n2, f = n?.n3 ?? j.n3, a = n?.n4 ?? j.n4, c = n?.w1 ?? j.w1, u = n?.w2 ?? j.w2, N = n?.w3 ?? j.w3, h = n?.w4 ?? j.w4;
+  const w = [r, o, e, l], m = [s, i, f, a];
+  for (const O of w.concat(m))
+    if (O <= 0)
+      throw new Error("Periods must be positive");
+  if (t.length === 0)
+    return new Float64Array(0);
+  const v = D(t, r), A = D(t, o), b = D(t, e), y = D(t, l), F = _(v, s), x = _(A, i), d = _(b, f), M = _(y, a), E = U(F, c), I = U(x, u), V = U(d, N), k = U(M, h);
+  return H(H(E, I), H(V, k));
+}
+function Le(t, n, r, o) {
+  if (o <= 0)
+    throw new Error("Period must be positive");
+  const e = r.length;
+  if (t.length !== e || n.length !== e)
+    throw new Error("high, low and close must have equal length");
+  const l = new Float64Array(e).fill(NaN);
+  if (e < o)
+    return l;
+  const s = new Float64Array(e);
+  for (let w = 0; w < e; w++)
+    s[w] = (t[w] + n[w] + r[w]) / 3;
+  let i = 0, f = 0;
+  const a = o;
+  for (let w = 0; w < a && w < e; w++) {
+    const m = s[w];
+    m === m && (i += m, f++);
+  }
+  const c = Math.abs, u = 1 / a, N = 0.015, h = 2 * a - 2;
+  for (let w = a - 1; w < e; w++) {
+    if (f === a && w >= h) {
+      const m = i * u;
+      let g = 0;
+      const v = w - a + 1;
+      for (let y = v; y <= w; y++)
+        g += c(s[y] - m);
+      g = g * u;
+      const A = N * g, b = s[w];
+      l[w] = A === 0 ? 0 : (b - m) / A;
+    }
+    if (w + 1 < e) {
+      const m = w - a + 1, g = s[m];
+      g === g && (i -= g, f--);
+      const v = s[w + 1];
+      v === v && (i += v, f++);
+    }
+  }
+  return l;
+}
+function G(t, n, r, o) {
+  if (o <= 0)
+    throw new Error("Period must be positive");
+  const e = t.length;
+  if (n.length !== e || r.length !== e)
+    throw new Error("high, low and close must have equal length");
+  const l = new Float64Array(e), s = new Float64Array(e), i = new Float64Array(e), f = new Float64Array(e), a = new Float64Array(e);
+  if (e < o)
+    return l.fill(NaN), s.fill(NaN), i.fill(NaN), f.fill(NaN), a.fill(NaN), { diplus: l, diminus: s, dx: i, adx: f, adxr: a };
+  let c = 0, u = 0, N = 0;
+  function h(y) {
+    const F = t[y] - t[y - 1], x = n[y - 1] - n[y], d = F > x && F > 0 ? F : 0, M = x > F && x > 0 ? x : 0, E = t[y] - n[y], I = Math.abs(t[y] - r[y - 1]), V = Math.abs(n[y] - r[y - 1]);
+    return { tr: Math.max(E, Math.max(I, V)), p: d, m: M };
+  }
+  t[0] - n[0], c += 0;
+  for (let y = 1; y < o; y++) {
+    const F = h(y);
+    c += F.tr, u += F.p, N += F.m;
+  }
+  for (let y = 0; y < o - 1 && y < e; y++)
+    l[y] = NaN, s[y] = NaN, i[y] = NaN, a[y] = NaN;
+  const w = c !== 0 ? 100 * (u / c) : NaN, m = c !== 0 ? 100 * (N / c) : NaN;
+  l[o - 1] = w, s[o - 1] = m, i[o - 1] = 100 * Math.abs(w - m) / (w + m);
+  const g = 2 * o - 2;
+  g > 0 && (f.fill(NaN, 0, Math.min(e, g + 1)), a.fill(NaN, 0, Math.min(e, g + 1)));
+  let v = 0, A = 0;
+  const b = i[o - 1];
+  b === b && (v += b, A++);
+  for (let y = o; y <= g && y < e; y++) {
+    const { tr: F, p: x, m: d } = h(y);
+    c = c - c / o + F, u = u - u / o + x, N = N - N / o + d;
+    const M = c !== 0 ? 100 * (u / c) : NaN, E = c !== 0 ? 100 * (N / c) : NaN;
+    l[y] = M, s[y] = E;
+    const I = 100 * Math.abs(M - E) / (M + E);
+    i[y] = I, I === I && (v += I, A++), y === g && (f[g] = A === o ? v / A : NaN);
+  }
+  for (let y = Math.max(o, g + 1); y < e; y++) {
+    const { tr: F, p: x, m: d } = h(y);
+    c = c - c / o + F, u = u - u / o + x, N = N - N / o + d;
+    const M = c !== 0 ? 100 * (u / c) : NaN, E = c !== 0 ? 100 * (N / c) : NaN;
+    l[y] = M, s[y] = E;
+    const I = 100 * Math.abs(M - E) / (M + E);
+    i[y] = I, f[y] = (f[y - 1] * (o - 1) + I) / o;
+    const V = f[y - o + 1];
+    a[y] = (f[y] + V) / 2;
+  }
+  return { diplus: l, diminus: s, dx: i, adx: f, adxr: a };
+}
+function Se(t, n, r, o) {
+  const e = G(t, n, r, o);
+  return [e.diplus, e.diminus];
+}
+function Ve(t, n, r, o) {
+  return G(t, n, r, o).dx;
+}
+function _e(t, n, r, o) {
+  return G(t, n, r, o).adx;
+}
+function je(t, n, r, o) {
+  return G(t, n, r, o).adxr;
+}
+function ke(t, n) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const r = t.length, o = new Float64Array(r);
+  if (r < n)
+    return o.fill(NaN);
+  const e = _(t, n, !0), l = Math.floor(n / 2) + 1;
+  for (let s = 0; s < l && s < r; s++)
+    o[s] = NaN;
+  for (let s = l; s < r; s++)
+    o[s] = t[s - l] - e[s];
+  return o;
+}
+function qe(t, n, r, o, e = !0) {
+  if (r <= 0 || o <= 0)
+    throw new Error("step and maxStep must be positive");
+  if (r > o)
+    throw new Error("step must be <= maxStep");
+  const l = t.length;
+  if (n.length !== l)
+    throw new Error("high and low must have same length");
+  const s = new Float64Array(l);
+  if (l === 0)
+    return s;
+  function i(c, u, N, h, w, m, g, v, A, b) {
+    let y = c + u * (N - c), F, x = u, d = c, M = h, E = N;
+    return h ? (y > b && (y = b), y > A && (y = A), w > E && (E = w, x += r, x >= o && (x = o)), d = y, m < y && (x = r, d = E, M = !1, E = m), F = d) : (y < v && (y = v), y < g && (y = g), m < E && (E = m, x += r, x >= o && (x = o)), d = y, w > y && (x = r, d = E, M = !0, E = w), F = d), { sar: d, accel: x, lng: M, extreme: E, outVal: F };
+  }
+  function f(c, u) {
+    const N = c.length, h = new Float64Array(N);
+    if (h.fill(NaN), N < 2)
+      return h;
+    let w = c[0] + u[0] <= c[1] + u[1], m, g;
+    w ? (g = c[0], m = u[0]) : (g = u[0], m = c[0]);
+    let v = r;
+    {
+      const b = c[0], y = u[0], F = i(m, v, g, w, c[1], u[1], b, b, y, y);
+      m = F.sar, v = F.accel, w = F.lng, g = F.extreme, h[1] = F.outVal;
+    }
+    for (let A = 2; A < N; A++) {
+      const b = c[A], y = u[A], F = c[A - 1], x = c[A - 2], d = u[A - 1], M = u[A - 2], E = i(m, v, g, w, b, y, F, x, d, M);
+      m = E.sar, v = E.accel, w = E.lng, g = E.extreme, h[A] = E.outVal;
+    }
+    return h;
+  }
+  function a(c, u) {
+    const N = new Float64Array(l).fill(NaN);
+    if (l < 2)
+      return N;
+    const h = (M) => {
+      const E = c[M], I = u[M];
+      return E === E && I === I;
+    }, w = (M) => {
+      let E = M;
+      for (; E < l && !h(E); )
+        E++;
+      return E;
+    }, m = w(0);
+    if (m >= l)
+      return N;
+    const g = w(m + 1);
+    if (g >= l)
+      return N;
+    let v = c[m] + u[m] <= c[g] + u[g], A, b;
+    v ? (b = c[m], A = u[m]) : (b = u[m], A = c[m]);
+    let y = r;
+    {
+      const M = g, E = c[m], I = u[m], V = i(A, y, b, v, c[M], u[M], E, E, I, I);
+      A = V.sar, y = V.accel, v = V.lng, b = V.extreme, N[M] = V.outVal;
+    }
+    let F = m, x = g, d = w(x + 1);
+    for (; d < l; ) {
+      const M = c[d], E = u[d], I = c[x], V = c[F], k = u[x], O = u[F], q = i(A, y, b, v, M, E, I, V, k, O);
+      A = q.sar, y = q.accel, v = q.lng, b = q.extreme, N[d] = q.outVal, F = x, x = d, d = w(x + 1);
+    }
+    return N;
+  }
+  return e && !S() && (L(t, n) || (e = !1)), e ? a(t, n) : f(t, n);
+}
+function Et(t, n, r) {
+  const o = t.length;
+  if (n.length !== o || r.length !== o)
+    throw new Error("high/low/close must have the same length");
+  const e = new Float64Array(o);
+  if (o === 0)
+    return new Float64Array(o);
+  e[0] = r[0] === r[0] ? t[0] - n[0] : NaN;
+  for (let l = 1; l < o; l++) {
+    const s = t[l] - n[l], i = Math.abs(t[l] - r[l - 1]), f = Math.abs(n[l] - r[l - 1]);
+    e[l] = Math.max(s, Math.max(i, f));
+  }
+  return e;
+}
+function $(t, n, r, o) {
+  if (o <= 0)
+    throw new Error("Period must be positive");
+  const e = t.length;
+  if (e < o)
+    return new Float64Array(e).fill(NaN);
+  const l = Et(t, n, r);
+  return !S() && !L(t, n, r) ? tt(l, o, !1) : tt(l, o, !0);
+}
+function Oe(t, n, r, o) {
+  const e = $(t, n, r, o);
+  return Ct(e, (l, s) => l / r[s] * 100), e;
+}
+function Ce(t, n, r, o, e) {
+  if (o <= 0)
+    throw new Error("Period must be positive");
+  const l = t.length;
+  if (n.length !== l || r.length !== l)
+    throw new Error("high/low/close must have the same length");
+  const s = new Float64Array(l), i = new Float64Array(l), f = new Float64Array(l), a = new Uint8Array(l);
+  if (l === 0)
+    return [s, i, f, a];
+  const c = $(t, n, r, o);
+  for (let w = 0; w < l; w++)
+    s[w] = i[w] = f[w] = NaN;
+  let u = NaN, N = NaN, h = 1;
+  for (let w = 0; w < l; w++) {
+    const m = c[w], g = t[w], v = n[w], A = r[w];
+    if (m !== m || g !== g || v !== v || A !== A)
+      continue;
+    const b = (g + v) / 2, y = b + e * m, F = b - e * m;
+    let x = y, d = F;
+    if (w > 0 && u === u) {
+      const E = r[w - 1];
+      y < u || E === E && E > u || (x = u);
+    }
+    if (w > 0 && N === N) {
+      const E = r[w - 1];
+      F > N || E === E && E < N || (d = N);
+    }
+    let M = h;
+    A > x ? M = 1 : A < d && (M = 0), s[w] = M ? d : x, i[w] = x, f[w] = d, a[w] = M ? 1 : 0, u = x, N = d, h = M;
+  }
+  return [s, i, f, a];
+}
+const Pe = 9, Ue = 26, De = 52;
+function Te(t, n, r, o) {
+  const e = o?.tenkan ?? Pe, l = o?.kijun ?? Ue, s = o?.senkouB ?? De, i = l;
+  if (e <= 0 || l <= 0 || s <= 0)
+    throw new Error("Periods must be positive");
+  const f = t.length;
+  if (n.length !== f || r.length !== f)
+    throw new Error("high/low/close must have the same length");
+  const a = new Float64Array(f), c = new Float64Array(f), u = new Float64Array(f), N = new Float64Array(f);
+  a.fill(NaN), c.fill(NaN), u.fill(NaN), N.fill(NaN);
+  function h(F, x, d, M, E) {
+    if (!(f < d))
+      for (let I = d - 1; I < f; I++) {
+        let V = -1 / 0, k = 1 / 0, O = !1;
+        for (let q = I - d + 1; q <= I; q++) {
+          const X = F[q], Y = x[q];
+          if (X !== X || Y !== Y) {
+            O = !0;
+            break;
+          }
+          X > V && (V = X), Y < k && (k = Y);
+        }
+        if (O) {
+          M[I] = E[I] = NaN;
+          continue;
+        }
+        M[I] = V, E[I] = k;
+      }
+  }
+  const w = new Float64Array(f), m = new Float64Array(f);
+  w.fill(NaN), m.fill(NaN), h(t, n, e, w, m);
+  for (let F = 0; F < f; F++) {
+    const x = w[F], d = m[F];
+    x !== x || d !== d ? a[F] = NaN : a[F] = (x + d) / 2;
+  }
+  const g = new Float64Array(f), v = new Float64Array(f);
+  g.fill(NaN), v.fill(NaN), h(t, n, l, g, v);
+  for (let F = 0; F < f; F++) {
+    const x = g[F], d = v[F];
+    x !== x || d !== d ? c[F] = NaN : c[F] = (x + d) / 2;
+  }
+  for (let F = 0; F < f; F++) {
+    const x = a[F], d = c[F];
+    if (x !== x || d !== d)
+      continue;
+    const M = (x + d) / 2, E = F + i;
+    E < f && (u[E] = M);
+  }
+  const A = new Float64Array(f), b = new Float64Array(f);
+  A.fill(NaN), b.fill(NaN), h(t, n, s, A, b);
+  for (let F = 0; F < f; F++) {
+    const x = A[F], d = b[F];
+    if (x !== x || d !== d)
+      continue;
+    const M = (x + d) / 2, E = F + i;
+    E < f && (N[E] = M);
+  }
+  const y = ut(r, -i);
+  return [a, c, u, N, y];
+}
+function dt(t, n, r) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = _(t, n, !0), l = new Float64Array(o), s = new Float64Array(o);
+  if (s.fill(NaN, 0, Math.min(o, n)), l.fill(NaN, 0, Math.min(o, n)), o < n)
+    return [e.fill(NaN), l.fill(NaN), s.fill(NaN)];
+  const i = !(S() === !1 && !L(t)), f = K(t, n, { skipna: i, ddof: 0 });
+  for (let a = n - 1; a < o; a++) {
+    const c = e[a], u = f[a];
+    if (c !== c || u !== u) {
+      l[a] = s[a] = NaN;
+      continue;
+    }
+    l[a] = c + r * u, s[a] = c - r * u;
+  }
+  return [e, l, s];
+}
+function Be(t, n, r) {
+  if (n <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length, e = new Float64Array(o);
+  if (o === 0)
+    return e;
+  const [l, s, i] = dt(t, n, r);
+  for (let f = 0; f < o; f++) {
+    const a = l[f], c = s[f], u = i[f];
+    a !== 0 && (e[f] = 100 * (c - u) / a);
+  }
+  return e;
+}
+function Xe(t, n, r) {
+  if (r <= 0)
+    throw new Error("Period must be positive");
+  const o = t.length;
+  if (n.length !== o)
+    throw new Error("high/low must have the same length");
+  const e = new Float64Array(o), l = new Float64Array(o), s = new Float64Array(o);
+  if (e.fill(NaN, 0, Math.min(o, r - 1)), l.fill(NaN, 0, Math.min(o, r - 1)), s.fill(NaN, 0, Math.min(o, r - 1)), o < r)
+    return [e, l, s];
+  const i = !S() && !L(t, n);
+  for (let f = r - 1; f < o; f++) {
+    let a = -1 / 0, c = 1 / 0, u = !1;
+    for (let N = f - r + 1; N <= f; N++) {
+      const h = t[N], w = n[N];
+      if (h !== h || w !== w) {
+        if (u = !0, i)
+          break;
+        break;
+      }
+      h > a && (a = h), w < c && (c = w);
+    }
+    if (u) {
+      e[f] = l[f] = s[f] = NaN;
+      continue;
+    }
+    e[f] = a, l[f] = c, s[f] = (a + c) / 2;
+  }
+  return [e, l, s];
+}
+function Ye(t, n, r, o, e) {
+  if (o <= 0)
+    throw new Error("Period must be positive");
+  const l = t.length;
+  if (n.length !== l || r.length !== l)
+    throw new Error("high/low/close must have the same length");
+  if (l === 0)
+    return [new Float64Array(0), new Float64Array(0), new Float64Array(0)];
+  const s = new Float64Array(l);
+  for (let u = 0; u < l; u++) {
+    const N = t[u], h = n[u], w = r[u];
+    N !== N || h !== h || w !== w ? s[u] = NaN : s[u] = (N + h + w) / 3;
+  }
+  const i = mt(s, o), f = $(t, n, r, o), a = new Float64Array(l), c = new Float64Array(l);
+  for (let u = 0; u < l; u++) {
+    const N = i[u], h = f[u];
+    if (N !== N || h !== h) {
+      a[u] = c[u] = NaN;
+      continue;
+    }
+    a[u] = N + e * h, c[u] = N - e * h;
+  }
+  return [i, a, c];
+}
+function ze(t, n, r, o) {
+  const e = r.length;
+  if (t.length !== e || n.length !== e || o.length !== e)
+    throw new Error("high/low/close/volume must have same length");
+  const l = new Float64Array(e);
+  let s = 0;
+  for (let i = 0; i < e; i++) {
+    const f = t[i], a = n[i], c = r[i], u = o[i], N = f - a, h = N === 0 ? 0 : (c - a - (f - c)) / N, w = s + h * u;
+    w === w && (s = w), l[i] = w;
+  }
+  return l;
+}
+function He(t, n, r, o, e, l, s, i) {
+  if (e < s)
+    return i.fill(NaN);
+  const f = 2 / (l + 1), a = 2 / (s + 1), c = t[0], u = n[0], N = r[0], h = o[0];
+  let w = 0;
+  const m = c - u;
+  m !== 0 && (w = (N - u - (c - N)) / m);
+  let v = w * h, A = v, b = v;
+  i[0] = NaN;
+  for (let y = 1; y < s; y++) {
+    const F = t[y], x = n[y], d = r[y], M = o[y];
+    let E = 0;
+    const I = F - x;
+    I !== 0 && (E = (d - x - (F - d)) / I);
+    const V = E * M;
+    v += V, A = A + f * (v - A), b = b + a * (v - b), i[y] = NaN;
+  }
+  i[s - 1] = A - b;
+  for (let y = s; y < e; y++) {
+    const F = t[y], x = n[y], d = r[y], M = o[y];
+    let E = 0;
+    const I = F - x;
+    I !== 0 && (E = (d - x - (F - d)) / I);
+    const V = E * M;
+    v += V, A = A + f * (v - A), b = b + a * (v - b), i[y] = A - b;
+  }
+  return i;
+}
+function Re(t, n, r, o, e, l, s, i) {
+  i.fill(NaN);
+  const f = 2 / (l + 1), a = 2 / (s + 1);
+  let c = 0, u = NaN, N = NaN, h = 0;
+  for (let w = 0; w < e; w++) {
+    const m = t[w], g = n[w], v = r[w], A = o[w];
+    if (!(m === m && g === g && v === v && A === A))
+      continue;
+    const b = m - g;
+    let y = 0;
+    b !== 0 && (y = (v - g - (m - v)) / b);
+    const F = y * A;
+    c += F, h === 0 ? (u = c, N = c) : (u = u + f * (c - u), N = N + a * (c - N)), h++, h >= s && (i[w] = u - N);
+  }
+  return i;
+}
+function Ke(t, n, r, o, e, l, s = !0) {
+  if (e <= 0 || l <= 0)
+    throw new Error("Periods must be positive");
+  if (e >= l)
+    throw new Error("shortPeriod should be less than longPeriod");
+  const i = r.length;
+  if (t.length !== i || n.length !== i || o.length !== i)
+    throw new Error("high, low, close and volume must have equal length");
+  s && !S() && !L(t, n, r, o) && (s = !1);
+  const f = new Float64Array(i);
+  return i === 0 ? f : s ? Re(t, n, r, o, i, e, l, f) : He(t, n, r, o, i, e, l, f);
+}
+function We(t, n, r, o, e) {
+  if (e <= 0)
+    throw new Error("Period must be positive");
+  const l = r.length;
+  if (t.length !== l || n.length !== l || o.length !== l)
+    throw new Error("high, low, close and volume must have equal length");
+  const s = new Float64Array(l);
+  if (s.fill(NaN), l <= e)
+    return s;
+  const i = new Float64Array(e), f = new Float64Array(e), a = new Uint8Array(e);
+  let c = 0, u = 0, N = 0, w = (t[0] + n[0] + r[0]) / 3;
+  for (let g = 1; g < e; g++) {
+    const v = (t[g] + n[g] + r[g]) / 3, A = v * o[g], b = Number.isFinite(A);
+    let y = 0, F = 0;
+    b ? v > w ? y = A : v < w && (F = A) : (a[g] = 1, N++), i[g] = y, f[g] = F, c += y, u += F, w = v;
+  }
+  {
+    const g = e, v = (t[g] + n[g] + r[g]) / 3, A = v * o[g], b = Number.isFinite(A);
+    let y = 0, F = 0;
+    if (b ? v > w ? y = A : v < w && (F = A) : (a[0] = 1, N++), i[0] = y, f[0] = F, c += y, u += F, Number.isFinite(v) && N === 0)
+      if (c + u === 0)
+        s[g] = 50;
+      else if (u === 0)
+        s[g] = 100;
+      else {
+        const d = c / u;
+        s[g] = 100 - 100 / (1 + d);
+      }
+    w = v;
+  }
+  let m = 1;
+  for (let g = e + 1; g < l; g++) {
+    const v = (t[g] + n[g] + r[g]) / 3, A = v * o[g], b = Number.isFinite(A);
+    let y = 0, F = 0, x = 0;
+    if (b ? v > w ? y = A : v < w && (F = A) : x = 1, c += y - i[m], u += F - f[m], N += x - a[m], i[m] = y, f[m] = F, a[m] = x, m++, m === e && (m = 0), Number.isFinite(v) && N === 0)
+      if (c + u === 0)
+        s[g] = 50;
+      else if (u === 0)
+        s[g] = 100;
+      else {
+        const M = c / u;
+        s[g] = 100 - 100 / (1 + M);
+      }
+    w = v;
+  }
+  return s;
+}
+function Ge(t, n) {
+  const r = t.length;
+  if (n.length !== r)
+    throw new Error("price and volume must have same length");
+  const o = new Float64Array(r);
+  if (r === 0)
+    return o;
+  let e = 0;
+  o[0] = e;
+  for (let l = 1; l < r; l++) {
+    const s = t[l], i = t[l - 1], f = n[l];
+    if (s !== s || i !== i || f !== f) {
+      o[l] = NaN;
+      continue;
+    }
+    s > i ? e += f : s < i && (e -= f), o[l] = e;
+  }
+  return o;
+}
+function $e(t, n, r = 1e3) {
+  const o = t.length;
+  if (n.length !== o)
+    throw new Error("close and volume must have equal length");
+  const e = new Float64Array(o), l = new Float64Array(o);
+  if (o === 0)
+    return [e, l];
+  e.fill(NaN), l.fill(NaN);
+  let s = -1;
+  for (let u = 0; u < o; u++) {
+    const N = t[u], h = n[u];
+    if (N === N && h === h && N !== 0) {
+      s = u;
+      break;
+    }
+  }
+  if (s === -1)
+    return [e, l];
+  let i = r, f = r;
+  e[s] = i, l[s] = f;
+  let a = t[s], c = n[s];
+  for (let u = s + 1; u < o; u++) {
+    const N = t[u], h = n[u];
+    if (!(N === N && h === h && N !== 0))
+      continue;
+    const w = (N - a) / a;
+    h > c && (i = i + w * i), h < c && (f = f + w * f), e[u] = i, l[u] = f, a = N, c = h;
+  }
+  return [e, l];
+}
+function it(t, n, r, o, e) {
+  let l = 0;
+  e[0] = NaN;
+  for (let s = 1; s < o; s++) {
+    const i = r[s - 1], f = r[s];
+    let a = 0;
+    f > i ? a = f - Math.min(n[s], i) : f < i && (a = f - Math.max(t[s], i)), l += a, e[s] = l;
+  }
+  return e;
+}
+function Je(t, n, r, o, e) {
+  let l = 0, s = -1;
+  for (let i = 0; i < o; i++) {
+    const f = t[i], a = n[i], c = r[i];
+    if (f === f && a === a && c === c) {
+      e[i] = NaN, s = i;
+      break;
+    }
+  }
+  if (s === -1)
+    return e;
+  for (let i = s + 1; i < o; i++) {
+    const f = t[i], a = n[i], c = r[i], u = r[i - 1];
+    if (f === f && a === a && c === c && u === u) {
+      let N = 0;
+      c > u ? N = c - Math.min(a, u) : c < u && (N = c - Math.max(f, u)), l += N, e[i] = l;
+    }
+  }
+  return e;
+}
+function Qe(t, n, r, o = !0) {
+  const e = r.length;
+  if (t.length !== e || n.length !== e)
+    throw new Error("high, low and close must have equal length");
+  const l = new Float64Array(e);
+  return e === 0 ? l : o && !S() && !L(t, n, r) || !o ? it(t, n, r, e, l) : (l.fill(NaN), Je(t, n, r, e, l));
+}
+const no = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ad: ze,
+  adosc: Ke,
+  adx: _e,
+  adxr: je,
+  ao: Ne,
+  apo: he,
+  aroon: de,
+  atr: $,
+  bb: dt,
+  bbw: Be,
+  cci: Le,
+  change: ye,
+  cmo: we,
+  cross: ot,
+  crossover: Jt,
+  crossunder: Qt,
+  dema: qn,
+  di: Se,
+  donchian: Xe,
+  dpo: ke,
+  dx: Ve,
+  ema: mt,
+  falling: $t,
+  hma: Pn,
+  ichimoku: Te,
+  kama: Un,
+  keltner: Ye,
+  kst: Ie,
+  macd: me,
+  mfi: We,
+  mom: ve,
+  natr: Oe,
+  obv: Ge,
+  pnvi: $e,
+  ppo: ge,
+  psar: qe,
+  rising: Gt,
+  rma: tt,
+  roc: D,
+  rsi: xt,
+  sma: _,
+  stoch: Fe,
+  stochrsi: Me,
+  supertrend: Ce,
+  t3: Xn,
+  tema: Cn,
+  tr: Et,
+  trima: On,
+  ultosc: xe,
+  vwma: _n,
+  wad: Qe,
+  wma: R,
+  wpr: Ee
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Ze as arr,
+  pe as math,
+  to as stats,
+  no as ta
+};