pinets 0.1.1 → 0.1.33

package/dist/pinets.dev.cjs

@@ -1,6 +1,3 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
 
 /* 
  * Copyright (C) 2025 Alaa-eddine KADDOURI
@@ -17,7 +14,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */// This file was generated. Do not modify manually!
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// This file was generated. Do not modify manually!
 var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
 
 // This file was generated. Do not modify manually!
@@ -6146,22 +6148,7 @@ function parse(input, options) {
   return Parser.parse(input, options)
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */// AST walker module for ESTree compatible trees
+// AST walker module for ESTree compatible trees
 
 // A simple walk is one where you simply specify callbacks to be
 // called on specific nodes. The last two arguments are optional. A
@@ -6465,22 +6452,7 @@ base.MethodDefinition = base.PropertyDefinition = base.Property = function (node
   if (node.value) { c(node.value, st, "Expression"); }
 };
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */// Astring is a tiny and fast JavaScript code generator from an ESTree-compliant AST.
+// Astring is a tiny and fast JavaScript code generator from an ESTree-compliant AST.
 //
 // Astring was written by David Bonnet and released under an MIT license.
 //
@@ -7701,22 +7673,7 @@ function generate(node, options) {
   return state.output
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */class ScopeManager {
+class ScopeManager {
   scopes = [];
   scopeTypes = [];
   scopeCounts = /* @__PURE__ */ new Map();
@@ -7728,6 +7685,7 @@ function generate(node, options) {
   loopVarNames = /* @__PURE__ */ new Map();
   // Map original names to transformed names
   paramIdCounter = 0;
+  cacheIdCounter = 0;
   tempVarCounter = 0;
   get nextParamIdArg() {
     return {
@@ -7735,6 +7693,12 @@ function generate(node, options) {
       name: `'p${this.paramIdCounter++}'`
     };
   }
+  get nextCacheIdArg() {
+    return {
+      type: "Identifier",
+      name: `'cache_${this.cacheIdCounter++}'`
+    };
+  }
   constructor() {
     this.pushScope("glb");
   }
@@ -7818,6 +7782,7 @@ function generate(node, options) {
   }
 }
 
+//!!!Warning!!! this code is not clean, it was initially written as a PoC then used as transpiler for PineTS
 const CONTEXT_NAME = "$";
 const UNDEFINED_ARG = {
   type: "Identifier",
@@ -7914,6 +7879,9 @@ function transformMemberExpression(memberNode, originalParamName, scopeManager)
 }
 function transformVariableDeclaration(varNode, scopeManager) {
   varNode.declarations.forEach((decl) => {
+    if (decl.init.name == "na") {
+      decl.init.name = "NaN";
+    }
     const isContextProperty = decl.init && decl.init.type === "MemberExpression" && decl.init.object && (decl.init.object.name === "context" || decl.init.object.name === CONTEXT_NAME || decl.init.object.name === "context2");
     const isSubContextProperty = decl.init && decl.init.type === "MemberExpression" && decl.init.object?.object && (decl.init.object.object.name === "context" || decl.init.object.object.name === CONTEXT_NAME || decl.init.object.object.name === "context2");
     const isArrowFunction = decl.init && decl.init.type === "ArrowFunctionExpression";
@@ -8076,7 +8044,28 @@ function transformVariableDeclaration(varNode, scopeManager) {
       }
     };
     if (isArrayPatternVar) {
-      assignmentExpr.expression.right.object.property.name += "?.[0]";
+      assignmentExpr.expression.right.object.property.name += `?.[0][${decl.init.property.value}]`;
+      const obj = assignmentExpr.expression.right.object;
+      assignmentExpr.expression.right = {
+        type: "CallExpression",
+        callee: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: CONTEXT_NAME
+          },
+          property: {
+            type: "Identifier",
+            name: "init"
+          },
+          computed: false
+        },
+        arguments: [
+          targetVarRef,
+          obj
+          /*, decl.init.property.value*/
+        ]
+      };
     }
     if (isArrowFunction) {
       scopeManager.pushScope("fn");
@@ -8229,14 +8218,22 @@ function transformAssignmentExpression(node, scopeManager) {
     { parent: node.right, inNamespaceCall: false },
     {
       Identifier(node2, state, c) {
+        if (node2.name == "na") {
+          node2.name = "NaN";
+        }
         node2.parent = state.parent;
         transformIdentifier(node2, scopeManager);
         const isBinaryOperation = node2.parent && node2.parent.type === "BinaryExpression";
         const isConditional = node2.parent && node2.parent.type === "ConditionalExpression";
-        if (isConditional || isBinaryOperation) {
+        const isContextBound = scopeManager.isContextBound(node2.name) && !scopeManager.isRootParam(node2.name);
+        const hasArrayAccess = node2.parent && node2.parent.type === "MemberExpression" && node2.parent.computed && node2.parent.object === node2;
+        const isParamCall = node2.parent && node2.parent._isParamCall;
+        const isMemberExpression = node2.parent && node2.parent.type === "MemberExpression";
+        const isReserved = node2.name === "NaN";
+        if (isContextBound || isConditional || isBinaryOperation) {
           if (node2.type === "MemberExpression") {
             transformArrayIndex(node2, scopeManager);
-          } else if (node2.type === "Identifier") {
+          } else if (node2.type === "Identifier" && !isMemberExpression && !hasArrayAccess && !isParamCall && !isReserved) {
             addArrayAccess(node2);
           }
         }
@@ -8418,6 +8415,10 @@ function transformReturnStatement(node, scopeManager) {
 }
 function transformIdentifierForParam(node, scopeManager) {
   if (node.type === "Identifier") {
+    if (node.name === "na") {
+      node.name = "NaN";
+      return node;
+    }
     if (scopeManager.isLoopVariable(node.name)) {
       return node;
     }
@@ -8471,40 +8472,58 @@ function transformIdentifierForParam(node, scopeManager) {
   }
   return node;
 }
+function getParamFromUnaryExpression(node, scopeManager, namespace) {
+  const transformedArgument = transformOperand(node.argument, scopeManager, namespace);
+  const unaryExpr = {
+    type: "UnaryExpression",
+    operator: node.operator,
+    prefix: node.prefix,
+    argument: transformedArgument,
+    start: node.start,
+    end: node.end
+  };
+  return unaryExpr;
+}
 function transformOperand(node, scopeManager, namespace = "") {
-  if (node.type === "BinaryExpression") {
-    return transformBinaryExpression(node, scopeManager, namespace);
-  }
-  if (node.type === "MemberExpression") {
-    const transformedObject = node.object.type === "Identifier" ? transformIdentifierForParam(node.object, scopeManager) : node.object;
-    return {
-      type: "MemberExpression",
-      object: transformedObject,
-      property: node.property,
-      computed: node.computed
-    };
-  } else if (node.type === "Identifier") {
-    if (scopeManager.isLoopVariable(node.name)) {
-      return node;
+  switch (node.type) {
+    case "BinaryExpression": {
+      return getParamFromBinaryExpression(node, scopeManager, namespace);
     }
-    const isMemberExprProperty = node.parent && node.parent.type === "MemberExpression" && node.parent.property === node;
-    if (isMemberExprProperty) {
-      return node;
+    case "MemberExpression": {
+      const transformedObject = node.object.type === "Identifier" ? transformIdentifierForParam(node.object, scopeManager) : node.object;
+      return {
+        type: "MemberExpression",
+        object: transformedObject,
+        property: node.property,
+        computed: node.computed
+      };
+    }
+    case "Identifier": {
+      if (scopeManager.isLoopVariable(node.name)) {
+        return node;
+      }
+      const isMemberExprProperty = node.parent && node.parent.type === "MemberExpression" && node.parent.property === node;
+      if (isMemberExprProperty) {
+        return node;
+      }
+      const transformedObject = transformIdentifierForParam(node, scopeManager);
+      return {
+        type: "MemberExpression",
+        object: transformedObject,
+        property: {
+          type: "Literal",
+          value: 0
+        },
+        computed: true
+      };
+    }
+    case "UnaryExpression": {
+      return getParamFromUnaryExpression(node, scopeManager, namespace);
     }
-    const transformedObject = transformIdentifierForParam(node, scopeManager);
-    return {
-      type: "MemberExpression",
-      object: transformedObject,
-      property: {
-        type: "Literal",
-        value: 0
-      },
-      computed: true
-    };
   }
   return node;
 }
-function transformBinaryExpression(node, scopeManager, namespace) {
+function getParamFromBinaryExpression(node, scopeManager, namespace) {
   const transformedLeft = transformOperand(node.left, scopeManager, namespace);
   const transformedRight = transformOperand(node.right, scopeManager, namespace);
   const binaryExpr = {
@@ -8525,28 +8544,89 @@ function transformBinaryExpression(node, scopeManager, namespace) {
       transformMemberExpression(node2, "", scopeManager);
     }
   });
+  return binaryExpr;
+}
+function getParamFromLogicalExpression(node, scopeManager, namespace) {
+  const transformedLeft = transformOperand(node.left, scopeManager, namespace);
+  const transformedRight = transformOperand(node.right, scopeManager, namespace);
+  const logicalExpr = {
+    type: "LogicalExpression",
+    operator: node.operator,
+    left: transformedLeft,
+    right: transformedRight,
+    start: node.start,
+    end: node.end
+  };
+  recursive(logicalExpr, scopeManager, {
+    CallExpression(node2, scopeManager2) {
+      if (!node2._transformed) {
+        transformCallExpression(node2, scopeManager2);
+      }
+    }
+  });
+  return logicalExpr;
+}
+function getParamFromConditionalExpression(node, scopeManager, namespace) {
+  recursive(
+    node,
+    { parent: node, inNamespaceCall: false },
+    {
+      Identifier(node2, state, c) {
+        if (node2.name == "NaN") return;
+        if (node2.name == "na") {
+          node2.name = "NaN";
+          return;
+        }
+        node2.parent = state.parent;
+        transformIdentifier(node2, scopeManager);
+        const isBinaryOperation = node2.parent && node2.parent.type === "BinaryExpression";
+        const isConditional = node2.parent && node2.parent.type === "ConditionalExpression";
+        if (isConditional || isBinaryOperation) {
+          if (node2.type === "MemberExpression") {
+            transformArrayIndex(node2, scopeManager);
+          } else if (node2.type === "Identifier") {
+            addArrayAccess(node2);
+          }
+        }
+      },
+      MemberExpression(node2, state, c) {
+        transformArrayIndex(node2, scopeManager);
+        if (node2.object) {
+          c(node2.object, { parent: node2, inNamespaceCall: state.inNamespaceCall });
+        }
+      },
+      CallExpression(node2, state, c) {
+        const isNamespaceCall = node2.callee && node2.callee.type === "MemberExpression" && node2.callee.object && node2.callee.object.type === "Identifier" && scopeManager.isContextBound(node2.callee.object.name);
+        transformCallExpression(node2, scopeManager);
+        node2.arguments.forEach((arg) => c(arg, { parent: node2, inNamespaceCall: isNamespaceCall || state.inNamespaceCall }));
+      }
+    }
+  );
   return {
     type: "CallExpression",
     callee: {
       type: "MemberExpression",
-      object: {
-        type: "Identifier",
-        name: namespace
-      },
-      property: {
-        type: "Identifier",
-        name: "param"
-      },
-      computed: false
+      object: { type: "Identifier", name: namespace },
+      property: { type: "Identifier", name: "param" }
     },
-    arguments: [binaryExpr, UNDEFINED_ARG, scopeManager.nextParamIdArg],
+    arguments: [node, UNDEFINED_ARG, scopeManager.nextParamIdArg],
     _transformed: true,
     _isParamCall: true
   };
 }
 function transformFunctionArgument(arg, namespace, scopeManager) {
-  if (arg.type === "BinaryExpression") {
-    return transformBinaryExpression(arg, scopeManager, namespace);
+  switch (arg?.type) {
+    case "BinaryExpression":
+      arg = getParamFromBinaryExpression(arg, scopeManager, namespace);
+      break;
+    case "LogicalExpression":
+      arg = getParamFromLogicalExpression(arg, scopeManager, namespace);
+      break;
+    case "ConditionalExpression":
+      return getParamFromConditionalExpression(arg, scopeManager, namespace);
+    case "UnaryExpression":
+      arg = getParamFromUnaryExpression(arg, scopeManager, namespace);
+      break;
   }
   const isArrayAccess = arg.type === "MemberExpression" && arg.computed && arg.property;
   if (isArrayAccess) {
@@ -8611,6 +8691,10 @@ function transformFunctionArgument(arg, namespace, scopeManager) {
     });
   }
   if (arg.type === "Identifier") {
+    if (arg.name === "na") {
+      arg.name = "NaN";
+      return arg;
+    }
     if (scopeManager.isContextBound(arg.name) && !scopeManager.isRootParam(arg.name)) {
       return {
         type: "CallExpression",
@@ -8654,18 +8738,18 @@ function transformFunctionArgument(arg, namespace, scopeManager) {
     _isParamCall: true
   };
 }
-function transformCallExpression(node, scopeManager) {
+function transformCallExpression(node, scopeManager, namespace) {
   if (node._transformed) {
     return;
   }
   const isNamespaceCall = node.callee && node.callee.type === "MemberExpression" && node.callee.object && node.callee.object.type === "Identifier" && (scopeManager.isContextBound(node.callee.object.name) || node.callee.object.name === "math" || node.callee.object.name === "ta");
   if (isNamespaceCall) {
-    const namespace = node.callee.object.name;
+    const namespace2 = node.callee.object.name;
     node.arguments = node.arguments.map((arg) => {
       if (arg._isParamCall) {
         return arg;
       }
-      return transformFunctionArgument(arg, namespace, scopeManager);
+      return transformFunctionArgument(arg, namespace2, scopeManager);
     });
     node._transformed = true;
   } else if (node.callee && node.callee.type === "Identifier") {
@@ -8679,13 +8763,29 @@ function transformCallExpression(node, scopeManager) {
   }
   node.arguments.forEach((arg) => {
     recursive(arg, scopeManager, {
-      CallExpression(node2, state) {
+      Identifier(node2, state, c) {
+        node2.parent = state.parent;
+        transformIdentifier(node2, scopeManager);
+        const isBinaryOperation = node2.parent && node2.parent.type === "BinaryExpression";
+        const isConditional = node2.parent && node2.parent.type === "ConditionalExpression";
+        if (isConditional || isBinaryOperation) {
+          if (node2.type === "MemberExpression") {
+            transformArrayIndex(node2, scopeManager);
+          } else if (node2.type === "Identifier") {
+            addArrayAccess(node2);
+          }
+        }
+      },
+      CallExpression(node2, state, c) {
         if (!node2._transformed) {
           transformCallExpression(node2, state);
         }
       },
-      MemberExpression(node2) {
+      MemberExpression(node2, state, c) {
         transformMemberExpression(node2, "", scopeManager);
+        if (node2.object) {
+          c(node2.object, { parent: node2, inNamespaceCall: state.inNamespaceCall });
+        }
       }
     });
   });
@@ -9118,13 +9218,22 @@ class PineTS {
     if (!this._readyPromise) throw new Error("PineTS is not ready");
     return this._readyPromise;
   }
-  async run(fn, n) {
+  async run(pineTSCode, n, useTACache) {
     await this.ready();
     if (!n) n = this._periods;
-    const context = new Context(this.data);
-    context.timeframe = this.timeframe;
+    const context = new Context({
+      marketData: this.data,
+      source: this.source,
+      tickerId: this.tickerId,
+      timeframe: this.timeframe,
+      limit: this.limit,
+      sDate: this.sDate,
+      eDate: this.eDate
+    });
+    context.pineTSCode = pineTSCode;
+    context.useTACache = useTACache;
     const transformer = transpile.bind(this);
-    let transformedFn = transformer(fn);
+    let transpiledFn = transformer(pineTSCode);
     const contextVarNames = ["const", "var", "let", "params"];
     for (let i = this._periods - n, idx = n - 1; i < this._periods; i++, idx--) {
       context.idx = i;
@@ -9138,7 +9247,7 @@ class PineTS {
       context.data.ohlc4 = this.ohlc4.slice(idx);
       context.data.openTime = this.openTime.slice(idx);
       context.data.closeTime = this.closeTime.slice(idx);
-      const result = await transformedFn(context);
+      const result = await transpiledFn(context);
       if (typeof result === "object") {
         if (typeof context.result !== "object") {
           context.result = {};
@@ -9169,26 +9278,28 @@ class PineTS {
   }
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */class Core {
+class Core {
   constructor(context) {
     this.context = context;
   }
   color = {
+    param: (source, index = 0) => {
+      if (Array.isArray(source)) {
+        return source[index];
+      }
+      return source;
+    },
+    rgb: (r, g, b, a) => a ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`,
+    new: (color, a) => {
+      if (color && color.startsWith("#")) {
+        const hex = color.slice(1);
+        const r = parseInt(hex.slice(0, 2), 16);
+        const g = parseInt(hex.slice(2, 4), 16);
+        const b = parseInt(hex.slice(4, 6), 16);
+        return a ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`;
+      }
+      return a ? `rgba(${color}, ${a})` : color;
+    },
     white: "white",
     lime: "lime",
     green: "green",
@@ -9219,7 +9330,7 @@ class PineTS {
     this.context.plots[title].data.push({
       time: this.context.marketData[this.context.marketData.length - this.context.idx - 1].openTime,
       value: series[0],
-      options: this.extractPlotOptions(options)
+      options: { ...this.extractPlotOptions(options), style: "char" }
     });
   }
   plot(series, title, options) {
@@ -9236,30 +9347,13 @@ class PineTS {
     return Array.isArray(series) ? isNaN(series[0]) : isNaN(series);
   }
   nz(series, replacement = 0) {
-    if (Array.isArray(series)) {
-      return isNaN(series[0]) ? replacement : series[0];
-    } else {
-      return isNaN(series) ? replacement : series;
-    }
+    const val = Array.isArray(series) ? series[0] : series;
+    const rep = Array.isArray(series) ? replacement[0] : replacement;
+    return isNaN(val) ? rep : val;
   }
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */class Input {
+class Input {
   constructor(context) {
     this.context = context;
   }
@@ -9313,87 +9407,92 @@ class PineTS {
   }
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */class PineMath {
+class PineMath {
   constructor(context) {
     this.context = context;
   }
   _cache = {};
-  param(source, index = 0) {
+  param(source, index, name) {
+    if (!this.context.params[name]) this.context.params[name] = [];
     if (Array.isArray(source)) {
-      return source[index];
+      if (index) {
+        this.context.params[name] = source.slice(index);
+        this.context.params[name].length = source.length;
+        return this.context.params[name];
+      }
+      this.context.params[name] = source.slice(0);
+      return this.context.params[name];
+    } else {
+      this.context.params[name][0] = source;
+      return this.context.params[name];
     }
-    return source;
   }
-  abs(n) {
-    return Math.abs(n);
+  abs(source) {
+    return Math.abs(source[0]);
   }
-  pow(a, b) {
-    return Math.pow(a, b);
+  pow(source, power) {
+    return Math.pow(source[0], power[0]);
   }
-  sqrt(a) {
-    return Math.sqrt(a);
+  sqrt(source) {
+    return Math.sqrt(source[0]);
   }
-  log(a) {
-    return Math.log(a);
+  log(source) {
+    return Math.log(source[0]);
   }
-  ln(a) {
-    return Math.log(a);
+  ln(source) {
+    return Math.log(source[0]);
   }
-  exp(a) {
-    return Math.exp(a);
+  exp(source) {
+    return Math.exp(source[0]);
   }
-  floor(a) {
-    return Math.floor(a);
+  floor(source) {
+    return Math.floor(source[0]);
   }
-  ceil(a) {
-    return Math.ceil(a);
+  ceil(source) {
+    return Math.ceil(source[0]);
   }
-  round(a) {
-    return Math.round(a);
+  round(source) {
+    return Math.round(source[0]);
   }
   random() {
     return Math.random();
   }
-  max(...args) {
-    return Math.max(...args);
+  max(...source) {
+    const arg = source.map((e) => Array.isArray(e) ? e[0] : e);
+    return Math.max(...arg);
   }
-  min(...args) {
-    return Math.min(...args);
+  min(...source) {
+    const arg = source.map((e) => Array.isArray(e) ? e[0] : e);
+    return Math.min(...arg);
   }
-  sin(a) {
-    return Math.sin(a);
+  //sum of last n values
+  sum(source, length) {
+    const len = Array.isArray(length) ? length[0] : length;
+    if (Array.isArray(source)) {
+      return source.slice(0, len).reduce((a, b) => a + b, 0);
+    }
+    return source;
   }
-  cos(a) {
-    return Math.cos(a);
+  sin(source) {
+    return Math.sin(source[0]);
   }
-  tan(a) {
-    return Math.tan(a);
+  cos(source) {
+    return Math.cos(source[0]);
   }
-  asin(a) {
-    return Math.asin(a);
+  tan(source) {
+    return Math.tan(source[0]);
   }
-  acos(a) {
-    return Math.acos(a);
+  acos(source) {
+    return Math.acos(source[0]);
   }
-  atan(a) {
-    return Math.atan(a);
+  asin(source) {
+    return Math.asin(source[0]);
   }
-  avg(...args) {
+  atan(source) {
+    return Math.atan(source[0]);
+  }
+  avg(...sources) {
+    const args = sources.map((e) => Array.isArray(e) ? e[0] : e);
     return args.reduce((a, b) => {
       const aVal = Array.isArray(a) ? a[0] : a;
       const bVal = Array.isArray(b) ? b[0] : b;
@@ -9402,22 +9501,8 @@ class PineTS {
   }
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */class PineRequest {
+const TIMEFRAMES = ["1", "3", "5", "15", "30", "45", "60", "120", "180", "240", "D", "W", "M"];
+class PineRequest {
   constructor(context) {
     this.context = context;
   }
@@ -9436,27 +9521,46 @@ class PineTS {
       return [source, name];
     }
   }
-  async security(symbol, timeframe, expression) {
-    throw new Error("Not implemented");
+  async security(symbol, timeframe, expression, gaps = false, lookahead = false, ignore_invalid_symbol = false, currency = null, calc_bars_count = null) {
+    const _symbol = symbol[0];
+    const _timeframe = timeframe[0];
+    const _expression = expression[0];
+    const _expression_name = expression[1];
+    const ctxTimeframeIdx = TIMEFRAMES.indexOf(this.context.timeframe);
+    const reqTimeframeIdx = TIMEFRAMES.indexOf(_timeframe);
+    if (ctxTimeframeIdx == -1 || reqTimeframeIdx == -1) {
+      throw new Error("Invalid timeframe");
+    }
+    if (ctxTimeframeIdx > reqTimeframeIdx) {
+      throw new Error("Only higher timeframes are supported for now");
+    }
+    if (ctxTimeframeIdx === reqTimeframeIdx) {
+      return _expression;
+    }
+    const myOpenTime = this.context.data.openTime[0];
+    const myCloseTime = this.context.data.closeTime[0];
+    if (this.context.cache[_expression_name]) {
+      const secContext2 = this.context.cache[_expression_name];
+      const secContextIdx2 = this._findSecContextIdx(myOpenTime, myCloseTime, secContext2.data.openTime, secContext2.data.closeTime, lookahead);
+      return secContextIdx2 == -1 ? NaN : secContext2.params[_expression_name][secContextIdx2];
+    }
+    const pineTS = new PineTS(this.context.source, _symbol, _timeframe, this.context.limit || 1e3, this.context.sDate, this.context.eDate);
+    const secContext = await pineTS.run(this.context.pineTSCode);
+    this.context.cache[_expression_name] = secContext;
+    const secContextIdx = this._findSecContextIdx(myOpenTime, myCloseTime, secContext.data.openTime, secContext.data.closeTime, lookahead);
+    return secContextIdx == -1 ? NaN : secContext.params[_expression_name][secContextIdx];
+  }
+  _findSecContextIdx(myOpenTime, myCloseTime, openTime, closeTime, lookahead = false) {
+    for (let i = 0; i < openTime.length; i++) {
+      if (openTime[i] <= myOpenTime && myCloseTime <= closeTime[i]) {
+        return i + (lookahead ? 1 : 2);
+      }
+    }
+    return -1;
   }
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */class TechnicalAnalysis {
+class TechnicalAnalysis {
   constructor(context) {
     this.context = context;
   }
@@ -9473,6 +9577,7 @@ class PineTS {
     if (Array.isArray(source)) {
       if (index) {
         this.context.params[name] = source.slice(index);
+        this.context.params[name].length = source.length;
         return this.context.params[name];
       }
       this.context.params[name] = source.slice(0);
@@ -9488,9 +9593,21 @@ class PineTS {
     const idx = this.context.idx;
     return this.context.precision(result[idx]);
   }
-  sma(source, _period) {
+  sma(source, _period, _cacheId) {
     const period = Array.isArray(_period) ? _period[0] : _period;
-    const result = sma(source.slice(0).reverse(), 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]);
   }
@@ -9606,6 +9723,44 @@ class PineTS {
     const idx = this.context.idx;
     return [[this.context.precision(supertrend[idx]), direction[idx]]];
   }
+  crossover(source1, source2) {
+    const current1 = Array.isArray(source1) ? source1[0] : source1;
+    const current2 = Array.isArray(source2) ? source2[0] : source2;
+    const prev1 = Array.isArray(source1) ? source1[1] : this.context.data.series[source1][1];
+    const prev2 = Array.isArray(source2) ? source2[1] : this.context.data.series[source2][1];
+    return prev1 < prev2 && current1 > current2;
+  }
+  crossunder(source1, source2) {
+    const current1 = Array.isArray(source1) ? source1[0] : source1;
+    const current2 = Array.isArray(source2) ? source2[0] : source2;
+    const prev1 = Array.isArray(source1) ? source1[1] : this.context.data.series[source1][1];
+    const prev2 = Array.isArray(source2) ? source2[1] : this.context.data.series[source2][1];
+    return prev1 > prev2 && current1 < current2;
+  }
+  pivothigh(source, _leftbars, _rightbars) {
+    if (_rightbars == void 0) {
+      _rightbars = _leftbars;
+      _leftbars = source;
+      source = this.context.data.high;
+    }
+    const leftbars = Array.isArray(_leftbars) ? _leftbars[0] : _leftbars;
+    const rightbars = Array.isArray(_rightbars) ? _rightbars[0] : _rightbars;
+    const result = pivothigh(source.slice(0).reverse(), leftbars, rightbars);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  pivotlow(source, _leftbars, _rightbars) {
+    if (_rightbars == void 0) {
+      _rightbars = _leftbars;
+      _leftbars = source;
+      source = this.context.data.low;
+    }
+    const leftbars = Array.isArray(_leftbars) ? _leftbars[0] : _leftbars;
+    const rightbars = Array.isArray(_rightbars) ? _rightbars[0] : _rightbars;
+    const result = pivotlow(source.slice(0).reverse(), leftbars, rightbars);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
 }
 function atr(high, low, close, period) {
   const tr = new Array(high.length);
@@ -9679,6 +9834,35 @@ function rma(source, period) {
   }
   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++) {
@@ -9797,7 +9981,7 @@ function lowest(source, length) {
     let min = Infinity;
     for (let j = 0; j < length; j++) {
       const value = source[i - j];
-      if (isNaN(value)) {
+      if (isNaN(value) || value === void 0) {
         min = min === Infinity ? NaN : min;
       } else {
         min = Math.min(min, value);
@@ -9916,23 +10100,247 @@ function calculateSupertrend(high, low, close, factor, atrPeriod) {
   }
   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++) {
+    const pivot = source[i - rightbars];
+    let isPivot = true;
+    for (let j = 1; j <= leftbars; j++) {
+      if (source[i - rightbars - j] >= pivot) {
+        isPivot = false;
+        break;
+      }
+    }
+    if (isPivot) {
+      for (let j = 1; j <= rightbars; j++) {
+        if (source[i - rightbars + j] >= pivot) {
+          isPivot = false;
+          break;
+        }
+      }
+    }
+    if (isPivot) {
+      result[i] = pivot;
+    }
+  }
+  return result;
+}
+function pivotlow(source, leftbars, rightbars) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = leftbars + rightbars; i < source.length; i++) {
+    const pivot = source[i - rightbars];
+    let isPivot = true;
+    for (let j = 1; j <= leftbars; j++) {
+      if (source[i - rightbars - j] <= pivot) {
+        isPivot = false;
+        break;
+      }
+    }
+    if (isPivot) {
+      for (let j = 1; j <= rightbars; j++) {
+        if (source[i - rightbars + j] <= pivot) {
+          isPivot = false;
+          break;
+        }
+      }
+    }
+    if (isPivot) {
+      result[i] = pivot;
+    }
+  }
+  return result;
+}
 
-class Context {
-  constructor(marketData) {
-    this.marketData = marketData;
-    this.math = new PineMath(this);
-    this.ta = new TechnicalAnalysis(this);
-    this.input = new Input(this);
-    this.request = new PineRequest(this);
-    const core = new Core(this);
-    this.core = {
-      plotchar: core.plotchar.bind(core),
-      na: core.na.bind(core),
-      color: core.color,
-      plot: core.plot.bind(core),
-      nz: core.nz.bind(core)
-    };
+class PineArrayObject {
+  constructor(array) {
+    this.array = array;
+  }
+}
+class PineArray {
+  constructor(context) {
+    this.context = context;
   }
+  _cache = {};
+  param(source, index = 0) {
+    if (Array.isArray(source)) {
+      return source[index];
+    }
+    return source;
+  }
+  /**
+   * This function simulates PineScript's array.get() function
+   * @param id - the array object to get the value from
+   * @param index - the index of the value to get
+   * @returns the value at the given index
+   */
+  get(id, index) {
+    return id.array[index];
+  }
+  set(id, index, value) {
+    id.array[index] = value;
+  }
+  push(id, value) {
+    id.array.push(value);
+  }
+  // Basic statistics
+  sum(id) {
+    return id.array.reduce((a, b) => a + (isNaN(b) ? 0 : b), 0);
+  }
+  avg(id) {
+    return this.sum(id) / id.array.length;
+  }
+  min(id, nth = 0) {
+    const sorted = [...id.array].sort((a, b) => a - b);
+    return sorted[nth] ?? this.context.NA;
+  }
+  max(id, nth = 0) {
+    const sorted = [...id.array].sort((a, b) => b - a);
+    return sorted[nth] ?? this.context.NA;
+  }
+  size(id) {
+    return id.array.length;
+  }
+  // Array creation
+  new_bool(size, initial_value = false) {
+    return new PineArrayObject(Array(size).fill(initial_value));
+  }
+  new_float(size, initial_value = NaN) {
+    return new PineArrayObject(Array(size).fill(initial_value));
+  }
+  new_int(size, initial_value = 0) {
+    return new PineArrayObject(Array(size).fill(Math.round(initial_value)));
+  }
+  new_string(size, initial_value = "") {
+    return new PineArrayObject(Array(size).fill(initial_value));
+  }
+  new(size, initial_value) {
+    return new PineArrayObject(Array(size).fill(initial_value));
+  }
+  // Array operations
+  slice(id, start, end) {
+    const adjustedEnd = end !== void 0 ? end + 1 : void 0;
+    return new PineArrayObject(id.array.slice(start, adjustedEnd));
+  }
+  reverse(id) {
+    id.array.reverse();
+  }
+  includes(id, value) {
+    return id.array.includes(value);
+  }
+  indexof(id, value) {
+    return id.array.indexOf(value);
+  }
+  lastindexof(id, value) {
+    return id.array.lastIndexOf(value);
+  }
+  // More complex functions
+  stdev(id, biased = true) {
+    const mean = this.avg(id);
+    const deviations = id.array.map((x) => Math.pow(x - mean, 2));
+    const divisor = biased ? id.array.length : id.array.length - 1;
+    return Math.sqrt(this.sum(new PineArrayObject(deviations)) / divisor);
+  }
+  variance(id, biased = true) {
+    const mean = this.avg(id);
+    const deviations = id.array.map((x) => Math.pow(x - mean, 2));
+    const divisor = biased ? id.array.length : id.array.length - 1;
+    return this.sum(new PineArrayObject(deviations)) / divisor;
+  }
+  covariance(arr1, arr2, biased = true) {
+    if (arr1.array.length !== arr2.array.length || arr1.array.length < 2) return NaN;
+    const divisor = biased ? arr1.array.length : arr1.array.length - 1;
+    const mean1 = this.avg(arr1);
+    const mean2 = this.avg(arr2);
+    let sum = 0;
+    for (let i = 0; i < arr1.array.length; i++) {
+      sum += (arr1.array[i] - mean1) * (arr2.array[i] - mean2);
+    }
+    return sum / divisor;
+  }
+  // Additional utility methods
+  first(id) {
+    return id.array.length > 0 ? id.array[0] : this.context.NA;
+  }
+  last(id) {
+    return id.array.length > 0 ? id.array[id.array.length - 1] : this.context.NA;
+  }
+  clear(id) {
+    id.array.length = 0;
+  }
+  join(id, separator = ",") {
+    return id.array.join(separator);
+  }
+  /** Array Manipulation Functions */
+  abs(id) {
+    return new PineArrayObject(id.array.map((val) => Math.abs(val)));
+  }
+  concat(id, other) {
+    id.array.push(...other.array);
+    return id;
+  }
+  copy(id) {
+    return new PineArrayObject([...id.array]);
+  }
+  every(id, callback) {
+    return id.array.every(callback);
+  }
+  fill(id, value, start = 0, end) {
+    const length = id.array.length;
+    const adjustedEnd = end !== void 0 ? Math.min(end, length) : length;
+    for (let i = start; i < adjustedEnd; i++) {
+      id.array[i] = value;
+    }
+  }
+  from(source) {
+    return new PineArrayObject([...source]);
+  }
+  insert(id, index, value) {
+    id.array.splice(index, 0, value);
+  }
+  pop(id) {
+    return id.array.pop();
+  }
+  range(id) {
+    return this.max(id) - this.min(id);
+  }
+  remove(id, index) {
+    if (index >= 0 && index < id.array.length) {
+      return id.array.splice(index, 1)[0];
+    }
+    return this.context.NA;
+  }
+  shift(id) {
+    return id.array.shift();
+  }
+  sort(id, order = "asc") {
+    id.array.sort((a, b) => order === "asc" ? a - b : b - a);
+  }
+  sort_indices(id, comparator) {
+    const indices = id.array.map((_, index) => index);
+    indices.sort((a, b) => {
+      const valA = id.array[a];
+      const valB = id.array[b];
+      return comparator ? comparator(valA, valB) : valA - valB;
+    });
+    return new PineArrayObject(indices);
+  }
+  standardize(id) {
+    const mean = this.avg(id);
+    const stdev = this.stdev(id);
+    if (stdev === 0) {
+      return new PineArrayObject(id.array.map(() => 0));
+    }
+    return new PineArrayObject(id.array.map((x) => (x - mean) / stdev));
+  }
+  unshift(id, value) {
+    id.array.unshift(value);
+  }
+  some(id, callback) {
+    return id.array.some(callback);
+  }
+}
+
+class Context {
   data = {
     open: [],
     high: [],
@@ -9943,11 +10351,16 @@ class Context {
     hlc3: [],
     ohlc4: []
   };
+  cache = {};
+  useTACache = false;
+  NA = NaN;
   math;
   ta;
   input;
   request;
+  array;
   core;
+  lang;
   idx = 0;
   params = {};
   const = {};
@@ -9955,7 +10368,44 @@ class Context {
   let = {};
   result = void 0;
   plots = {};
+  marketData;
+  source;
+  tickerId;
   timeframe = "";
+  limit;
+  sDate;
+  eDate;
+  pineTSCode;
+  constructor({
+    marketData,
+    source,
+    tickerId,
+    timeframe,
+    limit,
+    sDate,
+    eDate
+  }) {
+    this.marketData = marketData;
+    this.source = source;
+    this.tickerId = tickerId;
+    this.timeframe = timeframe;
+    this.limit = limit;
+    this.sDate = sDate;
+    this.eDate = eDate;
+    this.math = new PineMath(this);
+    this.ta = new TechnicalAnalysis(this);
+    this.input = new Input(this);
+    this.request = new PineRequest(this);
+    this.array = new PineArray(this);
+    const core = new Core(this);
+    this.core = {
+      plotchar: core.plotchar.bind(core),
+      na: core.na.bind(core),
+      color: core.color,
+      plot: core.plot.bind(core),
+      nz: core.nz.bind(core)
+    };
+  }
   //#region [Runtime functions] ===========================
   /**
    * this function is used to initialize the target variable with the source array
@@ -9982,12 +10432,13 @@ class Context {
     return trg;
   }
   /**
-   * this function is used to set the floating point precision of a number
-   * by default it is set to 10 decimals which is the same as pine script
-   * @param n - the number to be precision
-   * @param decimals - the number of decimals to precision to
-   * @returns the precision number
-   */
+       * this function is used to set the floating point precision of a number
+       * by default it is set to 10 decimals which is the same as pine script
+       * @param n - the number to be precision
+       * @param decimals - the number of decimals to precision to
+  
+       * @returns the precision number
+       */
   precision(n, decimals = 10) {
     if (typeof n !== "number" || isNaN(n)) return n;
     return Number(n.toFixed(decimals));
@@ -10006,6 +10457,7 @@ class Context {
     if (Array.isArray(source)) {
       if (index) {
         this.params[name] = source.slice(index);
+        this.params[name].length = source.length;
         return this.params[name];
       }
       this.params[name] = source.slice(0);
@@ -10018,22 +10470,7 @@ class Context {
   //#endregion
 }
 
-/* 
- * Copyright (C) 2025 Alaa-eddine KADDOURI
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */const BINANCE_API_URL = "https://api.binance.com/api/v3";
+const BINANCE_API_URL = "https://api.binance.com/api/v3";
 const timeframe_to_binance = {
   "1": "1m",
   // 1 minute
@@ -10055,6 +10492,8 @@ const timeframe_to_binance = {
   // 3 hours (not directly supported by Binance, needs custom handling)
   "240": "4h",
   // 4 hours
+  "4H": "4h",
+  // 4 hours
   "1D": "1d",
   // 1 day
   D: "1d",
@@ -10068,15 +10507,119 @@ const timeframe_to_binance = {
   M: "1M"
   // 1 month
 };
+class CacheManager {
+  cache;
+  cacheDuration;
+  constructor(cacheDuration = 5 * 60 * 1e3) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cacheDuration = cacheDuration;
+  }
+  generateKey(params) {
+    return Object.entries(params).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}:${value}`).join("|");
+  }
+  get(params) {
+    const key = this.generateKey(params);
+    const cached = this.cache.get(key);
+    if (!cached) return null;
+    if (Date.now() - cached.timestamp > this.cacheDuration) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.data;
+  }
+  set(params, data) {
+    const key = this.generateKey(params);
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  clear() {
+    this.cache.clear();
+  }
+  // Optional: method to remove expired entries
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.cacheDuration) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
 class BinanceProvider {
+  cacheManager;
+  constructor() {
+    this.cacheManager = new CacheManager(5 * 60 * 1e3);
+  }
+  async getMarketDataInterval(tickerId, timeframe, sDate, eDate) {
+    try {
+      const interval = timeframe_to_binance[timeframe.toUpperCase()];
+      if (!interval) {
+        console.error(`Unsupported timeframe: ${timeframe}`);
+        return [];
+      }
+      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
+      };
+      let allData = [];
+      let currentStart = sDate;
+      const endTime = eDate;
+      const intervalDuration = timeframeDurations[interval];
+      if (!intervalDuration) {
+        console.error(`Duration not defined for interval: ${interval}`);
+        return [];
+      }
+      while (currentStart < endTime) {
+        const chunkEnd = Math.min(currentStart + 1e3 * intervalDuration, endTime);
+        const data = await this.getMarketData(
+          tickerId,
+          timeframe,
+          1e3,
+          // Max allowed by Binance
+          currentStart,
+          chunkEnd
+        );
+        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) {
+      console.error("Error in getMarketDataInterval:", error);
+      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 };
+      const cachedData = this.cacheManager.get(cacheParams);
+      if (cachedData) {
+        console.log("cache hit", tickerId, timeframe, limit, sDate, eDate);
+        return cachedData;
+      }
       const interval = timeframe_to_binance[timeframe.toUpperCase()];
       if (!interval) {
         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);
+      }
       if (limit) {
         url += `&limit=${limit}`;
       }
@@ -10093,13 +10636,13 @@ class BinanceProvider {
       const result = await response.json();
       const data = result.map((item) => {
         return {
-          openTime: parseInt(item[0]) / 1e3,
+          openTime: parseInt(item[0]),
           open: parseFloat(item[1]),
           high: parseFloat(item[2]),
           low: parseFloat(item[3]),
           close: parseFloat(item[4]),
           volume: parseFloat(item[5]),
-          closeTime: parseInt(item[6]) / 1e3,
+          closeTime: parseInt(item[6]),
           quoteAssetVolume: parseFloat(item[7]),
           numberOfTrades: parseInt(item[8]),
           takerBuyBaseAssetVolume: parseFloat(item[9]),
@@ -10107,6 +10650,7 @@ class BinanceProvider {
           ignore: item[11]
         };
       });
+      this.cacheManager.set(cacheParams, data);
       return data;
     } catch (error) {
       console.error("Error in binance.klines:", error);
@@ -10117,6 +10661,7 @@ class BinanceProvider {
 
 const Provider = {
   Binance: new BinanceProvider()
+  //TODO : add other providers (polygon, etc.)
 };
 
 exports.Context = Context;