@lacspace/patterns 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,664 @@
+'use strict';
+
+// src/core.ts
+var nulls = (n) => new Array(n).fill(null);
+function rma(values, n) {
+  const out = nulls(values.length);
+  if (n < 1) return out;
+  let prev = null;
+  let seed = 0;
+  let seen = 0;
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    if (v == null) continue;
+    if (prev == null) {
+      seed += v;
+      seen++;
+      if (seen === n) {
+        prev = seed / n;
+        out[i] = prev;
+      }
+      continue;
+    }
+    prev = (prev * (n - 1) + v) / n;
+    out[i] = prev;
+  }
+  return out;
+}
+function trueRange(bars2) {
+  return bars2.map((b, i) => {
+    if (i === 0) return b.high - b.low;
+    const pc = bars2[i - 1].close;
+    return Math.max(b.high - b.low, Math.abs(b.high - pc), Math.abs(b.low - pc));
+  });
+}
+function atr(bars2, n = 14) {
+  return rma(trueRange(bars2), n);
+}
+function volumeProfile(bars2, rows = 24) {
+  if (!bars2.length) return null;
+  let lo = Infinity, hi = -Infinity;
+  for (const b of bars2) {
+    lo = Math.min(lo, b.low);
+    hi = Math.max(hi, b.high);
+  }
+  if (!(hi > lo)) return null;
+  const step = (hi - lo) / rows;
+  const buckets = Array.from({ length: rows }, (_, k) => ({ lo: lo + k * step, hi: lo + (k + 1) * step, up: 0, down: 0 }));
+  for (const b of bars2) {
+    if (!b.volume) continue;
+    const a2 = Math.max(0, Math.floor((b.low - lo) / step));
+    const z2 = Math.min(rows - 1, Math.floor((b.high - lo) / step));
+    const share = b.volume / (z2 - a2 + 1);
+    for (let k = a2; k <= z2; k++) {
+      if (b.close >= b.open) buckets[k].up += share;
+      else buckets[k].down += share;
+    }
+  }
+  let poc = 0;
+  buckets.forEach((x, k) => {
+    if (x.up + x.down > buckets[poc].up + buckets[poc].down) poc = k;
+  });
+  const total = buckets.reduce((s, x) => s + x.up + x.down, 0);
+  let inVa = buckets[poc].up + buckets[poc].down, a = poc, z = poc;
+  while (inVa < total * 0.7 && (a > 0 || z < rows - 1)) {
+    const below = a > 0 ? buckets[a - 1].up + buckets[a - 1].down : -1;
+    const above = z < rows - 1 ? buckets[z + 1].up + buckets[z + 1].down : -1;
+    if (above >= below) {
+      z++;
+      inVa += above;
+    } else {
+      a--;
+      inVa += below;
+    }
+  }
+  return { buckets, poc, vaLow: buckets[a].lo, vaHigh: buckets[z].hi, max: Math.max(...buckets.map((x) => x.up + x.down)) };
+}
+
+// src/patterns.ts
+function swings(bars2, k = 2) {
+  const n = bars2.length;
+  const a = atr(bars2, 14);
+  const at = new Array(n);
+  let rs = 0;
+  for (let i = 0; i < n; i++) {
+    rs += bars2[i].high - bars2[i].low;
+    at[i] = a[i] ?? rs / (i + 1);
+  }
+  const piv = [];
+  if (n < 3) return { piv, tail: null, atr: at };
+  let trend = 0;
+  let hiI = 0;
+  let loI = 0;
+  for (let i = 1; i < n; i++) {
+    const t = at[i] * k;
+    const b = bars2[i];
+    if (trend === 0) {
+      if (b.high >= bars2[hiI].high) hiI = i;
+      if (b.low <= bars2[loI].low) loI = i;
+      if (bars2[hiI].high - bars2[loI].low >= t) {
+        if (hiI > loI) {
+          piv.push({ i: loI, p: bars2[loI].low, hi: false });
+          trend = 1;
+        } else {
+          piv.push({ i: hiI, p: bars2[hiI].high, hi: true });
+          trend = -1;
+        }
+      }
+    } else if (trend === 1) {
+      if (b.high >= bars2[hiI].high) hiI = i;
+      else if (bars2[hiI].high - b.low >= t) {
+        piv.push({ i: hiI, p: bars2[hiI].high, hi: true });
+        trend = -1;
+        loI = i;
+      }
+    } else {
+      if (b.low <= bars2[loI].low) loI = i;
+      else if (b.high - bars2[loI].low >= t) {
+        piv.push({ i: loI, p: bars2[loI].low, hi: false });
+        trend = 1;
+        hiI = i;
+      }
+    }
+  }
+  const tail = trend === 1 ? { i: hiI, p: bars2[hiI].high, hi: true } : trend === -1 ? { i: loI, p: bars2[loI].low, hi: false } : null;
+  return { piv, tail, atr: at };
+}
+var r2 = (n) => Math.round(n * 100) / 100;
+var fmt = (n) => Math.abs(n) >= 1e3 ? n.toFixed(0) : n.toFixed(2);
+var HARMONICS = [
+  { name: "Gartley", ab: [0.618, 0.618], bc: [0.382, 0.886], cd: [1.13, 1.618], xd: [0.786, 0.786] },
+  { name: "Bat", ab: [0.382, 0.5], bc: [0.382, 0.886], cd: [1.618, 2.618], xd: [0.886, 0.886] },
+  { name: "Alt Bat", ab: [0.382, 0.382], bc: [0.382, 0.886], cd: [2, 3.618], xd: [1.13, 1.13] },
+  { name: "Butterfly", ab: [0.786, 0.786], bc: [0.382, 0.886], cd: [1.618, 2.618], xd: [1.27, 1.618] },
+  { name: "Crab", ab: [0.382, 0.618], bc: [0.382, 0.886], cd: [2.24, 3.618], xd: [1.618, 1.618] },
+  { name: "Deep Crab", ab: [0.886, 0.886], bc: [0.382, 0.886], cd: [2, 3.618], xd: [1.618, 1.618] }
+];
+var inR = (v, r, tol) => v >= r[0] * (1 - tol) && v <= r[1] * (1 + tol);
+function harmonics(bars2, k = 2, tolPct = 6, show = 3, up = "#16A34A", down = "#DC2626") {
+  const { piv, tail } = swings(bars2, k);
+  const all = tail ? [...piv, tail] : piv;
+  const tol = tolPct / 100;
+  const hits = [];
+  const legLen = (a, b) => Math.abs(b.p - a.p);
+  for (let s = 0; s + 4 < all.length; s++) {
+    const [X, A, B, C, D] = all.slice(s, s + 5);
+    const XA = legLen(X, A), AB = legLen(A, B), BC = legLen(B, C), CD = legLen(C, D);
+    if (!XA || !AB || !BC) continue;
+    const bull = !X.hi;
+    const ab = AB / XA, bc = BC / AB, cd = CD / BC, xd = Math.abs(A.p - D.p) / XA;
+    let name = null;
+    for (const h of HARMONICS) {
+      if (bc > 1 * (1 + tol)) break;
+      if (inR(ab, h.ab, tol) && inR(bc, h.bc, tol) && inR(cd, h.cd, tol) && inR(xd, h.xd, tol)) {
+        name = h.name;
+        break;
+      }
+    }
+    if (!name) {
+      const xc = Math.abs(C.p - X.p) / XA;
+      const xcD = Math.abs(C.p - D.p) / Math.abs(C.p - X.p);
+      const beyondA = bull ? C.p > A.p : C.p < A.p;
+      if (beyondA && inR(ab, [0.382, 0.618], tol) && inR(xc, [1.13, 1.414], tol) && inR(xcD, [0.786, 0.786], tol)) name = "Cypher";
+    }
+    if (name) hits.push({ name, bull, pts: [X, A, B, C, D], forming: D === tail });
+  }
+  for (let s = Math.max(0, all.length - 6); s + 3 < all.length; s++) {
+    const [A, B, C, D] = all.slice(s, s + 4);
+    const AB = legLen(A, B), BC = legLen(B, C), CD = legLen(C, D);
+    if (!AB || !BC) continue;
+    const bc = BC / AB;
+    if (inR(bc, [0.382, 0.886], tol) && Math.abs(CD / AB - 1) <= tol * 2) {
+      if (!hits.some((h) => h.pts[4] === D)) hits.push({ name: "AB=CD", bull: A.hi, pts: [A, B, C, D], forming: D === tail });
+    }
+  }
+  const paths = [];
+  const zones = [];
+  const shown = hits.slice(-show);
+  for (const h of shown) {
+    const color = h.bull ? up : down;
+    const tag = `${h.bull ? "Bullish" : "Bearish"} ${h.name}${h.forming ? " (forming)" : ""}`;
+    if (h.pts.length === 5) {
+      const [X, A, B, C, D] = h.pts;
+      paths.push({ pts: [{ i: X.i, p: X.p, label: "X" }, { i: A.i, p: A.p, label: "A" }, { i: B.i, p: B.p, label: "B" }], color, fill: true, width: 1.5 });
+      paths.push({ pts: [{ i: B.i, p: B.p }, { i: C.i, p: C.p, label: "C" }, { i: D.i, p: D.p, label: "D" }], color, fill: true, width: 1.5, label: tag });
+      paths.push({ pts: [{ i: X.i, p: X.p }, { i: B.i, p: B.p }], color, dashed: true, width: 1, label: (Math.abs(A.p - B.p) / Math.abs(A.p - X.p)).toFixed(3), labelAt: 0.5 });
+      paths.push({ pts: [{ i: B.i, p: B.p }, { i: D.i, p: D.p }], color, dashed: true, width: 1, label: (Math.abs(C.p - D.p) / Math.abs(C.p - B.p)).toFixed(3), labelAt: 0.5 });
+      paths.push({ pts: [{ i: X.i, p: X.p }, { i: D.i, p: D.p }], color, dashed: true, width: 1, label: (Math.abs(A.p - D.p) / Math.abs(A.p - X.p)).toFixed(3), labelAt: 0.5 });
+    } else {
+      const [A, B, C, D] = h.pts;
+      paths.push({ pts: [{ i: A.i, p: A.p, label: "A" }, { i: B.i, p: B.p, label: "B" }, { i: C.i, p: C.p, label: "C" }, { i: D.i, p: D.p, label: "D" }], color, width: 1.5, label: tag });
+    }
+  }
+  if (piv.length >= 4) {
+    const [X, A, B, C] = piv.slice(-4);
+    const XA = legLen(X, A), AB = legLen(A, B), BC = legLen(B, C);
+    if (XA && AB && BC) {
+      const bull = !X.hi;
+      const dir = bull ? -1 : 1;
+      const ab = AB / XA, bc = BC / AB;
+      for (const h of HARMONICS) {
+        if (!inR(ab, h.ab, tol) || !inR(bc, h.bc, tol)) continue;
+        const xd1 = A.p + dir * h.xd[0] * XA, xd2 = A.p + dir * h.xd[1] * XA;
+        const cd1 = C.p + dir * h.cd[0] * BC, cd2 = C.p + dir * h.cd[1] * BC;
+        const loX = Math.min(xd1, xd2) - XA * tol * 0.5, hiX = Math.max(xd1, xd2) + XA * tol * 0.5;
+        const lo = Math.max(loX, Math.min(cd1, cd2)), hi = Math.min(hiX, Math.max(cd1, cd2));
+        if (!(hi >= lo)) continue;
+        const done = tail && tail.i > C.i && (bull ? tail.p <= hi : tail.p >= lo);
+        zones.push({ from: C.i, to: null, top: r2(hi + (hi === lo ? XA * 0.01 : 0)), bottom: r2(lo), color: bull ? up : down, dashed: true, label: `${bull ? "Bullish" : "Bearish"} ${h.name} D zone ${fmt(lo)}\u2013${fmt(hi)}${done ? " \xB7 reached" : ""}` });
+        paths.push({ pts: [{ i: X.i, p: X.p, label: "X" }, { i: A.i, p: A.p, label: "A" }, { i: B.i, p: B.p, label: "B" }, { i: C.i, p: C.p, label: "C" }], color: bull ? up : down, dashed: true, width: 1 });
+        break;
+      }
+    }
+  }
+  return { paths, zones, hits };
+}
+function elliott(bars2, k = 2, up = "#16A34A", down = "#DC2626", neutral = "#94A3B8") {
+  const { piv, tail } = swings(bars2, k);
+  const all = tail ? [...piv, tail] : piv;
+  const paths = [];
+  const zones = [];
+  const valid = (w, upTrend, upTo = 5) => {
+    const s = upTrend ? 1 : -1;
+    const v = w.map((x) => s * x.p);
+    const w1 = v[1] - v[0], w3 = upTo >= 3 ? v[3] - v[2] : 0;
+    if (!(w1 > 0)) return false;
+    if (!(v[2] > v[0])) return false;
+    if (upTo >= 3 && !(v[3] > v[1])) return false;
+    if (upTo >= 4 && !(v[4] > v[1])) return false;
+    if (upTo >= 5) {
+      const w5 = v[5] - v[4];
+      if (!(w5 > 0)) return false;
+      if (w3 < w1 && w3 < w5) return false;
+    }
+    return true;
+  };
+  let found = null;
+  for (let s = all.length - 6; s >= 0; s--) {
+    const w = all.slice(s, s + 6);
+    const upTrend = !w[0].hi;
+    if (valid(w, upTrend)) {
+      found = { start: s, upTrend };
+      break;
+    }
+  }
+  if (found) {
+    const w = all.slice(found.start, found.start + 6);
+    const color = found.upTrend ? up : down;
+    paths.push({ pts: w.map((x, j) => ({ i: x.i, p: x.p, label: j === 0 ? "0" : `(${j})` })), color, width: 2, label: `Impulse ${found.upTrend ? "up" : "down"}${w[5] === tail ? " \xB7 wave 5 forming" : ""}` });
+    const after = all.slice(found.start + 5, found.start + 9);
+    if (after.length >= 2) {
+      const lab = ["", "(a)", "(b)", "(c)"];
+      paths.push({ pts: after.map((x, j) => ({ i: x.i, p: x.p, label: lab[j] || void 0 })), color: neutral, width: 1.5, dashed: true, label: "Correction" });
+    }
+  }
+  const last5 = all.slice(-5);
+  if (last5.length === 5 && (!found || found.start + 5 < all.length - 5)) {
+    const upTrend = !last5[0].hi;
+    if (valid(last5, upTrend, 4) && (last5[4] !== tail || piv.length >= 5)) {
+      const s = upTrend ? 1 : -1;
+      const [p0, p1, , p3, p4] = last5;
+      const w1 = Math.abs(p1.p - p0.p);
+      const t1 = p4.p + s * w1;
+      const t2 = p4.p + s * 0.618 * Math.abs(p3.p - p0.p);
+      const color = upTrend ? up : down;
+      paths.push({ pts: last5.map((x, j) => ({ i: x.i, p: x.p, label: j === 0 ? "0" : `(${j})` })), color, width: 1.5, dashed: true, label: "Waves 1\u20134 (possible)" });
+      zones.push({ from: p4.i, to: null, top: r2(Math.max(t1, t2)), bottom: r2(Math.min(t1, t2)), color, dashed: true, label: `Wave 5 target ${fmt(Math.min(t1, t2))}\u2013${fmt(Math.max(t1, t2))}` });
+    }
+  }
+  return { paths, zones };
+}
+function fit(pts) {
+  const n = pts.length;
+  const mx = pts.reduce((s, q) => s + q.i, 0) / n;
+  const my = pts.reduce((s, q) => s + q.p, 0) / n;
+  let sxy = 0, sxx = 0;
+  for (const q of pts) {
+    sxy += (q.i - mx) * (q.p - my);
+    sxx += (q.i - mx) ** 2;
+  }
+  const m = sxx ? sxy / sxx : 0;
+  const b = my - m * mx;
+  const err = Math.max(...pts.map((q) => Math.abs(q.p - (m * q.i + b))));
+  return { m, b, at: (i) => m * i + b, err };
+}
+function chartPatterns(bars2, k = 1.5, look = 200, up = "#16A34A", down = "#DC2626", neutral = "#94A3B8", show = 2) {
+  const n = bars2.length;
+  const { piv, tail, atr: at } = swings(bars2, k);
+  const paths = [];
+  const zones = [];
+  if (n < 20 || piv.length < 3) return { paths, zones, found: [] };
+  const found = [];
+  const from = n - look;
+  const A = (i) => at[Math.min(n - 1, Math.max(0, i))];
+  const lastClose = bars2[n - 1].close;
+  const firstClose = (i, test) => {
+    for (let j = i + 1; j < n; j++) if (test(j)) return j;
+    return -1;
+  };
+  const liveFrom = piv.length >= 3 ? piv[piv.length - 3].i : 0;
+  const cands = [];
+  for (let s = 0; s + 2 < piv.length; s++) {
+    const [p1, mid, p2] = piv.slice(s, s + 3);
+    if (p2.i < from) continue;
+    const a = A(p2.i);
+    if (Math.abs(p1.p - p2.p) > 0.6 * a) continue;
+    const top = p1.hi;
+    const sg = top ? 1 : -1;
+    const peak = top ? Math.max(p1.p, p2.p) : Math.min(p1.p, p2.p);
+    const h = Math.abs(peak - mid.p);
+    if (h < 2 * a) continue;
+    const brk = firstClose(p2.i, (j) => sg * (mid.p - bars2[j].close) > 0);
+    const fail = firstClose(p2.i, (j) => sg * (bars2[j].close - peak) > 0);
+    if (fail >= 0 && (brk < 0 || fail < brk)) continue;
+    if (brk < 0 && p2.i < liveFrom) continue;
+    const color = top ? down : up;
+    const name = top ? "Double top" : "Double bottom";
+    const target = mid.p - sg * h;
+    const c = { start: p1.i, end: brk >= 0 ? brk : p2.i, name, paths: [], zones: [] };
+    c.paths.push({ pts: [{ i: p1.i, p: p1.p, label: top ? "T1" : "B1" }, { i: mid.i, p: mid.p }, { i: p2.i, p: p2.p, label: top ? "T2" : "B2" }], color, width: 1.5, label: `${name}${brk >= 0 ? " \xB7 confirmed" : " \xB7 watching neckline"}`, labelAt: 1 });
+    c.zones.push({ from: p1.i, to: brk >= 0 ? brk : null, top: mid.p, bottom: mid.p, color: neutral, dashed: true, label: "Neckline" });
+    if (brk >= 0) c.zones.push({ from: brk, to: Math.min(n - 1, brk + (p2.i - p1.i)), top: target, bottom: target, color, dashed: true, label: `Measured move ${fmt(target)}` });
+    cands.push(c);
+  }
+  for (let s = 0; s + 4 < piv.length; s++) {
+    const [l, t1, h, t2, r] = piv.slice(s, s + 5);
+    if (r.i < from) continue;
+    const top = h.hi;
+    const sg = top ? 1 : -1;
+    const a = A(r.i);
+    if (!(sg * (h.p - l.p) > 0.5 * a && sg * (h.p - r.p) > 0.5 * a)) continue;
+    if (Math.abs(l.p - r.p) > 1.25 * a) continue;
+    const neck = fit([t1, t2]);
+    const depth = Math.abs(h.p - neck.at(h.i));
+    if (depth < 2 * a) continue;
+    const brk = firstClose(r.i, (j) => sg * (neck.at(j) - bars2[j].close) > 0);
+    const fail = firstClose(r.i, (j) => sg * (bars2[j].close - h.p) > 0);
+    if (fail >= 0 && (brk < 0 || fail < brk)) continue;
+    if (brk < 0 && r.i < liveFrom) continue;
+    const color = top ? down : up;
+    const name = top ? "Head & shoulders" : "Inverse head & shoulders";
+    const c = { start: l.i, end: brk >= 0 ? brk : r.i, name, paths: [], zones: [] };
+    c.paths.push({ pts: [{ i: l.i, p: l.p, label: "LS" }, { i: t1.i, p: t1.p }, { i: h.i, p: h.p, label: "H" }, { i: t2.i, p: t2.p }, { i: r.i, p: r.p, label: "RS" }], color, width: 1.5, label: `${name}${brk >= 0 ? " \xB7 confirmed" : " \xB7 watching neckline"}`, labelAt: 2 });
+    const e = brk >= 0 ? brk : n - 1;
+    c.paths.push({ pts: [{ i: t1.i, p: neck.at(t1.i) }, { i: e, p: neck.at(e) }], color: neutral, dashed: true, width: 1, label: "Neckline", labelAt: 0 });
+    if (brk >= 0) {
+      const target = neck.at(brk) - sg * depth;
+      c.zones.push({ from: brk, to: Math.min(n - 1, brk + (r.i - l.i)), top: target, bottom: target, color, dashed: true, label: `Measured move ${fmt(target)}` });
+    }
+    cands.push(c);
+  }
+  cands.sort((x, y) => y.end - x.end || (y.name.includes("shoulders") ? 1 : 0) - (x.name.includes("shoulders") ? 1 : 0));
+  const kept = [];
+  for (const c of cands) {
+    if (kept.length >= show) break;
+    if (kept.some((q) => c.start < q.end && q.start < c.end)) continue;
+    kept.push(c);
+  }
+  for (const c of kept) {
+    paths.push(...c.paths);
+    zones.push(...c.zones);
+    found.push(c.name);
+  }
+  const conf = tail ? [...piv, tail] : piv;
+  for (const m of [6, 5, 4]) {
+    if (conf.length < m) continue;
+    const w = conf.slice(-m);
+    if (w[0].i < from) continue;
+    const hs = w.filter((q) => q.hi), ls = w.filter((q) => !q.hi);
+    if (hs.length < 2 || ls.length < 2) continue;
+    const U = fit(hs), Lo = fit(ls);
+    const a = A(w[w.length - 1].i);
+    if (U.err > 0.6 * a || Lo.err > 0.6 * a) continue;
+    const i0 = w[0].i, i1 = n - 1;
+    const span = i1 - i0;
+    const du = U.m * span, dl = Lo.m * span;
+    const flat = (d) => Math.abs(d) <= 1 * a;
+    const w0 = U.at(i0) - Lo.at(i0), w1 = U.at(i1) - Lo.at(i1);
+    if (!(w0 > 0)) continue;
+    const conv = w1 < w0 * 0.75, par = Math.abs(w1 - w0) <= w0 * 0.25;
+    let name = "";
+    if (flat(du) && dl > a && conv) name = "Ascending triangle";
+    else if (flat(dl) && du < -a && conv) name = "Descending triangle";
+    else if (du < -a && dl > a) name = "Symmetrical triangle";
+    else if (du > 0 && dl > 0 && conv && !flat(dl)) name = "Rising wedge";
+    else if (du < 0 && dl < 0 && conv && !flat(du)) name = "Falling wedge";
+    else if (flat(du) && flat(dl) && par) name = "Range (rectangle)";
+    else if (du > a && dl > a && par) name = "Rising channel";
+    else if (du < -a && dl < -a && par) name = "Falling channel";
+    else if (w1 > w0 * 1.25) name = "Broadening formation";
+    if (!name) continue;
+    const brokeUp = lastClose > U.at(i1);
+    const brokeDn = lastClose < Lo.at(i1);
+    const color = brokeUp ? up : brokeDn ? down : neutral;
+    const st = brokeUp ? " \xB7 broke up" : brokeDn ? " \xB7 broke down" : "";
+    paths.push({ pts: [{ i: i0, p: U.at(i0) }, { i: i1, p: U.at(i1) }], color, width: 1.5, label: `${name}${st}`, labelAt: 1 });
+    paths.push({ pts: [{ i: i0, p: Lo.at(i0) }, { i: i1, p: Lo.at(i1) }], color, width: 1.5 });
+    found.push(name);
+    break;
+  }
+  return { paths, zones, found };
+}
+var LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function niceStep(v) {
+  if (!(v > 0)) return 0;
+  const mag = Math.pow(10, Math.floor(Math.log10(v)));
+  const f = v / mag;
+  return (f < 1.5 ? 1 : f < 3.5 ? 2 : f < 7.5 ? 5 : 10) * mag;
+}
+function sessions(bars2) {
+  const out = [];
+  let cur = -1;
+  bars2.forEach((b, i) => {
+    const d = Math.floor(b.time / 86400);
+    if (d !== cur) {
+      out.push({ from: i, to: i });
+      cur = d;
+    } else out[out.length - 1].to = i;
+  });
+  return out;
+}
+function valueArea(counts, poc, share = 0.7) {
+  const total = counts.reduce((s, x) => s + x, 0);
+  let inVa = counts[poc], a = poc, z = poc;
+  while (inVa < total * share && (a > 0 || z < counts.length - 1)) {
+    const below = a > 0 ? counts[a - 1] : -1;
+    const above = z < counts.length - 1 ? counts[z + 1] : -1;
+    if (above >= below) {
+      z++;
+      inVa += above;
+    } else {
+      a--;
+      inVa += below;
+    }
+  }
+  return { a, z };
+}
+function tpoProfiles(bars2, rowsWanted = 24, sessionsShown = 5, color = "#6366F1") {
+  const ss = sessions(bars2).slice(-sessionsShown);
+  if (!ss.length) return [];
+  const ranges = ss.map((s) => {
+    let hi = -Infinity, lo = Infinity;
+    for (let i = s.from; i <= s.to; i++) {
+      hi = Math.max(hi, bars2[i].high);
+      lo = Math.min(lo, bars2[i].low);
+    }
+    return hi - lo;
+  }).filter((r) => r > 0).sort((x, y) => x - y);
+  const step = niceStep((ranges[Math.floor(ranges.length / 2)] || 0) / rowsWanted);
+  if (!step) return [];
+  const out = [];
+  for (const s of ss) {
+    const t0 = bars2[s.from].time;
+    const period = bars2.length > 1 && bars2[s.from + 1] && bars2[s.from + 1].time - t0 >= 3600 ? 3600 : 1800;
+    let lo = Infinity, hi = -Infinity;
+    for (let i = s.from; i <= s.to; i++) {
+      hi = Math.max(hi, bars2[i].high);
+      lo = Math.min(lo, bars2[i].low);
+    }
+    if (!(hi >= lo)) continue;
+    const base = Math.floor(lo / step + 1e-9);
+    const top = Math.floor(hi / step + 1e-9);
+    const nRows = top - base + 1;
+    if (nRows > 200) continue;
+    const letters = new Array(nRows).fill("");
+    const marked = Array.from({ length: nRows }, () => /* @__PURE__ */ new Set());
+    let ibLo = Infinity, ibHi = -Infinity;
+    for (let i = s.from; i <= s.to; i++) {
+      const b = bars2[i];
+      const per = Math.min(LETTERS.length - 1, Math.floor((b.time - t0) / period));
+      if (b.time - t0 < 3600) {
+        ibLo = Math.min(ibLo, b.low);
+        ibHi = Math.max(ibHi, b.high);
+      }
+      const a2 = Math.floor(b.low / step + 1e-9) - base, z2 = Math.floor(b.high / step + 1e-9) - base;
+      for (let r = Math.max(0, a2); r <= Math.min(nRows - 1, z2); r++) {
+        if (!marked[r].has(per)) {
+          marked[r].add(per);
+          letters[r] += LETTERS[per];
+        }
+      }
+    }
+    const counts = marked.map((m) => m.size);
+    let poc = 0;
+    const mid = (nRows - 1) / 2;
+    counts.forEach((c, r) => {
+      if (c > counts[poc] || c === counts[poc] && Math.abs(r - mid) < Math.abs(poc - mid)) poc = r;
+    });
+    const { a, z } = valueArea(counts, poc);
+    out.push({
+      from: s.from,
+      to: s.to,
+      kind: "tpo",
+      color,
+      rows: counts.map((v, r) => ({ lo: (base + r) * step, hi: (base + r + 1) * step, v, letters: letters[r] })),
+      poc,
+      vaLow: (base + a) * step,
+      vaHigh: (base + z + 1) * step,
+      ib: ibHi >= ibLo ? { lo: ibLo, hi: ibHi } : void 0
+    });
+  }
+  return out;
+}
+function sessionVolumeProfiles(bars2, rows = 20, sessionsShown = 5, color = "#0EA5E9") {
+  const out = [];
+  for (const s of sessions(bars2).slice(-sessionsShown)) {
+    const vp = volumeProfile(bars2.slice(s.from, s.to + 1), rows);
+    if (!vp || !vp.max) continue;
+    out.push({
+      from: s.from,
+      to: s.to,
+      kind: "vol",
+      color,
+      rows: vp.buckets.map((b) => ({ lo: b.lo, hi: b.hi, v: b.up + b.down, up: b.up })),
+      poc: vp.poc,
+      vaLow: vp.vaLow,
+      vaHigh: vp.vaHigh
+    });
+  }
+  return out;
+}
+
+// src/altCharts.ts
+function kagi(bars2, rev) {
+  const out = [];
+  const lines = [];
+  if (bars2.length < 2 || !(rev > 0)) return { bars: out, lines };
+  let dir = 0;
+  let start = bars2[0].close;
+  let end = start;
+  let t = bars2[0].time;
+  let vol = 0;
+  let lastT = -Infinity;
+  let shoulder = null;
+  let waist = null;
+  let yang = true;
+  const close = () => {
+    const time = Math.max(t, lastT + 1);
+    lastT = time;
+    let flipAt = null;
+    const startYang = yang;
+    if (dir > 0 && !yang && shoulder != null && end > shoulder) {
+      flipAt = shoulder;
+      yang = true;
+    }
+    if (dir < 0 && yang && waist != null && end < waist) {
+      flipAt = waist;
+      yang = false;
+    }
+    out.push({ time, open: start, high: Math.max(start, end), low: Math.min(start, end), close: end, volume: vol });
+    lines.push({ yang: startYang, flipAt });
+    if (dir > 0) shoulder = end;
+    else waist = end;
+    vol = 0;
+  };
+  for (let i = 0; i < bars2.length; i++) {
+    const b = bars2[i];
+    const c = b.close;
+    vol += b.volume || 0;
+    if (dir === 0) {
+      if (c >= start + rev || c <= start - rev) {
+        dir = c > start ? 1 : -1;
+        yang = dir > 0;
+        end = c;
+      }
+      continue;
+    }
+    if (dir * (c - end) > 0) {
+      end = c;
+    } else if (dir * (end - c) >= rev) {
+      close();
+      start = end;
+      end = c;
+      dir = -dir;
+      t = b.time;
+    }
+  }
+  if (dir !== 0) close();
+  return { bars: out, lines };
+}
+function pointFigure(bars2, box, rev = 3) {
+  const out = [];
+  const cols = [];
+  if (bars2.length < 2 || !(box > 0)) return { bars: out, cols };
+  const times = [];
+  const vols = [];
+  let lastT = -Infinity;
+  let vol = 0;
+  const k0 = Math.round(bars2[0].close / box);
+  let cur = null;
+  const open = (c, time) => {
+    const t = Math.max(time, lastT + 1);
+    lastT = t;
+    cols.push(c);
+    times.push(t);
+    vols.push(0);
+    cur = c;
+  };
+  for (const b of bars2) {
+    const c = b.close;
+    vol += b.volume || 0;
+    const up = Math.floor(c / box + 1e-9);
+    const dn = Math.ceil(c / box - 1e-9);
+    if (!cur) {
+      if (up >= k0 + 1) open({ up: true, lo: k0, hi: up }, b.time);
+      else if (dn <= k0 - 1) open({ up: false, lo: dn, hi: k0 }, b.time);
+    } else {
+      const col = cur;
+      if (col.up) {
+        if (up > col.hi) col.hi = up;
+        else if (dn <= col.hi - rev) open({ up: false, lo: dn, hi: col.hi - 1 }, b.time);
+      } else {
+        if (dn < col.lo) col.lo = dn;
+        else if (up >= col.lo + rev) open({ up: true, lo: col.lo + 1, hi: up }, b.time);
+      }
+    }
+    if (cols.length) {
+      vols[cols.length - 1] += vol;
+      vol = 0;
+    }
+  }
+  cols.forEach((c, k) => {
+    const lo = c.lo * box - box / 2;
+    const hi = c.hi * box + box / 2;
+    out.push({ time: times[k], open: c.up ? lo : hi, high: hi, low: lo, close: c.up ? hi : lo, volume: vols[k] });
+  });
+  return { bars: out, cols };
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var bars = { type: "array", description: "OHLCV bars: { time (unix s), open, high, low, close, volume }[]" };
+function describe() {
+  return {
+    name: "@lacspace/patterns",
+    version: VERSION,
+    summary: "Rule-based chart-pattern detection on OHLCV: ATR swings, harmonics, Elliott impulse count, double tops/bottoms, head & shoulders, triangles/wedges/channels, TPO and session volume profiles, Kagi and Point & Figure. Descriptive only.",
+    commands: [
+      { name: "swings", input: { type: "object", properties: { bars, k: { type: "number", default: 2 } }, required: ["bars"] }, output: "{ piv: Pivot[], tail: Pivot|null, atr: number[] }" },
+      { name: "harmonics", input: { type: "object", properties: { bars, k: { type: "number", default: 2 }, tolPct: { type: "number", default: 6 }, show: { type: "integer", default: 3 } }, required: ["bars"] }, output: "{ paths, zones, hits: HarmonicHit[] }" },
+      { name: "elliott", input: { type: "object", properties: { bars, k: { type: "number", default: 2 } }, required: ["bars"] }, output: "{ paths, zones }" },
+      { name: "chartPatterns", input: { type: "object", properties: { bars, k: { type: "number", default: 1.5 }, look: { type: "integer", default: 200 }, show: { type: "integer", default: 2 } }, required: ["bars"] }, output: "{ paths, zones, found: string[] }" },
+      { name: "tpoProfiles", input: { type: "object", properties: { bars, rowsWanted: { type: "integer", default: 24 }, sessionsShown: { type: "integer", default: 5 } }, required: ["bars"] }, output: "StudyProfile[]" },
+      { name: "sessionVolumeProfiles", input: { type: "object", properties: { bars, rows: { type: "integer", default: 20 }, sessionsShown: { type: "integer", default: 5 } }, required: ["bars"] }, output: "StudyProfile[]" },
+      { name: "kagi", input: { type: "object", properties: { bars, rev: { type: "number" } }, required: ["bars", "rev"] }, output: "{ bars, lines }" },
+      { name: "pointFigure", input: { type: "object", properties: { bars, box: { type: "number" }, rev: { type: "integer", default: 3 } }, required: ["bars", "box"] }, output: "{ bars, cols }" }
+    ]
+  };
+}
+
+exports.atr = atr;
+exports.chartPatterns = chartPatterns;
+exports.describe = describe;
+exports.elliott = elliott;
+exports.harmonics = harmonics;
+exports.kagi = kagi;
+exports.pointFigure = pointFigure;
+exports.rma = rma;
+exports.sessionVolumeProfiles = sessionVolumeProfiles;
+exports.swings = swings;
+exports.tpoProfiles = tpoProfiles;
+exports.trueRange = trueRange;
+exports.volumeProfile = volumeProfile;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map