pinets 0.1.34 → 0.2.1

package/dist/pinets.dev.cjs

@@ -7687,6 +7687,7 @@ class ScopeManager {
   paramIdCounter = 0;
   cacheIdCounter = 0;
   tempVarCounter = 0;
+  taCallIdCounter = 0;
   get nextParamIdArg() {
     return {
       type: "Identifier",
@@ -7699,6 +7700,12 @@ class ScopeManager {
       name: `'cache_${this.cacheIdCounter++}'`
     };
   }
+  getNextTACallId() {
+    return {
+      type: "Literal",
+      value: `_ta${this.taCallIdCounter++}`
+    };
+  }
   constructor() {
     this.pushScope("glb");
   }
@@ -7723,6 +7730,14 @@ class ScopeManager {
       this.rootParams.add(name);
     }
   }
+  removeContextBoundVar(name) {
+    if (this.contextBoundVars.has(name)) {
+      this.contextBoundVars.delete(name);
+      if (this.rootParams.has(name)) {
+        this.rootParams.delete(name);
+      }
+    }
+  }
   addArrayPatternElement(name) {
     this.arrayPatternElements.add(name);
   }
@@ -8369,38 +8384,46 @@ function transformReturnStatement(node, scopeManager) {
         return prop;
       });
     } else if (node.argument.type === "Identifier") {
-      const [scopedName, kind] = scopeManager.getVariable(node.argument.name);
-      node.argument = {
-        type: "MemberExpression",
-        object: {
+      transformIdentifier(node.argument, scopeManager);
+      if (node.argument.type === "Identifier") {
+        addArrayAccess(node.argument);
+      }
+    }
+    if (curScope === "fn") {
+      if (node.argument.type === "Identifier" && scopeManager.isContextBound(node.argument.name) && !scopeManager.isRootParam(node.argument.name)) {
+        node.argument = {
           type: "MemberExpression",
-          object: {
-            type: "Identifier",
-            name: CONTEXT_NAME
-          },
+          object: node.argument,
           property: {
-            type: "Identifier",
-            name: kind
+            type: "Literal",
+            value: 0
           },
-          computed: false
-        },
-        property: {
-          type: "Identifier",
-          name: scopedName
-        },
-        computed: false
-      };
-      node.argument = {
-        type: "MemberExpression",
-        object: node.argument,
-        property: {
-          type: "Literal",
-          value: 0
-        },
-        computed: true
-      };
-    }
-    if (curScope === "fn") {
+          computed: true
+        };
+      } else if (node.argument.type === "MemberExpression") {
+        if (node.argument.object.type === "Identifier" && scopeManager.isContextBound(node.argument.object.name) && !scopeManager.isRootParam(node.argument.object.name)) {
+          if (!node.argument._indexTransformed) {
+            transformArrayIndex(node.argument, scopeManager);
+            node.argument._indexTransformed = true;
+          }
+        }
+      } else if (node.argument.type === "BinaryExpression" || node.argument.type === "LogicalExpression" || node.argument.type === "ConditionalExpression" || node.argument.type === "CallExpression") {
+        recursive(node.argument, scopeManager, {
+          Identifier(node2, state) {
+            transformIdentifier(node2, state);
+            if (node2.type === "Identifier" && !node2._arrayAccessed) {
+              addArrayAccess(node2);
+              node2._arrayAccessed = true;
+            }
+          },
+          MemberExpression(node2) {
+            transformMemberExpression(node2, "", scopeManager);
+          },
+          CallExpression(node2, state) {
+            transformCallExpression(node2, state);
+          }
+        });
+      }
       node.argument = {
         type: "CallExpression",
         callee: {
@@ -8751,6 +8774,9 @@ function transformCallExpression(node, scopeManager, namespace) {
       }
       return transformFunctionArgument(arg, namespace2, scopeManager);
     });
+    if (namespace2 === "ta") {
+      node.arguments.push(scopeManager.getNextTACallId());
+    }
     node._transformed = true;
   } else if (node.callee && node.callee.type === "Identifier") {
     node.arguments = node.arguments.map((arg) => {
@@ -8791,9 +8817,11 @@ function transformCallExpression(node, scopeManager, namespace) {
   });
 }
 function transformFunctionDeclaration(node, scopeManager) {
+  const boundParamNames = [];
   node.params.forEach((param) => {
     if (param.type === "Identifier") {
       scopeManager.addContextBoundVar(param.name, false);
+      boundParamNames.push(param.name);
     }
   });
   if (node.body && node.body.type === "BlockStatement") {
@@ -9141,11 +9169,40 @@ function transpile(fn) {
       transformIfStatement(node, state, c);
     }
   });
+  transformEqualityChecks(ast);
   const transformedCode = generate(ast);
   const _wraperFunction = new Function("", `return ${transformedCode}`);
   return _wraperFunction(this);
 }
