velo-plot 1.11.1

package/dist/plugins/analysis.js

@@ -0,0 +1,1202 @@
+import { a as I, s as _, g as z, f as E, d as T, b as V, m as H, e as X, h as Y, v as G, c as O, j as Z, i as U } from "../utils-Dbro9-qM.js";
+import { o as Mn, l as bn, k as pn, n as In } from "../utils-Dbro9-qM.js";
+function K(e, o, r, t = {}) {
+  const n = e.series.get(o);
+  if (!n) throw new Error(`Series ${o} not found`);
+  const s = n.getData();
+  if (!s || s.x.length < 2) return "";
+  const c = D(s.x, s.y, r, t), a = n.getBounds(), l = (a == null ? void 0 : a.xMin) ?? 0, i = ((a == null ? void 0 : a.xMax) ?? 1) - l, u = 200, h = new Float32Array(u), m = new Float32Array(u);
+  for (let g = 0; g < u; g++) {
+    const F = l + g / (u - 1) * i;
+    h[g] = F, m[g] = c.predict(F);
+  }
+  const y = `${o}-fit-${Date.now()}`, w = n.getStyle();
+  return e.addSeries({
+    id: y,
+    type: "line",
+    yAxisId: n.getYAxisId(),
+    data: { x: h, y: m },
+    style: {
+      color: w.color,
+      width: (w.width || 1) * 1.5,
+      opacity: 0.8,
+      lineDash: [5, 5]
+    }
+  }), e.addAnnotation({
+    type: "text",
+    x: l + i * 0.05,
+    y: c.predict(l + i * 0.05),
+    text: `${c.equation}
+(R² = ${c.rSquared.toFixed(4)})`,
+    fontSize: 12,
+    backgroundColor: "rgba(0,0,0,0.7)",
+    color: w.color || "#ffffff",
+    padding: 4,
+    anchor: "bottom-left",
+    interactive: !0
+  }), y;
+}
+function v(e) {
+  const o = e.length, r = S(o), t = new Float64Array(r);
+  for (let s = 0; s < o; s++)
+    t[s] = e[s];
+  const n = new Array(r);
+  for (let s = 0; s < r; s++)
+    n[s] = { re: t[s], im: 0 };
+  q(n);
+  for (let s = 2; s <= r; s *= 2) {
+    const c = s / 2, a = -2 * Math.PI / s;
+    for (let l = 0; l < r; l += s)
+      for (let f = 0; f < c; f++) {
+        const i = a * f, u = Math.cos(i), h = Math.sin(i), m = l + f, y = l + f + c, w = u * n[y].re - h * n[y].im, g = u * n[y].im + h * n[y].re;
+        n[y].re = n[m].re - w, n[y].im = n[m].im - g, n[m].re = n[m].re + w, n[m].im = n[m].im + g;
+      }
+  }
+  return n;
+}
+function Q(e) {
+  const o = e.length, r = e.map((s) => ({ re: s.re, im: -s.im })), t = J(r), n = new Float32Array(o);
+  for (let s = 0; s < o; s++)
+    n[s] = t[s].re / o;
+  return n;
+}
+function J(e) {
+  const o = e.length, r = e.map((t) => ({ ...t }));
+  q(r);
+  for (let t = 2; t <= o; t *= 2) {
+    const n = t / 2, s = -2 * Math.PI / t;
+    for (let c = 0; c < o; c += t)
+      for (let a = 0; a < n; a++) {
+        const l = s * a, f = Math.cos(l), i = Math.sin(l), u = c + a, h = c + a + n, m = f * r[h].re - i * r[h].im, y = f * r[h].im + i * r[h].re;
+        r[h].re = r[u].re - m, r[h].im = r[u].im - y, r[u].re = r[u].re + m, r[u].im = r[u].im + y;
+      }
+  }
+  return r;
+}
+function q(e) {
+  const o = e.length, r = Math.log2(o);
+  for (let t = 0; t < o; t++) {
+    const n = tt(t, r);
+    if (n > t) {
+      const s = e[t];
+      e[t] = e[n], e[n] = s;
+    }
+  }
+}
+function tt(e, o) {
+  let r = 0;
+  for (let t = 0; t < o; t++)
+    r = r << 1 | e & 1, e >>= 1;
+  return r;
+}
+function S(e) {
+  let o = 1;
+  for (; o < e; ) o *= 2;
+  return o;
+}
+function C(e, o = 1) {
+  const r = v(e), t = r.length, n = t / 2, s = new Float32Array(n), c = new Float32Array(n), a = new Float32Array(n), l = new Float32Array(t), f = new Float32Array(t);
+  for (let i = 0; i < t; i++)
+    l[i] = r[i].re, f[i] = r[i].im;
+  for (let i = 0; i < n; i++)
+    s[i] = i * o / t, c[i] = Math.sqrt(r[i].re * r[i].re + r[i].im * r[i].im) / t, a[i] = Math.atan2(r[i].im, r[i].re);
+  for (let i = 1; i < n; i++)
+    c[i] *= 2;
+  return {
+    frequency: s,
+    magnitude: c,
+    phase: a,
+    complex: r,
+    real: l,
+    imag: f
+  };
+}
+function Pt(e, o = 1) {
+  const r = C(e, o), t = r.frequency.length, n = new Float32Array(t), s = new Float32Array(t);
+  for (let c = 0; c < t; c++)
+    n[c] = r.magnitude[c] * r.magnitude[c], s[c] = 10 * Math.log10(Math.max(n[c], 1e-20));
+  return {
+    frequency: r.frequency,
+    power: n,
+    powerDb: s
+  };
+}
+function vt(e, o = 1, r = 0) {
+  const t = C(e, o);
+  let n = 0, s = 0;
+  for (let c = 0; c < t.magnitude.length; c++)
+    t.frequency[c] >= r && t.magnitude[c] > n && (n = t.magnitude[c], s = c);
+  return {
+    frequency: t.frequency[s],
+    magnitude: n
+  };
+}
+function $t(e) {
+  const o = e.length, r = new Float32Array(o);
+  for (let t = 0; t < o; t++) {
+    const n = 0.5 * (1 - Math.cos(2 * Math.PI * t / (o - 1)));
+    r[t] = e[t] * n;
+  }
+  return r;
+}
+function jt(e) {
+  const o = e.length, r = new Float32Array(o);
+  for (let t = 0; t < o; t++) {
+    const n = 0.54 - 0.46 * Math.cos(2 * Math.PI * t / (o - 1));
+    r[t] = e[t] * n;
+  }
+  return r;
+}
+function Rt(e) {
+  const o = e.length, r = new Float32Array(o), t = 0.42, n = 0.5, s = 0.08;
+  for (let c = 0; c < o; c++) {
+    const a = t - n * Math.cos(2 * Math.PI * c / (o - 1)) + s * Math.cos(4 * Math.PI * c / (o - 1));
+    r[c] = e[c] * a;
+  }
+  return r;
+}
+function kt(e, o = 1) {
+  const r = v(e), t = r.length, n = t / 2, s = new Float32Array(t), c = new Float32Array(t), a = new Float32Array(t), l = new Float32Array(t), f = new Float32Array(t);
+  for (let i = 0; i < t; i++)
+    s[i] = r[i].re, c[i] = r[i].im, a[i] = i * o / t, l[i] = Math.sqrt(r[i].re * r[i].re + r[i].im * r[i].im), f[i] = Math.atan2(r[i].im, r[i].re);
+  return {
+    real: s,
+    imag: c,
+    frequency: a,
+    magnitude: l,
+    phase: f,
+    length: t,
+    nyquist: n
+  };
+}
+function St(e, o) {
+  const r = e.length;
+  if (o.length !== r)
+    throw new Error("Real and imaginary arrays must have the same length");
+  const t = S(r), n = new Array(t);
+  for (let i = 0; i < t; i++)
+    n[i] = {
+      re: i < r ? e[i] : 0,
+      im: i < r ? o[i] : 0
+    };
+  q(n);
+  for (let i = 2; i <= t; i *= 2) {
+    const u = i / 2, h = -2 * Math.PI / i;
+    for (let m = 0; m < t; m += i)
+      for (let y = 0; y < u; y++) {
+        const w = h * y, g = Math.cos(w), F = Math.sin(w), A = m + y, b = m + y + u, p = g * n[b].re - F * n[b].im, d = g * n[b].im + F * n[b].re;
+        n[b].re = n[A].re - p, n[b].im = n[A].im - d, n[A].re = n[A].re + p, n[A].im = n[A].im + d;
+      }
+  }
+  const s = new Float32Array(t), c = new Float32Array(t), a = new Float32Array(t), l = new Float32Array(t), f = new Float32Array(t);
+  for (let i = 0; i < t; i++)
+    s[i] = n[i].re, c[i] = n[i].im, a[i] = i / t, l[i] = Math.sqrt(n[i].re * n[i].re + n[i].im * n[i].im), f[i] = Math.atan2(n[i].im, n[i].re);
+  return {
+    real: s,
+    imag: c,
+    frequency: a,
+    magnitude: l,
+    phase: f,
+    length: t,
+    nyquist: t / 2
+  };
+}
+function Ct(e) {
+  const o = e.length, r = new Float32Array(o), t = new Float32Array(o);
+  for (let n = 0; n < o; n++)
+    r[n] = e[n].re, t[n] = e[n].im;
+  return { real: r, imag: t };
+}
+function nt(e, o) {
+  const r = e.length;
+  if (o.length !== r)
+    throw new Error("Real and imaginary arrays must have the same length");
+  const t = new Array(r);
+  for (let n = 0; n < r; n++)
+    t[n] = { re: e[n], im: o[n] };
+  return t;
+}
+function Dt(e, o) {
+  const r = nt(e, o);
+  return Q(r);
+}
+function Lt(e) {
+  const o = e.length, t = e.map((c) => ({ re: c.re, im: -c.im })).map((c) => ({ ...c }));
+  q(t);
+  for (let c = 2; c <= o; c *= 2) {
+    const a = c / 2, l = -2 * Math.PI / c;
+    for (let f = 0; f < o; f += c)
+      for (let i = 0; i < a; i++) {
+        const u = l * i, h = Math.cos(u), m = Math.sin(u), y = f + i, w = f + i + a, g = h * t[w].re - m * t[w].im, F = h * t[w].im + m * t[w].re;
+        t[w].re = t[y].re - g, t[w].im = t[y].im - F, t[y].re = t[y].re + g, t[y].im = t[y].im + F;
+      }
+  }
+  const n = new Float32Array(o), s = new Float32Array(o);
+  for (let c = 0; c < o; c++)
+    n[c] = t[c].re / o, s[c] = -t[c].im / o;
+  return { real: n, imag: s };
+}
+function Bt(e) {
+  const o = e.nyquist;
+  return {
+    real: e.real.slice(0, o),
+    imag: e.imag.slice(0, o),
+    frequency: e.frequency.slice(0, o),
+    magnitude: e.magnitude.slice(0, o),
+    phase: e.phase.slice(0, o)
+  };
+}
+function D(e, o, r, t = {}) {
+  if (e.length < 2) throw new Error("At least 2 points are required for fitting");
+  switch (r) {
+    case "linear":
+      return x(e, o, t);
+    case "polynomial":
+      return et(e, o, t.degree ?? 2, t);
+    case "exponential":
+      return ot(e, o, t);
+    case "logarithmic":
+      return rt(e, o, t);
+    case "power":
+      return st(e, o, t);
+    default:
+      throw new Error(`Unsupported fit type: ${r}`);
+  }
+}
+function x(e, o, r) {
+  const t = e.length;
+  let n = 0, s = 0, c = 0, a = 0;
+  for (let m = 0; m < t; m++)
+    n += e[m], s += o[m], c += e[m] * o[m], a += e[m] * e[m];
+  const l = (t * c - n * s) / (t * a - n * n), f = (s - l * n) / t, i = (m) => l * m + f, u = r.precision ?? 4, h = r.label || "y";
+  return {
+    type: "linear",
+    coefficients: [l, f],
+    equation: `${h} = ${l.toFixed(u)}x ${f >= 0 ? "+" : "-"} ${Math.abs(f).toFixed(u)}`,
+    rSquared: I(e, o, i),
+    predict: i
+  };
+}
+function et(e, o, r, t) {
+  const n = e.length, s = r + 1, c = Array.from({ length: s }, () => new Array(s).fill(0)), a = new Array(s).fill(0);
+  for (let m = 0; m < s; m++) {
+    for (let w = 0; w < s; w++) {
+      let g = 0;
+      for (let F = 0; F < n; F++)
+        g += Math.pow(e[F], m + w);
+      c[m][w] = g;
+    }
+    let y = 0;
+    for (let w = 0; w < n; w++)
+      y += o[w] * Math.pow(e[w], m);
+    a[m] = y;
+  }
+  const l = _(c, a), f = (m) => {
+    let y = 0;
+    for (let w = 0; w < l.length; w++)
+      y += l[w] * Math.pow(m, w);
+    return y;
+  }, i = t.precision ?? 4;
+  let u = "y = ";
+  for (let m = l.length - 1; m >= 0; m--) {
+    const y = l[m];
+    m < l.length - 1 ? u += y >= 0 ? " + " : " - " : y < 0 && (u += "-"), u += `${Math.abs(y).toFixed(i)}${m > 0 ? m > 1 ? `x^${m}` : "x" : ""}`;
+  }
+  const h = t.label || "y";
+  return {
+    type: "polynomial",
+    coefficients: l,
+    equation: `${h} = ${u.substring(4)}`,
+    // replace "y = " with custom label
+    rSquared: I(e, o, f),
+    predict: f
+  };
+}
+function ot(e, o, r) {
+  const t = e.length, n = [], s = [];
+  for (let h = 0; h < t; h++)
+    o[h] > 0 && (n.push(e[h]), s.push(Math.log(o[h])));
+  const c = x(n, s, r), a = c.coefficients[0], l = Math.exp(c.coefficients[1]), f = (h) => l * Math.exp(a * h), i = r.precision ?? 4, u = r.label || "y";
+  return {
+    type: "exponential",
+    coefficients: [l, a],
+    equation: `${u} = ${l.toFixed(i)} * e^(${a.toFixed(i)}x)`,
+    rSquared: I(e, o, f),
+    predict: f
+  };
+}
+function rt(e, o, r) {
+  const t = e.length, n = [], s = [];
+  for (let h = 0; h < t; h++)
+    e[h] > 0 && (n.push(Math.log(e[h])), s.push(o[h]));
+  const c = x(n, s, r), a = c.coefficients[0], l = c.coefficients[1], f = (h) => l + a * Math.log(h), i = r.precision ?? 4, u = r.label || "y";
+  return {
+    type: "logarithmic",
+    coefficients: [l, a],
+    equation: `${u} = ${l.toFixed(i)} ${a >= 0 ? "+" : "-"} ${Math.abs(a).toFixed(i)} * ln(x)`,
+    rSquared: I(e, o, f),
+    predict: f
+  };
+}
+function st(e, o, r) {
+  const t = e.length, n = [], s = [];
+  for (let h = 0; h < t; h++)
+    e[h] > 0 && o[h] > 0 && (n.push(Math.log(e[h])), s.push(Math.log(o[h])));
+  const c = x(n, s, r), a = c.coefficients[0], l = Math.exp(c.coefficients[1]), f = (h) => l * Math.pow(h, a), i = r.precision ?? 4, u = r.label || "y";
+  return {
+    type: "power",
+    coefficients: [l, a],
+    equation: `${u} = ${l.toFixed(i)} * x^(${a.toFixed(i)})`,
+    rSquared: I(e, o, f),
+    predict: f
+  };
+}
+function N(e, o) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  if (o < 1 || o > r.length)
+    return t.fill(NaN), t;
+  for (let s = 0; s < o - 1; s++)
+    t[s] = NaN;
+  let n = 0;
+  for (let s = 0; s < o; s++)
+    n += r[s];
+  t[o - 1] = n / o;
+  for (let s = o; s < r.length; s++)
+    n = n - r[s - o] + r[s], t[s] = n / o;
+  return t;
+}
+function M(e, o) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  if (o < 1 || o > r.length)
+    return t.fill(NaN), t;
+  const n = 2 / (o + 1);
+  for (let c = 0; c < o - 1; c++)
+    t[c] = NaN;
+  let s = 0;
+  for (let c = 0; c < o; c++)
+    s += r[c];
+  t[o - 1] = s / o;
+  for (let c = o; c < r.length; c++)
+    t[c] = (r[c] - t[c - 1]) * n + t[c - 1];
+  return t;
+}
+function Wt(e, o) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  if (o < 1 || o > r.length)
+    return t.fill(NaN), t;
+  const n = o * (o + 1) / 2;
+  for (let s = 0; s < o - 1; s++)
+    t[s] = NaN;
+  for (let s = o - 1; s < r.length; s++) {
+    let c = 0;
+    for (let a = 0; a < o; a++)
+      c += r[s - o + 1 + a] * (a + 1);
+    t[s] = c / n;
+  }
+  return t;
+}
+function _t(e, o) {
+  const r = M(e, o), t = M(r, o), n = new Float32Array(e.length);
+  for (let s = 0; s < e.length; s++)
+    n[s] = 2 * r[s] - t[s];
+  return n;
+}
+function zt(e, o) {
+  const r = M(e, o), t = M(r, o), n = M(t, o), s = new Float32Array(e.length);
+  for (let c = 0; c < e.length; c++)
+    s[c] = 3 * r[c] - 3 * t[c] + n[c];
+  return s;
+}
+function ct(e, o = 14) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  if (o < 1 || r.length < o + 1)
+    return t.fill(NaN), t;
+  for (let c = 0; c < o; c++)
+    t[c] = NaN;
+  let n = 0, s = 0;
+  for (let c = 1; c <= o; c++) {
+    const a = r[c] - r[c - 1];
+    a > 0 ? n += a : s += Math.abs(a);
+  }
+  if (n /= o, s /= o, s === 0)
+    t[o] = 100;
+  else {
+    const c = n / s;
+    t[o] = 100 - 100 / (1 + c);
+  }
+  for (let c = o + 1; c < r.length; c++) {
+    const a = r[c] - r[c - 1];
+    let l = 0, f = 0;
+    if (a > 0 ? l = a : f = Math.abs(a), n = (n * (o - 1) + l) / o, s = (s * (o - 1) + f) / o, s === 0)
+      t[c] = 100;
+    else {
+      const i = n / s;
+      t[c] = 100 - 100 / (1 + i);
+    }
+  }
+  return t;
+}
+function Et(e, o = 12, r = 26, t = 9) {
+  const n = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), s = M(n, o), c = M(n, r), a = new Float32Array(n.length);
+  for (let i = 0; i < n.length; i++)
+    a[i] = s[i] - c[i];
+  const l = M(a, t), f = new Float32Array(n.length);
+  for (let i = 0; i < n.length; i++)
+    f[i] = a[i] - l[i];
+  return {
+    values: a,
+    signal: l,
+    histogram: f
+  };
+}
+function Tt(e, o = 14, r = 3) {
+  const { high: t, low: n, close: s } = e, c = s.length, a = new Float32Array(c);
+  for (let f = 0; f < c; f++) {
+    if (f < o - 1) {
+      a[f] = NaN;
+      continue;
+    }
+    let i = -1 / 0, u = 1 / 0;
+    for (let m = f - o + 1; m <= f; m++)
+      t[m] > i && (i = t[m]), n[m] < u && (u = n[m]);
+    const h = i - u;
+    h === 0 ? a[f] = 50 : a[f] = (s[f] - u) / h * 100;
+  }
+  const l = N(a, r);
+  return {
+    values: a,
+    // %K
+    signal: l
+    // %D
+  };
+}
+function Vt(e, o = 10) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  for (let n = 0; n < o; n++)
+    t[n] = NaN;
+  for (let n = o; n < r.length; n++) {
+    const s = r[n - o];
+    s === 0 ? t[n] = NaN : t[n] = (r[n] - s) / s * 100;
+  }
+  return t;
+}
+function Ht(e, o = 10) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  for (let n = 0; n < o; n++)
+    t[n] = NaN;
+  for (let n = o; n < r.length; n++)
+    t[n] = r[n] - r[n - o];
+  return t;
+}
+function Xt(e, o = 20, r = 2) {
+  const t = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), n = N(t, o), s = new Float32Array(t.length), c = new Float32Array(t.length);
+  for (let a = 0; a < t.length; a++) {
+    if (a < o - 1) {
+      s[a] = NaN, c[a] = NaN;
+      continue;
+    }
+    let l = 0;
+    for (let i = a - o + 1; i <= a; i++) {
+      const u = t[i] - n[a];
+      l += u * u;
+    }
+    const f = Math.sqrt(l / o);
+    s[a] = n[a] + r * f, c[a] = n[a] - r * f;
+  }
+  return {
+    values: n,
+    upper: s,
+    lower: c
+  };
+}
+function Yt(e, o = 14) {
+  const { high: r, low: t, close: n } = e, s = n.length, c = new Float32Array(s);
+  c[0] = r[0] - t[0];
+  for (let a = 1; a < s; a++) {
+    const l = r[a] - t[a], f = Math.abs(r[a] - n[a - 1]), i = Math.abs(t[a] - n[a - 1]);
+    c[a] = Math.max(l, f, i);
+  }
+  return M(c, o);
+}
+function Gt(e, o = 20) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length), n = N(r, o);
+  for (let s = 0; s < r.length; s++) {
+    if (s < o - 1) {
+      t[s] = NaN;
+      continue;
+    }
+    let c = 0;
+    for (let a = s - o + 1; a <= s; a++) {
+      const l = r[a] - n[s];
+      c += l * l;
+    }
+    t[s] = Math.sqrt(c / o);
+  }
+  return t;
+}
+function Ot(e) {
+  const { high: o, low: r, close: t, volume: n } = e;
+  if (!n)
+    throw new Error("VWAP requires volume data");
+  const s = t.length, c = new Float32Array(s);
+  let a = 0, l = 0;
+  for (let f = 0; f < s; f++) {
+    const i = (o[f] + r[f] + t[f]) / 3;
+    a += i * n[f], l += n[f], l === 0 ? c[f] = i : c[f] = a / l;
+  }
+  return c;
+}
+function Zt(e, o) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = o instanceof Float32Array || o instanceof Float64Array ? o : Float32Array.from(o), n = new Float32Array(r.length);
+  n[0] = t[0];
+  for (let s = 1; s < r.length; s++)
+    r[s] > r[s - 1] ? n[s] = n[s - 1] + t[s] : r[s] < r[s - 1] ? n[s] = n[s - 1] - t[s] : n[s] = n[s - 1];
+  return n;
+}
+function Ut(e, o = 14) {
+  const { high: r, low: t, close: n } = e, s = n.length, c = new Float32Array(s), a = new Float32Array(s), l = new Float32Array(s);
+  l[0] = r[0] - t[0], c[0] = 0, a[0] = 0;
+  for (let g = 1; g < s; g++) {
+    const F = r[g] - r[g - 1], A = t[g - 1] - t[g];
+    c[g] = F > A && F > 0 ? F : 0, a[g] = A > F && A > 0 ? A : 0;
+    const b = r[g] - t[g], p = Math.abs(r[g] - n[g - 1]), d = Math.abs(t[g] - n[g - 1]);
+    l[g] = Math.max(b, p, d);
+  }
+  const f = M(l, o), i = M(c, o), u = M(a, o), h = new Float32Array(s), m = new Float32Array(s), y = new Float32Array(s);
+  for (let g = 0; g < s; g++)
+    if (f[g] === 0 || isNaN(f[g]))
+      h[g] = NaN, m[g] = NaN, y[g] = NaN;
+    else {
+      h[g] = i[g] / f[g] * 100, m[g] = u[g] / f[g] * 100;
+      const F = h[g] + m[g];
+      y[g] = F === 0 ? 0 : Math.abs(h[g] - m[g]) / F * 100;
+    }
+  return {
+    values: M(y, o),
+    upper: h,
+    // +DI
+    lower: m
+    // -DI
+  };
+}
+function Kt(e, o = 25) {
+  const { high: r, low: t } = e, n = r.length, s = new Float32Array(n), c = new Float32Array(n);
+  for (let l = 0; l < n; l++) {
+    if (l < o) {
+      s[l] = NaN, c[l] = NaN;
+      continue;
+    }
+    let f = l, i = l, u = -1 / 0, h = 1 / 0;
+    for (let m = l - o; m <= l; m++)
+      r[m] > u && (u = r[m], f = m), t[m] < h && (h = t[m], i = m);
+    s[l] = (o - (l - f)) / o * 100, c[l] = (o - (l - i)) / o * 100;
+  }
+  const a = new Float32Array(n);
+  for (let l = 0; l < n; l++)
+    a[l] = s[l] - c[l];
+  return {
+    values: a,
+    upper: s,
+    lower: c
+  };
+}
+function Qt(e, o = 1) {
+  const r = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), t = new Float32Array(r.length);
+  for (let n = 0; n < o; n++)
+    t[n] = NaN;
+  for (let n = o; n < r.length; n++) {
+    const s = r[n - o];
+    s === 0 ? t[n] = NaN : t[n] = (r[n] - s) / s * 100;
+  }
+  return t;
+}
+function Jt(e) {
+  const o = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), r = new Float32Array(o.length);
+  r[0] = o[0];
+  for (let t = 1; t < o.length; t++)
+    r[t] = r[t - 1] + o[t];
+  return r;
+}
+function tn(e) {
+  const o = e instanceof Float32Array || e instanceof Float64Array ? e : Float32Array.from(e), r = new Float32Array(o.length);
+  let t = 1 / 0, n = -1 / 0;
+  for (let c = 0; c < o.length; c++)
+    isNaN(o[c]) || (o[c] < t && (t = o[c]), o[c] > n && (n = o[c]));
+  const s = n - t;
+  if (s === 0)
+    r.fill(50);
+  else
+    for (let c = 0; c < o.length; c++)
+      r[c] = (o[c] - t) / s * 100;
+  return r;
+}
+function nn(e, o, r, t = 5) {
+  const n = o / (r / 2), s = L(Math.min(n, 0.99), t);
+  return P(e, s);
+}
+function en(e, o, r, t = 5) {
+  const n = o / (r / 2), s = at(Math.min(n, 0.99), t);
+  return P(e, s);
+}
+function on(e, o, r, t, n = 5) {
+  const s = o / (t / 2), c = r / (t / 2), a = B(
+    Math.max(s, 0.01),
+    Math.min(c, 0.99),
+    n
+  );
+  return P(e, a);
+}
+function rn(e, o, r, t, n = 5) {
+  const s = o / (t / 2), c = r / (t / 2), a = lt(
+    Math.max(s, 0.01),
+    Math.min(c, 0.99),
+    n
+  );
+  return P(e, a);
+}
+function L(e, o) {
+  const r = 2 * o + 1, t = new Float32Array(r), n = e;
+  for (let c = 0; c < r; c++) {
+    const a = c - o;
+    a === 0 ? t[c] = 2 * n : t[c] = Math.sin(2 * Math.PI * n * a) / (Math.PI * a), t[c] *= 0.54 - 0.46 * Math.cos(2 * Math.PI * c / (r - 1));
+  }
+  let s = 0;
+  for (let c = 0; c < r; c++) s += t[c];
+  for (let c = 0; c < r; c++) t[c] /= s;
+  return t;
+}
+function at(e, o) {
+  const r = L(e, o), t = r.length, n = new Float32Array(t);
+  for (let s = 0; s < t; s++)
+    n[s] = -r[s];
+  return n[o] += 1, n;
+}
+function B(e, o, r) {
+  const t = 2 * r + 1, n = new Float32Array(t), s = e, c = o;
+  for (let a = 0; a < t; a++) {
+    const l = a - r;
+    l === 0 ? n[a] = 2 * (c - s) : n[a] = (Math.sin(2 * Math.PI * c * l) - Math.sin(2 * Math.PI * s * l)) / (Math.PI * l), n[a] *= 0.54 - 0.46 * Math.cos(2 * Math.PI * a / (t - 1));
+  }
+  return n;
+}
+function lt(e, o, r) {
+  const t = B(e, o, r), n = t.length, s = new Float32Array(n);
+  for (let c = 0; c < n; c++)
+    s[c] = -t[c];
+  return s[r] += 1, s;
+}
+function P(e, o) {
+  const r = e.length, t = o.length, n = Math.floor(t / 2), s = new Float32Array(r);
+  for (let c = 0; c < r; c++) {
+    let a = 0;
+    for (let l = 0; l < t; l++) {
+      const f = c - n + l;
+      f >= 0 && f < r && (a += e[f] * o[l]);
+    }
+    s[c] = a;
+  }
+  return s;
+}
+function sn(e, o) {
+  const { type: r, cutoff: t, cutoffHigh: n, sampleRate: s = 1, order: c = 2 } = o, a = 2 * t / s, l = n ? 2 * n / s : void 0, { b: f, a: i } = ut(r, a, l);
+  return W(e, f, i);
+}
+function it(e, o) {
+  const { frequency: r, sampleRate: t, bandwidth: n = 1 } = o, { b: s, a: c } = ft(r, t, n);
+  return W(e, s, c);
+}
+function ft(e, o, r) {
+  const t = 2 * Math.PI * e / o, s = 1 - 2 * Math.PI * r / o / 2, c = Math.cos(t), a = [1, -2 * c, 1], l = [1, -2 * s * c, s * s];
+  return { b: a, a: l };
+}
+function ut(e, o, r, t) {
+  const n = Math.tan(Math.PI * o / 2);
+  if (e === "lowpass")
+    return $(n);
+  if (e === "highpass")
+    return ht(n);
+  if (e === "bandpass" && r) {
+    const s = Math.tan(Math.PI * r / 2);
+    return mt(n, s);
+  } else if (e === "bandstop" && r) {
+    const s = Math.tan(Math.PI * r / 2);
+    return gt(n, s);
+  }
+  return $(n);
+}
+function $(e, o) {
+  const r = e, t = r * r, n = Math.sqrt(2), s = 1 / (1 + n * r + t);
+  return {
+    b: [t * s, 2 * t * s, t * s],
+    a: [1, 2 * (t - 1) * s, (1 - n * r + t) * s]
+  };
+}
+function ht(e, o) {
+  const r = e, t = r * r, n = Math.sqrt(2), s = 1 / (1 + n * r + t);
+  return {
+    b: [s, -2 * s, s],
+    a: [1, 2 * (t - 1) * s, (1 - n * r + t) * s]
+  };
+}
+function mt(e, o, r) {
+  const t = Math.sqrt(e * o), n = o - e, s = t / n, c = 1 / (1 + t / s + t * t);
+  return {
+    b: [t / s * c, 0, -t / s * c],
+    a: [1, 2 * (t * t - 1) * c, (1 - t / s + t * t) * c]
+  };
+}
+function gt(e, o, r) {
+  const t = Math.sqrt(e * o), n = o - e, s = t / n, c = 1 / (1 + t / s + t * t);
+  return {
+    b: [(1 + t * t) * c, 2 * (t * t - 1) * c, (1 + t * t) * c],
+    a: [1, 2 * (t * t - 1) * c, (1 - t / s + t * t) * c]
+  };
+}
+function j(e, o, r) {
+  const t = e.length, n = new Float32Array(t);
+  for (let s = 0; s < t; s++) {
+    n[s] = o[0] * e[s];
+    for (let c = 1; c < o.length; c++)
+      s - c >= 0 && (n[s] += o[c] * e[s - c], n[s] -= r[c] * n[s - c]);
+  }
+  return n;
+}
+function W(e, o, r) {
+  const t = j(e, o, r), n = new Float32Array(t.length);
+  for (let a = 0; a < t.length; a++)
+    n[a] = t[t.length - 1 - a];
+  const s = j(n, o, r), c = new Float32Array(s.length);
+  for (let a = 0; a < s.length; a++)
+    c[a] = s[s.length - 1 - a];
+  return c;
+}
+function cn(e, o = 0.3) {
+  const r = e.length, t = new Float32Array(r);
+  t[0] = e[0];
+  for (let n = 1; n < r; n++)
+    t[n] = o * e[n] + (1 - o) * t[n - 1];
+  return t;
+}
+function an(e, o = 2) {
+  const r = e.length, t = new Float32Array(r), n = Math.ceil(o * 3) * 2 + 1, s = Math.floor(n / 2), c = new Float32Array(n);
+  let a = 0;
+  for (let l = 0; l < n; l++) {
+    const f = l - s;
+    c[l] = Math.exp(-(f * f) / (2 * o * o)), a += c[l];
+  }
+  for (let l = 0; l < n; l++)
+    c[l] /= a;
+  for (let l = 0; l < r; l++) {
+    let f = 0;
+    for (let i = 0; i < n; i++) {
+      const u = l - s + i;
+      u >= 0 && u < r && (f += e[u] * c[i]);
+    }
+    t[l] = f;
+  }
+  return t;
+}
+function ln(e, o = 5, r = 2) {
+  const t = e.length, n = new Float32Array(t), s = Math.floor(o / 2), c = yt(o);
+  for (let a = 0; a < t; a++) {
+    let l = 0;
+    for (let f = -s; f <= s; f++) {
+      const i = a + f;
+      i >= 0 && i < t ? l += e[i] * c[f + s] : i < 0 ? l += e[0] * c[f + s] : l += e[t - 1] * c[f + s];
+    }
+    n[a] = l;
+  }
+  return n;
+}
+function yt(e, o) {
+  const r = Math.floor(e / 2), t = new Float32Array(e), n = 1 / e;
+  for (let c = 0; c < e; c++) {
+    const a = c - r;
+    t[c] = n * (1 - a * a / ((r + 1) * (r + 1)));
+  }
+  let s = 0;
+  for (let c = 0; c < e; c++) s += t[c];
+  for (let c = 0; c < e; c++) t[c] /= s;
+  return t;
+}
+function fn(e, o = 5) {
+  const r = e.length, t = new Float32Array(r), n = Math.floor(o / 2);
+  for (let s = 0; s < r; s++) {
+    const c = [];
+    for (let a = -n; a <= n; a++) {
+      const l = s + a;
+      l >= 0 && l < r && c.push(e[l]);
+    }
+    c.sort((a, l) => a - l), t[s] = c[Math.floor(c.length / 2)];
+  }
+  return t;
+}
+function un(e, o, r, t = {}) {
+  const n = o.length, s = r.length, c = Math.min(...e), a = Math.max(...e), l = t.levels || wt(c, a, t.numLevels || 10), f = [];
+  for (const i of l) {
+    const u = [];
+    for (let h = 0; h < s - 1; h++)
+      for (let m = 0; m < n - 1; m++) {
+        const y = e[h * n + m], w = e[h * n + (m + 1)], g = e[(h + 1) * n + (m + 1)], F = e[(h + 1) * n + m];
+        Ft(m, h, y, w, g, F, i, o, r, u);
+      }
+    if (u.length > 0) {
+      const h = [];
+      for (const m of u)
+        h.push({ x: m[0], y: m[1] }), h.push({ x: m[2], y: m[3] });
+      f.push({ level: i, points: h });
+    }
+  }
+  return f;
+}
+function wt(e, o, r) {
+  const t = [], n = (o - e) / (r + 1);
+  for (let s = 1; s <= r; s++)
+    t.push(e + s * n);
+  return t;
+}
+function Ft(e, o, r, t, n, s, c, a, l, f) {
+  let i = 0;
+  if (r >= c && (i |= 1), t >= c && (i |= 2), n >= c && (i |= 4), s >= c && (i |= 8), i === 0 || i === 15) return;
+  const u = (w, g, F) => w + (g - w) * F, h = (w, g) => (c - w) / (g - w), m = (w) => {
+    switch (w) {
+      case 0:
+        return [u(a[e], a[e + 1], h(r, t)), l[o]];
+      case 1:
+        return [a[e + 1], u(l[o], l[o + 1], h(t, n))];
+      case 2:
+        return [u(a[e], a[e + 1], h(s, n)), l[o + 1]];
+      case 3:
+        return [a[e], u(l[o], l[o + 1], h(r, s))];
+      default:
+        return [0, 0];
+    }
+  }, y = (w, g) => {
+    const F = m(w), A = m(g);
+    f.push([F[0], F[1], A[0], A[1]]);
+  };
+  switch (i) {
+    case 1:
+    case 14:
+      y(0, 3);
+      break;
+    case 2:
+    case 13:
+      y(0, 1);
+      break;
+    case 3:
+    case 12:
+      y(1, 3);
+      break;
+    case 4:
+    case 11:
+      y(1, 2);
+      break;
+    case 5:
+      y(0, 1), y(2, 3);
+      break;
+    case 6:
+    case 9:
+      y(0, 2);
+      break;
+    case 7:
+    case 8:
+      y(2, 3);
+      break;
+    case 10:
+      y(0, 3), y(1, 2);
+      break;
+  }
+}
+function At(e, o, r) {
+  const t = e.length, n = o.length, s = r ?? Math.min(t, n) - 1, c = 2 * s + 1, a = new Float32Array(c), l = new Float32Array(c);
+  let f = 0, i = 0;
+  for (let g = 0; g < t; g++) f += e[g];
+  for (let g = 0; g < n; g++) i += o[g];
+  f /= t, i /= n;
+  let u = 0, h = 0;
+  for (let g = 0; g < t; g++) u += (e[g] - f) ** 2;
+  for (let g = 0; g < n; g++) h += (o[g] - i) ** 2;
+  u = Math.sqrt(u / t), h = Math.sqrt(h / n);
+  const m = u * h * Math.min(t, n);
+  let y = -1 / 0, w = 0;
+  for (let g = 0; g < c; g++) {
+    const F = g - s;
+    l[g] = F;
+    let A = 0;
+    for (let b = 0; b < t; b++) {
+      const p = b + F;
+      p >= 0 && p < n && (A += (e[b] - f) * (o[p] - i));
+    }
+    a[g] = m > 0 ? A / m : 0, a[g] > y && (y = a[g], w = g);
+  }
+  return {
+    correlation: a,
+    lags: l,
+    maxCorrelation: y,
+    lagAtMax: l[w]
+  };
+}
+function hn(e, o) {
+  return At(e, e, o);
+}
+function mn(e, o = {}) {
+  const { method: r = "zscore", windowSize: t } = o;
+  switch (r) {
+    case "zscore":
+      return R(e, o.threshold ?? 3, t);
+    case "mad":
+      return Mt(e, o.threshold ?? 2.5);
+    case "iqr":
+      return bt(e, o.threshold ?? 1.5);
+    case "isolation":
+      return pt(e, o.threshold ?? 0.5);
+    default:
+      return R(e, 3, t);
+  }
+}
+function R(e, o, r) {
+  const t = e.length, n = new Float32Array(t), s = [];
+  if (r && r < t) {
+    const c = Math.floor(r / 2);
+    for (let a = 0; a < t; a++) {
+      const l = Math.max(0, a - c), f = Math.min(t, a + c + 1);
+      let i = 0;
+      for (let h = l; h < f; h++) i += e[h];
+      i /= f - l;
+      let u = 0;
+      for (let h = l; h < f; h++) u += (e[h] - i) ** 2;
+      u = Math.sqrt(u / (f - l)), n[a] = u > 0 ? Math.abs(e[a] - i) / u : 0, n[a] > o && s.push(a);
+    }
+  } else {
+    let c = 0;
+    for (let l = 0; l < t; l++) c += e[l];
+    c /= t;
+    let a = 0;
+    for (let l = 0; l < t; l++) a += (e[l] - c) ** 2;
+    a = Math.sqrt(a / t);
+    for (let l = 0; l < t; l++)
+      n[l] = a > 0 ? Math.abs(e[l] - c) / a : 0, n[l] > o && s.push(l);
+  }
+  return { indices: s, scores: n, threshold: o };
+}
+function Mt(e, o, r) {
+  const t = e.length, n = new Float32Array(t), s = [], c = Array.from(e).sort((u, h) => u - h), a = c[Math.floor(t / 2)], i = 1.4826 * c.map((u) => Math.abs(u - a)).sort((u, h) => u - h)[Math.floor(t / 2)];
+  for (let u = 0; u < t; u++)
+    n[u] = i > 0 ? Math.abs(e[u] - a) / i : 0, n[u] > o && s.push(u);
+  return { indices: s, scores: n, threshold: o };
+}
+function bt(e, o) {
+  const r = e.length, t = new Float32Array(r), n = [], s = Array.from(e).sort((u, h) => u - h), c = s[Math.floor(r * 0.25)], a = s[Math.floor(r * 0.75)], l = a - c, f = c - o * l, i = a + o * l;
+  for (let u = 0; u < r; u++)
+    e[u] < f ? (t[u] = (f - e[u]) / l, n.push(u)) : e[u] > i ? (t[u] = (e[u] - i) / l, n.push(u)) : t[u] = 0;
+  return { indices: n, scores: t, threshold: o };
+}
+function pt(e, o, r) {
+  const t = e.length, n = new Float32Array(t), s = [], c = It(e);
+  for (let a = 0; a < t; a++) {
+    let l = 0;
+    for (let f = 0; f < t; f++)
+      a !== f && Math.abs(e[a] - e[f]) < c && l++;
+    n[a] = 1 - l / t, n[a] > o && s.push(a);
+  }
+  return { indices: s, scores: n, threshold: o };
+}
+function It(e) {
+  let o = 1 / 0, r = -1 / 0;
+  for (let t = 0; t < e.length; t++)
+    e[t] < o && (o = e[t]), e[t] > r && (r = e[t]);
+  return (r - o) * 0.1;
+}
+function k(e, o) {
+  const r = e.length;
+  if (r < 2) return 0;
+  let t = 0;
+  if (typeof o == "number") {
+    const n = o;
+    for (let s = 1; s < r; s++)
+      t += (e[s - 1] + e[s]) * n / 2;
+  } else if (o)
+    for (let n = 1; n < r; n++)
+      t += (e[n - 1] + e[n]) * (o[n] - o[n - 1]) / 2;
+  else
+    for (let n = 1; n < r; n++)
+      t += (e[n - 1] + e[n]) / 2;
+  return t;
+}
+function dt(e, o) {
+  const r = e.length;
+  if (r < 3) return k(e, o);
+  const t = r % 2 === 0 ? r - 1 : r;
+  let n = 0;
+  if (typeof o == "number") {
+    const s = o;
+    n = e[0] + e[t - 1];
+    for (let c = 1; c < t - 1; c++)
+      n += (c % 2 === 0 ? 2 : 4) * e[c];
+    n *= s / 3, r !== t && (n += (e[r - 2] + e[r - 1]) * s / 2);
+  } else return o ? k(e, o) : dt(e, 1);
+  return n;
+}
+function gn(e, o) {
+  const r = e.length, t = new Float32Array(r);
+  if (r < 2)
+    return t[0] = 0, t;
+  if (t[0] = 0, typeof o == "number") {
+    const n = o;
+    for (let s = 1; s < r; s++)
+      t[s] = t[s - 1] + (e[s - 1] + e[s]) * n / 2;
+  } else if (o)
+    for (let n = 1; n < r; n++)
+      t[n] = t[n - 1] + (e[n - 1] + e[n]) * (o[n] - o[n - 1]) / 2;
+  else
+    for (let n = 1; n < r; n++)
+      t[n] = t[n - 1] + (e[n - 1] + e[n]) / 2;
+  return t;
+}
+function yn(e, o) {
+  const r = e.length, t = o.length;
+  let n = 0, s = 0;
+  for (let y = 0; y < r; y++) n += e[y];
+  for (let y = 0; y < t; y++) s += o[y];
+  n /= r, s /= t;
+  let c = 0, a = 0;
+  for (let y = 0; y < r; y++) c += (e[y] - n) ** 2;
+  for (let y = 0; y < t; y++) a += (o[y] - s) ** 2;
+  c /= r - 1, a /= t - 1;
+  const l = Math.sqrt(c / r + a / t), f = (n - s) / l, i = (c / r + a / t) ** 2, u = (c / r) ** 2 / (r - 1) + (a / t) ** 2 / (t - 1), h = i / u, m = 2 * (1 - qt(Math.abs(f)));
+  return {
+    tStatistic: f,
+    degreesOfFreedom: h,
+    pValue: m,
+    significant: m < 0.05
+  };
+}
+function qt(e) {
+  const o = 0.254829592, r = -0.284496736, t = 1.421413741, n = -1.453152027, s = 1.061405429, c = 0.3275911, a = e < 0 ? -1 : 1;
+  e = Math.abs(e) / Math.sqrt(2);
+  const l = 1 / (1 + c * e), f = 1 - ((((s * l + n) * l + t) * l + r) * l + o) * l * Math.exp(-e * e);
+  return 0.5 * (1 + a * f);
+}
+const xt = {
+  name: "velo-plot-analysis",
+  version: "1.0.0",
+  description: "Data analysis and signal processing for velo-plot",
+  provides: ["analysis"],
+  tags: ["fft", "filters", "statistics", "math"]
+};
+function wn(e = {}) {
+  let o;
+  return {
+    manifest: xt,
+    onInit(r) {
+      o = r;
+    },
+    onDestroy(r) {
+    },
+    api: {
+      addFitLine(r, t, n) {
+        return K(o.chart, r, t, n);
+      },
+      // Math & Stats
+      integrate: U,
+      derivative: Z,
+      calculateStats: O,
+      validateData: G,
+      // Signal Processing
+      fft: (r) => v(r),
+      detectPeaks: Y,
+      detectCycles: X,
+      movingAverage: H,
+      subtractBaseline: V,
+      downsampleLTTB: T,
+      singleFrequencyFilter: it,
+      // Fitting
+      fitData: D,
+      // Indicators
+      sma: N,
+      ema: M,
+      rsi: ct,
+      // Utils
+      formatWithPrefix: E,
+      generateCycleColors: z
+    }
+  };
+}
+export {
+  wn as PluginAnalysis,
+  Ut as adx,
+  kt as analyzeComplexSpectrum,
+  C as analyzeSpectrum,
+  Kt as aroon,
+  nt as arraysToComplex,
+  Yt as atr,
+  hn as autoCorrelation,
+  on as bandPassFilter,
+  rn as bandStopFilter,
+  Rt as blackmanWindow,
+  Xt as bollingerBands,
+  sn as butterworth,
+  I as calculateR2,
+  O as calculateStats,
+  Ct as complexToArrays,
+  At as crossCorrelation,
+  Jt as cumsum,
+  Mn as cumulativeIntegral,
+  gn as cumulativeIntegral2,
+  wn as default,
+  _t as dema,
+  Z as derivative,
+  mn as detectAnomalies,
+  X as detectCycles,
+  Y as detectPeaks,
+  vt as dominantFrequency,
+  T as downsampleLTTB,
+  M as ema,
+  cn as exponentialMovingAverage,
+  v as fft,
+  St as fftFromComplexInput,
+  D as fitData,
+  bn as formatScientific,
+  pn as formatValue,
+  E as formatWithPrefix,
+  an as gaussianSmooth,
+  un as generateContours,
+  z as generateCycleColors,
+  In as getBestPrefix,
+  Bt as getPositiveFrequencies,
+  jt as hammingWindow,
+  $t as hanningWindow,
+  en as highPassFilter,
+  Q as ifft,
+  Lt as ifftComplex,
+  Dt as ifftFromArrays,
+  U as integrate,
+  nn as lowPassFilter,
+  Et as macd,
+  fn as medianFilter,
+  Ht as momentum,
+  H as movingAverage,
+  S as nextPowerOf2,
+  tn as normalize,
+  Zt as obv,
+  Qt as percentChange,
+  Pt as powerSpectrum,
+  Vt as roc,
+  ct as rsi,
+  ln as savitzkyGolay,
+  dt as simpsonsIntegration,
+  it as singleFrequencyFilter,
+  N as sma,
+  _ as solveLinearSystem,
+  Gt as standardDeviation,
+  Tt as stochastic,
+  V as subtractBaseline,
+  yn as tTest,
+  zt as tema,
+  k as trapezoidalIntegration,
+  G as validateData,
+  Ot as vwap,
+  Wt as wma
+};
+//# sourceMappingURL=analysis.js.map