oakscriptjs 0.10.1 → 0.11.1

package/dist/cjs/callsite/index.d.ts

@@ -9,10 +9,11 @@
  * - {@link whenCalled}: vectorized, when the bars of the calls are known in advance.
  * - {@link crossover} / {@link crossunder} / {@link cross} / {@link barssince}: one stateful call site for bar
  *   loops, called only on the bars where the Pine call runs.
- * - {@link lowest} / {@link highest}: `ta.lowest` / `ta.highest` with a series length (a different length on each
- *   call), which PineScript computes with a state kept between calls.
- * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a
- *   conditional block, whose history is kept by bar (not by call).
+ * - {@link lowestByBar} / {@link highestByBar} / {@link lowestbars} / {@link highestbars} / {@link pivothigh} /
+ *   {@link pivotlow}: `ta.lowest` / `ta.highest` / `ta.lowestbars` / `ta.highestbars` / `ta.pivothigh` /
+ *   `ta.pivotlow` in a conditional block or a loop, also with a length that changes on each call. They keep the
+ *   non-na values of their calls; {@link lowest} / {@link highest} are the same sites called with `(value, length)`.
+ * - {@link linreg}: `ta.linreg` in a conditional block, whose history is kept by bar (not by call).
  * - {@link sum} / {@link sma}: `math.sum` / `ta.sma` in a `for` / `while` loop, called several times on one bar.
  *
  * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide
@@ -74,16 +75,9 @@ export declare function barssince(): (condition: boolean | number) => number;
  */
 export declare function cross(): (a: number, b: number) => boolean;
 /**
- * One `ta.lowest(source, length)` call site with a series length (a different length on each call), called with
- * `(value, length)`.
- *
- * PineScript rules (measured with a length that changes on each bar):
- * - the extreme is kept with its bar; a new value that passes it replaces it; when the kept extreme is `length`
- *   calls old, the last `length` values are scanned again (na skipped, the oldest wins a tie)
- * - a length smaller than on the previous call: the last `length` values are scanned again
- * - a length larger than on the previous call: the values that enter the window at its old end are compared with the
- *   extreme; when one of them is na, the extreme restarts from the current value (the values in between are not read)
- * - an na value gives na and resets the extreme; na before call `length - 1`
+ * One `ta.lowest(source, length)` call site, called with `(value, length, barIndex?)`: the same site as
+ * {@link lowestByBar} (same rules). Pass the bar index when the call does not run on every bar; without it every
+ * call counts as one bar, which is right for a call on every bar (for example with a length that changes).
  *
  * @example
  * ```typescript
@@ -92,26 +86,28 @@ export declare function cross(): (a: number, b: number) => boolean;
  * const out = closes.map((_, i) => lowPrice(i > 0 ? closes[i - 1]! : NaN, lookback[i]!));
  * ```
  */
-export declare function lowest(): (value: number, length: number) => number;
+export declare function lowest(): (value: number, length: number, barIndex?: number) => number;
 /**
- * One `ta.highest(source, length)` call site with a series length (a different length on each call), called with
- * `(value, length)`. Same rules as {@link lowest}.
+ * One `ta.highest(source, length)` call site, called with `(value, length, barIndex?)`. Same rules as
+ * {@link lowest}.
  */
-export declare function highest(): (value: number, length: number) => number;
+export declare function highest(): (value: number, length: number, barIndex?: number) => number;
 /**
- * One `ta.lowest(source, length)` call site in a conditional block whose history is kept by bar (not by call), called
- * with `(barIndex, value, length)` on the bars where the Pine call runs.
+ * One `ta.lowest(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)` on the bars (and loop turns) where the Pine call runs. The length can change from one
+ * call to the next.
  *
- * PineScript rules (measured on a call in a ternary branch, length 6):
- * - the values are kept in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start and
- *   written only on the bars where the call runs: a bar before the first call counts as 0, and a bar without a call
- *   holds the value of the call `length + 1` bars earlier (0 if there was none)
- * - on a call, the value replaces the kept extreme when there is none or when it is strictly lower; only otherwise,
- *   when the kept extreme is `length` bars old, the last `length` bars are read again from the ring (the oldest bar
- *   wins a tie)
- * - na before bar `length - 1` (by bar, not by call)
+ * PineScript rules (measured in `if` blocks, ternaries, user functions and `for` loops, with constant lengths and
+ * lengths that change, on sources with and without na):
+ * - the call site keeps the non-na values it received, each with its bar; nothing is kept for a bar without a call
+ *   or for an na value
+ * - the result is na while `barIndex < length - 1` (by bar, not by call) and while no value was received
+ * - otherwise it is the lowest of the last `length` kept values, or of all of them when there are fewer: the first
+ *   call after bar `length - 1` gives its own value. A call with an na value also gives this result
+ * - in a loop (several calls on one bar), a bar has one kept value: each call replaces the value of the earlier
+ *   calls of that bar, so a call gives the lowest of its value and the values of the bars before
  *
- * {@link lowest} keeps the history by call instead; both rules were measured, on different scripts.
+ * Called on every bar, it equals `ta.lowest`.
  *
  * @example
  * ```typescript
@@ -122,11 +118,56 @@ export declare function highest(): (value: number, length: number) => number;
  */
 export declare function lowestByBar(): (barIndex: number, value: number, length: number) => number;
 /**
- * One `ta.highest(source, length)` call site in a conditional block whose history is kept by bar, called with
- * `(barIndex, value, length)`. Same rules as {@link lowestByBar} (a value replaces the kept extreme when it is
- * strictly higher).
+ * One `ta.highest(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)`. Same rules as {@link lowestByBar}.
  */
 export declare function highestByBar(): (barIndex: number, value: number, length: number) => number;
