@itssumitrai/fin-charter 0.2.0

package/dist/index81.js

@@ -0,0 +1,2 @@
+function r(r,t,n){const o=new Float64Array(n);o[0]=0;for(let e=1;e<n;e++)r[e]>r[e-1]?o[e]=o[e-1]+t[e]:r[e]<r[e-1]?o[e]=o[e-1]-t[e]:o[e]=o[e-1];return o}export{r as computeOBV};
+//# sourceMappingURL=index81.js.map

package/dist/index81.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index81.js","names":[],"sources":["../src/indicators/obv.ts"],"sourcesContent":["export function computeOBV(\n  close: Float64Array,\n  volume: Float64Array,\n  length: number\n): Float64Array {\n  const result = new Float64Array(length);\n\n  // Index 0 seeded at 0\n  result[0] = 0;\n\n  for (let i = 1; i < length; i++) {\n    if (close[i] > close[i - 1]) {\n      result[i] = result[i - 1] + volume[i];\n    } else if (close[i] < close[i - 1]) {\n      result[i] = result[i - 1] - volume[i];\n    } else {\n      result[i] = result[i - 1];\n    }\n  }\n\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EACd,EACA,EACA,GAEA,MAAM,EAAS,IAAI,aAAa,GAGhC,EAAO,GAAK,EAEZ,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IACtB,EAAM,GAAK,EAAM,EAAI,GACvB,EAAO,GAAK,EAAO,EAAI,GAAK,EAAO,GAC1B,EAAM,GAAK,EAAM,EAAI,GAC9B,EAAO,GAAK,EAAO,EAAI,GAAK,EAAO,GAEnC,EAAO,GAAK,EAAO,EAAI,GAI3B,OAAO"}

package/dist/index82.js

@@ -0,0 +1,2 @@
+function t(t,o,r,e,n){const l=new Float64Array(e);for(let f=0;f<n-1;f++)l[f]=NaN;for(let f=n-1;f<e;f++){let e=t[f],a=o[f];for(let r=f-n+1;r<=f;r++)t[r]>e&&(e=t[r]),o[r]<a&&(a=o[r]);const c=e-a;l[f]=0===c?0:(e-r[f])/c*-100}return l}export{t as computeWilliamsR};
+//# sourceMappingURL=index82.js.map

package/dist/index82.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index82.js","names":[],"sources":["../src/indicators/williams-r.ts"],"sourcesContent":["export function computeWilliamsR(\n  high: Float64Array,\n  low: Float64Array,\n  close: Float64Array,\n  length: number,\n  period: number\n): Float64Array {\n  const result = new Float64Array(length);\n\n  // NaN for indices [0, period-2]\n  for (let i = 0; i < period - 1; i++) {\n    result[i] = NaN;\n  }\n\n  for (let i = period - 1; i < length; i++) {\n    let highestHigh = high[i];\n    let lowestLow = low[i];\n\n    for (let j = i - period + 1; j <= i; j++) {\n      if (high[j] > highestHigh) highestHigh = high[j];\n      if (low[j] < lowestLow) lowestLow = low[j];\n    }\n\n    const range = highestHigh - lowestLow;\n    if (range === 0) {\n      result[i] = 0;\n    } else {\n      result[i] = ((highestHigh - close[i]) / range) * -100;\n    }\n  }\n\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EACd,EACA,EACA,EACA,EACA,GAEA,MAAM,EAAS,IAAI,aAAa,GAGhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAS,EAAG,IAC9B,EAAO,GAAK,IAGd,IAAK,IAAI,EAAI,EAAS,EAAG,EAAI,EAAQ,IAAK,CACxC,IAAI,EAAc,EAAK,GACnB,EAAY,EAAI,GAEpB,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IAC/B,EAAK,GAAK,IAAa,EAAc,EAAK,IAC1C,EAAI,GAAK,IAAW,EAAY,EAAI,IAG1C,MAAM,EAAQ,EAAc,EAE1B,EAAO,GADK,IAAV,EACU,GAEE,EAAc,EAAM,IAAM,GAAS,IAIrD,OAAO"}

package/dist/index83.js

@@ -0,0 +1,2 @@
+function t(t,n,r){const o=new Float64Array(n);let e=0;for(;e<n&&isNaN(t[e]);)e++;const l=e+r-1;for(let N=0;N<Math.min(l,n);N++)o[N]=NaN;if(l>=n)return o;let f=0;for(let N=e;N<e+r;N++)f+=t[N];o[l]=f/r;const a=2/(r+1);for(let N=l+1;N<n;N++)isNaN(t[N])?o[N]=o[N-1]:o[N]=t[N]*a+o[N-1]*(1-a);return o}function n(t,n,r){const o=new Float64Array(n),e=[];let l=0;for(let f=0;f<n;f++){for(;l<e.length&&e[l]<=f-r;)l++;for(;l<e.length&&t[e[e.length-1]]<=t[f];)e.pop();e.push(f),o[f]=f>=r-1?t[e[l]]:NaN}return o}function r(t,n,r){const o=new Float64Array(n),e=[];let l=0;for(let f=0;f<n;f++){for(;l<e.length&&e[l]<=f-r;)l++;for(;l<e.length&&t[e[e.length-1]]>=t[f];)e.pop();e.push(f),o[f]=f>=r-1?t[e[l]]:NaN}return o}export{t as computeEMASkipNaN,n as slidingMax,r as slidingMin};
+//# sourceMappingURL=index83.js.map

package/dist/index83.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index83.js","names":[],"sources":["../src/indicators/utils.ts"],"sourcesContent":["/**\n * EMA that skips leading NaN values in the input.\n * Used when chaining EMAs (e.g., TRIX = triple EMA) where prior stages\n * produce leading NaNs that would poison the SMA seed of a regular EMA.\n */\nexport function computeEMASkipNaN(data: Float64Array, length: number, period: number): Float64Array {\n  const result = new Float64Array(length);\n\n  // Find first non-NaN index\n  let start = 0;\n  while (start < length && isNaN(data[start])) start++;\n\n  // Fill everything before the valid EMA region with NaN\n  const firstValid = start + period - 1;\n  for (let i = 0; i < Math.min(firstValid, length); i++) result[i] = NaN;\n  if (firstValid >= length) return result;\n\n  // SMA seed from first `period` valid values\n  let sum = 0;\n  for (let i = start; i < start + period; i++) sum += data[i];\n  result[firstValid] = sum / period;\n\n  const k = 2 / (period + 1);\n  for (let i = firstValid + 1; i < length; i++) {\n    if (isNaN(data[i])) { result[i] = result[i - 1]; continue; }\n    result[i] = data[i] * k + result[i - 1] * (1 - k);\n  }\n  return result;\n}\n\n/**\n * O(n) sliding window maximum using monotone deque.\n * Returns Float64Array where result[i] = max of data[i-period+1..i].\n * Indices [0, period-2] are NaN.\n *\n * Uses a head-pointer instead of Array.shift() to avoid O(n) copies.\n */\nexport function slidingMax(data: Float64Array, length: number, period: number): Float64Array {\n  const result = new Float64Array(length);\n  const deque: number[] = []; // indices of potential maximums\n  let head = 0;\n\n  for (let i = 0; i < length; i++) {\n    while (head < deque.length && deque[head] <= i - period) head++;\n    while (head < deque.length && data[deque[deque.length - 1]] <= data[i]) deque.pop();\n    deque.push(i);\n    result[i] = i >= period - 1 ? data[deque[head]] : NaN;\n  }\n  return result;\n}\n\n/**\n * O(n) sliding window minimum using monotone deque.\n *\n * Uses a head-pointer instead of Array.shift() to avoid O(n) copies.\n */\nexport function slidingMin(data: Float64Array, length: number, period: number): Float64Array {\n  const result = new Float64Array(length);\n  const deque: number[] = [];\n  let head = 0;\n\n  for (let i = 0; i < length; i++) {\n    while (head < deque.length && deque[head] <= i - period) head++;\n    while (head < deque.length && data[deque[deque.length - 1]] >= data[i]) deque.pop();\n    deque.push(i);\n    result[i] = i >= period - 1 ? data[deque[head]] : NaN;\n  }\n  return result;\n}\n"],"mappings":"AAKA,SAAgB,EAAkB,EAAoB,EAAgB,GACpE,MAAM,EAAS,IAAI,aAAa,GAGhC,IAAI,EAAQ,EACZ,KAAO,EAAQ,GAAU,MAAM,EAAK,KAAS,IAG7C,MAAM,EAAa,EAAQ,EAAS,EACpC,IAAK,IAAI,EAAI,EAAG,EAAI,KAAK,IAAI,EAAY,GAAS,IAAK,EAAO,GAAK,IACnE,GAAI,GAAc,EAAQ,OAAO,EAGjC,IAAI,EAAM,EACV,IAAK,IAAI,EAAI,EAAO,EAAI,EAAQ,EAAQ,IAAK,GAAO,EAAK,GACzD,EAAO,GAAc,EAAM,EAE3B,MAAM,EAAI,GAAK,EAAS,GACxB,IAAK,IAAI,EAAI,EAAa,EAAG,EAAI,EAAQ,IACnC,MAAM,EAAK,IAAO,EAAO,GAAK,EAAO,EAAI,GAC7C,EAAO,GAAK,EAAK,GAAK,EAAI,EAAO,EAAI,IAAM,EAAI,GAEjD,OAAO,EAUT,SAAgB,EAAW,EAAoB,EAAgB,GAC7D,MAAM,EAAS,IAAI,aAAa,GAC1B,EAAkB,GACxB,IAAI,EAAO,EAEX,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,CAC/B,KAAO,EAAO,EAAM,QAAU,EAAM,IAAS,EAAI,GAAQ,IACzD,KAAO,EAAO,EAAM,QAAU,EAAK,EAAM,EAAM,OAAS,KAAO,EAAK,IAAI,EAAM,MAC9E,EAAM,KAAK,GACX,EAAO,GAAK,GAAK,EAAS,EAAI,EAAK,EAAM,IAAS,IAEpD,OAAO,EAQT,SAAgB,EAAW,EAAoB,EAAgB,GAC7D,MAAM,EAAS,IAAI,aAAa,GAC1B,EAAkB,GACxB,IAAI,EAAO,EAEX,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,CAC/B,KAAO,EAAO,EAAM,QAAU,EAAM,IAAS,EAAI,GAAQ,IACzD,KAAO,EAAO,EAAM,QAAU,EAAK,EAAM,EAAM,OAAS,KAAO,EAAK,IAAI,EAAM,MAC9E,EAAM,KAAK,GACX,EAAO,GAAK,GAAK,EAAS,EAAI,EAAK,EAAM,IAAS,IAEpD,OAAO"}

package/dist/index84.js

@@ -0,0 +1,2 @@
+import{slidingMax as o,slidingMin as n}from"./index83.js";function t(t,r,a,e,l=9,N=26,s=52){const i=o(t,e,l),f=n(r,e,l),c=o(t,e,N),u=n(r,e,N),A=o(t,e,s),k=n(r,e,s),w=new Float64Array(e),y=new Float64Array(e);for(let o=0;o<e;o++)w[o]=(i[o]+f[o])/2,y[o]=(c[o]+u[o])/2;const F=new Float64Array(e).fill(NaN);for(let o=N;o<e;o++){const n=o-N,t=(w[n]+y[n])/2;F[o]=isNaN(t)?NaN:t}const j=new Float64Array(e).fill(NaN);for(let o=N;o<e;o++){const n=o-N,t=(A[n]+k[n])/2;j[o]=isNaN(t)?NaN:t}const m=new Float64Array(e).fill(NaN);for(let o=0;o<e-N;o++)m[o]=a[o+N];return{tenkan:w,kijun:y,senkouA:F,senkouB:j,chikou:m}}export{t as computeIchimoku};
+//# sourceMappingURL=index84.js.map

package/dist/index84.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index84.js","names":[],"sources":["../src/indicators/ichimoku.ts"],"sourcesContent":["import { slidingMax, slidingMin } from './utils';\n\nexport interface IchimokuResult {\n  tenkan: Float64Array;\n  kijun: Float64Array;\n  senkouA: Float64Array;\n  senkouB: Float64Array;\n  chikou: Float64Array;\n}\n\nexport function computeIchimoku(\n  high: Float64Array,\n  low: Float64Array,\n  close: Float64Array,\n  length: number,\n  tenkanPeriod = 9,\n  kijunPeriod = 26,\n  senkouPeriod = 52,\n): IchimokuResult {\n  const highMaxTenkan = slidingMax(high, length, tenkanPeriod);\n  const lowMinTenkan = slidingMin(low, length, tenkanPeriod);\n  const highMaxKijun = slidingMax(high, length, kijunPeriod);\n  const lowMinKijun = slidingMin(low, length, kijunPeriod);\n  const highMaxSenkou = slidingMax(high, length, senkouPeriod);\n  const lowMinSenkou = slidingMin(low, length, senkouPeriod);\n\n  const tenkan = new Float64Array(length);\n  const kijun = new Float64Array(length);\n\n  for (let i = 0; i < length; i++) {\n    tenkan[i] = (highMaxTenkan[i] + lowMinTenkan[i]) / 2;\n    kijun[i] = (highMaxKijun[i] + lowMinKijun[i]) / 2;\n  }\n\n  // SenkouA = (Tenkan + Kijun) / 2, shifted AHEAD by kijunPeriod positions\n  // senkouA[i] = computed value at [i - kijunPeriod], for i >= kijunPeriod\n  const senkouA = new Float64Array(length).fill(NaN);\n  for (let i = kijunPeriod; i < length; i++) {\n    const src = i - kijunPeriod;\n    const a = (tenkan[src] + kijun[src]) / 2;\n    senkouA[i] = isNaN(a) ? NaN : a;\n  }\n\n  // SenkouB = (slidingMax(high, senkouPeriod) + slidingMin(low, senkouPeriod)) / 2, also shifted ahead by kijunPeriod\n  const senkouB = new Float64Array(length).fill(NaN);\n  for (let i = kijunPeriod; i < length; i++) {\n    const src = i - kijunPeriod;\n    const b = (highMaxSenkou[src] + lowMinSenkou[src]) / 2;\n    senkouB[i] = isNaN(b) ? NaN : b;\n  }\n\n  // Chikou = close shifted BEHIND by kijunPeriod positions\n  // chikou[i] = close[i + kijunPeriod]\n  const chikou = new Float64Array(length).fill(NaN);\n  for (let i = 0; i < length - kijunPeriod; i++) {\n    chikou[i] = close[i + kijunPeriod];\n  }\n\n  return { tenkan, kijun, senkouA, senkouB, chikou };\n}\n"],"mappings":"0DAUA,SAAgB,EACd,EACA,EACA,EACA,EACA,EAAe,EACf,EAAc,GACd,EAAe,IAEf,MAAM,EAAgB,EAAW,EAAM,EAAQ,GACzC,EAAe,EAAW,EAAK,EAAQ,GACvC,EAAe,EAAW,EAAM,EAAQ,GACxC,EAAc,EAAW,EAAK,EAAQ,GACtC,EAAgB,EAAW,EAAM,EAAQ,GACzC,EAAe,EAAW,EAAK,EAAQ,GAEvC,EAAS,IAAI,aAAa,GAC1B,EAAQ,IAAI,aAAa,GAE/B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAO,IAAM,EAAc,GAAK,EAAa,IAAM,EACnD,EAAM,IAAM,EAAa,GAAK,EAAY,IAAM,EAKlD,MAAM,EAAU,IAAI,aAAa,GAAQ,KAAK,KAC9C,IAAK,IAAI,EAAI,EAAa,EAAI,EAAQ,IAAK,CACzC,MAAM,EAAM,EAAI,EACV,GAAK,EAAO,GAAO,EAAM,IAAQ,EACvC,EAAQ,GAAK,MAAM,GAAK,IAAM,EAIhC,MAAM,EAAU,IAAI,aAAa,GAAQ,KAAK,KAC9C,IAAK,IAAI,EAAI,EAAa,EAAI,EAAQ,IAAK,CACzC,MAAM,EAAM,EAAI,EACV,GAAK,EAAc,GAAO,EAAa,IAAQ,EACrD,EAAQ,GAAK,MAAM,GAAK,IAAM,EAKhC,MAAM,EAAS,IAAI,aAAa,GAAQ,KAAK,KAC7C,IAAK,IAAI,EAAI,EAAG,EAAI,EAAS,EAAa,IACxC,EAAO,GAAK,EAAM,EAAI,GAGxB,MAAO,CAAE,SAAQ,QAAO,UAAS,UAAS"}

package/dist/index85.js

@@ -0,0 +1,2 @@
+function t(t,n,a,r=.02,e=.2){const h=new Float64Array(a);if(0===a)return h;let i="up",m=n[0],o=t[0],u=r;h[0]=m;for(let M=1;M<a;M++){let a=m+u*(o-m);"up"===i?(M>=2?a=Math.min(a,n[M-1],n[M-2]):M>=1&&(a=Math.min(a,n[M-1])),n[M]<a?(i="down",a=o,o=n[M],u=r):t[M]>o&&(o=t[M],u=Math.min(u+r,e))):(M>=2?a=Math.max(a,t[M-1],t[M-2]):M>=1&&(a=Math.max(a,t[M-1])),t[M]>a?(i="up",a=o,o=t[M],u=r):n[M]<o&&(o=n[M],u=Math.min(u+r,e))),m=a,h[M]=m}return h}export{t as computeParabolicSAR};
+//# sourceMappingURL=index85.js.map

package/dist/index85.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index85.js","names":[],"sources":["../src/indicators/parabolic-sar.ts"],"sourcesContent":["export function computeParabolicSAR(\n  high: Float64Array,\n  low: Float64Array,\n  length: number,\n  afStep = 0.02,\n  afMax = 0.20,\n): Float64Array {\n  const result = new Float64Array(length);\n\n  if (length === 0) return result;\n\n  // Initialize with uptrend\n  let trend: 'up' | 'down' = 'up';\n  let sar = low[0];\n  let ep = high[0];\n  let af = afStep;\n\n  result[0] = sar;\n\n  for (let i = 1; i < length; i++) {\n    // Calculate new SAR\n    let newSar = sar + af * (ep - sar);\n\n    if (trend === 'up') {\n      // Clamp SAR to not exceed prior two lows\n      if (i >= 2) newSar = Math.min(newSar, low[i - 1], low[i - 2]);\n      else if (i >= 1) newSar = Math.min(newSar, low[i - 1]);\n\n      if (low[i] < newSar) {\n        // Reverse to downtrend\n        trend = 'down';\n        newSar = ep; // SAR becomes prior EP (the highest high)\n        ep = low[i];\n        af = afStep;\n      } else {\n        // Stay in uptrend\n        if (high[i] > ep) {\n          ep = high[i];\n          af = Math.min(af + afStep, afMax);\n        }\n      }\n    } else {\n      // Downtrend: clamp SAR to not be below prior two highs\n      if (i >= 2) newSar = Math.max(newSar, high[i - 1], high[i - 2]);\n      else if (i >= 1) newSar = Math.max(newSar, high[i - 1]);\n\n      if (high[i] > newSar) {\n        // Reverse to uptrend\n        trend = 'up';\n        newSar = ep; // SAR becomes prior EP (the lowest low)\n        ep = high[i];\n        af = afStep;\n      } else {\n        // Stay in downtrend\n        if (low[i] < ep) {\n          ep = low[i];\n          af = Math.min(af + afStep, afMax);\n        }\n      }\n    }\n\n    sar = newSar;\n    result[i] = sar;\n  }\n\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EACd,EACA,EACA,EACA,EAAS,IACT,EAAQ,IAER,MAAM,EAAS,IAAI,aAAa,GAEhC,GAAe,IAAX,EAAc,OAAO,EAGzB,IAAI,EAAuB,KACvB,EAAM,EAAI,GACV,EAAK,EAAK,GACV,EAAK,EAET,EAAO,GAAK,EAEZ,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,CAE/B,IAAI,EAAS,EAAM,GAAM,EAAK,GAEhB,OAAV,GAEE,GAAK,EAAG,EAAS,KAAK,IAAI,EAAQ,EAAI,EAAI,GAAI,EAAI,EAAI,IACjD,GAAK,IAAG,EAAS,KAAK,IAAI,EAAQ,EAAI,EAAI,KAE/C,EAAI,GAAK,GAEX,EAAQ,OACR,EAAS,EACT,EAAK,EAAI,GACT,EAAK,GAGD,EAAK,GAAK,IACZ,EAAK,EAAK,GACV,EAAK,KAAK,IAAI,EAAK,EAAQ,MAK3B,GAAK,EAAG,EAAS,KAAK,IAAI,EAAQ,EAAK,EAAI,GAAI,EAAK,EAAI,IACnD,GAAK,IAAG,EAAS,KAAK,IAAI,EAAQ,EAAK,EAAI,KAEhD,EAAK,GAAK,GAEZ,EAAQ,KACR,EAAS,EACT,EAAK,EAAK,GACV,EAAK,GAGD,EAAI,GAAK,IACX,EAAK,EAAI,GACT,EAAK,KAAK,IAAI,EAAK,EAAQ,KAKjC,EAAM,EACN,EAAO,GAAK,EAGd,OAAO"}

package/dist/index86.js

@@ -0,0 +1,2 @@
+import{computeEMA as r}from"./index72.js";import{computeATR as o}from"./index79.js";function e(e,t,a,i,n=20,N=10,l=2){const m=r(e,i,n),p=o(t,a,e,i,N),s=new Float64Array(i),d=new Float64Array(i);for(let r=0;r<i;r++)isNaN(m[r])||isNaN(p[r])?(s[r]=NaN,d[r]=NaN):(s[r]=m[r]+l*p[r],d[r]=m[r]-l*p[r]);return{upper:s,middle:m,lower:d}}export{e as computeKeltner};
+//# sourceMappingURL=index86.js.map

package/dist/index86.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index86.js","names":[],"sources":["../src/indicators/keltner.ts"],"sourcesContent":["import { computeEMA } from './ema';\nimport { computeATR } from './atr';\n\nexport interface KeltnerResult {\n  upper: Float64Array;\n  middle: Float64Array;\n  lower: Float64Array;\n}\n\nexport function computeKeltner(\n  close: Float64Array,\n  high: Float64Array,\n  low: Float64Array,\n  length: number,\n  emaPeriod = 20,\n  atrPeriod = 10,\n  multiplier = 2.0,\n): KeltnerResult {\n  const middle = computeEMA(close, length, emaPeriod);\n  const atr = computeATR(high, low, close, length, atrPeriod);\n\n  const upper = new Float64Array(length);\n  const lower = new Float64Array(length);\n\n  for (let i = 0; i < length; i++) {\n    if (isNaN(middle[i]) || isNaN(atr[i])) {\n      upper[i] = NaN;\n      lower[i] = NaN;\n    } else {\n      upper[i] = middle[i] + multiplier * atr[i];\n      lower[i] = middle[i] - multiplier * atr[i];\n    }\n  }\n\n  return { upper, middle, lower };\n}\n"],"mappings":"oFASA,SAAgB,EACd,EACA,EACA,EACA,EACA,EAAY,GACZ,EAAY,GACZ,EAAa,GAEb,MAAM,EAAS,EAAW,EAAO,EAAQ,GACnC,EAAM,EAAW,EAAM,EAAK,EAAO,EAAQ,GAE3C,EAAQ,IAAI,aAAa,GACzB,EAAQ,IAAI,aAAa,GAE/B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IACtB,MAAM,EAAO,KAAO,MAAM,EAAI,KAChC,EAAM,GAAK,IACX,EAAM,GAAK,MAEX,EAAM,GAAK,EAAO,GAAK,EAAa,EAAI,GACxC,EAAM,GAAK,EAAO,GAAK,EAAa,EAAI,IAI5C,MAAO,CAAE,QAAO,SAAQ"}

package/dist/index87.js

@@ -0,0 +1,2 @@
+import{slidingMax as r,slidingMin as e}from"./index83.js";function o(o,t,n,i=20){const l=r(o,n,i),p=e(t,n,i),d=new Float64Array(n);for(let r=0;r<n;r++)d[r]=(l[r]+p[r])/2;return{upper:l,middle:d,lower:p}}export{o as computeDonchian};
+//# sourceMappingURL=index87.js.map

package/dist/index87.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index87.js","names":[],"sources":["../src/indicators/donchian.ts"],"sourcesContent":["import { slidingMax, slidingMin } from './utils';\n\nexport interface DonchianResult {\n  upper: Float64Array;\n  middle: Float64Array;\n  lower: Float64Array;\n}\n\nexport function computeDonchian(\n  high: Float64Array,\n  low: Float64Array,\n  length: number,\n  period = 20,\n): DonchianResult {\n  const upper = slidingMax(high, length, period);\n  const lower = slidingMin(low, length, period);\n  const middle = new Float64Array(length);\n\n  for (let i = 0; i < length; i++) {\n    middle[i] = (upper[i] + lower[i]) / 2;\n  }\n\n  return { upper, middle, lower };\n}\n"],"mappings":"0DAQA,SAAgB,EACd,EACA,EACA,EACA,EAAS,IAET,MAAM,EAAQ,EAAW,EAAM,EAAQ,GACjC,EAAQ,EAAW,EAAK,EAAQ,GAChC,EAAS,IAAI,aAAa,GAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAO,IAAM,EAAM,GAAK,EAAM,IAAM,EAGtC,MAAO,CAAE,QAAO,SAAQ"}

package/dist/index88.js

@@ -0,0 +1,2 @@
+function t(t,e,o,r,n=20){const l=new Float64Array(r),a=new Float64Array(r);for(let f=0;f<r;f++)a[f]=(t[f]+e[f]+o[f])/3;for(let f=0;f<r;f++){if(f<n-1){l[f]=NaN;continue}let t=0;for(let r=f-n+1;r<=f;r++)t+=a[r];const e=t/n;let o=0;for(let r=f-n+1;r<=f;r++)o+=Math.abs(a[r]-e);o/=n,l[f]=0===o?0:(a[f]-e)/(.015*o)}return l}export{t as computeCCI};
+//# sourceMappingURL=index88.js.map

package/dist/index88.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index88.js","names":[],"sources":["../src/indicators/cci.ts"],"sourcesContent":["export function computeCCI(\n  high: Float64Array,\n  low: Float64Array,\n  close: Float64Array,\n  length: number,\n  period = 20,\n): Float64Array {\n  const result = new Float64Array(length);\n\n  // Typical price\n  const tp = new Float64Array(length);\n  for (let i = 0; i < length; i++) {\n    tp[i] = (high[i] + low[i] + close[i]) / 3;\n  }\n\n  for (let i = 0; i < length; i++) {\n    if (i < period - 1) {\n      result[i] = NaN;\n      continue;\n    }\n\n    // SMA of TP over window\n    let sum = 0;\n    for (let j = i - period + 1; j <= i; j++) {\n      sum += tp[j];\n    }\n    const sma = sum / period;\n\n    // Mean deviation\n    let meanDev = 0;\n    for (let j = i - period + 1; j <= i; j++) {\n      meanDev += Math.abs(tp[j] - sma);\n    }\n    meanDev /= period;\n\n    result[i] = meanDev === 0 ? 0 : (tp[i] - sma) / (0.015 * meanDev);\n  }\n\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EACd,EACA,EACA,EACA,EACA,EAAS,IAET,MAAM,EAAS,IAAI,aAAa,GAG1B,EAAK,IAAI,aAAa,GAC5B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAG,IAAM,EAAK,GAAK,EAAI,GAAK,EAAM,IAAM,EAG1C,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,CAC/B,GAAI,EAAI,EAAS,EAAG,CAClB,EAAO,GAAK,IACZ,SAIF,IAAI,EAAM,EACV,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IACnC,GAAO,EAAG,GAEZ,MAAM,EAAM,EAAM,EAGlB,IAAI,EAAU,EACd,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IACnC,GAAW,KAAK,IAAI,EAAG,GAAK,GAE9B,GAAW,EAEX,EAAO,GAAiB,IAAZ,EAAgB,GAAK,EAAG,GAAK,IAAQ,KAAQ,GAG3D,OAAO"}

package/dist/index89.js

@@ -0,0 +1,2 @@
+function a(a,l,r,n,t="standard"){const o=new Float64Array(n).fill(NaN),e=new Float64Array(n).fill(NaN),N=new Float64Array(n).fill(NaN),f=new Float64Array(n).fill(NaN),i=new Float64Array(n).fill(NaN),s=new Float64Array(n).fill(NaN),c=new Float64Array(n).fill(NaN);for(let w=1;w<n;w++){const n=a[w-1],y=l[w-1],A=r[w-1],F=n-y;if("standard"===t){const a=(n+y+A)/3;o[w]=a,e[w]=2*a-y,i[w]=2*a-n,N[w]=a+F,s[w]=a-F,f[w]=n+2*(a-y),c[w]=y-2*(n-a)}else if("fibonacci"===t){const a=(n+y+A)/3;o[w]=a,e[w]=a+.382*F,N[w]=a+.618*F,f[w]=a+F,i[w]=a-.382*F,s[w]=a-.618*F,c[w]=a-F}else{const a=(n+y+2*A)/4;o[w]=a,e[w]=2*a-y,i[w]=2*a-n,N[w]=a+F,s[w]=a-F,f[w]=n+2*(a-y),c[w]=y-2*(n-a)}}return{pp:o,r1:e,r2:N,r3:f,s1:i,s2:s,s3:c}}export{a as computePivotPoints};
+//# sourceMappingURL=index89.js.map

package/dist/index89.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index89.js","names":[],"sources":["../src/indicators/pivot-points.ts"],"sourcesContent":["export interface PivotPointsResult {\n  pp: Float64Array;\n  r1: Float64Array;\n  r2: Float64Array;\n  r3: Float64Array;\n  s1: Float64Array;\n  s2: Float64Array;\n  s3: Float64Array;\n}\n\nexport function computePivotPoints(\n  high: Float64Array,\n  low: Float64Array,\n  close: Float64Array,\n  length: number,\n  variant: 'standard' | 'fibonacci' | 'woodie' = 'standard',\n): PivotPointsResult {\n  const pp = new Float64Array(length).fill(NaN);\n  const r1 = new Float64Array(length).fill(NaN);\n  const r2 = new Float64Array(length).fill(NaN);\n  const r3 = new Float64Array(length).fill(NaN);\n  const s1 = new Float64Array(length).fill(NaN);\n  const s2 = new Float64Array(length).fill(NaN);\n  const s3 = new Float64Array(length).fill(NaN);\n\n  // Uses PREVIOUS bar's HLC. First bar = NaN.\n  for (let i = 1; i < length; i++) {\n    const H = high[i - 1];\n    const L = low[i - 1];\n    const C = close[i - 1];\n    const range = H - L;\n\n    if (variant === 'standard') {\n      const pivot = (H + L + C) / 3;\n      pp[i] = pivot;\n      r1[i] = 2 * pivot - L;\n      s1[i] = 2 * pivot - H;\n      r2[i] = pivot + range;\n      s2[i] = pivot - range;\n      r3[i] = H + 2 * (pivot - L);\n      s3[i] = L - 2 * (H - pivot);\n    } else if (variant === 'fibonacci') {\n      const pivot = (H + L + C) / 3;\n      pp[i] = pivot;\n      r1[i] = pivot + 0.382 * range;\n      r2[i] = pivot + 0.618 * range;\n      r3[i] = pivot + range;\n      s1[i] = pivot - 0.382 * range;\n      s2[i] = pivot - 0.618 * range;\n      s3[i] = pivot - range;\n    } else {\n      // woodie\n      const pivot = (H + L + 2 * C) / 4;\n      pp[i] = pivot;\n      r1[i] = 2 * pivot - L;\n      s1[i] = 2 * pivot - H;\n      r2[i] = pivot + range;\n      s2[i] = pivot - range;\n      r3[i] = H + 2 * (pivot - L);\n      s3[i] = L - 2 * (H - pivot);\n    }\n  }\n\n  return { pp, r1, r2, r3, s1, s2, s3 };\n}\n"],"mappings":"AAUA,SAAgB,EACd,EACA,EACA,EACA,EACA,EAA+C,YAE/C,MAAM,EAAK,IAAI,aAAa,GAAQ,KAAK,KACnC,EAAK,IAAI,aAAa,GAAQ,KAAK,KACnC,EAAK,IAAI,aAAa,GAAQ,KAAK,KACnC,EAAK,IAAI,aAAa,GAAQ,KAAK,KACnC,EAAK,IAAI,aAAa,GAAQ,KAAK,KACnC,EAAK,IAAI,aAAa,GAAQ,KAAK,KACnC,EAAK,IAAI,aAAa,GAAQ,KAAK,KAGzC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,CAC/B,MAAM,EAAI,EAAK,EAAI,GACb,EAAI,EAAI,EAAI,GACZ,EAAI,EAAM,EAAI,GACd,EAAQ,EAAI,EAElB,GAAgB,aAAZ,EAAwB,CAC1B,MAAM,GAAS,EAAI,EAAI,GAAK,EAC5B,EAAG,GAAK,EACR,EAAG,GAAK,EAAI,EAAQ,EACpB,EAAG,GAAK,EAAI,EAAQ,EACpB,EAAG,GAAK,EAAQ,EAChB,EAAG,GAAK,EAAQ,EAChB,EAAG,GAAK,EAAI,GAAK,EAAQ,GACzB,EAAG,GAAK,EAAI,GAAK,EAAI,WACA,cAAZ,EAAyB,CAClC,MAAM,GAAS,EAAI,EAAI,GAAK,EAC5B,EAAG,GAAK,EACR,EAAG,GAAK,EAAQ,KAAQ,EACxB,EAAG,GAAK,EAAQ,KAAQ,EACxB,EAAG,GAAK,EAAQ,EAChB,EAAG,GAAK,EAAQ,KAAQ,EACxB,EAAG,GAAK,EAAQ,KAAQ,EACxB,EAAG,GAAK,EAAQ,MACX,CAEL,MAAM,GAAS,EAAI,EAAI,EAAI,GAAK,EAChC,EAAG,GAAK,EACR,EAAG,GAAK,EAAI,EAAQ,EACpB,EAAG,GAAK,EAAI,EAAQ,EACpB,EAAG,GAAK,EAAQ,EAChB,EAAG,GAAK,EAAQ,EAChB,EAAG,GAAK,EAAI,GAAK,EAAQ,GACzB,EAAG,GAAK,EAAI,GAAK,EAAI,IAIzB,MAAO,CAAE,KAAI,KAAI,KAAI,KAAI,KAAI,KAAI"}

package/dist/index9.js

@@ -0,0 +1,2 @@
+var t=class{constructor(t){this._height=0,this._min=0,this._max=1,this._targetMin=0,this._targetMax=1,this._initialized=!1,this._animating=!1,this._manualRange=!1,this._comparisonMode=!1,this._mode="linear",this.position=t}get mode(){return this._mode}setMode(t){this._mode=t}setHeight(t){this._height=t}autoScale(t,i){if(this._manualRange)return;if(t===i){const h=.05*Math.abs(t)||.05;t-=h,i+=h}if(!this._initialized)return this._min=t,this._max=i,this._targetMin=t,this._targetMax=i,void(this._initialized=!0);const h=1e-6*(this._targetMax-this._targetMin)||1e-10;Math.abs(this._targetMin-t)<h&&Math.abs(this._targetMax-i)<h||(this._targetMin=t,this._targetMax=i,this._animating=!0)}tick(){if(!this._animating)return!1;this._min+=.25*(this._targetMin-this._min),this._max+=.25*(this._targetMax-this._max);const t=5e-4*Math.abs(this._targetMax-this._targetMin);return Math.abs(this._min-this._targetMin)<t&&Math.abs(this._max-this._targetMax)<t&&(this._min=this._targetMin,this._max=this._targetMax,this._animating=!1),this._animating}get isAnimating(){return this._animating}snapToTarget(){this._min=this._targetMin,this._max=this._targetMax,this._animating=!1}setRange(t,i){this._manualRange=!0,this._min=t,this._max=i,this._targetMin=t,this._targetMax=i,this._animating=!1}resetAutoScale(){this._manualRange=!1}setComparisonMode(t){this._comparisonMode=t}isComparisonMode(){return this._comparisonMode}priceToY(t){if(0===this._height||this._max===this._min)return 0;const i=.2*this._height,h=.1*this._height,s=this._height-i-h;let a;if("logarithmic"===this._mode&&this._min>0&&t>0){const i=Math.log(this._min),h=Math.log(this._max);a=(Math.log(t)-i)/(h-i)}else a=(t-this._min)/(this._max-this._min);const e=h+(s-1)*a;return this._height-1-e}yToPrice(t){if(0===this._height||this._max===this._min)return this._min;const i=.2*this._height,h=.1*this._height,s=this._height-i-h,a=(this._height-1-t-h)/(s-1);if("logarithmic"===this._mode&&this._min>0){const t=Math.log(this._min),i=Math.log(this._max);return Math.exp(t+a*(i-t))}return this._min+a*(this._max-this._min)}get priceRange(){return{min:this._min,max:this._max}}};export{t as PriceScale};
+//# sourceMappingURL=index9.js.map

package/dist/index9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index9.js","names":[],"sources":["../src/core/price-scale.ts"],"sourcesContent":["export type PriceScaleMode = 'linear' | 'logarithmic';\n\nexport interface PriceRange {\n  min: number;\n  max: number;\n}\n\n/**\n * TV-style scale margins: 20% top padding, 10% bottom padding.\n * These are applied in the coordinate conversion (priceToY / yToPrice),\n * NOT in autoScale. autoScale stores raw min/max from the data.\n */\nconst TOP_MARGIN = 0.2;\nconst BOTTOM_MARGIN = 0.1;\n\n/**\n * Exponential lerp factor for price scale animation.\n * Each frame, current values move 25% of the remaining distance toward the target.\n * Converges in ~10-12 frames (~170ms at 60fps) — snappy but smooth.\n */\nconst SCALE_LERP = 0.25;\n\n/**\n * When the animated value is within this fraction of the target range,\n * snap to avoid endless micro-adjustments.\n */\nconst SCALE_SNAP_THRESHOLD = 0.0005;\n\nexport class PriceScale {\n  public readonly position: 'left' | 'right';\n\n  private _height: number = 0;\n  /** Current (animated) min/max used by priceToY. */\n  private _min: number = 0;\n  private _max: number = 1;\n  /** Target min/max that autoScale sets. Current values chase these. */\n  private _targetMin: number = 0;\n  private _targetMax: number = 1;\n  /** True after the first autoScale call — before that, we snap instead of animating. */\n  private _initialized: boolean = false;\n  /** True while current min/max are still converging toward target. */\n  private _animating: boolean = false;\n  /** When true, setRange() was called manually and autoScale() will not override it. */\n  private _manualRange: boolean = false;\n  private _comparisonMode: boolean = false;\n  private _mode: PriceScaleMode = 'linear';\n\n  constructor(position: 'left' | 'right') {\n    this.position = position;\n  }\n\n  /** Get the current scale mode. */\n  get mode(): PriceScaleMode {\n    return this._mode;\n  }\n\n  /** Set the scale mode (linear or logarithmic). */\n  setMode(mode: PriceScaleMode): void {\n    this._mode = mode;\n  }\n\n  setHeight(height: number): void {\n    this._height = height;\n  }\n\n  /**\n   * Auto-scale to fit [minPrice, maxPrice].\n   * Margins are handled in coordinate conversion, not here.\n   * Ignored when a manual range is active.\n   *\n   * On the first call, values snap immediately. On subsequent calls,\n   * target values are set and current values animate toward them via tick().\n   */\n  autoScale(minPrice: number, maxPrice: number): void {\n    if (this._manualRange) return;\n    if (minPrice === maxPrice) {\n      // Flat price — create a symmetric window around the single price\n      const margin = Math.abs(minPrice) * 0.05 || 0.05;\n      minPrice -= margin;\n      maxPrice += margin;\n    }\n\n    if (!this._initialized) {\n      // First call — snap immediately, no animation\n      this._min = minPrice;\n      this._max = maxPrice;\n      this._targetMin = minPrice;\n      this._targetMax = maxPrice;\n      this._initialized = true;\n      return;\n    }\n\n    // Skip if target hasn't meaningfully changed\n    const range = this._targetMax - this._targetMin;\n    const eps = range * 1e-6 || 1e-10;\n    if (Math.abs(this._targetMin - minPrice) < eps &&\n        Math.abs(this._targetMax - maxPrice) < eps) {\n      return;\n    }\n\n    this._targetMin = minPrice;\n    this._targetMax = maxPrice;\n    this._animating = true;\n  }\n\n  /**\n   * Advance the price scale animation by one frame.\n   * Returns true if still animating (caller should schedule another repaint).\n   */\n  tick(): boolean {\n    if (!this._animating) return false;\n\n    this._min += (this._targetMin - this._min) * SCALE_LERP;\n    this._max += (this._targetMax - this._max) * SCALE_LERP;\n\n    // Snap when close enough to avoid endless micro-adjustments\n    const range = Math.abs(this._targetMax - this._targetMin);\n    const threshold = range * SCALE_SNAP_THRESHOLD;\n    if (Math.abs(this._min - this._targetMin) < threshold &&\n        Math.abs(this._max - this._targetMax) < threshold) {\n      this._min = this._targetMin;\n      this._max = this._targetMax;\n      this._animating = false;\n    }\n\n    return this._animating;\n  }\n\n  /** True while the scale is animating toward a new target range. */\n  get isAnimating(): boolean {\n    return this._animating;\n  }\n\n  /** Reset animation state — snap current values to target immediately. */\n  snapToTarget(): void {\n    this._min = this._targetMin;\n    this._max = this._targetMax;\n    this._animating = false;\n  }\n\n  /**\n   * Manually override the price range.\n   * Subsequent autoScale() calls will be ignored until resetAutoScale() is called.\n   */\n  setRange(min: number, max: number): void {\n    this._manualRange = true;\n    this._min = min;\n    this._max = max;\n    this._targetMin = min;\n    this._targetMax = max;\n    this._animating = false;\n  }\n\n  /** Re-enable auto-scaling (next autoScale() call will take effect). */\n  resetAutoScale(): void {\n    this._manualRange = false;\n  }\n\n  /**\n   * Enable or disable comparison mode.\n   * In comparison mode the scale operates in \"percent space\" — callers pass\n   * percentage-change values (e.g. +12.5 for +12.5%) instead of raw prices.\n   * priceToY / yToPrice work identically; the caller is responsible for the\n   * raw-price → percentage conversion before calling priceToY.\n   */\n  setComparisonMode(enabled: boolean): void {\n    this._comparisonMode = enabled;\n  }\n\n  /** Returns true when comparison mode is active. */\n  isComparisonMode(): boolean {\n    return this._comparisonMode;\n  }\n\n  /**\n   * Map a price to a y-pixel coordinate.\n   *\n   * In linear mode: equal vertical distance for equal price change.\n   * In logarithmic mode: equal vertical distance for equal percentage change.\n   */\n  priceToY(price: number): number {\n    if (this._height === 0 || this._max === this._min) return 0;\n\n    const topPx = this._height * TOP_MARGIN;\n    const bottomPx = this._height * BOTTOM_MARGIN;\n    const innerHeight = this._height - topPx - bottomPx;\n\n    let ratio: number;\n    if (this._mode === 'logarithmic' && this._min > 0 && price > 0) {\n      const logMin = Math.log(this._min);\n      const logMax = Math.log(this._max);\n      ratio = (Math.log(price) - logMin) / (logMax - logMin);\n    } else {\n      ratio = (price - this._min) / (this._max - this._min);\n    }\n\n    const invCoord = bottomPx + (innerHeight - 1) * ratio;\n    return this._height - 1 - invCoord;\n  }\n\n  /** Inverse of priceToY. */\n  yToPrice(y: number): number {\n    if (this._height === 0 || this._max === this._min) return this._min;\n\n    const topPx = this._height * TOP_MARGIN;\n    const bottomPx = this._height * BOTTOM_MARGIN;\n    const innerHeight = this._height - topPx - bottomPx;\n\n    const invCoord = this._height - 1 - y;\n    const ratio = (invCoord - bottomPx) / (innerHeight - 1);\n\n    if (this._mode === 'logarithmic' && this._min > 0) {\n      const logMin = Math.log(this._min);\n      const logMax = Math.log(this._max);\n      return Math.exp(logMin + ratio * (logMax - logMin));\n    }\n\n    return this._min + ratio * (this._max - this._min);\n  }\n\n  get priceRange(): PriceRange {\n    return { min: this._min, max: this._max };\n  }\n}\n"],"mappings":"AAYA,IAgBa,EAAb,MAmBE,WAAA,CAAY,gBAhBc,YAEH,YACA,kBAEM,kBACA,qBAEG,mBAEF,qBAEE,wBACG,aACH,SAG9B,KAAK,SAAW,EAIlB,QAAI,GACF,OAAO,KAAK,MAId,OAAA,CAAQ,GACN,KAAK,MAAQ,EAGf,SAAA,CAAU,GACR,KAAK,QAAU,EAWjB,SAAA,CAAU,EAAkB,GAC1B,GAAI,KAAK,aAAc,OACvB,GAAI,IAAa,EAAU,CAEzB,MAAM,EAA8B,IAArB,KAAK,IAAI,IAAoB,IAC5C,GAAY,EACZ,GAAY,EAGd,IAAK,KAAK,aAOR,OALA,KAAK,KAAO,EACZ,KAAK,KAAO,EACZ,KAAK,WAAa,EAClB,KAAK,WAAa,OAClB,KAAK,cAAe,GAMtB,MAAM,EAAc,MADN,KAAK,WAAa,KAAK,aACT,MACxB,KAAK,IAAI,KAAK,WAAa,GAAY,GACvC,KAAK,IAAI,KAAK,WAAa,GAAY,IAI3C,KAAK,WAAa,EAClB,KAAK,WAAa,EAClB,KAAK,YAAa,GAOpB,IAAA,GACE,IAAK,KAAK,WAAY,OAAO,EAE7B,KAAK,MA5FU,KA4FD,KAAK,WAAa,KAAK,MACrC,KAAK,MA7FU,KA6FD,KAAK,WAAa,KAAK,MAIrC,MAAM,EA3FmB,KA0FX,KAAK,IAAI,KAAK,WAAa,KAAK,YAS9C,OAPI,KAAK,IAAI,KAAK,KAAO,KAAK,YAAc,GACxC,KAAK,IAAI,KAAK,KAAO,KAAK,YAAc,IAC1C,KAAK,KAAO,KAAK,WACjB,KAAK,KAAO,KAAK,WACjB,KAAK,YAAa,GAGb,KAAK,WAId,eAAI,GACF,OAAO,KAAK,WAId,YAAA,GACE,KAAK,KAAO,KAAK,WACjB,KAAK,KAAO,KAAK,WACjB,KAAK,YAAa,EAOpB,QAAA,CAAS,EAAa,GACpB,KAAK,cAAe,EACpB,KAAK,KAAO,EACZ,KAAK,KAAO,EACZ,KAAK,WAAa,EAClB,KAAK,WAAa,EAClB,KAAK,YAAa,EAIpB,cAAA,GACE,KAAK,cAAe,EAUtB,iBAAA,CAAkB,GAChB,KAAK,gBAAkB,EAIzB,gBAAA,GACE,OAAO,KAAK,gBASd,QAAA,CAAS,GACP,GAAqB,IAAjB,KAAK,SAAiB,KAAK,OAAS,KAAK,KAAM,OAAO,EAE1D,MAAM,EA3KS,GA2KD,KAAK,QACb,EA3KY,GA2KD,KAAK,QAChB,EAAc,KAAK,QAAU,EAAQ,EAE3C,IAAI,EACJ,GAAmB,gBAAf,KAAK,OAA2B,KAAK,KAAO,GAAK,EAAQ,EAAG,CAC9D,MAAM,EAAS,KAAK,IAAI,KAAK,MACvB,EAAS,KAAK,IAAI,KAAK,MAC7B,GAAS,KAAK,IAAI,GAAS,IAAW,EAAS,QAE/C,GAAS,EAAQ,KAAK,OAAS,KAAK,KAAO,KAAK,MAGlD,MAAM,EAAW,GAAY,EAAc,GAAK,EAChD,OAAO,KAAK,QAAU,EAAI,EAI5B,QAAA,CAAS,GACP,GAAqB,IAAjB,KAAK,SAAiB,KAAK,OAAS,KAAK,KAAM,OAAO,KAAK,KAE/D,MAAM,EAhMS,GAgMD,KAAK,QACb,EAhMY,GAgMD,KAAK,QAChB,EAAc,KAAK,QAAU,EAAQ,EAGrC,GADW,KAAK,QAAU,EAAI,EACV,IAAa,EAAc,GAErD,GAAmB,gBAAf,KAAK,OAA2B,KAAK,KAAO,EAAG,CACjD,MAAM,EAAS,KAAK,IAAI,KAAK,MACvB,EAAS,KAAK,IAAI,KAAK,MAC7B,OAAO,KAAK,IAAI,EAAS,GAAS,EAAS,IAG7C,OAAO,KAAK,KAAO,GAAS,KAAK,KAAO,KAAK,MAG/C,cAAI,GACF,MAAO,CAAE,IAAK,KAAK,KAAM,IAAK,KAAK"}

package/dist/index90.js

@@ -0,0 +1,2 @@
+function r(r,t,o,e){const n=new Float64Array(o),a=new Float64Array(o);for(let l=0;l<e;l++)n[l]=NaN,a[l]=NaN;for(let l=e;l<o;l++){let o=l-e,f=l-e;for(let n=l-e;n<=l;n++)r[n]>=r[o]&&(o=n),t[n]<=t[f]&&(f=n);n[l]=(e-(l-o))/e*100,a[l]=(e-(l-f))/e*100}return{up:n,down:a}}export{r as computeAroon};
+//# sourceMappingURL=index90.js.map

package/dist/index90.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index90.js","names":[],"sources":["../src/indicators/aroon.ts"],"sourcesContent":["export interface AroonResult { up: Float64Array; down: Float64Array; }\n\nexport function computeAroon(high: Float64Array, low: Float64Array, length: number, period: number): AroonResult {\n  const up = new Float64Array(length), down = new Float64Array(length);\n  for (let i = 0; i < period; i++) { up[i] = NaN; down[i] = NaN; }\n  for (let i = period; i < length; i++) {\n    let highIdx = i - period, lowIdx = i - period;\n    for (let j = i - period; j <= i; j++) {\n      if (high[j] >= high[highIdx]) highIdx = j;\n      if (low[j] <= low[lowIdx]) lowIdx = j;\n    }\n    up[i] = ((period - (i - highIdx)) / period) * 100;\n    down[i] = ((period - (i - lowIdx)) / period) * 100;\n  }\n  return { up, down };\n}\n"],"mappings":"AAEA,SAAgB,EAAa,EAAoB,EAAmB,EAAgB,GAClF,MAAM,EAAK,IAAI,aAAa,GAAS,EAAO,IAAI,aAAa,GAC7D,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAO,EAAG,GAAK,IAAK,EAAK,GAAK,IAC1D,IAAK,IAAI,EAAI,EAAQ,EAAI,EAAQ,IAAK,CACpC,IAAI,EAAU,EAAI,EAAQ,EAAS,EAAI,EACvC,IAAK,IAAI,EAAI,EAAI,EAAQ,GAAK,EAAG,IAC3B,EAAK,IAAM,EAAK,KAAU,EAAU,GACpC,EAAI,IAAM,EAAI,KAAS,EAAS,GAEtC,EAAG,IAAO,GAAU,EAAI,IAAY,EAAU,IAC9C,EAAK,IAAO,GAAU,EAAI,IAAW,EAAU,IAEjD,MAAO,CAAE,KAAI"}

package/dist/index91.js

@@ -0,0 +1,2 @@
+import{computeSMA as r}from"./index71.js";function o(o,t,n,a,e){const N=new Float64Array(n);for(let r=0;r<n;r++)N[r]=(o[r]+t[r])/2;const i=r(N,n,a),s=r(N,n,e),f=new Float64Array(n);for(let r=0;r<n;r++)f[r]=isNaN(i[r])||isNaN(s[r])?NaN:i[r]-s[r];return f}export{o as computeAwesomeOscillator};
+//# sourceMappingURL=index91.js.map

package/dist/index91.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index91.js","names":[],"sources":["../src/indicators/awesome-oscillator.ts"],"sourcesContent":["import { computeSMA } from './sma';\n\nexport function computeAwesomeOscillator(high: Float64Array, low: Float64Array, length: number, fastPeriod: number, slowPeriod: number): Float64Array {\n  const median = new Float64Array(length);\n  for (let i = 0; i < length; i++) median[i] = (high[i] + low[i]) / 2;\n  const fast = computeSMA(median, length, fastPeriod);\n  const slow = computeSMA(median, length, slowPeriod);\n  const result = new Float64Array(length);\n  for (let i = 0; i < length; i++) result[i] = isNaN(fast[i]) || isNaN(slow[i]) ? NaN : fast[i] - slow[i];\n  return result;\n}\n"],"mappings":"0CAEA,SAAgB,EAAyB,EAAoB,EAAmB,EAAgB,EAAoB,GAClH,MAAM,EAAS,IAAI,aAAa,GAChC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,EAAO,IAAM,EAAK,GAAK,EAAI,IAAM,EAClE,MAAM,EAAO,EAAW,EAAQ,EAAQ,GAClC,EAAO,EAAW,EAAQ,EAAQ,GAClC,EAAS,IAAI,aAAa,GAChC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,EAAO,GAAK,MAAM,EAAK,KAAO,MAAM,EAAK,IAAM,IAAM,EAAK,GAAK,EAAK,GACrG,OAAO"}

package/dist/index92.js

@@ -0,0 +1,2 @@
+function t(t,o,r,e,n,l){const f=new Float64Array(n);for(let a=0;a<l-1;a++)f[a]=NaN;for(let a=l-1;a<n;a++){let n=0,c=0;for(let f=a-l+1;f<=a;f++){const l=t[f]-o[f];n+=(0===l?0:(r[f]-o[f]-(t[f]-r[f]))/l)*e[f],c+=e[f]}f[a]=0===c?0:n/c}return f}export{t as computeChaikinMF};
+//# sourceMappingURL=index92.js.map

package/dist/index92.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index92.js","names":[],"sources":["../src/indicators/chaikin-mf.ts"],"sourcesContent":["export function computeChaikinMF(high: Float64Array, low: Float64Array, close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array {\n  const result = new Float64Array(length);\n  for (let i = 0; i < period - 1; i++) result[i] = NaN;\n  for (let i = period - 1; i < length; i++) {\n    let mfvSum = 0, volSum = 0;\n    for (let j = i - period + 1; j <= i; j++) {\n      const hl = high[j] - low[j];\n      const mfm = hl === 0 ? 0 : ((close[j] - low[j]) - (high[j] - close[j])) / hl;\n      mfvSum += mfm * volume[j];\n      volSum += volume[j];\n    }\n    result[i] = volSum === 0 ? 0 : mfvSum / volSum;\n  }\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EAAiB,EAAoB,EAAmB,EAAqB,EAAsB,EAAgB,GACjI,MAAM,EAAS,IAAI,aAAa,GAChC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAS,EAAG,IAAK,EAAO,GAAK,IACjD,IAAK,IAAI,EAAI,EAAS,EAAG,EAAI,EAAQ,IAAK,CACxC,IAAI,EAAS,EAAG,EAAS,EACzB,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IAAK,CACxC,MAAM,EAAK,EAAK,GAAK,EAAI,GAEzB,IADmB,IAAP,EAAW,GAAM,EAAM,GAAK,EAAI,IAAO,EAAK,GAAK,EAAM,KAAO,GAC1D,EAAO,GACvB,GAAU,EAAO,GAEnB,EAAO,GAAgB,IAAX,EAAe,EAAI,EAAS,EAE1C,OAAO"}

package/dist/index93.js

@@ -0,0 +1,2 @@
+function t(t,a,r,o,N){const e=new Float64Array(a),l=Math.max(o,N);for(let f=0;f<l+r-1;f++)e[f]=NaN;const n=new Float64Array(a);for(let f=0;f<l;f++)n[f]=NaN;for(let f=l;f<a;f++)n[f]=(0===t[f-o]?0:(t[f]-t[f-o])/t[f-o]*100)+(0===t[f-N]?0:(t[f]-t[f-N])/t[f-N]*100);for(let f=l+r-1;f<a;f++){let t=0,a=0;for(let o=0;o<r;o++){const N=r-o,e=n[f-o];if(isNaN(e)){t=NaN;break}t+=e*N,a+=N}e[f]=isNaN(t)?NaN:t/a}return e}export{t as computeCoppock};
+//# sourceMappingURL=index93.js.map

package/dist/index93.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index93.js","names":[],"sources":["../src/indicators/coppock.ts"],"sourcesContent":["export function computeCoppock(close: Float64Array, length: number, wmaPeriod: number, longROC: number, shortROC: number): Float64Array {\n  const result = new Float64Array(length);\n  const maxLag = Math.max(longROC, shortROC);\n  for (let i = 0; i < maxLag + wmaPeriod - 1; i++) result[i] = NaN;\n  const roc = new Float64Array(length);\n  for (let i = 0; i < maxLag; i++) roc[i] = NaN;\n  for (let i = maxLag; i < length; i++) {\n    const lr = close[i - longROC] === 0 ? 0 : ((close[i] - close[i - longROC]) / close[i - longROC]) * 100;\n    const sr = close[i - shortROC] === 0 ? 0 : ((close[i] - close[i - shortROC]) / close[i - shortROC]) * 100;\n    roc[i] = lr + sr;\n  }\n  for (let i = maxLag + wmaPeriod - 1; i < length; i++) {\n    let num = 0, den = 0;\n    for (let j = 0; j < wmaPeriod; j++) {\n      const w = wmaPeriod - j, val = roc[i - j];\n      if (isNaN(val)) { num = NaN; break; }\n      num += val * w; den += w;\n    }\n    result[i] = isNaN(num) ? NaN : num / den;\n  }\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EAAe,EAAqB,EAAgB,EAAmB,EAAiB,GACtG,MAAM,EAAS,IAAI,aAAa,GAC1B,EAAS,KAAK,IAAI,EAAS,GACjC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAS,EAAY,EAAG,IAAK,EAAO,GAAK,IAC7D,MAAM,EAAM,IAAI,aAAa,GAC7B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,EAAI,GAAK,IAC1C,IAAK,IAAI,EAAI,EAAQ,EAAI,EAAQ,IAG/B,EAAI,IAF8B,IAAvB,EAAM,EAAI,GAAiB,GAAM,EAAM,GAAK,EAAM,EAAI,IAAY,EAAM,EAAI,GAAY,MAChE,IAAxB,EAAM,EAAI,GAAkB,GAAM,EAAM,GAAK,EAAM,EAAI,IAAa,EAAM,EAAI,GAAa,KAGxG,IAAK,IAAI,EAAI,EAAS,EAAY,EAAG,EAAI,EAAQ,IAAK,CACpD,IAAI,EAAM,EAAG,EAAM,EACnB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAW,IAAK,CAClC,MAAM,EAAI,EAAY,EAAG,EAAM,EAAI,EAAI,GACvC,GAAI,MAAM,GAAM,CAAE,EAAM,IAAK,MAC7B,GAAO,EAAM,EAAG,GAAO,EAEzB,EAAO,GAAK,MAAM,GAAO,IAAM,EAAM,EAEvC,OAAO"}

package/dist/index94.js

@@ -0,0 +1,2 @@
+import{computeEMASkipNaN as r}from"./index83.js";function o(o,t,n,e){const a=new Float64Array(n);a[0]=NaN;for(let r=1;r<n;r++)a[r]=(o[r]-o[r-1])*t[r];return r(a,n,e)}export{o as computeElderForce};
+//# sourceMappingURL=index94.js.map

package/dist/index94.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index94.js","names":[],"sources":["../src/indicators/elder-force.ts"],"sourcesContent":["import { computeEMASkipNaN } from './utils';\n\nexport function computeElderForce(close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array {\n  const raw = new Float64Array(length);\n  raw[0] = NaN;\n  for (let i = 1; i < length; i++) raw[i] = (close[i] - close[i - 1]) * volume[i];\n  // raw[0] is NaN — use NaN-aware EMA to skip it during SMA seed\n  return computeEMASkipNaN(raw, length, period);\n}\n"],"mappings":"iDAEA,SAAgB,EAAkB,EAAqB,EAAsB,EAAgB,GAC3F,MAAM,EAAM,IAAI,aAAa,GAC7B,EAAI,GAAK,IACT,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,EAAI,IAAM,EAAM,GAAK,EAAM,EAAI,IAAM,EAAO,GAE7E,OAAO,EAAkB,EAAK,EAAQ"}

package/dist/index95.js

@@ -0,0 +1,2 @@
+import{computeEMA as r}from"./index72.js";import{computeEMASkipNaN as i}from"./index83.js";function o(o,t,n,N){const a=i(i(r(o,t,n),t,n),t,n),e=new Float64Array(t);e[0]=NaN;for(let r=1;r<t;r++)e[r]=isNaN(a[r])||isNaN(a[r-1])||0===a[r-1]?NaN:(a[r]-a[r-1])/a[r-1]*100;return{trix:e,signal:i(e,t,N)}}export{o as computeTRIX};
+//# sourceMappingURL=index95.js.map

package/dist/index95.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index95.js","names":[],"sources":["../src/indicators/trix.ts"],"sourcesContent":["import { computeEMA } from './ema';\nimport { computeEMASkipNaN } from './utils';\n\nexport interface TRIXResult { trix: Float64Array; signal: Float64Array; }\n\nexport function computeTRIX(close: Float64Array, length: number, period: number, signalPeriod: number): TRIXResult {\n  const ema1 = computeEMA(close, length, period);\n  // Second and third EMAs chain on NaN-leading output — use NaN-aware variant\n  const ema2 = computeEMASkipNaN(ema1, length, period);\n  const ema3 = computeEMASkipNaN(ema2, length, period);\n  const trix = new Float64Array(length);\n  trix[0] = NaN;\n  for (let i = 1; i < length; i++) {\n    trix[i] = isNaN(ema3[i]) || isNaN(ema3[i - 1]) || ema3[i - 1] === 0 ? NaN : ((ema3[i] - ema3[i - 1]) / ema3[i - 1]) * 100;\n  }\n  return { trix, signal: computeEMASkipNaN(trix, length, signalPeriod) };\n}\n"],"mappings":"2FAKA,SAAgB,EAAY,EAAqB,EAAgB,EAAgB,GAI/E,MAAM,EAAO,EADA,EAFA,EAAW,EAAO,EAAQ,GAEF,EAAQ,GACR,EAAQ,GACvC,EAAO,IAAI,aAAa,GAC9B,EAAK,GAAK,IACV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAK,GAAK,MAAM,EAAK,KAAO,MAAM,EAAK,EAAI,KAAuB,IAAhB,EAAK,EAAI,GAAW,KAAQ,EAAK,GAAK,EAAK,EAAI,IAAM,EAAK,EAAI,GAAM,IAExH,MAAO,CAAE,OAAM,OAAQ,EAAkB,EAAM,EAAQ"}

package/dist/index96.js

@@ -0,0 +1,2 @@
+import{computeATR as t}from"./index79.js";function r(r,e,o,n,a,l){const i=t(r,e,o,n,a),c=new Float64Array(n),f=new Float64Array(n);for(let t=0;t<a;t++)c[t]=NaN,f[t]=NaN;let N=0,s=0,u=1;for(let t=a;t<n;t++){const n=(r[t]+e[t])/2;let d,m=n+l*i[t],p=n-l*i[t];t>a&&(p>s||o[t-1]<s||(p=s),m<N||o[t-1]>N||(m=N)),d=t===a?o[t]>m?1:-1:1===u?o[t]<p?-1:1:o[t]>m?1:-1,c[t]=1===d?p:m,f[t]=d,N=m,s=p,u=d}return{value:c,direction:f}}export{r as computeSupertrend};
+//# sourceMappingURL=index96.js.map

package/dist/index96.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index96.js","names":[],"sources":["../src/indicators/supertrend.ts"],"sourcesContent":["import { computeATR } from './atr';\n\nexport interface SupertrendResult { value: Float64Array; direction: Float64Array; }\n\nexport function computeSupertrend(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number, multiplier: number): SupertrendResult {\n  const atr = computeATR(high, low, close, length, period);\n  const value = new Float64Array(length), direction = new Float64Array(length);\n  for (let i = 0; i < period; i++) { value[i] = NaN; direction[i] = NaN; }\n  let prevUpper = 0, prevLower = 0, prevDir = 1;\n  for (let i = period; i < length; i++) {\n    const mid = (high[i] + low[i]) / 2;\n    let upper = mid + multiplier * atr[i];\n    let lower = mid - multiplier * atr[i];\n    if (i > period) {\n      if (!(lower > prevLower || close[i - 1] < prevLower)) lower = prevLower;\n      if (!(upper < prevUpper || close[i - 1] > prevUpper)) upper = prevUpper;\n    }\n    let dir: number;\n    if (i === period) dir = close[i] > upper ? 1 : -1;\n    else if (prevDir === 1) dir = close[i] < lower ? -1 : 1;\n    else dir = close[i] > upper ? 1 : -1;\n    value[i] = dir === 1 ? lower : upper;\n    direction[i] = dir;\n    prevUpper = upper; prevLower = lower; prevDir = dir;\n  }\n  return { value, direction };\n}\n"],"mappings":"0CAIA,SAAgB,EAAkB,EAAoB,EAAmB,EAAqB,EAAgB,EAAgB,GAC5H,MAAM,EAAM,EAAW,EAAM,EAAK,EAAO,EAAQ,GAC3C,EAAQ,IAAI,aAAa,GAAS,EAAY,IAAI,aAAa,GACrE,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAO,EAAM,GAAK,IAAK,EAAU,GAAK,IAClE,IAAI,EAAY,EAAG,EAAY,EAAG,EAAU,EAC5C,IAAK,IAAI,EAAI,EAAQ,EAAI,EAAQ,IAAK,CACpC,MAAM,GAAO,EAAK,GAAK,EAAI,IAAM,EACjC,IAMI,EANA,EAAQ,EAAM,EAAa,EAAI,GAC/B,EAAQ,EAAM,EAAa,EAAI,GAC/B,EAAI,IACA,EAAQ,GAAa,EAAM,EAAI,GAAK,IAAY,EAAQ,GACxD,EAAQ,GAAa,EAAM,EAAI,GAAK,IAAY,EAAQ,IAG9C,EAAd,IAAM,EAAc,EAAM,GAAK,EAAQ,GAAI,EAC1B,IAAZ,EAAqB,EAAM,GAAK,GAAQ,EAAK,EAC3C,EAAM,GAAK,EAAQ,GAAI,EAClC,EAAM,GAAa,IAAR,EAAY,EAAQ,EAC/B,EAAU,GAAK,EACf,EAAY,EAAO,EAAY,EAAO,EAAU,EAElD,MAAO,CAAE,QAAO"}

package/dist/index97.js

@@ -0,0 +1,2 @@
+function t(t,r,e,o){const l=new Float64Array(e);for(let n=0;n<o-1;n++)l[n]=NaN;for(let n=o-1;n<e;n++){let e=0,a=0;for(let l=n-o+1;l<=n;l++)e+=t[l]*r[l],a+=r[l];l[n]=0===a?NaN:e/a}return l}export{t as computeVWMA};
+//# sourceMappingURL=index97.js.map

package/dist/index97.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index97.js","names":[],"sources":["../src/indicators/vwma.ts"],"sourcesContent":["export function computeVWMA(close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array {\n  const result = new Float64Array(length);\n  for (let i = 0; i < period - 1; i++) result[i] = NaN;\n  for (let i = period - 1; i < length; i++) {\n    let sumCV = 0, sumV = 0;\n    for (let j = i - period + 1; j <= i; j++) { sumCV += close[j] * volume[j]; sumV += volume[j]; }\n    result[i] = sumV === 0 ? NaN : sumCV / sumV;\n  }\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EAAY,EAAqB,EAAsB,EAAgB,GACrF,MAAM,EAAS,IAAI,aAAa,GAChC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAS,EAAG,IAAK,EAAO,GAAK,IACjD,IAAK,IAAI,EAAI,EAAS,EAAG,EAAI,EAAQ,IAAK,CACxC,IAAI,EAAQ,EAAG,EAAO,EACtB,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IAAO,GAAS,EAAM,GAAK,EAAO,GAAI,GAAQ,EAAO,GAC1F,EAAO,GAAc,IAAT,EAAa,IAAM,EAAQ,EAEzC,OAAO"}

package/dist/index98.js

@@ -0,0 +1,2 @@
+import{computeATR as t}from"./index79.js";function o(o,r,e,a,l){const n=t(o,r,e,a,1),N=new Float64Array(a);for(let t=0;t<l;t++)N[t]=NaN;for(let t=l;t<a;t++){let e=0,a=-1/0,f=1/0;for(let N=t-l+1;N<=t;N++)e+=isNaN(n[N])?0:n[N],o[N]>a&&(a=o[N]),r[N]<f&&(f=r[N]);const i=a-f;N[t]=0===i?NaN:100*Math.log10(e/i)/Math.log10(l)}return N}export{o as computeChoppiness};
+//# sourceMappingURL=index98.js.map

package/dist/index98.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index98.js","names":[],"sources":["../src/indicators/choppiness.ts"],"sourcesContent":["import { computeATR } from './atr';\n\nexport function computeChoppiness(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number): Float64Array {\n  const atr1 = computeATR(high, low, close, length, 1);\n  const result = new Float64Array(length);\n  for (let i = 0; i < period; i++) result[i] = NaN;\n  for (let i = period; i < length; i++) {\n    let atrSum = 0, hh = -Infinity, ll = Infinity;\n    for (let j = i - period + 1; j <= i; j++) {\n      atrSum += isNaN(atr1[j]) ? 0 : atr1[j];\n      if (high[j] > hh) hh = high[j];\n      if (low[j] < ll) ll = low[j];\n    }\n    const range = hh - ll;\n    result[i] = range === 0 ? NaN : 100 * Math.log10(atrSum / range) / Math.log10(period);\n  }\n  return result;\n}\n"],"mappings":"0CAEA,SAAgB,EAAkB,EAAoB,EAAmB,EAAqB,EAAgB,GAC5G,MAAM,EAAO,EAAW,EAAM,EAAK,EAAO,EAAQ,GAC5C,EAAS,IAAI,aAAa,GAChC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,EAAO,GAAK,IAC7C,IAAK,IAAI,EAAI,EAAQ,EAAI,EAAQ,IAAK,CACpC,IAAI,EAAS,EAAG,GAAK,IAAW,EAAK,IACrC,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IACnC,GAAU,MAAM,EAAK,IAAM,EAAI,EAAK,GAChC,EAAK,GAAK,IAAI,EAAK,EAAK,IACxB,EAAI,GAAK,IAAI,EAAK,EAAI,IAE5B,MAAM,EAAQ,EAAK,EACnB,EAAO,GAAe,IAAV,EAAc,IAAM,IAAM,KAAK,MAAM,EAAS,GAAS,KAAK,MAAM,GAEhF,OAAO"}

package/dist/index99.js

@@ -0,0 +1,2 @@
+function t(t,o,r,e,n,l){const f=new Float64Array(n);for(let a=0;a<l;a++)f[a]=NaN;for(let a=l;a<n;a++){let n=0,c=0;for(let f=a-l+1;f<=a;f++){const l=(t[f]+o[f]+r[f])/3,a=(t[f-1]+o[f-1]+r[f-1])/3,s=l*e[f];l>a?n+=s:l<a&&(c+=s)}f[a]=0===c?100:100-100/(1+n/c)}return f}export{t as computeMFI};
+//# sourceMappingURL=index99.js.map

package/dist/index99.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index99.js","names":[],"sources":["../src/indicators/mfi.ts"],"sourcesContent":["export function computeMFI(high: Float64Array, low: Float64Array, close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array {\n  const result = new Float64Array(length);\n  for (let i = 0; i < period; i++) result[i] = NaN;\n  for (let i = period; i < length; i++) {\n    let posFlow = 0, negFlow = 0;\n    for (let j = i - period + 1; j <= i; j++) {\n      const tp = (high[j] + low[j] + close[j]) / 3;\n      const prevTp = (high[j - 1] + low[j - 1] + close[j - 1]) / 3;\n      const rawMF = tp * volume[j];\n      if (tp > prevTp) posFlow += rawMF;\n      else if (tp < prevTp) negFlow += rawMF;\n    }\n    result[i] = negFlow === 0 ? 100 : 100 - 100 / (1 + posFlow / negFlow);\n  }\n  return result;\n}\n"],"mappings":"AAAA,SAAgB,EAAW,EAAoB,EAAmB,EAAqB,EAAsB,EAAgB,GAC3H,MAAM,EAAS,IAAI,aAAa,GAChC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAAK,EAAO,GAAK,IAC7C,IAAK,IAAI,EAAI,EAAQ,EAAI,EAAQ,IAAK,CACpC,IAAI,EAAU,EAAG,EAAU,EAC3B,IAAK,IAAI,EAAI,EAAI,EAAS,EAAG,GAAK,EAAG,IAAK,CACxC,MAAM,GAAM,EAAK,GAAK,EAAI,GAAK,EAAM,IAAM,EACrC,GAAU,EAAK,EAAI,GAAK,EAAI,EAAI,GAAK,EAAM,EAAI,IAAM,EACrD,EAAQ,EAAK,EAAO,GACtB,EAAK,EAAQ,GAAW,EACnB,EAAK,IAAQ,GAAW,GAEnC,EAAO,GAAiB,IAAZ,EAAgB,IAAM,IAAM,KAAO,EAAI,EAAU,GAE/D,OAAO"}

package/dist/indicators/adx.d.ts

@@ -0,0 +1,6 @@
+export interface ADXResult {
+    adx: Float64Array;
+    plusDI: Float64Array;
+    minusDI: Float64Array;
+}
+export declare function computeADX(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number): ADXResult;

package/dist/indicators/aroon.d.ts

@@ -0,0 +1,5 @@
+export interface AroonResult {
+    up: Float64Array;
+    down: Float64Array;
+}
+export declare function computeAroon(high: Float64Array, low: Float64Array, length: number, period: number): AroonResult;

package/dist/indicators/atr.d.ts

@@ -0,0 +1 @@
+export declare function computeATR(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/awesome-oscillator.d.ts

@@ -0,0 +1 @@
+export declare function computeAwesomeOscillator(high: Float64Array, low: Float64Array, length: number, fastPeriod: number, slowPeriod: number): Float64Array;

package/dist/indicators/bollinger.d.ts

@@ -0,0 +1,6 @@
+export interface BollingerResult {
+    upper: Float64Array;
+    middle: Float64Array;
+    lower: Float64Array;
+}
+export declare function computeBollinger(close: Float64Array, length: number, period: number, stdDev: number): BollingerResult;

package/dist/indicators/cci.d.ts

@@ -0,0 +1 @@
+export declare function computeCCI(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period?: number): Float64Array;

package/dist/indicators/chaikin-mf.d.ts

@@ -0,0 +1 @@
+export declare function computeChaikinMF(high: Float64Array, low: Float64Array, close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/choppiness.d.ts

@@ -0,0 +1 @@
+export declare function computeChoppiness(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/coppock.d.ts

@@ -0,0 +1 @@
+export declare function computeCoppock(close: Float64Array, length: number, wmaPeriod: number, longROC: number, shortROC: number): Float64Array;

package/dist/indicators/donchian.d.ts

@@ -0,0 +1,6 @@
+export interface DonchianResult {
+    upper: Float64Array;
+    middle: Float64Array;
+    lower: Float64Array;
+}
+export declare function computeDonchian(high: Float64Array, low: Float64Array, length: number, period?: number): DonchianResult;

package/dist/indicators/elder-force.d.ts

@@ -0,0 +1 @@
+export declare function computeElderForce(close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/ema.d.ts

@@ -0,0 +1 @@
+export declare function computeEMA(close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/ichimoku.d.ts

@@ -0,0 +1,8 @@
+export interface IchimokuResult {
+    tenkan: Float64Array;
+    kijun: Float64Array;
+    senkouA: Float64Array;
+    senkouB: Float64Array;
+    chikou: Float64Array;
+}
+export declare function computeIchimoku(high: Float64Array, low: Float64Array, close: Float64Array, length: number, tenkanPeriod?: number, kijunPeriod?: number, senkouPeriod?: number): IchimokuResult;

package/dist/indicators/index.d.ts

@@ -0,0 +1,31 @@
+export { computeSMA } from './sma';
+export { computeEMA } from './ema';
+export { computeRSI } from './rsi';
+export { computeMACD, type MACDResult } from './macd';
+export { computeBollinger, type BollingerResult } from './bollinger';
+export { computeVolume } from './volume';
+export { computeVWAP } from './vwap';
+export { computeStochastic, type StochasticResult } from './stochastic';
+export { computeATR } from './atr';
+export { computeADX, type ADXResult } from './adx';
+export { computeOBV } from './obv';
+export { computeWilliamsR } from './williams-r';
+export { slidingMax, slidingMin } from './utils';
+export { computeIchimoku, type IchimokuResult } from './ichimoku';
+export { computeParabolicSAR } from './parabolic-sar';
+export { computeKeltner, type KeltnerResult } from './keltner';
+export { computeDonchian, type DonchianResult } from './donchian';
+export { computeCCI } from './cci';
+export { computePivotPoints, type PivotPointsResult } from './pivot-points';
+export { computeAroon, type AroonResult } from './aroon';
+export { computeAwesomeOscillator } from './awesome-oscillator';
+export { computeChaikinMF } from './chaikin-mf';
+export { computeCoppock } from './coppock';
+export { computeElderForce } from './elder-force';
+export { computeTRIX, type TRIXResult } from './trix';
+export { computeSupertrend, type SupertrendResult } from './supertrend';
+export { computeVWMA } from './vwma';
+export { computeChoppiness } from './choppiness';
+export { computeMFI } from './mfi';
+export { computeROC } from './roc';
+export { computeLinearRegression } from './linear-regression';

package/dist/indicators/keltner.d.ts

@@ -0,0 +1,6 @@
+export interface KeltnerResult {
+    upper: Float64Array;
+    middle: Float64Array;
+    lower: Float64Array;
+}
+export declare function computeKeltner(close: Float64Array, high: Float64Array, low: Float64Array, length: number, emaPeriod?: number, atrPeriod?: number, multiplier?: number): KeltnerResult;

package/dist/indicators/linear-regression.d.ts

@@ -0,0 +1 @@
+export declare function computeLinearRegression(close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/macd.d.ts

@@ -0,0 +1,6 @@
+export interface MACDResult {
+    macd: Float64Array;
+    signal: Float64Array;
+    histogram: Float64Array;
+}
+export declare function computeMACD(close: Float64Array, length: number, fastPeriod: number, slowPeriod: number, signalPeriod: number): MACDResult;

package/dist/indicators/mfi.d.ts

@@ -0,0 +1 @@
+export declare function computeMFI(high: Float64Array, low: Float64Array, close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/obv.d.ts

@@ -0,0 +1 @@
+export declare function computeOBV(close: Float64Array, volume: Float64Array, length: number): Float64Array;

package/dist/indicators/parabolic-sar.d.ts

@@ -0,0 +1 @@
+export declare function computeParabolicSAR(high: Float64Array, low: Float64Array, length: number, afStep?: number, afMax?: number): Float64Array;

package/dist/indicators/pivot-points.d.ts

@@ -0,0 +1,10 @@
+export interface PivotPointsResult {
+    pp: Float64Array;
+    r1: Float64Array;
+    r2: Float64Array;
+    r3: Float64Array;
+    s1: Float64Array;
+    s2: Float64Array;
+    s3: Float64Array;
+}
+export declare function computePivotPoints(high: Float64Array, low: Float64Array, close: Float64Array, length: number, variant?: 'standard' | 'fibonacci' | 'woodie'): PivotPointsResult;

package/dist/indicators/roc.d.ts

@@ -0,0 +1 @@
+export declare function computeROC(close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/rsi.d.ts

@@ -0,0 +1 @@
+export declare function computeRSI(close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/sma.d.ts

@@ -0,0 +1 @@
+export declare function computeSMA(close: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/stochastic.d.ts

@@ -0,0 +1,5 @@
+export interface StochasticResult {
+    k: Float64Array;
+    d: Float64Array;
+}
+export declare function computeStochastic(high: Float64Array, low: Float64Array, close: Float64Array, length: number, kPeriod: number, dPeriod: number): StochasticResult;

package/dist/indicators/supertrend.d.ts

@@ -0,0 +1,5 @@
+export interface SupertrendResult {
+    value: Float64Array;
+    direction: Float64Array;
+}
+export declare function computeSupertrend(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number, multiplier: number): SupertrendResult;

package/dist/indicators/trix.d.ts

@@ -0,0 +1,5 @@
+export interface TRIXResult {
+    trix: Float64Array;
+    signal: Float64Array;
+}
+export declare function computeTRIX(close: Float64Array, length: number, period: number, signalPeriod: number): TRIXResult;

package/dist/indicators/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * EMA that skips leading NaN values in the input.
+ * Used when chaining EMAs (e.g., TRIX = triple EMA) where prior stages
+ * produce leading NaNs that would poison the SMA seed of a regular EMA.
+ */
+export declare function computeEMASkipNaN(data: Float64Array, length: number, period: number): Float64Array;
+/**
+ * O(n) sliding window maximum using monotone deque.
+ * Returns Float64Array where result[i] = max of data[i-period+1..i].
+ * Indices [0, period-2] are NaN.
+ *
+ * Uses a head-pointer instead of Array.shift() to avoid O(n) copies.
+ */
+export declare function slidingMax(data: Float64Array, length: number, period: number): Float64Array;
+/**
+ * O(n) sliding window minimum using monotone deque.
+ *
+ * Uses a head-pointer instead of Array.shift() to avoid O(n) copies.
+ */
+export declare function slidingMin(data: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/volume-profile.d.ts

@@ -0,0 +1,37 @@
+import { ColumnStore } from '../core/types';
+export interface VolumeProfileBin {
+    /** Price level at the center of this bin. */
+    price: number;
+    /** Price at bottom of bin. */
+    low: number;
+    /** Price at top of bin. */
+    high: number;
+    /** Total volume in this bin. */
+    volume: number;
+    /** Buy volume (close >= open). */
+    buyVolume: number;
+    /** Sell volume (close < open). */
+    sellVolume: number;
+}
+export interface VolumeProfileResult {
+    bins: VolumeProfileBin[];
+    /** Price level with highest volume (Point of Control). */
+    poc: number;
+    /** Value Area High — upper bound of the 70% volume area. */
+    vah: number;
+    /** Value Area Low — lower bound of the 70% volume area. */
+    val: number;
+    /** Total volume across all bins. */
+    totalVolume: number;
+}
+export interface VolumeProfileOptions {
+    /** Number of price bins (default: 24). */
+    binCount?: number;
+    /** Value area percentage (default: 0.7 = 70%). */
+    valueAreaPercent?: number;
+}
+/**
+ * Compute a volume profile (horizontal histogram of volume by price level)
+ * for the given range of bars.
+ */
+export declare function computeVolumeProfile(store: ColumnStore, fromIdx: number, toIdx: number, options?: VolumeProfileOptions): VolumeProfileResult;

package/dist/indicators/volume.d.ts

@@ -0,0 +1 @@
+export declare function computeVolume(volume: Float64Array, length: number): Float64Array;

package/dist/indicators/vwap.d.ts

@@ -0,0 +1 @@
+export declare function computeVWAP(high: Float64Array, low: Float64Array, close: Float64Array, volume: Float64Array, length: number): Float64Array;

package/dist/indicators/vwma.d.ts

@@ -0,0 +1 @@
+export declare function computeVWMA(close: Float64Array, volume: Float64Array, length: number, period: number): Float64Array;

package/dist/indicators/williams-r.d.ts

@@ -0,0 +1 @@
+export declare function computeWilliamsR(high: Float64Array, low: Float64Array, close: Float64Array, length: number, period: number): Float64Array;

package/dist/interactions/axis-drag.d.ts

@@ -0,0 +1,24 @@
+import { EventHandler } from './event-router';
+import { PriceScale } from '../core/price-scale';
+import { TimeScale } from '../core/time-scale';
+export interface AxisRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare class AxisDragHandler implements EventHandler {
+    private _priceScale;
+    private _timeScale;
+    private _requestInvalidation;
+    private _priceAxisRect;
+    private _timeAxisRect;
+    private _drag;
+    private _activePointerId;
+    constructor(priceScale: PriceScale, timeScale: TimeScale, requestInvalidation: () => void, priceAxisRect: () => AxisRect, timeAxisRect: () => AxisRect);
+    onPointerDown(x: number, y: number, pointerId: number): void;
+    onPointerMove(x: number, y: number, pointerId: number): void;
+    onPointerUp(pointerId: number): void;
+    private _handlePriceDrag;
+    private _handleTimeDrag;
+}

package/dist/interactions/context-menu-handler.d.ts

@@ -0,0 +1,42 @@
+import { EventHandler } from './event-router';
+import { BaseDrawing } from '../drawings/base';
+export interface ContextMenuCallbacks {
+    getDrawings(): {
+        drawing: BaseDrawing;
+        id: string;
+    }[];
+    getIndicatorAtPane(paneId: string): {
+        id: string;
+        label: string;
+    } | null;
+    getPaneAtY(y: number): string | null;
+    mainPaneId: string;
+    editDrawing(id: string): void;
+    removeDrawing(id: string): void;
+    duplicateDrawing(id: string): void;
+    bringDrawingToFront(id: string): void;
+    sendDrawingToBack(id: string): void;
+    openIndicatorSettings(id: string): void;
+    toggleIndicatorVisibility(id: string): void;
+    removeIndicator(id: string): void;
+    fitContent(): void;
+    scrollToRealTime(): void;
+    toggleCrosshair(): void;
+    theme: {
+        bg: string;
+        text: string;
+        border: string;
+    };
+    localToScreen(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+}
+export declare class ContextMenuHandler implements EventHandler {
+    private _callbacks;
+    constructor(callbacks: ContextMenuCallbacks);
+    onContextMenu(x: number, y: number): boolean;
+    private _showDrawingMenu;
+    private _showIndicatorMenu;
+    private _showChartMenu;
+}

package/dist/interactions/crosshair.d.ts

@@ -0,0 +1,20 @@
+import { EventHandler } from './event-router';
+import { Crosshair } from '../core/crosshair';
+import { DataLayer } from '../core/data-layer';
+import { TimeScale } from '../core/time-scale';
+import { PriceScale } from '../core/price-scale';
+export declare class CrosshairHandler implements EventHandler {
+    private _crosshair;
+    private _dataLayer;
+    private _timeScale;
+    private _priceScale;
+    private _requestInvalidation;
+    private _sourcePaneId;
+    constructor(crosshair: Crosshair, dataLayer: DataLayer, timeScale: TimeScale, priceScale: PriceScale, requestInvalidation: () => void, sourcePaneId?: string);
+    /** Update the source pane ID (used when pointer moves between panes). */
+    setSourcePaneId(paneId: string): void;
+    /** Update the price scale (used when crosshair moves to a different pane). */
+    setPriceScale(priceScale: PriceScale): void;
+    onPointerMove(x: number, y: number, _pointerId: number): void;
+    onPointerUp(_pointerId: number): void;
+}