velo-plot 2.0.0 → 3.0.0

package/dist/plugins/pattern-recognition.js

@@ -1,38 +1,38 @@
-function C(s) {
-  const e = [], n = [];
-  for (let t = 1; t < s.length - 1; t++) {
-    const o = s[t - 1], i = s[t], g = s[t + 1];
-    i.y > o.y && i.y > g.y ? e.push({ ...i, type: "peak" }) : i.y < o.y && i.y < g.y && n.push({ ...i, type: "valley" });
+function R(o) {
+  const n = [], e = [];
+  for (let s = 1; s < o.length - 1; s++) {
+    const l = o[s - 1], a = o[s], f = o[s + 1];
+    a.y > l.y && a.y > f.y ? n.push({ ...a, type: "peak" }) : a.y < l.y && a.y < f.y && e.push({ ...a, type: "valley" });
   }
-  return { peaks: e, valleys: n };
+  return { peaks: n, valleys: e };
 }
-function I(s, e) {
-  return (e.y - s.y) / (e.x - s.x);
+function C(o, n) {
+  return (n.y - o.y) / (n.x - o.x);
 }
-function T(s) {
-  const e = s.map((g) => g.y), n = s.map((g) => g.x), t = Math.max(...e) - Math.min(...e), o = Math.max(...n) - Math.min(...n), i = I(s[0], s[s.length - 1]);
+function T(o) {
+  const n = o.map((f) => f.y), e = o.map((f) => f.x), s = Math.max(...n) - Math.min(...n), l = Math.max(...e) - Math.min(...e), a = C(o[0], o[o.length - 1]);
   return {
-    height: t,
-    width: o,
-    slope: i,
+    height: s,
+    width: l,
+    slope: a,
     volumeProfile: {
       increasing: 0.4,
       // Mock values
       decreasing: 0.3,
       neutral: 0.3
     },
-    breakoutTarget: Math.max(...e) + t * 0.8,
-    stopLoss: Math.min(...e) - t * 0.2
+    breakoutTarget: Math.max(...n) + s * 0.8,
+    stopLoss: Math.min(...n) - s * 0.2
   };
 }
-function D(s) {
-  if (s.length < 5)
+function _(o) {
+  if (o.length < 5)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for head-shoulders pattern"] };
-  const { peaks: e, valleys: n } = C(s);
-  if (e.length < 3 || n.length < 2)
+  const { peaks: n, valleys: e } = R(o);
+  if (n.length < 3 || e.length < 2)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
-  const t = e[0], o = e[1], i = e[2], g = n[0], u = n[1], p = o.y > t.y && o.y > i.y, y = Math.abs(t.y - i.y) / t.y < 0.1, k = g.y < t.y && u.y < i.y;
-  if (!p || !y || !k)
+  const s = n[0], l = n[1], a = n[2], f = e[0], m = e[1], v = l.y > s.y && l.y > a.y, y = Math.abs(s.y - a.y) / s.y < 0.1, S = f.y < s.y && m.y < a.y;
+  if (!v || !y || !S)
     return {
       valid: !1,
       confidence: 0,
@@ -40,89 +40,89 @@ function D(s) {
       keyPoints: [],
       errors: ["Invalid head-shoulders structure"]
     };
-  const x = [
-    { start: t, end: g, type: "resistance", strength: 0.8 },
-    { start: g, end: o, type: "support", strength: 0.7 },
-    { start: o, end: u, type: "resistance", strength: 0.8 },
-    { start: u, end: i, type: "support", strength: 0.7 }
-  ], b = [t, g, o, u, i], M = T(s), a = 1 - Math.abs(t.y - i.y) / o.y, l = 1 - Math.abs(g.y - u.y) / o.y;
+  const w = [
+    { start: s, end: f, type: "resistance", strength: 0.8 },
+    { start: f, end: l, type: "support", strength: 0.7 },
+    { start: l, end: m, type: "resistance", strength: 0.8 },
+    { start: m, end: a, type: "support", strength: 0.7 }
+  ], x = [s, f, l, m, a], M = T(o), k = 1 - Math.abs(s.y - a.y) / l.y, z = 1 - Math.abs(f.y - m.y) / l.y;
   return {
     valid: !0,
-    confidence: (a + l) / 2,
-    segments: x,
-    keyPoints: b,
+    confidence: (k + z) / 2,
+    segments: w,
+    keyPoints: x,
     measurements: M
   };
 }
-function q(s) {
-  if (s.length < 4)
+function N(o) {
+  if (o.length < 4)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for double top"] };
-  const { peaks: e, valleys: n } = C(s);
-  if (e.length < 2 || n.length < 1)
+  const { peaks: n, valleys: e } = R(o);
+  if (n.length < 2 || e.length < 1)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
-  const t = e[0], o = e[1], i = n[0], g = Math.abs(t.y - o.y) / t.y < 0.05, u = i.y < t.y && i.y < o.y, p = (t.y - i.y) / t.y > 0.1;
-  if (!g || !u || !p)
+  const s = n[0], l = n[1], a = e[0], f = Math.abs(s.y - l.y) / s.y < 0.05, m = a.y < s.y && a.y < l.y, v = (s.y - a.y) / s.y > 0.1;
+  if (!f || !m || !v)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Invalid double top structure"] };
   const y = [
-    { start: t, end: i, type: "resistance", strength: 0.9 },
-    { start: i, end: o, type: "support", strength: 0.8 },
-    { start: t, end: o, type: "resistance", strength: 0.9 }
-  ], k = [t, i, o], x = T(s), b = 1 - Math.abs(t.y - o.y) / t.y, M = (t.y - i.y) / t.y;
+    { start: s, end: a, type: "resistance", strength: 0.9 },
+    { start: a, end: l, type: "support", strength: 0.8 },
+    { start: s, end: l, type: "resistance", strength: 0.9 }
+  ], S = [s, a, l], w = T(o), x = 1 - Math.abs(s.y - l.y) / s.y, M = (s.y - a.y) / s.y;
   return {
     valid: !0,
-    confidence: (b + Math.min(M * 2, 1)) / 2,
+    confidence: (x + Math.min(M * 2, 1)) / 2,
     segments: y,
-    keyPoints: k,
-    measurements: x
+    keyPoints: S,
+    measurements: w
   };
 }
-function E(s) {
-  if (s.length < 4)
+function V(o) {
+  if (o.length < 4)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for double bottom"] };
-  const { peaks: e, valleys: n } = C(s);
-  if (n.length < 2 || e.length < 1)
+  const { peaks: n, valleys: e } = R(o);
+  if (e.length < 2 || n.length < 1)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
-  const t = n[0], o = n[1], i = e[0], g = Math.abs(t.y - o.y) / t.y < 0.05, u = i.y > t.y && i.y > o.y, p = (i.y - t.y) / t.y > 0.1;
-  if (!g || !u || !p)
+  const s = e[0], l = e[1], a = n[0], f = Math.abs(s.y - l.y) / s.y < 0.05, m = a.y > s.y && a.y > l.y, v = (a.y - s.y) / s.y > 0.1;
+  if (!f || !m || !v)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Invalid double bottom structure"] };
   const y = [
-    { start: t, end: i, type: "support", strength: 0.9 },
-    { start: i, end: o, type: "resistance", strength: 0.8 },
-    { start: t, end: o, type: "support", strength: 0.9 }
-  ], k = [t, i, o], x = T(s), b = 1 - Math.abs(t.y - o.y) / t.y, M = (i.y - t.y) / t.y;
+    { start: s, end: a, type: "support", strength: 0.9 },
+    { start: a, end: l, type: "resistance", strength: 0.8 },
+    { start: s, end: l, type: "support", strength: 0.9 }
+  ], S = [s, a, l], w = T(o), x = 1 - Math.abs(s.y - l.y) / s.y, M = (a.y - s.y) / s.y;
   return {
     valid: !0,
-    confidence: (b + Math.min(M * 2, 1)) / 2,
+    confidence: (x + Math.min(M * 2, 1)) / 2,
     segments: y,
-    keyPoints: k,
-    measurements: x
+    keyPoints: S,
+    measurements: w
   };
 }
-function _(s) {
-  if (s.length < 4)
+function q(o) {
+  if (o.length < 4)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for ascending triangle"] };
-  const e = s.map((a) => a.y), n = Math.max(...e), t = s.filter((a) => Math.abs(a.y - n) / n < 0.02);
-  if (t.length < 2)
+  const n = o.map((k) => k.y), e = Math.max(...n), s = o.filter((k) => Math.abs(k.y - e) / e < 0.02);
+  if (s.length < 2)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient resistance points"] };
-  const o = s.filter((a, l) => l === 0 || a.y < s[l - 1].y);
-  if (o.length < 2)
+  const l = o.filter((k, z) => z === 0 || k.y < o[z - 1].y);
+  if (l.length < 2)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient low points"] };
-  const i = o[0], g = o[o.length - 1], u = I(i, g);
-  if (u <= 0)
+  const a = l[0], f = l[l.length - 1], m = C(a, f);
+  if (m <= 0)
     return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Support not ascending"] };
-  const p = [
-    { start: t[0], end: t[t.length - 1], type: "resistance", strength: 0.8 },
-    { start: i, end: g, type: "support", strength: 0.7 }
-  ], y = [...t.slice(0, 2), i, g], k = T(s), x = 1 - Math.abs(t[0].y - t[t.length - 1].y) / n, b = Math.min(u / 0.01, 1);
+  const v = [
+    { start: s[0], end: s[s.length - 1], type: "resistance", strength: 0.8 },
+    { start: a, end: f, type: "support", strength: 0.7 }
+  ], y = [...s.slice(0, 2), a, f], S = T(o), w = 1 - Math.abs(s[0].y - s[s.length - 1].y) / e, x = Math.min(m / 0.01, 1);
   return {
     valid: !0,
-    confidence: (x + b) / 2,
-    segments: p,
+    confidence: (w + x) / 2,
+    segments: v,
     keyPoints: y,
-    measurements: k
+    measurements: S
   };
 }
-const B = {
+const A = {
   "head-shoulders": {
     id: "head-shoulders",
     type: "head-shoulders",
@@ -130,7 +130,7 @@ const B = {
     description: "Bearish reversal pattern with three peaks",
     minPoints: 5,
     maxPoints: 7,
-    validator: D
+    validator: _
   },
   "inverse-head-shoulders": {
     id: "inverse-head-shoulders",
@@ -139,9 +139,9 @@ const B = {
     description: "Bullish reversal pattern with three valleys",
     minPoints: 5,
     maxPoints: 7,
-    validator: (s) => {
-      const e = s.map((t) => ({ ...t, y: -t.y }));
-      return D(e);
+    validator: (o) => {
+      const n = o.map((s) => ({ ...s, y: -s.y }));
+      return _(n);
     }
   },
   "double-top": {
@@ -151,7 +151,7 @@ const B = {
     description: "Bearish reversal pattern with two equal peaks",
     minPoints: 4,
     maxPoints: 6,
-    validator: q
+    validator: N
   },
   "double-bottom": {
     id: "double-bottom",
@@ -160,7 +160,7 @@ const B = {
     description: "Bullish reversal pattern with two equal valleys",
     minPoints: 4,
     maxPoints: 6,
-    validator: E
+    validator: V
   },
   "triple-top": {
     id: "triple-top",
@@ -169,24 +169,24 @@ const B = {
     description: "Bearish reversal pattern with three equal peaks",
     minPoints: 5,
     maxPoints: 7,
-    validator: (s) => {
-      if (s.length < 5)
+    validator: (o) => {
+      if (o.length < 5)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
-      const { peaks: e } = C(s);
-      if (e.length < 3)
+      const { peaks: n } = R(o);
+      if (n.length < 3)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Need at least 3 peaks"] };
-      const n = e[0].y, t = e[1].y, o = e[2].y, i = 0.05;
-      if (!(Math.abs(n - t) / n < i && Math.abs(t - o) / t < i))
+      const e = n[0].y, s = n[1].y, l = n[2].y, a = 0.05;
+      if (!(Math.abs(e - s) / e < a && Math.abs(s - l) / s < a))
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Peaks not equal"] };
-      const u = [
-        { start: e[0], end: e[1], type: "resistance", strength: 0.8 },
-        { start: e[1], end: e[2], type: "resistance", strength: 0.8 }
-      ], p = [e[0], e[1], e[2]], y = T(s);
+      const m = [
+        { start: n[0], end: n[1], type: "resistance", strength: 0.8 },
+        { start: n[1], end: n[2], type: "resistance", strength: 0.8 }
+      ], v = [n[0], n[1], n[2]], y = T(o);
       return {
         valid: !0,
         confidence: 0.8,
-        segments: u,
-        keyPoints: p,
+        segments: m,
+        keyPoints: v,
         measurements: y
       };
     }
@@ -198,9 +198,9 @@ const B = {
     description: "Bullish reversal pattern with three equal valleys",
     minPoints: 5,
     maxPoints: 7,
-    validator: (s) => {
-      const e = s.map((n) => ({ ...n, y: -n.y }));
-      return B["triple-top"].validator(e);
+    validator: (o) => {
+      const n = o.map((e) => ({ ...e, y: -e.y }));
+      return A["triple-top"].validator(n);
     }
   },
   "ascending-triangle": {
@@ -210,7 +210,7 @@ const B = {
     description: "Continuation pattern with horizontal resistance and ascending support",
     minPoints: 4,
     maxPoints: 8,
-    validator: _
+    validator: q
   },
   "descending-triangle": {
     id: "descending-triangle",
@@ -219,9 +219,9 @@ const B = {
     description: "Continuation pattern with horizontal support and descending resistance",
     minPoints: 4,
     maxPoints: 8,
-    validator: (s) => {
-      const e = s.map((t) => ({ ...t, y: -t.y }));
-      return _(e);
+    validator: (o) => {
+      const n = o.map((s) => ({ ...s, y: -s.y }));
+      return q(n);
     }
   },
   "symmetrical-triangle": {
@@ -231,22 +231,22 @@ const B = {
     description: "Continuation pattern with converging support and resistance",
     minPoints: 4,
     maxPoints: 8,
-    validator: (s) => {
-      if (s.length < 4)
+    validator: (o) => {
+      if (o.length < 4)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
-      const e = s.slice(0, Math.floor(s.length / 2)), n = s.slice(Math.floor(s.length / 2)), t = I(e[0], e[e.length - 1]), o = I(n[0], n[n.length - 1]);
-      if (!(t > 0 && o < 0 || t < 0 && o > 0))
+      const n = o.slice(0, Math.floor(o.length / 2)), e = o.slice(Math.floor(o.length / 2)), s = C(n[0], n[n.length - 1]), l = C(e[0], e[e.length - 1]);
+      if (!(s > 0 && l < 0 || s < 0 && l > 0))
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Lines not converging"] };
-      const g = [
-        { start: e[0], end: e[e.length - 1], type: "trendline", strength: 0.7 },
-        { start: n[0], end: n[n.length - 1], type: "trendline", strength: 0.7 }
-      ], u = [e[0], e[e.length - 1], n[0], n[n.length - 1]], p = T(s);
+      const f = [
+        { start: n[0], end: n[n.length - 1], type: "trendline", strength: 0.7 },
+        { start: e[0], end: e[e.length - 1], type: "trendline", strength: 0.7 }
+      ], m = [n[0], n[n.length - 1], e[0], e[e.length - 1]], v = T(o);
       return {
         valid: !0,
         confidence: 0.7,
-        segments: g,
-        keyPoints: u,
-        measurements: p
+        segments: f,
+        keyPoints: m,
+        measurements: v
       };
     }
   },
@@ -257,25 +257,25 @@ const B = {
     description: "Bearish reversal pattern with two converging upward lines",
     minPoints: 4,
     maxPoints: 8,
-    validator: (s) => {
-      if (s.length < 4)
+    validator: (o) => {
+      if (o.length < 4)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
-      const { peaks: e, valleys: n } = C(s);
-      if (e.length < 2 || n.length < 2)
+      const { peaks: n, valleys: e } = R(o);
+      if (n.length < 2 || e.length < 2)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
-      const t = I(e[0], e[e.length - 1]), o = I(n[0], n[n.length - 1]);
-      if (!(t > 0 && o > 0 && o > t))
+      const s = C(n[0], n[n.length - 1]), l = C(e[0], e[e.length - 1]);
+      if (!(s > 0 && l > 0 && l > s))
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Not a rising wedge pattern"] };
-      const g = [
-        { start: e[0], end: e[e.length - 1], type: "resistance", strength: 0.8 },
-        { start: n[0], end: n[n.length - 1], type: "support", strength: 0.8 }
-      ], u = [e[0], e[e.length - 1], n[0], n[n.length - 1]], p = T(s);
+      const f = [
+        { start: n[0], end: n[n.length - 1], type: "resistance", strength: 0.8 },
+        { start: e[0], end: e[e.length - 1], type: "support", strength: 0.8 }
+      ], m = [n[0], n[n.length - 1], e[0], e[e.length - 1]], v = T(o);
       return {
         valid: !0,
         confidence: 0.75,
-        segments: g,
-        keyPoints: u,
-        measurements: p
+        segments: f,
+        keyPoints: m,
+        measurements: v
       };
     }
   },
@@ -286,9 +286,9 @@ const B = {
     description: "Bullish reversal pattern with two converging downward lines",
     minPoints: 4,
     maxPoints: 8,
-    validator: (s) => {
-      const e = s.map((t) => ({ ...t, y: -t.y }));
-      return B["rising-wedge"].validator(e);
+    validator: (o) => {
+      const n = o.map((s) => ({ ...s, y: -s.y }));
+      return A["rising-wedge"].validator(n);
     }
   },
   rectangle: {
@@ -298,22 +298,22 @@ const B = {
     description: "Continuation pattern with horizontal support and resistance",
     minPoints: 4,
     maxPoints: 10,
-    validator: (s) => {
-      if (s.length < 4)
+    validator: (o) => {
+      if (o.length < 4)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
-      const e = s.map((y) => y.y), n = Math.max(...e), t = Math.min(...e), o = s.filter((y) => Math.abs(y.y - n) / n < 0.05), i = s.filter((y) => Math.abs(y.y - t) / t < 0.05);
-      if (o.length < 2 || i.length < 2)
+      const n = o.map((y) => y.y), e = Math.max(...n), s = Math.min(...n), l = o.filter((y) => Math.abs(y.y - e) / e < 0.05), a = o.filter((y) => Math.abs(y.y - s) / s < 0.05);
+      if (l.length < 2 || a.length < 2)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient horizontal lines"] };
-      const g = [
-        { start: o[0], end: o[o.length - 1], type: "resistance", strength: 0.9 },
-        { start: i[0], end: i[i.length - 1], type: "support", strength: 0.9 }
-      ], u = [o[0], o[o.length - 1], i[0], i[i.length - 1]], p = T(s);
+      const f = [
+        { start: l[0], end: l[l.length - 1], type: "resistance", strength: 0.9 },
+        { start: a[0], end: a[a.length - 1], type: "support", strength: 0.9 }
+      ], m = [l[0], l[l.length - 1], a[0], a[a.length - 1]], v = T(o);
       return {
         valid: !0,
         confidence: 0.8,
-        segments: g,
-        keyPoints: u,
-        measurements: p
+        segments: f,
+        keyPoints: m,
+        measurements: v
       };
     }
   },
@@ -324,21 +324,21 @@ const B = {
     description: "Short-term continuation pattern after strong move",
     minPoints: 3,
     maxPoints: 6,
-    validator: (s) => {
-      if (s.length < 3)
+    validator: (o) => {
+      if (o.length < 3)
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
-      const e = I(s[0], s[s.length - 1]);
-      if (!(Math.abs(e) < 0.01))
+      const n = C(o[0], o[o.length - 1]);
+      if (!(Math.abs(n) < 0.01))
         return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Not horizontal enough"] };
-      const t = [
-        { start: s[0], end: s[s.length - 1], type: "trendline", strength: 0.6 }
-      ], o = [s[0], s[s.length - 1]], i = T(s);
+      const s = [
+        { start: o[0], end: o[o.length - 1], type: "trendline", strength: 0.6 }
+      ], l = [o[0], o[o.length - 1]], a = T(o);
       return {
         valid: !0,
         confidence: 0.6,
-        segments: t,
-        keyPoints: o,
-        measurements: i
+        segments: s,
+        keyPoints: l,
+        measurements: a
       };
     }
   },
@@ -349,7 +349,7 @@ const B = {
     description: "Short-term continuation pattern with converging lines",
     minPoints: 3,
     maxPoints: 5,
-    validator: (s) => B["symmetrical-triangle"].validator(s)
+    validator: (o) => A["symmetrical-triangle"].validator(o)
   },
   custom: {
     id: "custom",
@@ -357,15 +357,15 @@ const B = {
     name: "Custom Pattern",
     description: "User-defined pattern",
     minPoints: 3,
-    validator: (s) => ({ valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Custom pattern not implemented"] })
+    validator: (o) => ({ valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Custom pattern not implemented"] })
   }
-}, L = {
+}, F = {
   name: "pattern-recognition",
   version: "1.0.0",
   description: "Technical pattern recognition for financial and scientific data",
-  author: "Sci Plot Team",
+  author: "Velo Plot Team",
   provides: ["patterns", "technical-analysis", "chart-patterns"]
-}, V = {
+}, H = {
   defaultParameters: {
     minConfidence: 0.7,
     maxPatterns: 10,
@@ -411,211 +411,284 @@ const B = {
     alertTypes: ["head-shoulders", "double-top", "double-bottom"]
   }
 };
-function F(s = {}) {
-  const e = { ...V, ...s };
-  let n = null;
-  const t = /* @__PURE__ */ new Map(), o = new Map(Object.entries(B)), i = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map();
-  async function u(a, l, d) {
-    const r = { ...e.defaultParameters, ...d }, f = performance.now(), c = [], m = {}, h = p(l, r.sensitivity);
-    for (const v of r.patternTypes) {
-      const w = o.get(v);
-      if (w) {
-        for (let z = r.minPatternSize; z <= Math.min(h.length, r.maxPatternSize); z++) {
-          const $ = h.slice(Math.max(0, z - r.maxPatternSize), z);
-          if ($.length < w.minPoints || w.maxPoints && $.length > w.maxPoints) continue;
-          const R = w.validator($);
-          if (R.valid && R.confidence >= r.minConfidence) {
-            const A = {
-              pattern: w,
-              confidence: R.confidence,
-              location: {
-                startIndex: Math.max(0, z - r.maxPatternSize),
-                endIndex: z,
-                startPoint: $[0],
-                endPoint: $[$.length - 1]
-              },
-              validation: R,
-              timestamp: Date.now(),
-              seriesId: a
-            };
-            if (!y(A, c, r.overlapTolerance) && (c.push(A), m[v] = (m[v] || 0) + 1, c.length >= r.maxPatterns))
-              break;
-          }
-        }
-        if (c.length >= r.maxPatterns)
-          break;
+function O(o = {}) {
+  const n = { ...H, ...o };
+  let e = null;
+  const s = /* @__PURE__ */ new Map(), l = new Map(Object.entries(A)), a = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Map(), v = {
+    "head-shoulders": "bearish",
+    "inverse-head-shoulders": "bullish",
+    "double-top": "bearish",
+    "double-bottom": "bullish",
+    "triple-top": "bearish",
+    "triple-bottom": "bullish",
+    "ascending-triangle": "bullish",
+    "descending-triangle": "bearish",
+    "symmetrical-triangle": "neutral",
+    "rising-wedge": "bearish",
+    "falling-wedge": "bullish",
+    rectangle: "neutral",
+    flag: "neutral",
+    pennant: "neutral",
+    custom: "neutral"
+  };
+  function y(t, r, c, i, u, d, h) {
+    for (let g = i.minPatternSize; g <= Math.min(c.length, i.maxPatternSize); g++) {
+      const p = c.slice(Math.max(0, g - i.maxPatternSize), g);
+      if (p.length < t.minPoints || t.maxPoints && p.length > t.maxPoints) continue;
+      const P = t.validator(p);
+      if (P.valid && P.confidence >= i.minConfidence) {
+        const $ = {
+          pattern: t,
+          confidence: P.confidence,
+          location: {
+            startIndex: Math.max(0, g - i.maxPatternSize),
+            endIndex: g,
+            startPoint: p[0],
+            endPoint: p[p.length - 1]
+          },
+          validation: P,
+          timestamp: Date.now(),
+          seriesId: u
+        };
+        if (!M($, d, i.overlapTolerance) && (d.push($), h[r] = (h[r] || 0) + 1, d.length >= i.maxPatterns))
+          return !0;
+      }
+    }
+    return !1;
+  }
+  function S(t) {
+    var c, i;
+    const r = v[t.pattern.type] ?? "neutral";
+    e == null || e.events.emit("pattern:signal", {
+      seriesId: t.seriesId,
+      patternType: t.pattern.type,
+      patternName: t.pattern.name,
+      direction: r,
+      confidence: t.confidence,
+      price: t.location.endPoint.y,
+      x: t.location.endPoint.x,
+      target: (c = t.validation.measurements) == null ? void 0 : c.breakoutTarget,
+      stopLoss: (i = t.validation.measurements) == null ? void 0 : i.stopLoss,
+      timestamp: t.timestamp
+    });
+  }
+  async function w(t, r, c) {
+    const i = { ...n.defaultParameters, ...c }, u = performance.now(), d = [], h = {}, g = x(r, i.sensitivity);
+    let p = !1;
+    for (const b of i.patternTypes) {
+      const I = l.get(b);
+      if (I && y(I, b, g, i, t, d, h)) {
+        p = !0;
+        break;
       }
     }
-    c.sort((v, w) => w.confidence - v.confidence), t.set(a, c);
-    const P = performance.now() - f;
-    for (const v of c)
-      v.confidence >= e.notifications.minAlertConfidence && e.notifications.alertTypes.includes(v.pattern.type) && (n == null || n.events.emit("pattern:detected", {
-        match: v,
-        seriesId: a,
+    if (!p && a.size > 0 && i.patternTypes.includes("custom")) {
+      for (const [b, I] of a)
+        if (y(I, b, g, i, t, d, h))
+          break;
+    }
+    d.sort((b, I) => I.confidence - b.confidence), s.set(t, d);
+    const P = performance.now() - u;
+    for (const b of d)
+      b.confidence >= n.notifications.minAlertConfidence && S(b), b.confidence >= n.notifications.minAlertConfidence && n.notifications.alertTypes.includes(b.pattern.type) && (e == null || e.events.emit("pattern:detected", {
+        match: b,
+        seriesId: t,
         timestamp: Date.now()
       }));
-    const S = {
-      matches: c,
+    const $ = {
+      matches: d,
       summary: {
-        totalPatterns: c.length,
-        patternsByType: m,
-        averageConfidence: c.length > 0 ? c.reduce((v, w) => v + w.confidence, 0) / c.length : 0,
+        totalPatterns: d.length,
+        patternsByType: h,
+        averageConfidence: d.length > 0 ? d.reduce((b, I) => b + I.confidence, 0) / d.length : 0,
         detectionTime: P
       },
-      processedPoints: h.length,
-      parameters: r
+      processedPoints: g.length,
+      parameters: i
     };
-    return n == null || n.log.info(`Pattern detection completed for ${a}: ${c.length} patterns found`), S;
+    return e == null || e.log.info(`Pattern detection completed for ${t}: ${d.length} patterns found`), $;
   }
-  function p(a, l) {
-    return a.filter((d, r) => {
-      if (r === 0 || r === a.length - 1) return !0;
-      const f = a[r - 1];
-      return Math.abs(d.y - f.y) / f.y >= l * 0.01;
+  function x(t, r) {
+    return t.filter((c, i) => {
+      if (i === 0 || i === t.length - 1) return !0;
+      const u = t[i - 1];
+      return Math.abs(c.y - u.y) / u.y >= r * 0.01;
     });
   }
-  function y(a, l, d) {
-    for (const r of l) {
-      const f = Math.max(a.location.startIndex, r.location.startIndex), m = Math.min(a.location.endIndex, r.location.endIndex) - f, h = a.location.endIndex - a.location.startIndex, P = r.location.endIndex - r.location.startIndex;
-      if (m / Math.min(h, P) > d)
+  function M(t, r, c) {
+    for (const i of r) {
+      const u = Math.max(t.location.startIndex, i.location.startIndex), h = Math.min(t.location.endIndex, i.location.endIndex) - u, g = t.location.endIndex - t.location.startIndex, p = i.location.endIndex - i.location.startIndex;
+      if (h / Math.min(g, p) > c)
         return !0;
     }
     return !1;
   }
-  function k(a) {
-    const l = {
-      id: a.id,
+  function k(t) {
+    const r = {
+      id: t.id,
       type: "custom",
-      name: a.name,
-      minPoints: a.pointSequence.length,
-      maxPoints: a.pointSequence.length,
-      validator: (d) => x(d, a)
+      name: t.name,
+      minPoints: t.pointSequence.length,
+      maxPoints: t.pointSequence.length,
+      validator: (c) => L(c, t)
     };
-    o.set("custom", l), n == null || n.log.info(`Custom pattern registered: ${a.id}`);
+    a.set(t.id, r), e == null || e.log.info(`Custom pattern registered: ${t.id}`);
   }
-  function x(a, l) {
-    if (a.length < l.pointSequence.length)
+  function z(t, r) {
+    if ("pointSequence" in r) {
+      k({ ...r, id: t });
+      return;
+    }
+    const c = r;
+    if (typeof c.validator != "function") {
+      e == null || e.log.error(`Cannot register pattern '${t}': a validator function is required`);
+      return;
+    }
+    const i = {
+      id: t,
+      type: "custom",
+      name: c.name ?? t,
+      description: c.description,
+      minPoints: c.minPoints ?? 3,
+      maxPoints: c.maxPoints,
+      validator: c.validator,
+      confidenceCalculator: c.confidenceCalculator
+    };
+    a.set(t, i), e == null || e.log.info(`Custom pattern registered: ${t}`);
+  }
+  function D(t) {
+    const r = a.delete(t);
+    return r && (e == null || e.log.info(`Custom pattern removed: ${t}`)), r;
+  }
+  function L(t, r) {
+    if (t.length < r.pointSequence.length)
       return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
-    let d = 1;
-    const r = [];
-    for (let f = 0; f < l.pointSequence.length; f++) {
-      const c = l.pointSequence[f], m = a[f];
-      if (c.constraints) {
-        const h = c.constraints;
-        if (h.higherThanPrevious && f > 0 && m.y <= a[f - 1].y && (d *= 0.8, r.push(`Point ${f} not higher than previous`)), h.lowerThanPrevious && f > 0 && m.y >= a[f - 1].y && (d *= 0.8, r.push(`Point ${f} not lower than previous`)), h.withinRange) {
-          const [P, S] = h.withinRange;
-          (m.y < P || m.y > S) && (d *= 0.7, r.push(`Point ${f} not within range [${P}, ${S}]`));
+    let c = 1;
+    const i = [];
+    for (let u = 0; u < r.pointSequence.length; u++) {
+      const d = r.pointSequence[u], h = t[u];
+      if (d.constraints) {
+        const g = d.constraints;
+        if (g.higherThanPrevious && u > 0 && h.y <= t[u - 1].y && (c *= 0.8, i.push(`Point ${u} not higher than previous`)), g.lowerThanPrevious && u > 0 && h.y >= t[u - 1].y && (c *= 0.8, i.push(`Point ${u} not lower than previous`)), g.withinRange) {
+          const [p, P] = g.withinRange;
+          (h.y < p || h.y > P) && (c *= 0.7, i.push(`Point ${u} not within range [${p}, ${P}]`));
         }
       }
     }
     return {
-      valid: d >= 0.5,
-      confidence: d,
+      valid: c >= 0.5,
+      confidence: c,
       segments: [],
-      keyPoints: a,
-      errors: r.length > 0 ? r : void 0
+      keyPoints: t,
+      errors: i.length > 0 ? i : void 0
     };
   }
-  const b = {
-    detectPatterns: u,
+  const B = {
+    detectPatterns: w,
     registerCustomPattern: k,
+    register: z,
+    unregister: D,
+    onSignal(t) {
+      return (e == null ? void 0 : e.events.onPlugin("pattern:signal", (r) => t(r))) ?? (() => {
+      });
+    },
     getRegisteredPatterns() {
-      return Array.from(o.values());
+      return [...l.values(), ...a.values()];
     },
-    getPatternMatches(a) {
-      return t.get(a) || [];
+    getPatternMatches(t) {
+      return s.get(t) || [];
     },
-    clearPatternMatches(a) {
-      t.delete(a), n == null || n.log.info(`Pattern matches cleared for series: ${a}`);
+    clearPatternMatches(t) {
+      s.delete(t), e == null || e.log.info(`Pattern matches cleared for series: ${t}`);
     },
-    enableRealtimeDetection(a, l) {
-      i.add(a);
-      const d = n == null ? void 0 : n.chart;
-      if (d) {
-        const r = d.getSeries(a);
-        if (r) {
-          const f = r.getData();
-          if (f && f.x.length > 0) {
-            const c = Array.from(f.x).map((m, h) => ({
-              x: m,
-              y: f.y[h]
+    enableRealtimeDetection(t, r) {
+      f.add(t);
+      const c = e == null ? void 0 : e.chart;
+      if (c) {
+        const i = c.getSeries(t);
+        if (i) {
+          const u = i.getData();
+          if (u && u.x.length > 0) {
+            const d = Array.from(u.x).map((h, g) => ({
+              x: h,
+              y: u.y[g]
             }));
-            u(a, c, l);
+            w(t, d, r);
           }
         }
       }
-      n == null || n.log.info(`Real-time pattern detection enabled for series: ${a}`);
+      e == null || e.log.info(`Real-time pattern detection enabled for series: ${t}`);
     },
-    disableRealtimeDetection(a) {
-      i.delete(a);
-      const l = g.get(a);
-      l && (clearTimeout(l), g.delete(a)), n == null || n.log.info(`Real-time pattern detection disabled for series: ${a}`);
+    disableRealtimeDetection(t) {
+      f.delete(t);
+      const r = m.get(t);
+      r && (clearTimeout(r), m.delete(t)), e == null || e.log.info(`Real-time pattern detection disabled for series: ${t}`);
     },
-    getStatistics(a) {
-      if (a) {
-        const l = t.get(a) || [], d = {};
-        for (const r of l)
-          d[r.pattern.type] = (d[r.pattern.type] || 0) + 1;
+    getStatistics(t) {
+      if (t) {
+        const r = s.get(t) || [], c = {};
+        for (const i of r)
+          c[i.pattern.type] = (c[i.pattern.type] || 0) + 1;
         return {
-          totalDetections: l.length,
-          patternsByType: d,
-          averageConfidence: l.length > 0 ? l.reduce((r, f) => r + f.confidence, 0) / l.length : 0,
-          detectionRate: l.length / 100
+          totalDetections: r.length,
+          patternsByType: c,
+          averageConfidence: r.length > 0 ? r.reduce((i, u) => i + u.confidence, 0) / r.length : 0,
+          detectionRate: r.length / 100
         };
       } else {
-        let l = 0;
-        const d = {}, r = [];
-        for (const f of t.values()) {
-          l += f.length, r.push(...f.map((c) => c.confidence));
-          for (const c of f)
-            d[c.pattern.type] = (d[c.pattern.type] || 0) + 1;
+        let r = 0;
+        const c = {}, i = [];
+        for (const u of s.values()) {
+          r += u.length, i.push(...u.map((d) => d.confidence));
+          for (const d of u)
+            c[d.pattern.type] = (c[d.pattern.type] || 0) + 1;
         }
         return {
-          totalDetections: l,
-          patternsByType: d,
-          averageConfidence: r.length > 0 ? r.reduce((f, c) => f + c, 0) / r.length : 0,
-          detectionRate: l / 100
+          totalDetections: r,
+          patternsByType: c,
+          averageConfidence: i.length > 0 ? i.reduce((u, d) => u + d, 0) / i.length : 0,
+          detectionRate: r / 100
         };
       }
     },
-    updateConfig: (a) => {
-      Object.assign(e, a);
+    updateConfig: (t) => {
+      Object.assign(n, t);
     },
-    getConfig: () => ({ ...e }),
-    visualizePatterns(a, l) {
-      const d = n == null ? void 0 : n.chart;
-      if (!d) return;
-      const r = t.get(a) || [], f = l ? r.filter((c) => l.includes(c.pattern.type)) : r;
-      b.hidePatterns(a);
-      for (const c of f) {
-        const m = e.visualization.colorScheme[c.pattern.type] || "#666666";
-        for (const h of c.validation.segments) {
-          const P = `${a}_pattern_${c.pattern.id}_${c.location.startIndex}`;
-          d.addSeries({
-            id: P,
+    getConfig: () => ({ ...n }),
+    visualizePatterns(t, r) {
+      const c = e == null ? void 0 : e.chart;
+      if (!c) return;
+      const i = s.get(t) || [], u = r ? i.filter((d) => r.includes(d.pattern.type)) : i;
+      B.hidePatterns(t);
+      for (const d of u) {
+        const h = n.visualization.colorScheme[d.pattern.type] || "#666666";
+        for (const g of d.validation.segments) {
+          const p = `${t}_pattern_${d.pattern.id}_${d.location.startIndex}`;
+          c.addSeries({
+            id: p,
             type: "line",
             data: {
-              x: new Float32Array([h.start.x, h.end.x]),
-              y: new Float32Array([h.start.y, h.end.y])
+              x: new Float32Array([g.start.x, g.end.x]),
+              y: new Float32Array([g.start.y, g.end.y])
             },
             style: {
-              color: m,
-              width: e.visualization.lineWidth,
-              opacity: e.visualization.opacity,
+              color: h,
+              width: n.visualization.lineWidth,
+              opacity: n.visualization.opacity,
               lineDash: [5, 5]
             }
           });
         }
-        if (e.visualization.showLabels) {
-          const h = `${a}_label_${c.pattern.id}_${c.location.startIndex}`, P = (c.location.startPoint.x + c.location.endPoint.x) / 2, S = (c.location.startPoint.y + c.location.endPoint.y) / 2;
-          d.addAnnotation({
-            id: h,
+        if (n.visualization.showLabels) {
+          const g = `${t}_label_${d.pattern.id}_${d.location.startIndex}`, p = (d.location.startPoint.x + d.location.endPoint.x) / 2, P = (d.location.startPoint.y + d.location.endPoint.y) / 2;
+          c.addAnnotation({
+            id: g,
             type: "text",
-            text: c.pattern.name,
-            x: P,
-            y: S,
+            text: d.pattern.name,
+            x: p,
+            y: P,
             style: {
-              color: m,
+              color: h,
               fontSize: 12,
               backgroundColor: "rgba(255, 255, 255, 0.8)"
             }
@@ -623,68 +696,68 @@ function F(s = {}) {
         }
       }
     },
-    hidePatterns(a) {
-      const l = n == null ? void 0 : n.chart;
-      if (!l) return;
-      const d = t.get(a) || [];
-      for (const r of d) {
-        for (let c = 0; c < r.validation.segments.length; c++) {
-          const m = `${a}_pattern_${r.pattern.id}_${r.location.startIndex}`;
-          l.getSeries(m) && l.removeSeries(m);
+    hidePatterns(t) {
+      const r = e == null ? void 0 : e.chart;
+      if (!r) return;
+      const c = s.get(t) || [];
+      for (const i of c) {
+        for (let d = 0; d < i.validation.segments.length; d++) {
+          const h = `${t}_pattern_${i.pattern.id}_${i.location.startIndex}`;
+          r.getSeries(h) && r.removeSeries(h);
         }
-        const f = `${a}_label_${r.pattern.id}_${r.location.startIndex}`;
-        l.getAnnotation(f) && l.removeAnnotation(f);
+        const u = `${t}_label_${i.pattern.id}_${i.location.startIndex}`;
+        r.getAnnotation(u) && r.removeAnnotation(u);
       }
     }
   };
-  function M(a, l) {
-    if (!e.enableRealtime) return;
-    const { seriesId: d } = l;
-    if (i.has(d)) {
-      const r = g.get(d);
-      r && clearTimeout(r);
-      const f = setTimeout(() => {
-        const c = a.chart;
-        if (c) {
-          const m = c.getSeries(d);
-          if (m) {
-            const h = m.getData();
-            if (h && h.x.length > 0) {
-              const P = Array.from(h.x).map((S, v) => ({
-                x: S,
-                y: h.y[v]
+  function E(t, r) {
+    if (!n.enableRealtime) return;
+    const { seriesId: c } = r;
+    if (f.has(c)) {
+      const i = m.get(c);
+      i && clearTimeout(i);
+      const u = setTimeout(() => {
+        const d = t.chart;
+        if (d) {
+          const h = d.getSeries(c);
+          if (h) {
+            const g = h.getData();
+            if (g && g.x.length > 0) {
+              const p = Array.from(g.x).map((P, $) => ({
+                x: P,
+                y: g.y[$]
               }));
-              u(d, P), e.visualization.showPatterns && b.visualizePatterns(d);
+              w(c, p), n.visualization.showPatterns && B.visualizePatterns(c);
             }
           }
         }
-      }, e.debounceTime);
-      g.set(d, f);
+      }, n.debounceTime);
+      m.set(c, u);
     }
   }
   return {
-    manifest: L,
-    onInit(a) {
-      if (n = a, e.customPatterns)
-        for (const l of e.customPatterns)
-          k(l);
-      n.log.info(`Pattern Recognition plugin initialized with ${o.size} patterns`);
+    manifest: F,
+    onInit(t) {
+      if (e = t, n.customPatterns)
+        for (const r of n.customPatterns)
+          k(r);
+      e.log.info(`Pattern Recognition plugin initialized with ${l.size} patterns`);
     },
-    onConfigChange(a, l) {
+    onConfigChange(t, r) {
     },
-    onBeforeRender(a, l) {
+    onBeforeRender(t, r) {
     },
-    onDataUpdate: M,
-    onDestroy(a) {
-      for (const l of g.values())
-        clearTimeout(l);
-      g.clear(), t.clear(), i.clear(), o.clear();
+    onDataUpdate: E,
+    onDestroy(t) {
+      for (const r of m.values())
+        clearTimeout(r);
+      m.clear(), s.clear(), f.clear(), l.clear(), a.clear();
     },
-    api: b
+    api: B
   };
 }
 export {
-  F as PluginPatternRecognition,
-  F as default
+  O as PluginPatternRecognition,
+  O as default
 };
 //# sourceMappingURL=pattern-recognition.js.map