+/**
+ * One `ta.lowestbars(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)`: the offset (0 or negative) from this bar to the bar of the lowest of the last `length`
+ * kept values, the newest one on equal values. The values are kept as in {@link lowestByBar}; the offset counts
+ * bars, not calls, so it can be below `-(length - 1)`.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  off = cond ? ta.lowestbars(low, 10) : na
+ * const site = callsite.lowestbars();
+ * const off = lows.map((v, i) => (cond[i] ? site(i, v, 10) : NaN));
+ * ```
+ */
+export declare function lowestbars(): (barIndex: number, value: number, length: number) => number;
+/**
+ * One `ta.highestbars(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)`. Same rules as {@link lowestbars}.
+ */
+export declare function highestbars(): (barIndex: number, value: number, length: number) => number;
+/**
+ * One `ta.pivothigh(source, leftbars, rightbars)` call site in a conditional block, called with
+ * `(barIndex, value, leftbars, rightbars)` on the bars where the Pine call runs. The lengths can change from one call
+ * to the next (the lengths of the current call are used).
+ *
+ * PineScript rules (measured in `if` blocks and ternaries, and on sources with na):
+ * - the call site keeps the non-na values it received, each with its bar
+ * - on a call it takes the last `leftbars + rightbars + 1` kept values (all of them when there are fewer) and finds
+ *   the highest, the newest one on equal values
+ * - there is a pivot only when that value is on the bar `rightbars` BARS back (by bar index, not by call); the
+ *   result is its value, na otherwise and before bar `leftbars + rightbars`
+ *
+ * Called on every bar, it equals `ta.pivothigh`.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  ph = useFilter ? ta.pivothigh(src, 5, 5) : na
+ * const site = callsite.pivothigh();
+ * const ph = src.map((v, i) => (useFilter[i] ? site(i, v, 5, 5) : NaN));
+ * ```
+ */
+export declare function pivothigh(): (barIndex: number, value: number, leftbars: number, rightbars: number) => number;
+/**
+ * One `ta.pivotlow(source, leftbars, rightbars)` call site in a conditional block, called with
+ * `(barIndex, value, leftbars, rightbars)`. Same rules as {@link pivothigh} (the lowest value).
+ */
+export declare function pivotlow(): (barIndex: number, value: number, leftbars: number, rightbars: number) => number;
 /**
  * One `ta.linreg(source, length, offset)` call site in a conditional block, called with
  * `(barIndex, value, length, offset)` on the bars where the Pine call runs.

package/dist/cjs/callsite/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/callsite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,OAAO,EACnD,MAAM,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EACnC,EAAE,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAC3C,GAAG,OAAO,EAAE,MAAM,EAAE,GACnB,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,CASnB;AAmBD;;;GAGG;AACH,wBAAgB,SAAS,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAE9D;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,KAAK,MAAM,CAOnE;AAED;;;;GAIG;AACH,wBAAgB,KAAK,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CASzD;AA2CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAElE;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAEnE;AAgCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAEzF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAE1F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAUrG;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAGjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAGjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,MAAM,CAUrG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAE3E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/callsite/index.ts"],"names":[],"mappings":"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"}

package/dist/cjs/callsite/index.js

@@ -24,9 +24,13 @@ __export(callsite_exports, {
   crossunder: () => crossunder,
   highest: () => highest,
   highestByBar: () => highestByBar,
+  highestbars: () => highestbars,
   linreg: () => linreg,
   lowest: () => lowest,
   lowestByBar: () => lowestByBar,
+  lowestbars: () => lowestbars,
+  pivothigh: () => pivothigh,
+  pivotlow: () => pivotlow,
   random: () => random,
   sma: () => sma,
   stdev: () => stdev,
@@ -36,6 +40,7 @@ __export(callsite_exports, {
 module.exports = __toCommonJS(callsite_exports);
 var import_ta = require("../ta/index.js");
 var import_running_sum = require("../ta/running-sum.js");
+var import_limits = require("../ta/limits.js");
 var import_math = require("../math/index.js");
 function whenCalled(called, fn, ...sources) {
   const bars = [];
@@ -83,84 +88,82 @@ function cross() {
     return result;
   };
 }
-function extremeSite(isLowest) {
-  const better = isLowest ? (a, b) => a < b : (a, b) => a > b;
-  const values = [];
-  let extreme = NaN;
-  let extremeAt = -1;
-  let prevLength = NaN;
-  const keep = (v, at) => {
-    extreme = v;
-    extremeAt = at;
-  };
-  const rescan = (i, length) => {
-    extreme = NaN;
-    for (let b = i; b > i - length && b >= 0; b--) {
-      const v = values[b];
-      if (!Number.isNaN(v) && (Number.isNaN(extreme) || !better(extreme, v))) keep(v, b);
+class KeptCalls {
+  values = [];
+  bars = [];
+  /** Keeps a non-na value; a later call on the same bar (a loop) replaces the value of that bar. */
+  add(barIndex, value) {
+    if (Number.isNaN(value)) return;
+    const last = this.values.length - 1;
+    if (last >= 0 && this.bars[last] === barIndex) this.values[last] = value;
+    else {
+      this.values.push(value);
+      this.bars.push(barIndex);
     }
-  };
-  return (value, length) => {
-    const i = values.length;
-    values.push(value);
-    if (Number.isNaN(value)) {
-      extreme = NaN;
-      prevLength = length;
-      return NaN;
+  }
+  /** Position of the best of the last `count` kept values (the newest one on ties), -1 when there is none. */
+  best(count, isLowest) {
+    const last = this.values.length - 1;
+    if (last < 0 || !(count >= 1)) return -1;
+    let best = last;
+    for (let k = last - 1; k >= 0 && k > last - count; k--) {
+      if (isLowest ? this.values[k] < this.values[best] : this.values[k] > this.values[best]) best = k;
     }
-    if (length > prevLength) {
-      const from = Math.max(0, i - length + 1);
-      const to = Math.max(0, i - prevLength + 1);
-      if (values.slice(from, to).some(Number.isNaN)) keep(value, i);
-      else {
-        for (let b = from; b < to; b++) if (Number.isNaN(extreme) || better(values[b], extreme)) keep(values[b], b);
-        if (Number.isNaN(extreme) || better(value, extreme)) keep(value, i);
-      }
-    } else if (length < prevLength || Number.isNaN(extreme) || i - extremeAt >= length) rescan(i, length);
-    else if (better(value, extreme)) keep(value, i);
-    prevLength = length;
-    return i < length - 1 ? NaN : extreme;
+    return best;
+  }
+}
+function extremeByBarSite(isLowest, offsets) {
+  const kept = new KeptCalls();
+  const name = (isLowest ? "lowest" : "highest") + (offsets ? "bars" : "");
+  return (barIndex, value, length) => {
+    (0, import_limits.checkWindowLength)(name, length, barIndex);
+    kept.add(barIndex, value);
+    const len = Math.trunc(length);
+    if (barIndex < len - 1) return NaN;
+    const best = kept.best(len, isLowest);
+    if (best < 0) return NaN;
+    return offsets ? -(barIndex - kept.bars[best]) : kept.values[best];
   };
 }
+function extremeSite(isLowest) {
+  const site = extremeByBarSite(isLowest, false);
+  let calls = 0;
+  return (value, length, barIndex) => site(barIndex ?? calls++, value, length);
+}
 function lowest() {
   return extremeSite(true);
 }
 function highest() {
   return extremeSite(false);
 }
