@supersolutions/super-chart-core 0.0.0 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1192 @@
1
+ // packages/core/src/ta.ts
2
+ function nulls(n) {
3
+ return new Array(n).fill(null);
4
+ }
5
+ function isLength(len) {
6
+ return Number.isInteger(len) && len >= 1;
7
+ }
8
+ function plainSum(src, from, to) {
9
+ let a = 0;
10
+ for (let j = from; j <= to; j++)
11
+ a += src[j];
12
+ return a;
13
+ }
14
+ function sum(src, len) {
15
+ const n = src.length;
16
+ const out = nulls(n);
17
+ if (!isLength(len))
18
+ return out;
19
+ let run = 0;
20
+ let lastBad = -1;
21
+ let valid = false;
22
+ let s = 0;
23
+ let c = 0;
24
+ let sinceSeed = 0;
25
+ for (let i = 0; i < n; i++) {
26
+ const v = src[i];
27
+ if (v == null) {
28
+ run = 0;
29
+ valid = false;
30
+ continue;
31
+ }
32
+ run++;
33
+ if (!Number.isFinite(v))
34
+ lastBad = i;
35
+ if (run < len)
36
+ continue;
37
+ if (lastBad > i - len) {
38
+ out[i] = plainSum(src, i - len + 1, i);
39
+ valid = false;
40
+ continue;
41
+ }
42
+ if (!valid || ++sinceSeed >= len) {
43
+ s = 0;
44
+ c = 0;
45
+ for (let j = i - len + 1; j <= i; j++) {
46
+ const x = src[j];
47
+ const t = s + x;
48
+ c += Math.abs(s) >= Math.abs(x) ? s - t + x : x - t + s;
49
+ s = t;
50
+ }
51
+ sinceSeed = 0;
52
+ valid = true;
53
+ } else {
54
+ const o = -src[i - len];
55
+ let t = s + o;
56
+ c += Math.abs(s) >= Math.abs(o) ? s - t + o : o - t + s;
57
+ s = t;
58
+ t = s + v;
59
+ c += Math.abs(s) >= Math.abs(v) ? s - t + v : v - t + s;
60
+ s = t;
61
+ }
62
+ out[i] = s + c;
63
+ }
64
+ return out;
65
+ }
66
+ function sma(src, len) {
67
+ const s = sum(src, len);
68
+ for (let i = 0; i < s.length; i++) {
69
+ const v = s[i];
70
+ if (v != null)
71
+ s[i] = v / len;
72
+ }
73
+ return s;
74
+ }
75
+ function wma(src, len) {
76
+ const n = src.length;
77
+ const out = nulls(n);
78
+ if (!isLength(len))
79
+ return out;
80
+ const denom = len * (len + 1) / 2;
81
+ let run = 0;
82
+ let lastBad = -1;
83
+ let valid = false;
84
+ let s = 0;
85
+ let num = 0;
86
+ let sinceSeed = 0;
87
+ for (let i = 0; i < n; i++) {
88
+ const v = src[i];
89
+ if (v == null) {
90
+ run = 0;
91
+ valid = false;
92
+ continue;
93
+ }
94
+ run++;
95
+ if (!Number.isFinite(v))
96
+ lastBad = i;
97
+ if (run < len)
98
+ continue;
99
+ if (lastBad > i - len) {
100
+ let w = 0;
101
+ for (let j = 0; j < len; j++)
102
+ w += src[i - len + 1 + j] * (j + 1);
103
+ out[i] = w / denom;
104
+ valid = false;
105
+ continue;
106
+ }
107
+ if (!valid || ++sinceSeed >= len) {
108
+ s = 0;
109
+ num = 0;
110
+ for (let j = 0; j < len; j++) {
111
+ const x = src[i - len + 1 + j];
112
+ s += x;
113
+ num += x * (j + 1);
114
+ }
115
+ sinceSeed = 0;
116
+ valid = true;
117
+ } else {
118
+ num = num - s + len * v;
119
+ s = s - src[i - len] + v;
120
+ }
121
+ out[i] = num / denom;
122
+ }
123
+ return out;
124
+ }
125
+ function hma(src, len) {
126
+ if (!isLength(len) || len < 2)
127
+ return nulls(src.length);
128
+ const half = wma(src, Math.floor(len / 2));
129
+ const full = wma(src, len);
130
+ const diff = half.map((h, i) => {
131
+ const f = full[i];
132
+ return h == null || f == null ? null : 2 * h - f;
133
+ });
134
+ return wma(diff, Math.round(Math.sqrt(len)));
135
+ }
136
+ function vwma(src, volume, len) {
137
+ const pv = src.map((v, i) => {
138
+ const w = volume[i];
139
+ return v == null || w == null ? null : v * w;
140
+ });
141
+ const vol = volume.map((w, i) => src[i] == null ? null : w);
142
+ const num = sum(pv, len);
143
+ const den = sum(vol, len);
144
+ return num.map((a, i) => {
145
+ const b = den[i];
146
+ return a == null || b == null || b === 0 ? null : a / b;
147
+ });
148
+ }
149
+ function ema(src, len) {
150
+ const n = src.length;
151
+ const out = nulls(n);
152
+ if (!isLength(len))
153
+ return out;
154
+ let prev = null;
155
+ let seedSum = 0;
156
+ let seedCount = 0;
157
+ for (let i = 0; i < n; i++) {
158
+ const v = src[i];
159
+ if (v == null)
160
+ continue;
161
+ if (prev == null) {
162
+ seedSum += v;
163
+ seedCount++;
164
+ if (seedCount === len) {
165
+ prev = seedSum / len;
166
+ out[i] = prev;
167
+ }
168
+ } else {
169
+ prev = (2 * v + (len - 1) * prev) / (len + 1);
170
+ out[i] = prev;
171
+ }
172
+ }
173
+ return out;
174
+ }
175
+ function rma(src, len) {
176
+ const n = src.length;
177
+ const out = nulls(n);
178
+ if (!isLength(len))
179
+ return out;
180
+ let prev = null;
181
+ let seedSum = 0;
182
+ let seedCount = 0;
183
+ for (let i = 0; i < n; i++) {
184
+ const v = src[i];
185
+ if (v == null)
186
+ continue;
187
+ if (prev == null) {
188
+ seedSum += v;
189
+ seedCount++;
190
+ if (seedCount === len) {
191
+ prev = seedSum / len;
192
+ out[i] = prev;
193
+ }
194
+ } else {
195
+ prev = (prev * (len - 1) + v) / len;
196
+ out[i] = prev;
197
+ }
198
+ }
199
+ return out;
200
+ }
201
+ function rsiFrom(gain, loss) {
202
+ if (loss === 0)
203
+ return 100;
204
+ if (gain === 0)
205
+ return 0;
206
+ return 100 - 100 / (1 + gain / loss);
207
+ }
208
+ function rsi(src, len) {
209
+ const n = src.length;
210
+ const out = nulls(n);
211
+ if (!isLength(len))
212
+ return out;
213
+ let avgGain = 0;
214
+ let avgLoss = 0;
215
+ let prev = null;
216
+ let seeded = 0;
217
+ for (let i = 0; i < n; i++) {
218
+ const v = src[i];
219
+ if (v == null) {
220
+ prev = null;
221
+ continue;
222
+ }
223
+ if (prev != null) {
224
+ const ch = v - prev;
225
+ const gain = Math.max(ch, 0);
226
+ const loss = Math.max(-ch, 0);
227
+ if (seeded < len) {
228
+ avgGain += gain;
229
+ avgLoss += loss;
230
+ seeded++;
231
+ if (seeded === len) {
232
+ avgGain /= len;
233
+ avgLoss /= len;
234
+ out[i] = rsiFrom(avgGain, avgLoss);
235
+ }
236
+ } else {
237
+ avgGain = (avgGain * (len - 1) + gain) / len;
238
+ avgLoss = (avgLoss * (len - 1) + loss) / len;
239
+ out[i] = rsiFrom(avgGain, avgLoss);
240
+ }
241
+ }
242
+ prev = v;
243
+ }
244
+ return out;
245
+ }
246
+ function macd(src, fast = 12, slow = 26, signal = 9, options = {}) {
247
+ const m = options.histMultiplier ?? 1;
248
+ const f = ema(src, fast);
249
+ const s = ema(src, slow);
250
+ const dif = f.map((a, i) => {
251
+ const b = s[i];
252
+ return a == null || b == null ? null : a - b;
253
+ });
254
+ const dea = ema(dif, signal);
255
+ const hist = dif.map((a, i) => {
256
+ const b = dea[i];
257
+ return a == null || b == null ? null : (a - b) * m;
258
+ });
259
+ return { dif, dea, hist };
260
+ }
261
+ function stdev(src, len) {
262
+ const n = src.length;
263
+ const out = nulls(n);
264
+ if (!isLength(len))
265
+ return out;
266
+ let run = 0;
267
+ let lastBad = -1;
268
+ let valid = false;
269
+ let mean = 0;
270
+ let m2 = 0;
271
+ let sinceSeed = 0;
272
+ for (let i = 0; i < n; i++) {
273
+ const v = src[i];
274
+ if (v == null) {
275
+ run = 0;
276
+ valid = false;
277
+ continue;
278
+ }
279
+ run++;
280
+ if (!Number.isFinite(v))
281
+ lastBad = i;
282
+ if (run < len)
283
+ continue;
284
+ if (lastBad > i - len || !valid || ++sinceSeed >= len) {
285
+ let a = 0;
286
+ for (let j = i - len + 1; j <= i; j++)
287
+ a += src[j];
288
+ const m = a / len;
289
+ let q = 0;
290
+ for (let j = i - len + 1; j <= i; j++)
291
+ q += (src[j] - m) ** 2;
292
+ out[i] = Math.sqrt(q / len);
293
+ valid = !(lastBad > i - len);
294
+ if (valid) {
295
+ mean = m;
296
+ m2 = q;
297
+ sinceSeed = 0;
298
+ }
299
+ continue;
300
+ }
301
+ const o = src[i - len];
302
+ const next = mean + (v - o) / len;
303
+ m2 += (v - o) * (v - next + o - mean);
304
+ mean = next;
305
+ out[i] = Math.sqrt(Math.max(m2, 0) / len);
306
+ }
307
+ return out;
308
+ }
309
+ function dev(src, len) {
310
+ const n = src.length;
311
+ const out = nulls(n);
312
+ if (!isLength(len))
313
+ return out;
314
+ let run = 0;
315
+ for (let i = 0; i < n; i++) {
316
+ if (src[i] == null) {
317
+ run = 0;
318
+ continue;
319
+ }
320
+ run++;
321
+ if (run < len)
322
+ continue;
323
+ let a = 0;
324
+ for (let j = i - len + 1; j <= i; j++)
325
+ a += src[j];
326
+ const m = a / len;
327
+ let d = 0;
328
+ for (let j = i - len + 1; j <= i; j++)
329
+ d += Math.abs(src[j] - m);
330
+ out[i] = d / len;
331
+ }
332
+ return out;
333
+ }
334
+ function bollinger(src, len, mult = 2) {
335
+ const basis = sma(src, len);
336
+ const sd = stdev(src, len);
337
+ const upper = basis.map((b, i) => {
338
+ const d = sd[i];
339
+ return b == null || d == null ? null : b + mult * d;
340
+ });
341
+ const lower = basis.map((b, i) => {
342
+ const d = sd[i];
343
+ return b == null || d == null ? null : b - mult * d;
344
+ });
345
+ return { basis, upper, lower };
346
+ }
347
+ function extreme(src, len, max) {
348
+ const n = src.length;
349
+ const out = nulls(n);
350
+ if (!isLength(len))
351
+ return out;
352
+ if (len > n)
353
+ return out;
354
+ const dq = new Int32Array(len);
355
+ let head = 0;
356
+ let size = 0;
357
+ let run = 0;
358
+ let lastNaN = -1;
359
+ for (let i = 0; i < n; i++) {
360
+ const v = src[i];
361
+ if (v == null) {
362
+ run = 0;
363
+ head = 0;
364
+ size = 0;
365
+ continue;
366
+ }
367
+ run++;
368
+ if (size > 0 && dq[head] <= i - len) {
369
+ head = head + 1 === len ? 0 : head + 1;
370
+ size--;
371
+ }
372
+ if (Number.isNaN(v)) {
373
+ lastNaN = i;
374
+ } else {
375
+ while (size > 0) {
376
+ const tail2 = head + size - 1;
377
+ const b = src[dq[tail2 >= len ? tail2 - len : tail2]];
378
+ if (max ? b <= v : b >= v)
379
+ size--;
380
+ else
381
+ break;
382
+ }
383
+ const tail = head + size;
384
+ dq[tail >= len ? tail - len : tail] = i;
385
+ size++;
386
+ }
387
+ if (run < len)
388
+ continue;
389
+ out[i] = lastNaN > i - len ? NaN : size > 0 ? src[dq[head]] : max ? -Infinity : Infinity;
390
+ }
391
+ return out;
392
+ }
393
+ function highest(src, len) {
394
+ return extreme(src, len, true);
395
+ }
396
+ function lowest(src, len) {
397
+ return extreme(src, len, false);
398
+ }
399
+ function linregExact(src, end, len, offset) {
400
+ let sx = 0;
401
+ let sy = 0;
402
+ let sxx = 0;
403
+ let sxy = 0;
404
+ for (let x = 0; x < len; x++) {
405
+ const y = src[end - len + 1 + x];
406
+ sx += x;
407
+ sy += y;
408
+ sxx += x * x;
409
+ sxy += x * y;
410
+ }
411
+ const denom = len * sxx - sx * sx;
412
+ if (denom === 0)
413
+ return sy / len;
414
+ const slope = (len * sxy - sx * sy) / denom;
415
+ const intercept = (sy - slope * sx) / len;
416
+ return intercept + slope * (len - 1 - offset);
417
+ }
418
+ function linreg(src, len, offset = 0) {
419
+ const n = src.length;
420
+ const out = nulls(n);
421
+ if (!isLength(len))
422
+ return out;
423
+ const sx = len * (len - 1) / 2;
424
+ const sxx = (len - 1) * len * (2 * len - 1) / 6;
425
+ const denom = len * sxx - sx * sx;
426
+ let run = 0;
427
+ let lastBad = -1;
428
+ let ref = 0;
429
+ let sy = 0;
430
+ let sxy = 0;
431
+ let sinceSeed = len;
432
+ for (let i = 0; i < n; i++) {
433
+ const v = src[i];
434
+ if (v == null) {
435
+ run = 0;
436
+ sinceSeed = len;
437
+ continue;
438
+ }
439
+ run++;
440
+ if (!Number.isFinite(v))
441
+ lastBad = i;
442
+ if (run < len)
443
+ continue;
444
+ if (lastBad > i - len) {
445
+ out[i] = linregExact(src, i, len, offset);
446
+ sinceSeed = len;
447
+ continue;
448
+ }
449
+ if (sinceSeed >= len) {
450
+ ref = src[i - len + 1];
451
+ sy = 0;
452
+ sxy = 0;
453
+ for (let x = 0; x < len; x++) {
454
+ const y = src[i - len + 1 + x] - ref;
455
+ sy += y;
456
+ sxy += x * y;
457
+ }
458
+ sinceSeed = 0;
459
+ } else {
460
+ const first = src[i - len] - ref;
461
+ const y = v - ref;
462
+ sxy = sxy - (sy - first) + (len - 1) * y;
463
+ sy = sy - first + y;
464
+ sinceSeed++;
465
+ }
466
+ if (denom === 0) {
467
+ out[i] = sy / len + ref;
468
+ continue;
469
+ }
470
+ const slope = (len * sxy - sx * sy) / denom;
471
+ const intercept = (sy - slope * sx) / len;
472
+ out[i] = intercept + slope * (len - 1 - offset) + ref;
473
+ }
474
+ return out;
475
+ }
476
+ var DIRECT_CORRELATION = 32;
477
+ var CORRELATION_RESEED = 64;
478
+ function correlation(a, b, len) {
479
+ const n = a.length;
480
+ const out = nulls(n);
481
+ if (!isLength(len))
482
+ return out;
483
+ let run = 0;
484
+ let lastBad = -1;
485
+ let valid = false;
486
+ let sinceSeed = 0;
487
+ let rx = 0;
488
+ let ry = 0;
489
+ let mx = 0;
490
+ let my = 0;
491
+ let cxx = 0;
492
+ let cyy = 0;
493
+ let cxy = 0;
494
+ const reseed = Math.min(len, CORRELATION_RESEED);
495
+ const seed = (i) => {
496
+ rx = a[i - len + 1];
497
+ ry = b[i - len + 1];
498
+ mx = 0;
499
+ my = 0;
500
+ for (let j = i - len + 1; j <= i; j++) {
501
+ mx += a[j] - rx;
502
+ my += b[j] - ry;
503
+ }
504
+ mx /= len;
505
+ my /= len;
506
+ cxx = 0;
507
+ cyy = 0;
508
+ cxy = 0;
509
+ for (let j = i - len + 1; j <= i; j++) {
510
+ const p = a[j] - rx - mx;
511
+ const q = b[j] - ry - my;
512
+ cxx += p * p;
513
+ cyy += q * q;
514
+ cxy += p * q;
515
+ }
516
+ };
517
+ for (let i = 0; i < n; i++) {
518
+ const x = a[i];
519
+ const y = b[i];
520
+ if (x == null || y == null) {
521
+ run = 0;
522
+ valid = false;
523
+ continue;
524
+ }
525
+ run++;
526
+ if (!Number.isFinite(x) || !Number.isFinite(y))
527
+ lastBad = i;
528
+ if (run < len)
529
+ continue;
530
+ if (lastBad > i - len) {
531
+ let sa = 0;
532
+ let sb = 0;
533
+ let saa = 0;
534
+ let sbb = 0;
535
+ let sab = 0;
536
+ for (let j = i - len + 1; j <= i; j++) {
537
+ const p = a[j];
538
+ const q = b[j];
539
+ sa += p;
540
+ sb += q;
541
+ saa += p * p;
542
+ sbb += q * q;
543
+ sab += p * q;
544
+ }
545
+ const ma = sa / len;
546
+ const mb = sb / len;
547
+ const d = Math.sqrt((saa / len - ma * ma) * (sbb / len - mb * mb));
548
+ out[i] = d === 0 ? null : (sab / len - ma * mb) / d;
549
+ valid = false;
550
+ continue;
551
+ }
552
+ if (len <= DIRECT_CORRELATION || !valid || ++sinceSeed >= reseed) {
553
+ seed(i);
554
+ sinceSeed = 0;
555
+ valid = true;
556
+ } else {
557
+ const xo = a[i - len] - rx;
558
+ const yo = b[i - len] - ry;
559
+ const xn = x - rx;
560
+ const yn = y - ry;
561
+ const dx = xn - xo;
562
+ const dy = yn - yo;
563
+ const nx = mx + dx / len;
564
+ const ny = my + dy / len;
565
+ cxx += dx * (xn - nx + xo - mx);
566
+ cyy += dy * (yn - ny + yo - my);
567
+ cxy += dx * (yn - ny) + dy * (xo - mx);
568
+ mx = nx;
569
+ my = ny;
570
+ }
571
+ const flatX = cxx <= len * (16 * Number.EPSILON * Math.max(Math.abs(rx + mx), 1e-300)) ** 2;
572
+ const flatY = cyy <= len * (16 * Number.EPSILON * Math.max(Math.abs(ry + my), 1e-300)) ** 2;
573
+ out[i] = flatX || flatY ? null : Math.max(-1, Math.min(1, cxy / Math.sqrt(cxx * cyy)));
574
+ }
575
+ return out;
576
+ }
577
+ function change(src, len = 1) {
578
+ return src.map((v, i) => {
579
+ const p = i - len >= 0 ? src[i - len] : null;
580
+ return v == null || p == null ? null : v - p;
581
+ });
582
+ }
583
+ function mom(src, len) {
584
+ return change(src, len);
585
+ }
586
+ function roc(src, len) {
587
+ return src.map((v, i) => {
588
+ const p = i - len >= 0 ? src[i - len] : null;
589
+ return v == null || p == null || p === 0 ? null : 100 * (v - p) / p;
590
+ });
591
+ }
592
+ function crossover(a, b) {
593
+ return a.map((v, i) => {
594
+ const pa = a[i - 1];
595
+ const pb = b[i - 1];
596
+ const cb = b[i];
597
+ if (v == null || cb == null || pa == null || pb == null)
598
+ return null;
599
+ return pa <= pb && v > cb ? 1 : 0;
600
+ });
601
+ }
602
+ function crossunder(a, b) {
603
+ return a.map((v, i) => {
604
+ const pa = a[i - 1];
605
+ const pb = b[i - 1];
606
+ const cb = b[i];
607
+ if (v == null || cb == null || pa == null || pb == null)
608
+ return null;
609
+ return pa >= pb && v < cb ? 1 : 0;
610
+ });
611
+ }
612
+ function cross(a, b) {
613
+ return a.map((v, i) => {
614
+ const pa = a[i - 1];
615
+ const pb = b[i - 1];
616
+ const cb = b[i];
617
+ if (v == null || cb == null || pa == null || pb == null)
618
+ return null;
619
+ return pa <= pb && v > cb || pa >= pb && v < cb ? 1 : 0;
620
+ });
621
+ }
622
+ function cum(src) {
623
+ const out = nulls(src.length);
624
+ let acc = 0;
625
+ for (let i = 0; i < src.length; i++) {
626
+ const v = src[i];
627
+ if (v == null)
628
+ continue;
629
+ acc += v;
630
+ out[i] = acc;
631
+ }
632
+ return out;
633
+ }
634
+ function barssince(cond) {
635
+ const out = nulls(cond.length);
636
+ let count = null;
637
+ for (let i = 0; i < cond.length; i++) {
638
+ const c = cond[i];
639
+ if (c != null && c !== 0)
640
+ count = 0;
641
+ else if (count != null)
642
+ count++;
643
+ out[i] = count;
644
+ }
645
+ return out;
646
+ }
647
+ function valuewhen(cond, src, occurrence = 0) {
648
+ const out = nulls(cond.length);
649
+ if (occurrence === 0) {
650
+ let latest;
651
+ for (let i = 0; i < cond.length; i++) {
652
+ const c = cond[i];
653
+ if (c != null && c !== 0)
654
+ latest = i;
655
+ out[i] = latest === void 0 ? null : src[latest];
656
+ }
657
+ return out;
658
+ }
659
+ if (!Number.isInteger(occurrence) || occurrence < 0 || occurrence >= cond.length)
660
+ return out;
661
+ const hits = [];
662
+ const capacity = occurrence + 1;
663
+ let next = 0;
664
+ for (let i = 0; i < cond.length; i++) {
665
+ const c = cond[i];
666
+ if (c != null && c !== 0) {
667
+ hits[next] = i;
668
+ next = (next + 1) % capacity;
669
+ }
670
+ const idx = hits.length === capacity ? hits[next] : void 0;
671
+ out[i] = idx == null ? null : src[idx];
672
+ }
673
+ return out;
674
+ }
675
+ function pivot(src, left, right, kind) {
676
+ const width = left + right + 1;
677
+ if (width >= 64 && width <= src.length && Number.isSafeInteger(left) && Number.isSafeInteger(right) && left >= 0 && right >= 0 && src.every((v) => v == null || Number.isFinite(v)))
678
+ return pivotWindow(src, width, right, kind);
679
+ return pivotScan(src, left, right, kind);
680
+ }
681
+ function pivotWindow(src, width, right, kind) {
682
+ const out = nulls(src.length);
683
+ const deque = new Int32Array(width);
684
+ let head = 0, size = 0, run = 0;
685
+ for (let end = 0; end < src.length; end++) {
686
+ const v = src[end];
687
+ if (v == null) {
688
+ head = 0;
689
+ size = 0;
690
+ run = 0;
691
+ continue;
692
+ }
693
+ run++;
694
+ if (size > 0 && deque[head] <= end - width) {
695
+ head = head + 1 === width ? 0 : head + 1;
696
+ size--;
697
+ }
698
+ while (size > 0) {
699
+ const tail2 = head + size - 1;
700
+ const previous = src[deque[tail2 >= width ? tail2 - width : tail2]];
701
+ if (kind === "high" ? previous < v : previous > v)
702
+ size--;
703
+ else
704
+ break;
705
+ }
706
+ const tail = head + size;
707
+ deque[tail >= width ? tail - width : tail] = end;
708
+ size++;
709
+ const candidate = end - right;
710
+ if (run >= width && deque[head] === candidate)
711
+ out[end] = src[candidate];
712
+ }
713
+ return out;
714
+ }
715
+ function pivotScan(src, left, right, kind) {
716
+ const out = nulls(src.length);
717
+ for (let i = left; i < src.length - right; i++) {
718
+ const v = src[i];
719
+ if (v == null)
720
+ continue;
721
+ let ok = true;
722
+ for (let j = i - left; j <= i + right; j++) {
723
+ if (j === i)
724
+ continue;
725
+ const w = src[j];
726
+ if (w == null) {
727
+ ok = false;
728
+ break;
729
+ }
730
+ if (kind === "high" ? w > v : w < v) {
731
+ ok = false;
732
+ break;
733
+ }
734
+ if (w === v && j < i) {
735
+ ok = false;
736
+ break;
737
+ }
738
+ }
739
+ if (ok)
740
+ out[i + right] = v;
741
+ }
742
+ return out;
743
+ }
744
+ function trueRange(high, low, close) {
745
+ return high.map((h, i) => {
746
+ const l = low[i];
747
+ const pc = i > 0 ? close[i - 1] : null;
748
+ if (h == null || l == null)
749
+ return null;
750
+ if (pc == null)
751
+ return h - l;
752
+ return Math.max(h - l, Math.abs(h - pc), Math.abs(l - pc));
753
+ });
754
+ }
755
+ function atr(high, low, close, len) {
756
+ return rma(trueRange(high, low, close), len);
757
+ }
758
+ function obv(close, volume) {
759
+ const out = nulls(close.length);
760
+ let acc = 0;
761
+ let prev = null;
762
+ for (let i = 0; i < close.length; i++) {
763
+ const c = close[i];
764
+ const v = volume[i] ?? 0;
765
+ if (c == null)
766
+ continue;
767
+ if (prev != null)
768
+ acc += c > prev ? v : c < prev ? -v : 0;
769
+ out[i] = acc;
770
+ prev = c;
771
+ }
772
+ return out;
773
+ }
774
+ function vwap(high, low, close, volume) {
775
+ const out = nulls(close.length);
776
+ let pv = 0;
777
+ let vol = 0;
778
+ for (let i = 0; i < close.length; i++) {
779
+ const h = high[i];
780
+ const l = low[i];
781
+ const c = close[i];
782
+ const v = volume[i] ?? 0;
783
+ if (h == null || l == null || c == null)
784
+ continue;
785
+ pv += (h + l + c) / 3 * v;
786
+ vol += v;
787
+ out[i] = vol === 0 ? null : pv / vol;
788
+ }
789
+ return out;
790
+ }
791
+ function hlc3(high, low, close) {
792
+ return high.map((h, i) => {
793
+ const l = low[i];
794
+ const c = close[i];
795
+ return h == null || l == null || c == null ? null : (h + l + c) / 3;
796
+ });
797
+ }
798
+ function cci(high, low, close, len) {
799
+ const tp = hlc3(high, low, close);
800
+ const basis = sma(tp, len);
801
+ const md = dev(tp, len);
802
+ return tp.map((t, i) => {
803
+ const b = basis[i];
804
+ const m = md[i];
805
+ return t == null || b == null || m == null || m === 0 ? null : (t - b) / (0.015 * m);
806
+ });
807
+ }
808
+ function mfi(high, low, close, volume, len) {
809
+ const n = close.length;
810
+ const tp = hlc3(high, low, close);
811
+ const pos = new Array(n).fill(0);
812
+ const neg = new Array(n).fill(0);
813
+ for (let i = 1; i < n; i++) {
814
+ const t = tp[i];
815
+ const p = tp[i - 1];
816
+ const v = volume[i] ?? 0;
817
+ if (t == null || p == null)
818
+ continue;
819
+ if (t > p)
820
+ pos[i] = t * v;
821
+ else if (t < p)
822
+ neg[i] = t * v;
823
+ }
824
+ const sp = sum(pos, len);
825
+ const sn = sum(neg, len);
826
+ return sp.map((p, i) => {
827
+ const q = sn[i];
828
+ if (p == null || q == null)
829
+ return null;
830
+ if (q === 0)
831
+ return 100;
832
+ return 100 - 100 / (1 + p / q);
833
+ });
834
+ }
835
+ function stochK(high, low, close, len) {
836
+ const hh = highest(high, len);
837
+ const ll = lowest(low, len);
838
+ return close.map((c, i) => {
839
+ const h = hh[i];
840
+ const l = ll[i];
841
+ if (c == null || h == null || l == null)
842
+ return null;
843
+ const d = h - l;
844
+ return d === 0 ? 0 : 100 * (c - l) / d;
845
+ });
846
+ }
847
+ function sar(high, low, start = 0.02, inc = 0.02, max = 0.2) {
848
+ const n = high.length;
849
+ const out = nulls(n);
850
+ if (n < 2)
851
+ return out;
852
+ const h0 = high[0];
853
+ const l0 = low[0];
854
+ const h1 = high[1];
855
+ const l1 = low[1];
856
+ if (h0 == null || l0 == null || h1 == null || l1 == null)
857
+ return out;
858
+ let isLong = h1 >= h0;
859
+ let af = start;
860
+ let ep = isLong ? h1 : l1;
861
+ let s = isLong ? l0 : h0;
862
+ for (let i = 1; i < n; i++) {
863
+ const h = high[i];
864
+ const l = low[i];
865
+ if (h == null || l == null)
866
+ continue;
867
+ s = s + af * (ep - s);
868
+ if (isLong) {
869
+ if (l < s) {
870
+ isLong = false;
871
+ s = ep;
872
+ ep = l;
873
+ af = start;
874
+ } else if (h > ep) {
875
+ ep = h;
876
+ af = Math.min(af + inc, max);
877
+ }
878
+ } else {
879
+ if (h > s) {
880
+ isLong = true;
881
+ s = ep;
882
+ ep = h;
883
+ af = start;
884
+ } else if (l < ep) {
885
+ ep = l;
886
+ af = Math.min(af + inc, max);
887
+ }
888
+ }
889
+ out[i] = s;
890
+ }
891
+ return out;
892
+ }
893
+ function avg2(a, b) {
894
+ return a.map((x, i) => {
895
+ const y = b[i];
896
+ return x == null || y == null ? null : (x + y) / 2;
897
+ });
898
+ }
899
+ function stoch(src, len) {
900
+ return stochK(src, src, src, len);
901
+ }
902
+ function stochRsi(src, rsiLen, stochLen, kLen, dLen) {
903
+ const k = sma(stoch(rsi(src, rsiLen), stochLen), kLen);
904
+ return { k, d: sma(k, dLen) };
905
+ }
906
+ function bbPercent(src, len, mult = 2) {
907
+ const { upper, lower } = bollinger(src, len, mult);
908
+ return src.map((v, i) => {
909
+ const u = upper[i];
910
+ const l = lower[i];
911
+ return v == null || u == null || l == null || u === l ? null : (v - l) / (u - l);
912
+ });
913
+ }
914
+ function keltner(high, low, close, len = 20, mult = 2, atrLen = 10) {
915
+ const basis = ema(close, len);
916
+ const range = atr(high, low, close, atrLen);
917
+ const band = (sign) => basis.map((b, i) => {
918
+ const r = range[i];
919
+ return b == null || r == null ? null : b + sign * mult * r;
920
+ });
921
+ return { basis, upper: band(1), lower: band(-1) };
922
+ }
923
+ function donchian(high, low, len = 20) {
924
+ const upper = highest(high, len);
925
+ const lower = lowest(low, len);
926
+ return { basis: avg2(upper, lower), upper, lower };
927
+ }
928
+ function atrBands(high, low, close, len = 14, mult = 2) {
929
+ const range = atr(high, low, close, len);
930
+ const band = (sign) => close.map((c, i) => {
931
+ const r = range[i];
932
+ return c == null || r == null ? null : c + sign * mult * r;
933
+ });
934
+ return { basis: close.slice(), upper: band(1), lower: band(-1) };
935
+ }
936
+ function supertrend(high, low, close, len = 10, factor = 3) {
937
+ const n = close.length;
938
+ const line = nulls(n);
939
+ const trend = nulls(n);
940
+ const range = atr(high, low, close, len);
941
+ let prevUpper = 0;
942
+ let prevLower = 0;
943
+ let prevLine = null;
944
+ let prevAtr = null;
945
+ for (let i = 0; i < n; i++) {
946
+ const h = high[i];
947
+ const l = low[i];
948
+ const c = close[i];
949
+ const r = range[i];
950
+ if (h == null || l == null || c == null || r == null) {
951
+ prevAtr = r ?? null;
952
+ continue;
953
+ }
954
+ const mid = (h + l) / 2;
955
+ const pc = i > 0 ? close[i - 1] : null;
956
+ let upper = mid + factor * r;
957
+ let lower = mid - factor * r;
958
+ lower = lower > prevLower || pc != null && pc < prevLower ? lower : prevLower;
959
+ upper = upper < prevUpper || pc != null && pc > prevUpper ? upper : prevUpper;
960
+ let up;
961
+ if (prevAtr == null)
962
+ up = false;
963
+ else if (prevLine === prevUpper)
964
+ up = c > upper;
965
+ else
966
+ up = !(c < lower);
967
+ const v = up ? lower : upper;
968
+ line[i] = v;
969
+ trend[i] = up ? 1 : -1;
970
+ prevUpper = upper;
971
+ prevLower = lower;
972
+ prevLine = v;
973
+ prevAtr = r;
974
+ }
975
+ return { line, trend };
976
+ }
977
+ function ichimoku(high, low, close, conversion = 9, base = 26, spanBLen = 52, displacement = 26) {
978
+ const n = close.length;
979
+ const conv = donchian(high, low, conversion).basis;
980
+ const kijun = donchian(high, low, base).basis;
981
+ const lead1 = avg2(conv, kijun);
982
+ const lead2 = donchian(high, low, spanBLen).basis;
983
+ const shift = Math.max(0, Math.floor(displacement) - 1);
984
+ const spanA = nulls(n);
985
+ const spanB = nulls(n);
986
+ const lagging = nulls(n);
987
+ for (let i = 0; i < n; i++) {
988
+ if (i - shift >= 0) {
989
+ spanA[i] = lead1[i - shift];
990
+ spanB[i] = lead2[i - shift];
991
+ }
992
+ if (i + shift < n)
993
+ lagging[i] = close[i + shift];
994
+ }
995
+ const futureA = nulls(shift);
996
+ const futureB = nulls(shift);
997
+ for (let k = 0; k < shift; k++) {
998
+ const j = n - shift + k;
999
+ if (j >= 0) {
1000
+ futureA[k] = lead1[j];
1001
+ futureB[k] = lead2[j];
1002
+ }
1003
+ }
1004
+ return { conversion: conv, base: kijun, spanA, spanB, lagging, futureA, futureB };
1005
+ }
1006
+ function anchoredVwap(high, low, close, volume, periods, skipFirst = false) {
1007
+ const n = close.length;
1008
+ const vwap2 = nulls(n);
1009
+ const sd = nulls(n);
1010
+ let key = null;
1011
+ let index = -1;
1012
+ let ref = 0;
1013
+ let sv = 0;
1014
+ let s1 = 0;
1015
+ let s2 = 0;
1016
+ for (let i = 0; i < n; i++) {
1017
+ const p = periods[i];
1018
+ const h = high[i];
1019
+ const l = low[i];
1020
+ const c = close[i];
1021
+ if (p == null || h == null || l == null || c == null)
1022
+ continue;
1023
+ const tp = (h + l + c) / 3;
1024
+ if (p !== key) {
1025
+ key = p;
1026
+ index++;
1027
+ ref = tp;
1028
+ sv = 0;
1029
+ s1 = 0;
1030
+ s2 = 0;
1031
+ }
1032
+ const v = volume[i] ?? 0;
1033
+ const d = tp - ref;
1034
+ sv += v;
1035
+ s1 += v * d;
1036
+ s2 += v * d * d;
1037
+ if (skipFirst && index === 0)
1038
+ continue;
1039
+ if (sv > 0) {
1040
+ const m = s1 / sv;
1041
+ vwap2[i] = ref + m;
1042
+ sd[i] = Math.sqrt(Math.max(0, s2 / sv - m * m));
1043
+ }
1044
+ }
1045
+ return { vwap: vwap2, stdev: sd };
1046
+ }
1047
+
1048
+ // packages/core/src/analysis/previousRangeHighLow.ts
1049
+ var dayFormatterCache = /* @__PURE__ */ new Map();
1050
+ function dayFormatter(tz) {
1051
+ const hit = dayFormatterCache.get(tz);
1052
+ if (hit !== void 0)
1053
+ return hit;
1054
+ const fmt = new Intl.DateTimeFormat("en-CA", { timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit" });
1055
+ dayFormatterCache.set(tz, fmt);
1056
+ return fmt;
1057
+ }
1058
+ function dateKeyInTz(timestamp, tz) {
1059
+ try {
1060
+ return dayFormatter(tz).format(new Date(timestamp));
1061
+ } catch {
1062
+ return dayFormatter("UTC").format(new Date(timestamp));
1063
+ }
1064
+ }
1065
+ function weekKeyInTz(timestamp, tz) {
1066
+ const dateKey = dateKeyInTz(timestamp, tz);
1067
+ const [y, m, d] = dateKey.split("-").map(Number);
1068
+ const noonUtc = Date.UTC(y, m - 1, d, 12);
1069
+ const weekday = new Date(noonUtc).getUTCDay();
1070
+ const daysSinceMonday = (weekday + 6) % 7;
1071
+ const mondayUtc = noonUtc - daysSinceMonday * 864e5;
1072
+ return dayFormatter("UTC").format(new Date(mondayUtc));
1073
+ }
1074
+ function previousRangeHighLow(bars, period, tz) {
1075
+ if (bars.length === 0)
1076
+ return null;
1077
+ const keyOf = period === "day" ? dateKeyInTz : weekKeyInTz;
1078
+ const lastKey = keyOf(bars[bars.length - 1].timestamp, tz);
1079
+ let i = bars.length - 1;
1080
+ while (i >= 0 && keyOf(bars[i].timestamp, tz) === lastKey)
1081
+ i--;
1082
+ if (i < 0)
1083
+ return null;
1084
+ const previousKey = keyOf(bars[i].timestamp, tz);
1085
+ const toIndex = i;
1086
+ while (i >= 0 && keyOf(bars[i].timestamp, tz) === previousKey)
1087
+ i--;
1088
+ const fromIndex = i + 1;
1089
+ let high = -Infinity, low = Infinity;
1090
+ for (let j = fromIndex; j <= toIndex; j++) {
1091
+ if (bars[j].high > high)
1092
+ high = bars[j].high;
1093
+ if (bars[j].low < low)
1094
+ low = bars[j].low;
1095
+ }
1096
+ return { high, low, key: previousKey, fromIndex, toIndex };
1097
+ }
1098
+
1099
+ // packages/core/src/model/indicatorInputs.ts
1100
+ var kernels = /* @__PURE__ */ new WeakMap();
1101
+ function ownedKernel(calculate, plan) {
1102
+ kernels.set(calculate, plan);
1103
+ return calculate;
1104
+ }
1105
+ function kernelFor(calculate) {
1106
+ return kernels.get(calculate);
1107
+ }
1108
+ var windows = /* @__PURE__ */ new WeakMap();
1109
+ function ownedWindow(calculate, plan) {
1110
+ windows.set(calculate, plan);
1111
+ return calculate;
1112
+ }
1113
+ function windowFor(calculate) {
1114
+ return windows.get(calculate);
1115
+ }
1116
+ var inputs;
1117
+ function withIndicatorInputs(bars, calculate) {
1118
+ const previous = inputs;
1119
+ inputs = { bars, fields: /* @__PURE__ */ new Map() };
1120
+ try {
1121
+ return calculate();
1122
+ } finally {
1123
+ inputs = previous;
1124
+ }
1125
+ }
1126
+ function indicatorField(bars, field, policy = "raw") {
1127
+ const cache = inputs?.bars === bars ? inputs.fields : void 0, key = policy + ":" + field;
1128
+ const existing = cache?.get(key);
1129
+ if (existing !== void 0)
1130
+ return existing;
1131
+ const result = new Array(bars.length);
1132
+ for (let i = 0; i < bars.length; i++) {
1133
+ const value = bars[i][field];
1134
+ result[i] = typeof value !== "number" || policy !== "raw" && !Number.isFinite(value) || policy === "volume" && value < 0 ? null : value;
1135
+ }
1136
+ cache?.set(key, result);
1137
+ return result;
1138
+ }
1139
+
1140
+ export {
1141
+ isLength,
1142
+ sum,
1143
+ sma,
1144
+ wma,
1145
+ hma,
1146
+ vwma,
1147
+ ema,
1148
+ rma,
1149
+ rsi,
1150
+ macd,
1151
+ stdev,
1152
+ dev,
1153
+ bollinger,
1154
+ highest,
1155
+ lowest,
1156
+ linreg,
1157
+ correlation,
1158
+ change,
1159
+ mom,
1160
+ roc,
1161
+ crossover,
1162
+ crossunder,
1163
+ cross,
1164
+ cum,
1165
+ barssince,
1166
+ valuewhen,
1167
+ pivot,
1168
+ trueRange,
1169
+ atr,
1170
+ obv,
1171
+ vwap,
1172
+ cci,
1173
+ mfi,
1174
+ stochK,
1175
+ sar,
1176
+ stoch,
1177
+ stochRsi,
1178
+ bbPercent,
1179
+ keltner,
1180
+ donchian,
1181
+ atrBands,
1182
+ supertrend,
1183
+ ichimoku,
1184
+ anchoredVwap,
1185
+ ownedKernel,
1186
+ kernelFor,
1187
+ ownedWindow,
1188
+ windowFor,
1189
+ withIndicatorInputs,
1190
+ indicatorField,
1191
+ previousRangeHighLow
1192
+ };