+function transformEqualityChecks(ast) {
+  simple(ast, {
+    BinaryExpression(node) {
+      if (node.operator === "==" || node.operator === "===") {
+        const leftOperand = node.left;
+        const rightOperand = node.right;
+        Object.assign(node, {
+          type: "CallExpression",
+          callee: {
+            type: "MemberExpression",
+            object: {
+              type: "Identifier",
+              name: "$.math"
+            },
+            property: {
+              type: "Identifier",
+              name: "__eq"
+            },
+            computed: false
+          },
+          arguments: [leftOperand, rightOperand],
+          _transformed: true
+        });
+      }
+    }
+  });
+}
 
+const MAX_PERIODS = 5e3;
 class PineTS {
   constructor(source, tickerId, timeframe, limit, sDate, eDate) {
     this.source = source;
@@ -9156,7 +9213,7 @@ class PineTS {
     this.eDate = eDate;
     this._readyPromise = new Promise((resolve) => {
       this.loadMarketData(source, tickerId, timeframe, limit, sDate, eDate).then((data) => {
-        const marketData = data.reverse();
+        const marketData = data.slice(0, MAX_PERIODS);
         this._periods = marketData.length;
         this.data = marketData;
         const _open = marketData.map((d) => d.open);
@@ -9234,19 +9291,28 @@ class PineTS {
     context.useTACache = useTACache;
     const transformer = transpile.bind(this);
     let transpiledFn = transformer(pineTSCode);
+    context.data.close = [];
+    context.data.open = [];
+    context.data.high = [];
+    context.data.low = [];
+    context.data.volume = [];
+    context.data.hl2 = [];
+    context.data.hlc3 = [];
+    context.data.ohlc4 = [];
+    context.data.openTime = [];
+    context.data.closeTime = [];
     const contextVarNames = ["const", "var", "let", "params"];
-    for (let i = this._periods - n, idx = n - 1; i < this._periods; i++, idx--) {
+    for (let i = this._periods - n; i < this._periods; i++) {
       context.idx = i;
-      context.data.close = this.close.slice(idx);
-      context.data.open = this.open.slice(idx);
-      context.data.high = this.high.slice(idx);
-      context.data.low = this.low.slice(idx);
-      context.data.volume = this.volume.slice(idx);
-      context.data.hl2 = this.hl2.slice(idx);
-      context.data.hlc3 = this.hlc3.slice(idx);
-      context.data.ohlc4 = this.ohlc4.slice(idx);
-      context.data.openTime = this.openTime.slice(idx);
-      context.data.closeTime = this.closeTime.slice(idx);
+      context.data.close.unshift(this.close[i]);
+      context.data.open.unshift(this.open[i]);
+      context.data.high.unshift(this.high[i]);
+      context.data.low.unshift(this.low[i]);
+      context.data.volume.unshift(this.volume[i]);
+      context.data.hl2.unshift(this.hl2[i]);
+      context.data.hlc3.unshift(this.hlc3[i]);
+      context.data.ohlc4.unshift(this.ohlc4[i]);
+      context.data.openTime.unshift(this.openTime[i]);
       const result = await transpiledFn(context);
       if (typeof result === "object") {
         if (typeof context.result !== "object") {
@@ -9427,6 +9493,9 @@ class PineMath {
       return this.context.params[name];
     }
   }
+  __eq(a, b) {
+    return Math.abs(a - b) < 1e-8;
+  }
   abs(source) {
     return Math.abs(source[0]);
   }
@@ -9587,141 +9656,532 @@ class TechnicalAnalysis {
       return this.context.params[name];
     }
   }
-  ema(source, _period) {
+  ema(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const result = ema(source.slice(0).reverse(), period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
-  }
-  sma(source, _period, _cacheId) {
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `ema_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { prevEma: null, initSum: 0, initCount: 0 };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    if (state.initCount < period) {
+      state.initSum += currentValue;
+      state.initCount++;
+      if (state.initCount === period) {
+        state.prevEma = state.initSum / period;
+        return this.context.precision(state.prevEma);
+      }
+      return NaN;
+    }
+    const alpha = 2 / (period + 1);
+    const ema2 = currentValue * alpha + state.prevEma * (1 - alpha);
+    state.prevEma = ema2;
+    return this.context.precision(ema2);
+  }
+  sma(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const reversedSource = source.slice(0).reverse();
-    if (this.context.useTACache && _cacheId) {
-      if (!this.context.cache[_cacheId]) {
-        this.context.cache[_cacheId] = {};
-      }
-      const cacheObj = this.context.cache[_cacheId];
-      if (cacheObj) {
-        const result2 = sma_cache(reversedSource, period, cacheObj);
-        const idx2 = this.context.idx;
-        return this.context.precision(result2[idx2]);
-      }
-    }
-    const result = sma(reversedSource, period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
-  }
-  vwma(source, _period) {
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `sma_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [], sum: 0 };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0] || 0;
+    state.window.unshift(currentValue);
+    state.sum += currentValue;
+    if (state.window.length < period) {
+      return NaN;
+    }
+    if (state.window.length > period) {
+      const oldValue = state.window.pop();
+      state.sum -= oldValue;
+    }
+    const sma2 = state.sum / period;
+    return this.context.precision(sma2);
+  }
+  vwma(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const volume = this.context.data.volume;
-    const result = vwma(source.slice(0).reverse(), volume.slice(0).reverse(), period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `vwma_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [], volumeWindow: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    const currentVolume = this.context.data.volume[0];
+    state.window.unshift(currentValue);
+    state.volumeWindow.unshift(currentVolume);
+    if (state.window.length < period) {
+      return NaN;
+    }
+    if (state.window.length > period) {
+      state.window.pop();
+      state.volumeWindow.pop();
+    }
+    let sumVolPrice = 0;
+    let sumVol = 0;
+    for (let i = 0; i < period; i++) {
+      sumVolPrice += state.window[i] * state.volumeWindow[i];
+      sumVol += state.volumeWindow[i];
+    }
+    const vwma2 = sumVolPrice / sumVol;
+    return this.context.precision(vwma2);
   }
-  wma(source, _period) {
+  wma(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const result = wma(source.slice(0).reverse(), period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `wma_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length < period) {
+      return NaN;
+    }
+    if (state.window.length > period) {
+      state.window.pop();
+    }
+    let numerator = 0;
+    let denominator = 0;
+    for (let i = 0; i < period; i++) {
+      const weight = period - i;
+      numerator += state.window[i] * weight;
+      denominator += weight;
+    }
+    const wma2 = numerator / denominator;
+    return this.context.precision(wma2);
   }
-  hma(source, _period) {
+  hma(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const result = hma(source.slice(0).reverse(), period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    const halfPeriod = Math.floor(period / 2);
+    const sqrtPeriod = Math.floor(Math.sqrt(period));
+    const wma1 = this.wma(source, halfPeriod, _callId ? `${_callId}_wma1` : void 0);
+    const wma2 = this.wma(source, period, _callId ? `${_callId}_wma2` : void 0);
+    if (isNaN(wma1) || isNaN(wma2)) {
+      return NaN;
+    }
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `hma_raw_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = [];
+    }
+    const rawHma = 2 * wma1 - wma2;
+    this.context.taState[stateKey].unshift(rawHma);
+    const hmaStateKey = _callId ? `${_callId}_hma_final` : `hma_final_${period}`;
+    if (!this.context.taState[hmaStateKey]) {
+      this.context.taState[hmaStateKey] = { window: [] };
+    }
+    const state = this.context.taState[hmaStateKey];
+    state.window.unshift(rawHma);
+    if (state.window.length < sqrtPeriod) {
+      return NaN;
+    }
+    if (state.window.length > sqrtPeriod) {
+      state.window.pop();
+    }
+    let numerator = 0;
+    let denominator = 0;
+    for (let i = 0; i < sqrtPeriod; i++) {
+      const weight = sqrtPeriod - i;
+      numerator += state.window[i] * weight;
+      denominator += weight;
+    }
+    const hma2 = numerator / denominator;
+    return this.context.precision(hma2);
   }
-  rma(source, _period) {
+  rma(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const result = rma(source.slice(0).reverse(), period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
-  }
-  change(source, _length = 1) {
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `rma_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { prevRma: null, initSum: 0, initCount: 0 };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0] || 0;
+    if (state.initCount < period) {
+      state.initSum += currentValue;
+      state.initCount++;
+      if (state.initCount === period) {
+        state.prevRma = state.initSum / period;
+        return this.context.precision(state.prevRma);
+      }
+      return NaN;
+    }
+    const alpha = 1 / period;
+    const rma2 = currentValue * alpha + state.prevRma * (1 - alpha);
+    state.prevRma = rma2;
+    return this.context.precision(rma2);
+  }
+  change(source, _length = 1, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = change(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `change_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length <= length) {
+      return NaN;
+    }
+    if (state.window.length > length + 1) {
+      state.window.pop();
+    }
+    const change2 = currentValue - state.window[length];
+    return this.context.precision(change2);
   }
-  rsi(source, _period) {
+  rsi(source, _period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const result = rsi(source.slice(0).reverse(), period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `rsi_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = {
+        prevValue: null,
+        avgGain: 0,
+        avgLoss: 0,
+        initGains: [],
+        initLosses: []
+      };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    if (state.prevValue !== null) {
+      const diff = currentValue - state.prevValue;
+      const gain = diff > 0 ? diff : 0;
+      const loss = diff < 0 ? -diff : 0;
+      if (state.initGains.length < period) {
+        state.initGains.push(gain);
+        state.initLosses.push(loss);
+        if (state.initGains.length === period) {
+          state.avgGain = state.initGains.reduce((a, b) => a + b, 0) / period;
+          state.avgLoss = state.initLosses.reduce((a, b) => a + b, 0) / period;
+          state.prevValue = currentValue;
+          const rsi3 = state.avgLoss === 0 ? 100 : 100 - 100 / (1 + state.avgGain / state.avgLoss);
+          return this.context.precision(rsi3);
+        }
+        state.prevValue = currentValue;
+        return NaN;
+      }
+      state.avgGain = (state.avgGain * (period - 1) + gain) / period;
+      state.avgLoss = (state.avgLoss * (period - 1) + loss) / period;
+      const rsi2 = state.avgLoss === 0 ? 100 : 100 - 100 / (1 + state.avgGain / state.avgLoss);
+      state.prevValue = currentValue;
+      return this.context.precision(rsi2);
+    }
+    state.prevValue = currentValue;
+    return NaN;
   }
-  atr(_period) {
+  atr(_period, _callId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const high = this.context.data.high.slice().reverse();
-    const low = this.context.data.low.slice().reverse();
-    const close = this.context.data.close.slice().reverse();
-    const result = atr(high, low, close, period);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `atr_${period}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = {
+        prevAtr: null,
+        initSum: 0,
+        initCount: 0,
+        prevClose: null
+      };
+    }
+    const state = this.context.taState[stateKey];
+    const high = this.context.data.high[0];
+    const low = this.context.data.low[0];
+    const close = this.context.data.close[0];
+    let tr;
+    if (state.prevClose !== null) {
+      const hl = high - low;
+      const hc = Math.abs(high - state.prevClose);
+      const lc = Math.abs(low - state.prevClose);
+      tr = Math.max(hl, hc, lc);
+    } else {
+      tr = high - low;
+    }
+    state.prevClose = close;
+    if (state.initCount < period) {
+      state.initSum += tr;
+      state.initCount++;
+      if (state.initCount === period) {
+        state.prevAtr = state.initSum / period;
+        return this.context.precision(state.prevAtr);
+      }
+      return NaN;
+    }
+    const atr2 = (state.prevAtr * (period - 1) + tr) / period;
+    state.prevAtr = atr2;
+    return this.context.precision(atr2);
   }
-  mom(source, _length) {
+  mom(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = mom(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    return this.change(source, length);
   }
-  roc(source, _length) {
+  roc(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = roc(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `roc_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length <= length) {
+      return NaN;
+    }
+    if (state.window.length > length + 1) {
+      state.window.pop();
+    }
+    const prevValue = state.window[length];
+    const roc2 = (currentValue - prevValue) / prevValue * 100;
+    return this.context.precision(roc2);
   }
-  dev(source, _length) {
+  dev(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = dev(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `dev_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [], sum: 0 };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0] || 0;
+    state.window.unshift(currentValue);
+    state.sum += currentValue;
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      const oldValue = state.window.pop();
+      state.sum -= oldValue;
+    }
+    const mean = state.sum / length;
+    let sumDeviation = 0;
+    for (let i = 0; i < length; i++) {
+      sumDeviation += Math.abs(state.window[i] - mean);
+    }
+    const dev2 = sumDeviation / length;
+    return this.context.precision(dev2);
   }
-  variance(source, _length) {
+  variance(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = variance(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `variance_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      state.window.pop();
+    }
+    let sum = 0;
+    let sumSquares = 0;
+    for (let i = 0; i < length; i++) {
+      sum += state.window[i];
+      sumSquares += state.window[i] * state.window[i];
+    }
+    const mean = sum / length;
+    const variance2 = sumSquares / length - mean * mean;
+    return this.context.precision(variance2);
   }
-  highest(source, _length) {
+  highest(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = highest(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `highest_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      state.window.pop();
+    }
+    const max = Math.max(...state.window.filter((v) => !isNaN(v)));
+    return this.context.precision(max);
   }
-  lowest(source, _length) {
+  lowest(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = lowest(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `lowest_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      state.window.pop();
+    }
+    const validValues = state.window.filter((v) => !isNaN(v) && v !== void 0);
+    const min = validValues.length > 0 ? Math.min(...validValues) : NaN;
+    return this.context.precision(min);
   }
-  median(source, _length) {
+  median(source, _length, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
-    const result = median(source.slice(0).reverse(), length);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `median_${length}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      state.window.pop();
+    }
+    const sorted = state.window.slice().sort((a, b) => a - b);
+    const mid = Math.floor(length / 2);
+    const median2 = length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    return this.context.precision(median2);
   }
-  stdev(source, _length, _bias = true) {
+  stdev(source, _length, _bias = true, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
     const bias = Array.isArray(_bias) ? _bias[0] : _bias;
-    const result = stdev(source.slice(0).reverse(), length, bias);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `stdev_${length}_${bias}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [], sum: 0 };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    state.sum += currentValue;
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      const oldValue = state.window.pop();
+      state.sum -= oldValue;
+    }
+    const mean = state.sum / length;
+    let sumSquaredDiff = 0;
+    for (let i = 0; i < length; i++) {
+      sumSquaredDiff += Math.pow(state.window[i] - mean, 2);
+    }
+    const divisor = bias ? length : length - 1;
+    const stdev2 = Math.sqrt(sumSquaredDiff / divisor);
+    return this.context.precision(stdev2);
   }
-  linreg(source, _length, _offset) {
+  linreg(source, _length, _offset, _callId) {
     const length = Array.isArray(_length) ? _length[0] : _length;
     const offset = Array.isArray(_offset) ? _offset[0] : _offset;
-    const result = linreg(source.slice(0).reverse(), length, offset);
-    const idx = this.context.idx;
-    return this.context.precision(result[idx]);
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = _callId || `linreg_${length}_${offset}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = { window: [] };
+    }
+    const state = this.context.taState[stateKey];
+    const currentValue = source[0];
+    state.window.unshift(currentValue);
+    if (state.window.length < length) {
+      return NaN;
+    }
+    if (state.window.length > length) {
+      state.window.pop();
+    }
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumXX = 0;
+    const n = length;
+    for (let j = 0; j < length; j++) {
+      const x = length - 1 - j;
+      const y = state.window[j];
+      sumX += x;
+      sumY += y;
+      sumXY += x * y;
+      sumXX += x * x;
+    }
+    const denominator = n * sumXX - sumX * sumX;
+    if (denominator === 0) {
+      return NaN;
+    }
+    const slope = (n * sumXY - sumX * sumY) / denominator;
+    const intercept = (sumY - slope * sumX) / n;
+    const linRegValue = intercept + slope * (length - 1 - offset);
+    return this.context.precision(linRegValue);
   }
-  supertrend(_factor, _atrPeriod) {
+  supertrend(_factor, _atrPeriod, _callId) {
     const factor = Array.isArray(_factor) ? _factor[0] : _factor;
     const atrPeriod = Array.isArray(_atrPeriod) ? _atrPeriod[0] : _atrPeriod;
-    const high = this.context.data.high.slice().reverse();
-    const low = this.context.data.low.slice().reverse();
-    const close = this.context.data.close.slice().reverse();
-    const [supertrend, direction] = calculateSupertrend(high, low, close, factor, atrPeriod);
-    const idx = this.context.idx;
-    return [[this.context.precision(supertrend[idx]), direction[idx]]];
+    if (!this.context.taState) this.context.taState = {};
+    const stateKey = `supertrend_${factor}_${atrPeriod}`;
+    if (!this.context.taState[stateKey]) {
+      this.context.taState[stateKey] = {
+        prevUpperBand: null,
+        prevLowerBand: null,
+        prevSupertrend: null,
+        prevDirection: null
+      };
+    }
+    const state = this.context.taState[stateKey];
+    const high = this.context.data.high[0];
+    const low = this.context.data.low[0];
+    const close = this.context.data.close[0];
+    const atrValue = this.atr(atrPeriod, _callId ? `${_callId}_atr` : void 0);
+    if (isNaN(atrValue)) {
+      return [[NaN, 0]];
+    }
+    const hl2 = (high + low) / 2;
+    let upperBand = hl2 + factor * atrValue;
+    let lowerBand = hl2 - factor * atrValue;
+    if (state.prevUpperBand !== null) {
+      if (upperBand < state.prevUpperBand || this.context.data.close[1] > state.prevUpperBand) {
+        upperBand = upperBand;
+      } else {
+        upperBand = state.prevUpperBand;
+      }
+      if (lowerBand > state.prevLowerBand || this.context.data.close[1] < state.prevLowerBand) {
+        lowerBand = lowerBand;
+      } else {
+        lowerBand = state.prevLowerBand;
+      }
+    }
+    let direction;
+    let supertrend;
+    if (state.prevSupertrend === null) {
+      direction = close <= upperBand ? -1 : 1;
+      supertrend = direction === -1 ? upperBand : lowerBand;
+    } else {
+      if (state.prevSupertrend === state.prevUpperBand) {
+        if (close > upperBand) {
+          direction = 1;
+          supertrend = lowerBand;
+        } else {
+          direction = -1;
+          supertrend = upperBand;
+        }
+      } else {
+        if (close < lowerBand) {
+          direction = -1;
+          supertrend = upperBand;
+        } else {
+          direction = 1;
+          supertrend = lowerBand;
+        }
+      }
+    }
+    state.prevUpperBand = upperBand;
+    state.prevLowerBand = lowerBand;
+    state.prevSupertrend = supertrend;
+    state.prevDirection = direction;
+    return [[this.context.precision(supertrend), direction]];
   }
   crossover(source1, source2) {
     const current1 = Array.isArray(source1) ? source1[0] : source1;
@@ -9762,344 +10222,6 @@ class TechnicalAnalysis {
     return this.context.precision(result[idx]);
   }
 }
-function atr(high, low, close, period) {
-  const tr = new Array(high.length);
-  tr[0] = high[0] - low[0];
-  for (let i = 1; i < high.length; i++) {
-    const hl = high[i] - low[i];
-    const hc = Math.abs(high[i] - close[i - 1]);
-    const lc = Math.abs(low[i] - close[i - 1]);
-    tr[i] = Math.max(hl, hc, lc);
-  }
-  const atr2 = new Array(high.length).fill(NaN);
-  let sum = 0;
-  for (let i = 0; i < period; i++) {
-    sum += tr[i];
-  }
-  atr2[period - 1] = sum / period;
-  for (let i = period; i < tr.length; i++) {
-    atr2[i] = (atr2[i - 1] * (period - 1) + tr[i]) / period;
-  }
-  return atr2;
-}
-function ema(source, period) {
-  const result = new Array(source.length).fill(NaN);
-  const alpha = 2 / (period + 1);
-  let sum = 0;
-  for (let i = 0; i < period; i++) {
-    sum += source[i] || 0;
-  }
-  result[period - 1] = sum / period;
-  for (let i = period; i < source.length; i++) {
-    result[i] = source[i] * alpha + result[i - 1] * (1 - alpha);
-  }
-  return result;
-}
-function rsi(source, period) {
-  const result = new Array(source.length).fill(NaN);
-  const gains = new Array(source.length).fill(0);
-  const losses = new Array(source.length).fill(0);
-  for (let i = 1; i < source.length; i++) {
-    const diff = source[i] - source[i - 1];
-    gains[i] = diff > 0 ? diff : 0;
-    losses[i] = diff < 0 ? -diff : 0;
-  }
-  let avgGain = 0;
-  let avgLoss = 0;
-  for (let i = 1; i <= period; i++) {
-    avgGain += gains[i];
-    avgLoss += losses[i];
-  }
-  avgGain /= period;
-  avgLoss /= period;
-  result[period] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
-  for (let i = period + 1; i < source.length; i++) {
-    avgGain = (avgGain * (period - 1) + gains[i]) / period;
-    avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
-    result[i] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
-  }
-  return result;
-}
-function rma(source, period) {
-  const result = new Array(source.length).fill(NaN);
-  const alpha = 1 / period;
-  let sum = 0;
-  for (let i = 0; i < period; i++) {
-    sum += source[i] || 0;
-  }
-  result[period - 1] = sum / period;
-  for (let i = period; i < source.length; i++) {
-    const currentValue = source[i] || 0;
-    result[i] = currentValue * alpha + result[i - 1] * (1 - alpha);
-  }
-  return result;
-}
-function sma_cache(source, period, cacheObj) {
-  const result = cacheObj.previousResult || new Array(source.length).fill(NaN);
-  const lastProcessedIndex = cacheObj.lastProcessedIndex || -1;
-  let previousSum = cacheObj.previousSum || 0;
-  if (lastProcessedIndex === -1 || source.length !== lastProcessedIndex + 1) {
-    previousSum = 0;
-    for (let i = 0; i < period; i++) {
-      previousSum += source[i] || 0;
-    }
-    result[period - 1] = previousSum / period;
-    for (let i = 0; i < period - 1; i++) {
-      result[i] = NaN;
-    }
-    for (let i = period; i < source.length; i++) {
-      previousSum = previousSum - (source[i - period] || 0) + (source[i] || 0);
-      result[i] = previousSum / period;
-    }
-  } else if (source.length === lastProcessedIndex + 2) {
-    const newIndex = source.length - 1;
-    previousSum = previousSum - (source[newIndex - period] || 0) + (source[newIndex] || 0);
-    result[newIndex] = previousSum / period;
-  } else {
-    return sma(source, period);
-  }
-  cacheObj.previousSum = previousSum;
-  cacheObj.lastProcessedIndex = source.length - 1;
-  cacheObj.previousResult = result;
-  return result;
-}
-function sma(source, period) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = period - 1; i < source.length; i++) {
-    let sum = 0;
-    for (let j = 0; j < period; j++) {
-      sum += source[i - j] || 0;
-    }
-    result[i] = sum / period;
-  }
-  return result;
-}
-function vwma(source, volume, period) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = period - 1; i < source.length; i++) {
-    let sumVol = 0;
-    let sumVolPrice = 0;
-    for (let j = 0; j < period; j++) {
-      sumVol += volume[i - j];
-      sumVolPrice += source[i - j] * volume[i - j];
-    }
-    result[i] = sumVolPrice / sumVol;
-  }
-  return result;
-}
-function hma(source, period) {
-  const halfPeriod = Math.floor(period / 2);
-  const wma1 = wma(source, halfPeriod);
-  const wma2 = wma(source, period);
-  const rawHma = wma1.map((value, index) => 2 * value - wma2[index]);
-  const sqrtPeriod = Math.floor(Math.sqrt(period));
-  const result = wma(rawHma, sqrtPeriod);
-  return result;
-}
-function wma(source, period) {
-  const result = new Array(source.length);
-  for (let i = period - 1; i < source.length; i++) {
-    let numerator = 0;
-    let denominator = 0;
-    for (let j = 0; j < period; j++) {
-      numerator += source[i - j] * (period - j);
-      denominator += period - j;
-    }
-    result[i] = numerator / denominator;
-  }
-  for (let i = 0; i < period - 1; i++) {
-    result[i] = NaN;
-  }
-  return result;
-}
-function change(source, length = 1) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length; i < source.length; i++) {
-    result[i] = source[i] - source[i - length];
-  }
-  return result;
-}
-function mom(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length; i < source.length; i++) {
-    result[i] = source[i] - source[i - length];
-  }
-  return result;
-}
-function roc(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length; i < source.length; i++) {
-    result[i] = (source[i] - source[i - length]) / source[i - length] * 100;
-  }
-  return result;
-}
-function dev(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  const smaValues = sma(source, length);
-  for (let i = length - 1; i < source.length; i++) {
-    let sumDeviation = 0;
-    for (let j = 0; j < length; j++) {
-      sumDeviation += Math.abs(source[i - j] - smaValues[i]);
-    }
-    result[i] = sumDeviation / length;
-  }
-  return result;
-}
-function variance(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length - 1; i < source.length; i++) {
-    let sum = 0;
-    let sumSquares = 0;
-    for (let j = 0; j < length; j++) {
-      sum += source[i - j];
-      sumSquares += source[i - j] * source[i - j];
-    }
-    const mean = sum / length;
-    result[i] = sumSquares / length - mean * mean;
-  }
-  return result;
-}
-function highest(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length - 1; i < source.length; i++) {
-    let max = -Infinity;
-    for (let j = 0; j < length; j++) {
-      const value = source[i - j];
-      if (isNaN(value)) {
-        max = max === -Infinity ? NaN : max;
-      } else {
-        max = Math.max(max, value);
-      }
-    }
-    result[i] = max;
-  }
-  return result;
-}
-function lowest(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length - 1; i < source.length; i++) {
-    let min = Infinity;
-    for (let j = 0; j < length; j++) {
-      const value = source[i - j];
-      if (isNaN(value) || value === void 0) {
-        min = min === Infinity ? NaN : min;
-      } else {
-        min = Math.min(min, value);
-      }
-    }
-    result[i] = min;
-  }
-  return result;
-}
-function median(source, length) {
-  const result = new Array(source.length).fill(NaN);
-  for (let i = length - 1; i < source.length; i++) {
-    const window = source.slice(i - length + 1, i + 1);
-    const sorted = window.slice().sort((a, b) => a - b);
-    const mid = Math.floor(length / 2);
-    result[i] = length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-  }
-  return result;
-}
-function stdev(source, length, biased = true) {
-  const result = new Array(source.length).fill(NaN);
-  const smaValues = sma(source, length);
-  for (let i = length - 1; i < source.length; i++) {
-    let sum = 0;
-    for (let j = 0; j < length; j++) {
-      sum += Math.pow(source[i - j] - smaValues[i], 2);
-    }
-    const divisor = biased ? length : length - 1;
-    result[i] = Math.sqrt(sum / divisor);
-  }
-  return result;
-}
-function linreg(source, length, offset) {
-  const size = source.length;
-  const output = new Array(size).fill(NaN);
-  for (let i = length - 1; i < size; i++) {
-    let sumX = 0;
-    let sumY = 0;
-    let sumXY = 0;
-    let sumXX = 0;
-    const n = length;
-    for (let j = 0; j < length; j++) {
-      const x = j;
-      const y = source[i - length + 1 + j];
-      sumX += x;
-      sumY += y;
-      sumXY += x * y;
-      sumXX += x * x;
-    }
-    const denominator = n * sumXX - sumX * sumX;
-    if (denominator === 0) {
-      output[i] = NaN;
-      continue;
-    }
-    const slope = (n * sumXY - sumX * sumY) / denominator;
-    const intercept = (sumY - slope * sumX) / n;
-    const linRegValue = intercept + slope * (length - 1 - offset);
-    output[i] = linRegValue;
-  }
-  return output;
-}
-function calculateSupertrend(high, low, close, factor, atrPeriod) {
-  const length = high.length;
-  const supertrend = new Array(length).fill(NaN);
-  const direction = new Array(length).fill(0);
-  const atrValues = atr(high, low, close, atrPeriod);
-  const upperBand = new Array(length).fill(NaN);
-  const lowerBand = new Array(length).fill(NaN);
-  for (let i = 0; i < length; i++) {
-    const hl2 = (high[i] + low[i]) / 2;
-    const atrValue = atrValues[i];
-    if (!isNaN(atrValue)) {
-      upperBand[i] = hl2 + factor * atrValue;
-      lowerBand[i] = hl2 - factor * atrValue;
-    }
-  }
-  let prevUpperBand = upperBand[atrPeriod];
-  let prevLowerBand = lowerBand[atrPeriod];
-  let prevSupertrend = close[atrPeriod] <= prevUpperBand ? prevUpperBand : prevLowerBand;
-  let prevDirection = close[atrPeriod] <= prevUpperBand ? -1 : 1;
-  supertrend[atrPeriod] = prevSupertrend;
-  direction[atrPeriod] = prevDirection;
-  for (let i = atrPeriod + 1; i < length; i++) {
-    let currentUpperBand = upperBand[i];
-    if (currentUpperBand < prevUpperBand || close[i - 1] > prevUpperBand) {
-      upperBand[i] = currentUpperBand;
-    } else {
-      upperBand[i] = prevUpperBand;
-    }
-    let currentLowerBand = lowerBand[i];
-    if (currentLowerBand > prevLowerBand || close[i - 1] < prevLowerBand) {
-      lowerBand[i] = currentLowerBand;
-    } else {
-      lowerBand[i] = prevLowerBand;
-    }
-    if (prevSupertrend === prevUpperBand) {
-      if (close[i] > upperBand[i]) {
-        direction[i] = 1;
-        supertrend[i] = lowerBand[i];
-      } else {
-        direction[i] = -1;
-        supertrend[i] = upperBand[i];
-      }
-    } else {
-      if (close[i] < lowerBand[i]) {
-        direction[i] = -1;
-        supertrend[i] = upperBand[i];
-      } else {
-        direction[i] = 1;
-        supertrend[i] = lowerBand[i];
-      }
-    }
-    prevUpperBand = upperBand[i];
-    prevLowerBand = lowerBand[i];
-    prevSupertrend = supertrend[i];
-  }
-  return [supertrend, direction];
-}
 function pivothigh(source, leftbars, rightbars) {
   const result = new Array(source.length).fill(NaN);
   for (let i = leftbars + rightbars; i < source.length; i++) {
@@ -10352,6 +10474,8 @@ class Context {
     ohlc4: []
   };
   cache = {};
+  taState = {};
+  // State for incremental TA calculations
   useTACache = false;
   NA = NaN;
   math;
@@ -10593,7 +10717,6 @@ class BinanceProvider {
         if (data.length === 0) break;
         allData = allData.concat(data);
         currentStart = data[data.length - 1].closeTime + 1;
-        if (data.length < 1e3) break;
       }
       return allData;
     } catch (error) {
@@ -10601,8 +10724,6 @@ class BinanceProvider {
       return [];
     }
   }
-  //TODO : allow querying more than 1000 klines
-  //TODO : immplement cache
   async getMarketData(tickerId, timeframe, limit, sDate, eDate) {
     try {
       const cacheParams = { tickerId, timeframe, limit, sDate, eDate };
@@ -10616,12 +10737,16 @@ class BinanceProvider {
         console.error(`Unsupported timeframe: ${timeframe}`);
         return [];
       }
-      let url = `${BINANCE_API_URL}/klines?symbol=${tickerId}&interval=${interval}`;
-      if (!limit && sDate && eDate) {
-        return this.getMarketDataInterval(tickerId, timeframe, sDate, eDate);
+      const needsPagination = this.shouldPaginate(timeframe, limit, sDate, eDate);
+      if (needsPagination && sDate && eDate) {
+        const allData = await this.getMarketDataInterval(tickerId, timeframe, sDate, eDate);
+        const result2 = limit ? allData.slice(0, limit) : allData;
+        this.cacheManager.set(cacheParams, result2);
+        return result2;
       }
+      let url = `${BINANCE_API_URL}/klines?symbol=${tickerId}&interval=${interval}`;
       if (limit) {
-        url += `&limit=${limit}`;
+        url += `&limit=${Math.min(limit, 1e3)}`;
       }
       if (sDate) {
         url += `&startTime=${sDate}`;
@@ -10657,6 +10782,36 @@ class BinanceProvider {
       return [];
     }
   }
+  /**
+   * Determines if pagination is needed based on the parameters
+   */
+  shouldPaginate(timeframe, limit, sDate, eDate) {
+    if (limit && limit > 1e3) {
+      return true;
+    }
+    if (sDate && eDate) {
+      const interval = timeframe_to_binance[timeframe.toUpperCase()];
+      const timeframeDurations = {
+        "1m": 60 * 1e3,
+        "3m": 3 * 60 * 1e3,
+        "5m": 5 * 60 * 1e3,
+        "15m": 15 * 60 * 1e3,
+        "30m": 30 * 60 * 1e3,
+        "1h": 60 * 60 * 1e3,
+        "2h": 2 * 60 * 60 * 1e3,
+        "4h": 4 * 60 * 60 * 1e3,
+        "1d": 24 * 60 * 60 * 1e3,
+        "1w": 7 * 24 * 60 * 60 * 1e3,
+        "1M": 30 * 24 * 60 * 60 * 1e3
+      };
+      const intervalDuration = timeframeDurations[interval];
+      if (intervalDuration) {
+        const requiredCandles = Math.ceil((eDate - sDate) / intervalDuration);
+        return requiredCandles > 1e3;
+      }
+    }
+    return false;
+  }
 }
 
 const Provider = {