-function extremeByBarSite(isLowest) {
-  const better = isLowest ? (a, b) => a < b : (a, b) => a > b;
-  let ring = [];
-  let extreme = NaN;
-  let extremeAt = -1;
-  return (barIndex, value, length) => {
-    const len = Math.floor(length);
-    if (ring.length !== len + 1) {
-      ring = new Array(len + 1).fill(0);
-      extreme = NaN;
-    }
-    ring[barIndex % (len + 1)] = value;
-    if (Number.isNaN(extreme) || better(value, extreme)) {
-      extreme = value;
-      extremeAt = barIndex;
-    } else if (barIndex - extremeAt >= len) {
-      extreme = NaN;
-      for (let b = barIndex - len + 1; b <= barIndex; b++) {
-        const v = ring[b % (len + 1)];
-        if (!Number.isNaN(v) && (Number.isNaN(extreme) || better(v, extreme))) {
-          extreme = v;
-          extremeAt = b;
-        }
-      }
-    }
-    return barIndex < len - 1 ? NaN : extreme;
-  };
-}
 function lowestByBar() {
-  return extremeByBarSite(true);
+  return extremeByBarSite(true, false);
 }
 function highestByBar() {
-  return extremeByBarSite(false);
+  return extremeByBarSite(false, false);
+}
+function lowestbars() {
+  return extremeByBarSite(true, true);
+}
+function highestbars() {
+  return extremeByBarSite(false, true);
+}
+function pivotSite(isLowest) {
+  const kept = new KeptCalls();
+  return (barIndex, value, leftbars, rightbars) => {
+    kept.add(barIndex, value);
+    const left = Math.trunc(leftbars);
+    const right = Math.trunc(rightbars);
+    if (!(barIndex >= left + right)) return NaN;
+    const best = kept.best(left + right + 1, isLowest);
+    return best >= 0 && kept.bars[best] === barIndex - right ? kept.values[best] : NaN;
+  };
+}
+function pivothigh() {
+  return pivotSite(false);
+}
+function pivotlow() {
+  return pivotSite(true);
 }
 function linreg() {
   let ring = [];
@@ -180,6 +183,7 @@ function loopSumSite(name, squares) {
   let pending = false;
   return (barIndex, value, length) => {
     const len = Math.floor(length);
+    (0, import_limits.checkSumLength)(name === "sum" ? "math.sum" : `ta.${name}`, len, barIndex);
     if (!(len >= 1)) throw new Error(`callsite.${name}: length must be at least 1 (got ${length})`);
     if (barIndex !== lastBar) {
       if (pending) {

package/dist/cjs/callsite/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/callsite/index.ts"],
-  "sourcesContent": ["/**\n * @fileoverview Per-call history of ta.* functions called in a conditional block.\n *\n * In PineScript, every ta.* call keeps its own history of the values it receives. A call inside\n * an `if` block receives values only on the bars where the block runs, so its history skips the\n * other bars: `ta.crossover(a, b)` is false on the first bar the block runs, and `ta.sma(x, 3)`\n * averages the last 3 values it received, not the last 3 bars.\n *\n * - {@link whenCalled}: vectorized, when the bars of the calls are known in advance.\n * - {@link crossover} / {@link crossunder} / {@link cross} / {@link barssince}: one stateful call site for bar\n *   loops, called only on the bars where the Pine call runs.\n * - {@link lowest} / {@link highest}: `ta.lowest` / `ta.highest` with a series length (a different length on each\n *   call), which PineScript computes with a state kept between calls.\n * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a\n *   conditional block, whose history is kept by bar (not by call).\n * - {@link sum} / {@link sma}: `math.sum` / `ta.sma` in a `for` / `while` loop, called several times on one bar.\n *\n * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide\n * the result. A ta.* call in the right operand of `a or b` runs on the bars where `a` is false, in `a and b` on the\n * bars where `a` is true, so it needs a call site too:\n *\n * ```typescript\n * // Pine:  longCond = longUp or (src > sig and ta.barssince(longUp) <= lookback)\n * const since = callsite.whenCalled(longUp.map((u, i) => !u && src[i] > sig[i]), (c) => taCore.barssince(c.map(Boolean)), longUp);\n * // ta.barssince(longUp) only runs where longUp is false: it never sees true and stays na\n * ```\n *\n * ```typescript\n * // Pine:  if inRange\n * //            buy = ta.crossover(cumRsi, 60)\n * const buy = callsite.whenCalled(inRange, (a) => taCore.crossover(a, a.map(() => 60)), cumRsi);\n *\n * // Same call in a bar loop\n * const buyCross = callsite.crossover();\n * for (let i = 0; i < n; i++) {\n *   if (inRange[i]) {\n *     const buy = buyCross(cumRsi[i], 60);\n *   }\n * }\n * ```\n *\n * @module callsite\n */\n\nimport type { Source } from '../types/index.js';\nimport { linreg as linregSeries } from '../ta/index.js';\nimport { RunningSum, isNa } from '../ta/running-sum.js';\nimport { seededRandom } from '../math/index.js';\n\n/**\n * Runs `fn` on the bars where `called` is true only, like a ta.* call inside an `if` block.\n * `fn` receives the values of `sources` on those bars, in order; its results are placed back on\n * the same bars. The other bars get na (NaN).\n *\n * @param called - true (or non-zero) on the bars where the call runs\n * @param fn - the calculation, for example `(x) => taCore.sma(x, 3)`\n * @param sources - the arguments of the call, one value per chart bar\n */\nexport function whenCalled<T extends number | boolean>(\n  called: ArrayLike<boolean | number>,\n  fn: (...values: number[][]) => ArrayLike<T>,\n  ...sources: Source[]\n): Array<T | number> {\n  const bars: number[] = [];\n  for (let i = 0; i < called.length; i++) if (called[i]) bars.push(i);\n  const result = fn(...sources.map(s => bars.map(i => s[i] ?? NaN)));\n  const out = new Array<T | number>(called.length).fill(NaN);\n  bars.forEach((bar, k) => {\n    out[bar] = result[k]!;\n  });\n  return out;\n}\n\n/**\n * A call site that keeps the arguments of the last call where both were not na (na before such a call), as\n * ta.crossover / ta.crossunder / ta.cross.\n */\nfunction twoSeriesSite(test: (a: number, b: number, prevA: number, prevB: number) => boolean) {\n  let prevA = NaN;\n  let prevB = NaN;\n  return (a: number, b: number): boolean => {\n    const result = test(a, b, prevA, prevB);\n    if (!Number.isNaN(a) && !Number.isNaN(b)) {\n      prevA = a;\n      prevB = b;\n    }\n    return result;\n  };\n}\n\n/**\n * One `ta.crossover(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossover(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a > b && pa <= pb);\n}\n\n/**\n * One `ta.crossunder(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossunder(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a < b && pa >= pb);\n}\n\n/**\n * One `ta.barssince(condition)` call site: the number of calls since the condition was true on a call (0 on that\n * call), na before the first true condition. An na condition counts as false.\n */\nexport function barssince(): (condition: boolean | number) => number {\n  let count = NaN;\n  return (condition) => {\n    if (condition && !Number.isNaN(condition)) count = 0;\n    else if (!Number.isNaN(count)) count++;\n    return count;\n  };\n}\n\n/**\n * One `ta.cross(a, b)` call site, rules of `ta.cross`: the site keeps the side of the last call where `a` was\n * strictly above or strictly below `b` (none before such a call; equal values and na arguments do not change it),\n * and is true when the arguments are strictly on the other side. False with an na argument.\n */\nexport function cross(): (a: number, b: number) => boolean {\n  let side = 0; // -1: last strictly below, 1: last strictly above, 0: none yet\n  return (a, b) => {\n    if (Number.isNaN(a) || Number.isNaN(b)) return false;\n    const result = (side < 0 && a > b) || (side > 0 && a < b);\n    if (a < b) side = -1;\n    else if (a > b) side = 1;\n    return result;\n  };\n}\n\n/** One `ta.lowest` / `ta.highest` call site with a series length; rules in {@link lowest}. */\nfunction extremeSite(isLowest: boolean): (value: number, length: number) => number {\n  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;\n  const values: number[] = [];\n  let extreme = NaN;\n  let extremeAt = -1;\n  let prevLength = NaN;\n  const keep = (v: number, at: number) => {\n    extreme = v;\n    extremeAt = at;\n  };\n  const rescan = (i: number, length: number) => {\n    extreme = NaN;\n    for (let b = i; b > i - length && b >= 0; b--) {\n      const v = values[b]!;\n      if (!Number.isNaN(v) && (Number.isNaN(extreme) || !better(extreme, v))) keep(v, b);\n    }\n  };\n  return (value, length) => {\n    const i = values.length;\n    values.push(value);\n    if (Number.isNaN(value)) {\n      extreme = NaN;\n      prevLength = length;\n      return NaN;\n    }\n    if (length > prevLength) {\n      const from = Math.max(0, i - length + 1);\n      const to = Math.max(0, i - prevLength + 1);\n      if (values.slice(from, to).some(Number.isNaN)) keep(value, i);\n      else {\n        for (let b = from; b < to; b++) if (Number.isNaN(extreme) || better(values[b]!, extreme)) keep(values[b]!, b);\n        if (Number.isNaN(extreme) || better(value, extreme)) keep(value, i);\n      }\n    } else if (length < prevLength || Number.isNaN(extreme) || i - extremeAt >= length) rescan(i, length);\n    else if (better(value, extreme)) keep(value, i);\n    prevLength = length;\n    return i < length - 1 ? NaN : extreme;\n  };\n}\n\n/**\n * One `ta.lowest(source, length)` call site with a series length (a different length on each call), called with\n * `(value, length)`.\n *\n * PineScript rules (measured with a length that changes on each bar):\n * - the extreme is kept with its bar; a new value that passes it replaces it; when the kept extreme is `length`\n *   calls old, the last `length` values are scanned again (na skipped, the oldest wins a tie)\n * - a length smaller than on the previous call: the last `length` values are scanned again\n * - a length larger than on the previous call: the values that enter the window at its old end are compared with the\n *   extreme; when one of them is na, the extreme restarts from the current value (the values in between are not read)\n * - an na value gives na and resets the extreme; na before call `length - 1`\n *\n * @example\n * ```typescript\n * // Pine:  lowPrice = ta.lowest(close[1], lookback)   // lookback changes per bar\n * const lowPrice = callsite.lowest();\n * const out = closes.map((_, i) => lowPrice(i > 0 ? closes[i - 1]! : NaN, lookback[i]!));\n * ```\n */\nexport function lowest(): (value: number, length: number) => number {\n  return extremeSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site with a series length (a different length on each call), called with\n * `(value, length)`. Same rules as {@link lowest}.\n */\nexport function highest(): (value: number, length: number) => number {\n  return extremeSite(false);\n}\n\n/** One `ta.lowest` / `ta.highest` call site whose history is kept by bar; rules in {@link lowestByBar}. */\nfunction extremeByBarSite(isLowest: boolean): (barIndex: number, value: number, length: number) => number {\n  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;\n  let ring: number[] = [];\n  let extreme = NaN;\n  let extremeAt = -1;\n  return (barIndex, value, length) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) {\n      ring = new Array<number>(len + 1).fill(0);\n      extreme = NaN;\n    }\n    ring[barIndex % (len + 1)] = value;\n    if (Number.isNaN(extreme) || better(value, extreme)) {\n      extreme = value;\n      extremeAt = barIndex;\n    } else if (barIndex - extremeAt >= len) {\n      extreme = NaN;\n      for (let b = barIndex - len + 1; b <= barIndex; b++) {\n        const v = ring[b % (len + 1)]!;\n        if (!Number.isNaN(v) && (Number.isNaN(extreme) || better(v, extreme))) {\n          extreme = v;\n          extremeAt = b;\n        }\n      }\n    }\n    return barIndex < len - 1 ? NaN : extreme;\n  };\n}\n\n/**\n * One `ta.lowest(source, length)` call site in a conditional block whose history is kept by bar (not by call), called\n * with `(barIndex, value, length)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured on a call in a ternary branch, length 6):\n * - the values are kept in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start and\n *   written only on the bars where the call runs: a bar before the first call counts as 0, and a bar without a call\n *   holds the value of the call `length + 1` bars earlier (0 if there was none)\n * - on a call, the value replaces the kept extreme when there is none or when it is strictly lower; only otherwise,\n *   when the kept extreme is `length` bars old, the last `length` bars are read again from the ring (the oldest bar\n *   wins a tie)\n * - na before bar `length - 1` (by bar, not by call)\n *\n * {@link lowest} keeps the history by call instead; both rules were measured, on different scripts.\n *\n * @example\n * ```typescript\n * // Pine:  lo = cond ? ta.lowest(low, 6) : na\n * const site = callsite.lowestByBar();\n * const lo = lows.map((v, i) => (cond[i] ? site(i, v, 6) : NaN));\n * ```\n */\nexport function lowestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site in a conditional block whose history is kept by bar, called with\n * `(barIndex, value, length)`. Same rules as {@link lowestByBar} (a value replaces the kept extreme when it is\n * strictly higher).\n */\nexport function highestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(false);\n}\n\n/**\n * One `ta.linreg(source, length, offset)` call site in a conditional block, called with\n * `(barIndex, value, length, offset)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured): `ta.linreg` keeps the values it receives in a ring of `length + 1` slots indexed by the\n * bar index, filled with 0 at the start and written only on the bars where it is called. The window is read from the\n * ring for the last `length` bars: a bar before the first call counts as 0, and a bar without a call holds the value of\n * the call `length + 1` bars earlier (0 if there was none). The result is na before bar `length - 1`. Called on every\n * bar, it equals `ta.linreg`.\n *\n * @example\n * ```typescript\n * // Pine:  if bar_index >= 20\n * //            a := ta.linreg(close, 10, 0)\n * const site = callsite.linreg();\n * const a = closes.map((c, i) => (i >= 20 ? site(i, c, 10, 0) : NaN));\n * ```\n */\nexport function linreg(): (barIndex: number, value: number, length: number, offset?: number) => number {\n  let ring: number[] = [];\n  return (barIndex, value, length, offset = 0) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) ring = new Array<number>(len + 1).fill(0);\n    ring[barIndex % (len + 1)] = value;\n    if (barIndex < len - 1) return NaN;\n    const window = Array.from({ length: len }, (_, k) => ring[(barIndex - len + 1 + k) % (len + 1)]!);\n    return linregSeries(window, len, offset)[len - 1]!;\n  };\n}\n\n\n/**\n * One `math.sum` call site in a loop; rules in {@link sum}. With `squares`, it also keeps the running sum of the\n * squared values (for {@link stdev}). Returns `[sum, sumOfSquares]` (NaN when not kept).\n */\nfunction loopSumSite(\n  name: string,\n  squares: boolean\n): (barIndex: number, value: number, length: number) => [number, number] {\n  const running = new RunningSum();\n  const runningSq = new RunningSum();\n  let lastBar = NaN;\n  let pending = false;\n  return (barIndex, value, length) => {\n    const len = Math.floor(length);\n    if (!(len >= 1)) throw new Error(`callsite.${name}: length must be at least 1 (got ${length})`);\n    if (barIndex !== lastBar) {\n      if (pending) {\n        running.commit();\n        if (squares) runningSq.commit();\n      }\n      pending = false;\n      lastBar = barIndex;\n    }\n    if (isNa(value)) {\n      pending = false;\n      return [running.stepNa(len), squares ? runningSq.stepNa(len) : NaN];\n    }\n    const x = value;\n    const out: [number, number] = [running.step(x, len), squares ? runningSq.step(x * x, len) : NaN];\n    pending = true;\n    return out;\n  };\n}\n\n/**\n * One `math.sum(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on\n * each call.\n *\n * PineScript rules (measured on calls in loops, 1 to 3 calls per bar, and bars without a call):\n * - the call site keeps one history value per bar: the value of its last call on that bar\n * - every call on a bar starts from the state of the earlier bars, so it gives the sum of its value and the last\n *   `length - 1` kept values; the last call of the bar is the one kept for the later bars\n * - the length can change from one call to the next (also on the same bar): each call first moves the kept sum to\n *   its own length as `math.sum` with a series length does (Kahan steps of the raw values)\n * - a bar without a call is not in the history (as a call in an `if` block)\n * - the sum is the same compensated running sum as `math.sum` (bit for bit)\n *\n * An na value is skipped as in `math.sum` (it returns the sum of the last `length` earlier values); when it is the\n * last call of a bar, the bar is not in the history (not measured).\n *\n * @example\n * ```typescript\n * // Pine:  for i = 0 to 2\n * //            s = math.sum(close * (1 + 0.01 * i), 7)\n * const site = callsite.sum();\n * for (let b = 0; b < closes.length; b++) {\n *   for (let i = 0; i <= 2; i++) {\n *     const s = site(b, closes[b]! * (1 + 0.01 * i), 7);\n *   }\n * }\n * ```\n */\nexport function sum(): (barIndex: number, value: number, length: number) => number {\n  const site = loopSumSite('sum', false);\n  return (barIndex, value, length) => site(barIndex, value, length)[0];\n}\n\n/**\n * One `ta.sma(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on\n * each call: {@link sum} divided by the length (same rules).\n *\n * @example\n * ```typescript\n * // Pine:  evaluate(ratio) => ta.sma(gann(ratio), n)   // called once per ratio in a while loop\n * const site = callsite.sma();\n * for (let b = 0; b < closes.length; b++) {\n *   for (const ratio of ratios) {\n *     const avg = site(b, gann(b, ratio), n);\n *   }\n * }\n * ```\n */\nexport function sma(): (barIndex: number, value: number, length: number) => number {\n  const site = loopSumSite('sma', false);\n  return (barIndex, value, length) => site(barIndex, value, length)[0] / Math.floor(length);\n}\n\n/**\n * One `ta.stdev(source, length, biased)` call site inside a `for` / `while` loop, called with\n * `(barIndex, value, length, biased?)` on each call: the running sums of the values and of their squares follow the\n * rules of {@link sum}; the result is computed from them as `ta.stdev` (bit for bit).\n *\n * @example\n * ```typescript\n * // Pine:  for len in lengths\n * //            [mid, up, lo] = ta.bb(close, len, 2)\n * const avgSite = callsite.sma();\n * const devSite = callsite.stdev();\n * for (let b = 0; b < closes.length; b++) {\n *   for (const len of lengths) {\n *     const mid = avgSite(b, closes[b]!, len);\n *     const dev = devSite(b, closes[b]!, len);\n *   }\n * }\n * ```\n */\nexport function stdev(): (barIndex: number, value: number, length: number, biased?: boolean) => number {\n  const site = loopSumSite('stdev', true);\n  return (barIndex, value, length, biased = true) => {\n    const len = Math.floor(length);\n    const [s, sq] = site(barIndex, value, length);\n    const mean = s / len;\n    const variance = biased ? sq / len - mean * mean : sq / (len - 1) - (mean * s) / (len - 1);\n    if (!biased && len <= 1) return NaN;\n    return Number.isNaN(variance) ? NaN : variance > 0 ? Math.sqrt(variance) : 0;\n  };\n}\n\n/**\n * One `math.random(min, max, seed)` call site: PineScript keeps one generator per call site, so two call sites\n * with the same seed give the same sequence. Called with `(min?, max?)` once per bar.\n *\n * @example\n * ```typescript\n * // Pine: a = math.random(0, 1, 42), b = math.random(0, 1, 42)   // a == b on every bar\n * const a = callsite.random(42);\n * const b = callsite.random(42);\n * ```\n */\nexport function random(seed: number): (min?: number, max?: number) => number {\n  return seededRandom(seed);\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * @fileoverview Per-call history of ta.* functions called in a conditional block.\n *\n * In PineScript, every ta.* call keeps its own history of the values it receives. A call inside\n * an `if` block receives values only on the bars where the block runs, so its history skips the\n * other bars: `ta.crossover(a, b)` is false on the first bar the block runs, and `ta.sma(x, 3)`\n * averages the last 3 values it received, not the last 3 bars.\n *\n * - {@link whenCalled}: vectorized, when the bars of the calls are known in advance.\n * - {@link crossover} / {@link crossunder} / {@link cross} / {@link barssince}: one stateful call site for bar\n *   loops, called only on the bars where the Pine call runs.\n * - {@link lowestByBar} / {@link highestByBar} / {@link lowestbars} / {@link highestbars} / {@link pivothigh} /\n *   {@link pivotlow}: `ta.lowest` / `ta.highest` / `ta.lowestbars` / `ta.highestbars` / `ta.pivothigh` /\n *   `ta.pivotlow` in a conditional block or a loop, also with a length that changes on each call. They keep the\n *   non-na values of their calls; {@link lowest} / {@link highest} are the same sites called with `(value, length)`.\n * - {@link linreg}: `ta.linreg` in a conditional block, whose history is kept by bar (not by call).\n * - {@link sum} / {@link sma}: `math.sum` / `ta.sma` in a `for` / `while` loop, called several times on one bar.\n *\n * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide\n * the result. A ta.* call in the right operand of `a or b` runs on the bars where `a` is false, in `a and b` on the\n * bars where `a` is true, so it needs a call site too:\n *\n * ```typescript\n * // Pine:  longCond = longUp or (src > sig and ta.barssince(longUp) <= lookback)\n * const since = callsite.whenCalled(longUp.map((u, i) => !u && src[i] > sig[i]), (c) => taCore.barssince(c.map(Boolean)), longUp);\n * // ta.barssince(longUp) only runs where longUp is false: it never sees true and stays na\n * ```\n *\n * ```typescript\n * // Pine:  if inRange\n * //            buy = ta.crossover(cumRsi, 60)\n * const buy = callsite.whenCalled(inRange, (a) => taCore.crossover(a, a.map(() => 60)), cumRsi);\n *\n * // Same call in a bar loop\n * const buyCross = callsite.crossover();\n * for (let i = 0; i < n; i++) {\n *   if (inRange[i]) {\n *     const buy = buyCross(cumRsi[i], 60);\n *   }\n * }\n * ```\n *\n * @module callsite\n */\n\nimport type { Source } from '../types/index.js';\nimport { linreg as linregSeries } from '../ta/index.js';\nimport { RunningSum, isNa } from '../ta/running-sum.js';\nimport { checkSumLength, checkWindowLength } from '../ta/limits.js';\nimport { seededRandom } from '../math/index.js';\n\n/**\n * Runs `fn` on the bars where `called` is true only, like a ta.* call inside an `if` block.\n * `fn` receives the values of `sources` on those bars, in order; its results are placed back on\n * the same bars. The other bars get na (NaN).\n *\n * @param called - true (or non-zero) on the bars where the call runs\n * @param fn - the calculation, for example `(x) => taCore.sma(x, 3)`\n * @param sources - the arguments of the call, one value per chart bar\n */\nexport function whenCalled<T extends number | boolean>(\n  called: ArrayLike<boolean | number>,\n  fn: (...values: number[][]) => ArrayLike<T>,\n  ...sources: Source[]\n): Array<T | number> {\n  const bars: number[] = [];\n  for (let i = 0; i < called.length; i++) if (called[i]) bars.push(i);\n  const result = fn(...sources.map(s => bars.map(i => s[i] ?? NaN)));\n  const out = new Array<T | number>(called.length).fill(NaN);\n  bars.forEach((bar, k) => {\n    out[bar] = result[k]!;\n  });\n  return out;\n}\n\n/**\n * A call site that keeps the arguments of the last call where both were not na (na before such a call), as\n * ta.crossover / ta.crossunder / ta.cross.\n */\nfunction twoSeriesSite(test: (a: number, b: number, prevA: number, prevB: number) => boolean) {\n  let prevA = NaN;\n  let prevB = NaN;\n  return (a: number, b: number): boolean => {\n    const result = test(a, b, prevA, prevB);\n    if (!Number.isNaN(a) && !Number.isNaN(b)) {\n      prevA = a;\n      prevB = b;\n    }\n    return result;\n  };\n}\n\n/**\n * One `ta.crossover(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossover(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a > b && pa <= pb);\n}\n\n/**\n * One `ta.crossunder(a, b)` call site: compared with the last call where both arguments were not na; false before\n * such a call.\n */\nexport function crossunder(): (a: number, b: number) => boolean {\n  return twoSeriesSite((a, b, pa, pb) => a < b && pa >= pb);\n}\n\n/**\n * One `ta.barssince(condition)` call site: the number of calls since the condition was true on a call (0 on that\n * call), na before the first true condition. An na condition counts as false.\n */\nexport function barssince(): (condition: boolean | number) => number {\n  let count = NaN;\n  return (condition) => {\n    if (condition && !Number.isNaN(condition)) count = 0;\n    else if (!Number.isNaN(count)) count++;\n    return count;\n  };\n}\n\n/**\n * One `ta.cross(a, b)` call site, rules of `ta.cross`: the site keeps the side of the last call where `a` was\n * strictly above or strictly below `b` (none before such a call; equal values and na arguments do not change it),\n * and is true when the arguments are strictly on the other side. False with an na argument.\n */\nexport function cross(): (a: number, b: number) => boolean {\n  let side = 0; // -1: last strictly below, 1: last strictly above, 0: none yet\n  return (a, b) => {\n    if (Number.isNaN(a) || Number.isNaN(b)) return false;\n    const result = (side < 0 && a > b) || (side > 0 && a < b);\n    if (a < b) side = -1;\n    else if (a > b) side = 1;\n    return result;\n  };\n}\n\n/** The values a ta.highest / ta.lowest / ta.pivothigh call site keeps: the non-na values of its calls, one per bar. */\nclass KeptCalls {\n  readonly values: number[] = [];\n  readonly bars: number[] = [];\n\n  /** Keeps a non-na value; a later call on the same bar (a loop) replaces the value of that bar. */\n  add(barIndex: number, value: number): void {\n    if (Number.isNaN(value)) return;\n    const last = this.values.length - 1;\n    if (last >= 0 && this.bars[last] === barIndex) this.values[last] = value;\n    else {\n      this.values.push(value);\n      this.bars.push(barIndex);\n    }\n  }\n\n  /** Position of the best of the last `count` kept values (the newest one on ties), -1 when there is none. */\n  best(count: number, isLowest: boolean): number {\n    const last = this.values.length - 1;\n    if (last < 0 || !(count >= 1)) return -1;\n    let best = last;\n    for (let k = last - 1; k >= 0 && k > last - count; k--) {\n      if (isLowest ? this.values[k]! < this.values[best]! : this.values[k]! > this.values[best]!) best = k;\n    }\n    return best;\n  }\n}\n\n/** One `ta.lowest` / `ta.highest` / `ta.lowestbars` / `ta.highestbars` call site; rules in {@link lowestByBar}. */\nfunction extremeByBarSite(\n  isLowest: boolean,\n  offsets: boolean\n): (barIndex: number, value: number, length: number) => number {\n  const kept = new KeptCalls();\n  const name = (isLowest ? 'lowest' : 'highest') + (offsets ? 'bars' : '');\n  return (barIndex, value, length) => {\n    checkWindowLength(name, length, barIndex);\n    kept.add(barIndex, value);\n    const len = Math.trunc(length);\n    if (barIndex < len - 1) return NaN;\n    const best = kept.best(len, isLowest);\n    if (best < 0) return NaN;\n    return offsets ? -(barIndex - kept.bars[best]!) : kept.values[best]!;\n  };\n}\n\n/** {@link extremeByBarSite} called with `(value, length, barIndex?)`: without a bar index, every call is a new bar. */\nfunction extremeSite(isLowest: boolean): (value: number, length: number, barIndex?: number) => number {\n  const site = extremeByBarSite(isLowest, false);\n  let calls = 0;\n  return (value, length, barIndex) => site(barIndex ?? calls++, value, length);\n}\n\n/**\n * One `ta.lowest(source, length)` call site, called with `(value, length, barIndex?)`: the same site as\n * {@link lowestByBar} (same rules). Pass the bar index when the call does not run on every bar; without it every\n * call counts as one bar, which is right for a call on every bar (for example with a length that changes).\n *\n * @example\n * ```typescript\n * // Pine:  lowPrice = ta.lowest(close[1], lookback)   // lookback changes per bar\n * const lowPrice = callsite.lowest();\n * const out = closes.map((_, i) => lowPrice(i > 0 ? closes[i - 1]! : NaN, lookback[i]!));\n * ```\n */\nexport function lowest(): (value: number, length: number, barIndex?: number) => number {\n  return extremeSite(true);\n}\n\n/**\n * One `ta.highest(source, length)` call site, called with `(value, length, barIndex?)`. Same rules as\n * {@link lowest}.\n */\nexport function highest(): (value: number, length: number, barIndex?: number) => number {\n  return extremeSite(false);\n}\n\n/**\n * One `ta.lowest(source, length)` call site in a conditional block or a loop, called with\n * `(barIndex, value, length)` on the bars (and loop turns) where the Pine call runs. The length can change from one\n * call to the next.\n *\n * PineScript rules (measured in `if` blocks, ternaries, user functions and `for` loops, with constant lengths and\n * lengths that change, on sources with and without na):\n * - the call site keeps the non-na values it received, each with its bar; nothing is kept for a bar without a call\n *   or for an na value\n * - the result is na while `barIndex < length - 1` (by bar, not by call) and while no value was received\n * - otherwise it is the lowest of the last `length` kept values, or of all of them when there are fewer: the first\n *   call after bar `length - 1` gives its own value. A call with an na value also gives this result\n * - in a loop (several calls on one bar), a bar has one kept value: each call replaces the value of the earlier\n *   calls of that bar, so a call gives the lowest of its value and the values of the bars before\n *\n * Called on every bar, it equals `ta.lowest`.\n *\n * @example\n * ```typescript\n * // Pine:  lo = cond ? ta.lowest(low, 6) : na\n * const site = callsite.lowestByBar();\n * const lo = lows.map((v, i) => (cond[i] ? site(i, v, 6) : NaN));\n * ```\n */\nexport function lowestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(true, false);\n}\n\n/**\n * One `ta.highest(source, length)` call site in a conditional block or a loop, called with\n * `(barIndex, value, length)`. Same rules as {@link lowestByBar}.\n */\nexport function highestByBar(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(false, false);\n}\n\n/**\n * One `ta.lowestbars(source, length)` call site in a conditional block or a loop, called with\n * `(barIndex, value, length)`: the offset (0 or negative) from this bar to the bar of the lowest of the last `length`\n * kept values, the newest one on equal values. The values are kept as in {@link lowestByBar}; the offset counts\n * bars, not calls, so it can be below `-(length - 1)`.\n *\n * @example\n * ```typescript\n * // Pine:  off = cond ? ta.lowestbars(low, 10) : na\n * const site = callsite.lowestbars();\n * const off = lows.map((v, i) => (cond[i] ? site(i, v, 10) : NaN));\n * ```\n */\nexport function lowestbars(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(true, true);\n}\n\n/**\n * One `ta.highestbars(source, length)` call site in a conditional block or a loop, called with\n * `(barIndex, value, length)`. Same rules as {@link lowestbars}.\n */\nexport function highestbars(): (barIndex: number, value: number, length: number) => number {\n  return extremeByBarSite(false, true);\n}\n\n/** One `ta.pivothigh` / `ta.pivotlow` call site; rules in {@link pivothigh}. */\nfunction pivotSite(isLowest: boolean): (barIndex: number, value: number, leftbars: number, rightbars: number) => number {\n  const kept = new KeptCalls();\n  return (barIndex, value, leftbars, rightbars) => {\n    kept.add(barIndex, value);\n    const left = Math.trunc(leftbars);\n    const right = Math.trunc(rightbars);\n    if (!(barIndex >= left + right)) return NaN;\n    const best = kept.best(left + right + 1, isLowest);\n    return best >= 0 && kept.bars[best] === barIndex - right ? kept.values[best]! : NaN;\n  };\n}\n\n/**\n * One `ta.pivothigh(source, leftbars, rightbars)` call site in a conditional block, called with\n * `(barIndex, value, leftbars, rightbars)` on the bars where the Pine call runs. The lengths can change from one call\n * to the next (the lengths of the current call are used).\n *\n * PineScript rules (measured in `if` blocks and ternaries, and on sources with na):\n * - the call site keeps the non-na values it received, each with its bar\n * - on a call it takes the last `leftbars + rightbars + 1` kept values (all of them when there are fewer) and finds\n *   the highest, the newest one on equal values\n * - there is a pivot only when that value is on the bar `rightbars` BARS back (by bar index, not by call); the\n *   result is its value, na otherwise and before bar `leftbars + rightbars`\n *\n * Called on every bar, it equals `ta.pivothigh`.\n *\n * @example\n * ```typescript\n * // Pine:  ph = useFilter ? ta.pivothigh(src, 5, 5) : na\n * const site = callsite.pivothigh();\n * const ph = src.map((v, i) => (useFilter[i] ? site(i, v, 5, 5) : NaN));\n * ```\n */\nexport function pivothigh(): (barIndex: number, value: number, leftbars: number, rightbars: number) => number {\n  return pivotSite(false);\n}\n\n/**\n * One `ta.pivotlow(source, leftbars, rightbars)` call site in a conditional block, called with\n * `(barIndex, value, leftbars, rightbars)`. Same rules as {@link pivothigh} (the lowest value).\n */\nexport function pivotlow(): (barIndex: number, value: number, leftbars: number, rightbars: number) => number {\n  return pivotSite(true);\n}\n\n/**\n * One `ta.linreg(source, length, offset)` call site in a conditional block, called with\n * `(barIndex, value, length, offset)` on the bars where the Pine call runs.\n *\n * PineScript rules (measured): `ta.linreg` keeps the values it receives in a ring of `length + 1` slots indexed by the\n * bar index, filled with 0 at the start and written only on the bars where it is called. The window is read from the\n * ring for the last `length` bars: a bar before the first call counts as 0, and a bar without a call holds the value of\n * the call `length + 1` bars earlier (0 if there was none). The result is na before bar `length - 1`. Called on every\n * bar, it equals `ta.linreg`.\n *\n * @example\n * ```typescript\n * // Pine:  if bar_index >= 20\n * //            a := ta.linreg(close, 10, 0)\n * const site = callsite.linreg();\n * const a = closes.map((c, i) => (i >= 20 ? site(i, c, 10, 0) : NaN));\n * ```\n */\nexport function linreg(): (barIndex: number, value: number, length: number, offset?: number) => number {\n  let ring: number[] = [];\n  return (barIndex, value, length, offset = 0) => {\n    const len = Math.floor(length);\n    if (ring.length !== len + 1) ring = new Array<number>(len + 1).fill(0);\n    ring[barIndex % (len + 1)] = value;\n    if (barIndex < len - 1) return NaN;\n    const window = Array.from({ length: len }, (_, k) => ring[(barIndex - len + 1 + k) % (len + 1)]!);\n    return linregSeries(window, len, offset)[len - 1]!;\n  };\n}\n\n\n/**\n * One `math.sum` call site in a loop; rules in {@link sum}. With `squares`, it also keeps the running sum of the\n * squared values (for {@link stdev}). Returns `[sum, sumOfSquares]` (NaN when not kept).\n */\nfunction loopSumSite(\n  name: string,\n  squares: boolean\n): (barIndex: number, value: number, length: number) => [number, number] {\n  const running = new RunningSum();\n  const runningSq = new RunningSum();\n  let lastBar = NaN;\n  let pending = false;\n  return (barIndex, value, length) => {\n    const len = Math.floor(length);\n    checkSumLength(name === 'sum' ? 'math.sum' : `ta.${name}`, len, barIndex);\n    if (!(len >= 1)) throw new Error(`callsite.${name}: length must be at least 1 (got ${length})`);\n    if (barIndex !== lastBar) {\n      if (pending) {\n        running.commit();\n        if (squares) runningSq.commit();\n      }\n      pending = false;\n      lastBar = barIndex;\n    }\n    if (isNa(value)) {\n      pending = false;\n      return [running.stepNa(len), squares ? runningSq.stepNa(len) : NaN];\n    }\n    const x = value;\n    const out: [number, number] = [running.step(x, len), squares ? runningSq.step(x * x, len) : NaN];\n    pending = true;\n    return out;\n  };\n}\n\n/**\n * One `math.sum(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on\n * each call.\n *\n * PineScript rules (measured on calls in loops, 1 to 3 calls per bar, and bars without a call):\n * - the call site keeps one history value per bar: the value of its last call on that bar\n * - every call on a bar starts from the state of the earlier bars, so it gives the sum of its value and the last\n *   `length - 1` kept values; the last call of the bar is the one kept for the later bars\n * - the length can change from one call to the next (also on the same bar): each call first moves the kept sum to\n *   its own length as `math.sum` with a series length does (Kahan steps of the raw values)\n * - a bar without a call is not in the history (as a call in an `if` block)\n * - the sum is the same compensated running sum as `math.sum` (bit for bit)\n *\n * An na value is skipped as in `math.sum` (it returns the sum of the last `length` earlier values); when it is the\n * last call of a bar, the bar is not in the history (not measured).\n *\n * @example\n * ```typescript\n * // Pine:  for i = 0 to 2\n * //            s = math.sum(close * (1 + 0.01 * i), 7)\n * const site = callsite.sum();\n * for (let b = 0; b < closes.length; b++) {\n *   for (let i = 0; i <= 2; i++) {\n *     const s = site(b, closes[b]! * (1 + 0.01 * i), 7);\n *   }\n * }\n * ```\n */\nexport function sum(): (barIndex: number, value: number, length: number) => number {\n  const site = loopSumSite('sum', false);\n  return (barIndex, value, length) => site(barIndex, value, length)[0];\n}\n\n/**\n * One `ta.sma(source, length)` call site inside a `for` / `while` loop, called with `(barIndex, value, length)` on\n * each call: {@link sum} divided by the length (same rules).\n *\n * @example\n * ```typescript\n * // Pine:  evaluate(ratio) => ta.sma(gann(ratio), n)   // called once per ratio in a while loop\n * const site = callsite.sma();\n * for (let b = 0; b < closes.length; b++) {\n *   for (const ratio of ratios) {\n *     const avg = site(b, gann(b, ratio), n);\n *   }\n * }\n * ```\n */\nexport function sma(): (barIndex: number, value: number, length: number) => number {\n  const site = loopSumSite('sma', false);\n  return (barIndex, value, length) => site(barIndex, value, length)[0] / Math.floor(length);\n}\n\n/**\n * One `ta.stdev(source, length, biased)` call site inside a `for` / `while` loop, called with\n * `(barIndex, value, length, biased?)` on each call: the running sums of the values and of their squares follow the\n * rules of {@link sum}; the result is computed from them as `ta.stdev` (bit for bit).\n *\n * @example\n * ```typescript\n * // Pine:  for len in lengths\n * //            [mid, up, lo] = ta.bb(close, len, 2)\n * const avgSite = callsite.sma();\n * const devSite = callsite.stdev();\n * for (let b = 0; b < closes.length; b++) {\n *   for (const len of lengths) {\n *     const mid = avgSite(b, closes[b]!, len);\n *     const dev = devSite(b, closes[b]!, len);\n *   }\n * }\n * ```\n */\nexport function stdev(): (barIndex: number, value: number, length: number, biased?: boolean) => number {\n  const site = loopSumSite('stdev', true);\n  return (barIndex, value, length, biased = true) => {\n    const len = Math.floor(length);\n    const [s, sq] = site(barIndex, value, length);\n    const mean = s / len;\n    const variance = biased ? sq / len - mean * mean : sq / (len - 1) - (mean * s) / (len - 1);\n    if (!biased && len <= 1) return NaN;\n    return Number.isNaN(variance) ? NaN : variance > 0 ? Math.sqrt(variance) : 0;\n  };\n}\n\n/**\n * One `math.random(min, max, seed)` call site: PineScript keeps one generator per call site, so two call sites\n * with the same seed give the same sequence. Called with `(min?, max?)` once per bar.\n *\n * @example\n * ```typescript\n * // Pine: a = math.random(0, 1, 42), b = math.random(0, 1, 42)   // a == b on every bar\n * const a = callsite.random(42);\n * const b = callsite.random(42);\n * ```\n */\nexport function random(seed: number): (min?: number, max?: number) => number {\n  return seededRandom(seed);\n}\n"],
+  "mappings": "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",
   "names": ["linregSeries"]
 }

package/dist/cjs/drawing/registry.d.ts

@@ -8,6 +8,42 @@
  * - when a creation brings the count above `max_*_count + 5`, the oldest objects are deleted until
  *   `max_*_count` remain (default 50). Copies count as creations. Linefills follow the same rule with
  *   `max_lines_count`; lines deleted by this rule do not delete their linefills
+ * - the object that was just created is never deleted by this rule
+ * - an object that a `var` variable of the drawing type refers to is never deleted by this rule, and it still counts
+ *   (measured for lines, labels and boxes: with 9 held boxes and a maximum of 50, 9 held + 46 others stay; with 8
+ *   held lines and a maximum of 5, the 8 and the newest line stay). The protection starts on the bar after the
+ *   assignment: 12 `var` lines created on the first bar with a maximum of 5 lose the first 6. Only
+ *   the variable itself protects: an object in a `var` array, in a field of a user type or in a variable that got
+ *   another object or `na` later is deleted like any other. JavaScript has no `var` declaration to observe, so the
+ *   script says it: {@link varDrawing} (a variable), or {@link holdDrawing} / {@link releaseDrawing}
+ * - linefills have the limit of `max_lines_count` with another rule for the held ones (measured on one script, two
+ *   long runs): a fill is skipped when a `var` variable holds it or released it less than 5,000 bars ago (the bar
+ *   of {@link setDrawingBar}); when the count is still above the maximum + 5 after that, the oldest fills are
+ *   deleted until the maximum remain, the held ones too
+ * - the script deletes count (`line.delete`, `label.delete`, ...): each kind has a number `P` of deleted objects. A
+ *   delete adds 1; a creation first sets `P` to 0 when it is 5 or more (3 or more for polylines)
+ * - polylines use `P` on every bar: a creation cuts when the count is above `max_polylines_count + 5 + P`, down to
+ *   the maximum + `P`, and the polylines of the cut are added to `P`. A script that deletes and creates one polyline
+ *   per bar therefore sees the cut 0, 1 or 2 bars late
+ * - lines, labels and boxes use `P` on the last bar only, with its value at the start of that bar: there the cut is
+ *   above the maximum + 5 + `P`, down to the maximum + `P` (up to 4 more objects)
+ * - the last bar has rules of its own (measured from the count after each creation, on a closed and on an open last
+ *   bar): a cut deletes the objects of the bars before first, at most those (a line takes its linefills with it);
+ *   once none is left, a cut deletes objects of the last bar as on any bar. With 10 lines and a maximum of 10, 13
+ *   lines on the last bar leave these 13: the cut at the 16th line deletes the 10 old ones only. Lines, labels and
+ *   boxes: equal to PineScript, count after every operation and objects alive at the end, on 72 of 72 runs checked
+ *   after the rule was written (and 218 of 218 end states before)
+ * - polylines on the last bar: the `P` carried from the bar before is counted twice (the first creation adds it once
+ *   more, unless it sets `P` to 0), later creations do not set `P` to 0, and the polylines of the bars before that a
+ *   cut deletes are added to `P`. Once none is
+ *   left, `P` is at least the number of polylines of the bars before deleted on the last bar (by the count or by
+ *   the script) and a cut deletes polylines of the last bar: a script that deletes its 100 polylines and creates 200
+ *   on the last bar keeps them all (#176). Equal to PineScript for the polylines alive at the end on 271 of
+ *   281 probe runs; the count inside the bar can differ when the script deletes polylines of the last bar
+ *
+ * - a bar index (`xloc.bar_index`) more than 10,000 bars before the current bar stops the script (runtime error
+ *   RE10026) in `line.new`, `box.new`, `label.new`, `polyline.new` and the setters of x. The current bar is the one
+ *   of `eachBar` in a script run; a port with its own bar loop gives it with {@link setDrawingBar}
  *
  * The script API (`executeScript`) resets the registry at the start of every run and applies the
  * `max_*_count` values of `indicator()`. Outside a script run the registry is global to the module.
@@ -27,6 +63,54 @@ interface DrawingTypes {
 /** Default `max_lines_count`, `max_labels_count`, `max_boxes_count`, `max_polylines_count`. */
 export declare const DEFAULT_MAX_COUNT = 50;
 export type DrawingLimits = Partial<Record<Exclude<DrawingKind, 'linefill' | 'table'>, number>>;
+/**
+ * Marks an object as held by a `var` variable (PineScript `var line l = ...` or `l := line.new(...)` on a `var`
+ * variable): the maximum count never deletes it, and it still counts. Returns the object.
+ */
+export declare function holdDrawing<T extends object>(obj: T): T;
+/** The `var` variable no longer refers to the object (it got another object or `na`). */
+export declare function releaseDrawing(obj: object | null | undefined): void;
+/** A `var` variable of a drawing type: see {@link varDrawing}. */
+export interface DrawingVariable<T extends object> {
+    /** The object of the variable; setting it holds the new object and releases the one before */
+    value: T | undefined;
+}
+/**
+ * A PineScript `var` variable of a drawing type (`var line l = na`). The object it refers to is not deleted by the
+ * maximum count; assigning another object (or `undefined` for `na`) releases the one before.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  var line level = na
+ * //        level := line.new(bar_index, close, bar_index + 1, close)
+ * const level = varDrawing<Line>();
+ * level.value = line.new(i, close, i + 1, close);
+ * ```
+ */
+export declare function varDrawing<T extends object>(initial?: T): DrawingVariable<T>;
+/** Largest distance, in bars, of a bar index before the current bar (PineScript runtime error RE10026 above it). */
+export declare const MAX_DRAWING_BARS_BACK = 10000;
+/** Largest distance, in bars, of a bar index after the last bar of the data (PineScript runtime error RE10020 above it). */
+export declare const MAX_DRAWING_BARS_FORWARD = 500;
+/**
+ * Tells the drawing functions which bar is being calculated (`bar_index`), so that a bar index more than 10,000
+ * bars back throws as in PineScript; `null` turns the check off. `eachBar` of the script API calls it.
+ *
+ * The bar also dates the objects held by a `var` variable (protected from the next bar on). `last` says that it is
+ * the last bar of the data, which has rules of its own for the maximum count. `lastIndex` is the bar index of the
+ * last bar of the data (PineScript `last_bar_index`): with it, a bar index more than 500 bars after it throws, also
+ * on the bars before the last one (RE10020).
+ */
+export declare function setDrawingBar(barIndex: number | null, last?: boolean, lastIndex?: number): void;
+/**
+ * Throws the PineScript runtime error RE10026 when `x` is a bar index more than 10,000 bars before the current bar,
+ * and RE10020 when it is more than 500 bars after the last bar of the data (when {@link setDrawingBar} knows it).
+ * `method` and `variable` are the names of the PineScript message ("line.new", "x1").
+ *
+ * Returns `x`, truncated when it is a bar index: PineScript's x is an int (a box from 5537.94 starts on bar 5537,
+ * #176).
+ */
+export declare function checkBarIndex(method: string, variable: string, x: number, xloc: string | undefined): number;
 /** Records a new object and deletes the oldest objects of its kind when the count is too high. */
 export declare function register<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]): DrawingTypes[K];
 /** Deletes an object (no effect when it is already deleted). */

package/dist/cjs/drawing/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/drawing/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAErF,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;AAEvF,UAAU,YAAY;IACpB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;CACd;AAED,+FAA+F;AAC/F,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAIpC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAoChG,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAS9F;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAKjF;AAED,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAE/C;AAED,mEAAmE;AACnE,wBAAgB,GAAG,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE1E;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,SAAS,GAAE,aAAkB,GAAG,IAAI,CAQjE;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI,CAE/D"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/drawing/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAErF,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;AAEvF,UAAU,YAAY;IACpB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;CACd;AAED,+FAA+F;AAC/F,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAIpC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAkChG;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAOvD;AAED,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAKnE;AAgBD,kEAAkE;AAClE,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM;IAC/C,8FAA8F;IAC9F,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAY5E;AAED,oHAAoH;AACpH,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAC3C,4HAA4H;AAC5H,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAwB5C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,GAAE,OAAe,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAetG;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAiB3G;AAuDD,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAS9F;AA8BD,gEAAgE;AAChE,wBAAgB,MAAM,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CASjF;AAED,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAE/C;AAED,mEAAmE;AACnE,wBAAgB,GAAG,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE1E;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,SAAS,GAAE,aAAkB,GAAG,IAAI,CAejE;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI,CAE/D"}