pinets 0.1.0 → 0.1.31

package/dist/pinets.dev.es.js

@@ -1,24 +1,42 @@
+
+/* 
+ * 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/>.
+ */
 import * as acorn from 'acorn';
 import * as walk from 'acorn-walk';
 import * as astring from 'astring';
 
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
 class ScopeManager {
   constructor() {
-    __publicField$5(this, "scopes", []);
-    __publicField$5(this, "scopeTypes", []);
-    __publicField$5(this, "scopeCounts", /* @__PURE__ */ new Map());
-    __publicField$5(this, "contextBoundVars", /* @__PURE__ */ new Set());
-    __publicField$5(this, "arrayPatternElements", /* @__PURE__ */ new Set());
-    __publicField$5(this, "rootParams", /* @__PURE__ */ new Set());
-    __publicField$5(this, "varKinds", /* @__PURE__ */ new Map());
-    __publicField$5(this, "loopVars", /* @__PURE__ */ new Set());
-    __publicField$5(this, "loopVarNames", /* @__PURE__ */ new Map());
+    __publicField$7(this, "scopes", []);
+    __publicField$7(this, "scopeTypes", []);
+    __publicField$7(this, "scopeCounts", /* @__PURE__ */ new Map());
+    __publicField$7(this, "contextBoundVars", /* @__PURE__ */ new Set());
+    __publicField$7(this, "arrayPatternElements", /* @__PURE__ */ new Set());
+    __publicField$7(this, "rootParams", /* @__PURE__ */ new Set());
+    __publicField$7(this, "varKinds", /* @__PURE__ */ new Map());
+    __publicField$7(this, "loopVars", /* @__PURE__ */ new Set());
+    __publicField$7(this, "loopVarNames", /* @__PURE__ */ new Map());
     // Map original names to transformed names
-    __publicField$5(this, "paramIdCounter", 0);
-    __publicField$5(this, "tempVarCounter", 0);
+    __publicField$7(this, "paramIdCounter", 0);
+    __publicField$7(this, "cacheIdCounter", 0);
+    __publicField$7(this, "tempVarCounter", 0);
     this.pushScope("glb");
   }
   get nextParamIdArg() {
@@ -27,6 +45,12 @@ class ScopeManager {
       name: `'p${this.paramIdCounter++}'`
     };
   }
+  get nextCacheIdArg() {
+    return {
+      type: "Identifier",
+      name: `'cache_${this.cacheIdCounter++}'`
+    };
+  }
   pushScope(type) {
     this.scopes.push(/* @__PURE__ */ new Map());
     this.scopeTypes.push(type);
@@ -204,6 +228,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";
@@ -366,7 +393,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");
@@ -519,14 +567,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);
           }
         }
@@ -708,6 +764,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;
     }
@@ -761,40 +821,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 = {
@@ -815,28 +893,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
+  };
+  walk.recursive(logicalExpr, scopeManager, {
+    CallExpression(node2, scopeManager2) {
+      if (!node2._transformed) {
+        transformCallExpression(node2, scopeManager2);
+      }
+    }
+  });
+  return logicalExpr;
+}
+function getParamFromConditionalExpression(node, scopeManager, namespace) {
+  walk.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) {
@@ -901,6 +1040,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",
@@ -944,18 +1087,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") {
@@ -969,13 +1112,29 @@ function transformCallExpression(node, scopeManager) {
   }
   node.arguments.forEach((arg) => {
     walk.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 });
+        }
       }
     });
   });
@@ -1336,9 +1495,9 @@ function transpile(fn) {
   return _wraperFunction(this);
 }
 
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
 class PineTS {
   constructor(source, tickerId, timeframe, limit, sDate, eDate) {
     this.source = source;
@@ -1347,25 +1506,25 @@ class PineTS {
     this.limit = limit;
     this.sDate = sDate;
     this.eDate = eDate;
-    __publicField$4(this, "data", []);
+    __publicField$6(this, "data", []);
     //#region [Pine Script built-in variables]
-    __publicField$4(this, "open", []);
-    __publicField$4(this, "high", []);
-    __publicField$4(this, "low", []);
-    __publicField$4(this, "close", []);
-    __publicField$4(this, "volume", []);
-    __publicField$4(this, "hl2", []);
-    __publicField$4(this, "hlc3", []);
-    __publicField$4(this, "ohlc4", []);
-    __publicField$4(this, "openTime", []);
-    __publicField$4(this, "closeTime", []);
+    __publicField$6(this, "open", []);
+    __publicField$6(this, "high", []);
+    __publicField$6(this, "low", []);
+    __publicField$6(this, "close", []);
+    __publicField$6(this, "volume", []);
+    __publicField$6(this, "hl2", []);
+    __publicField$6(this, "hlc3", []);
+    __publicField$6(this, "ohlc4", []);
+    __publicField$6(this, "openTime", []);
+    __publicField$6(this, "closeTime", []);
     //#endregion
     //#region run context
-    __publicField$4(this, "_periods");
+    __publicField$6(this, "_periods");
     //#endregion
     //public fn: Function;
-    __publicField$4(this, "_readyPromise", null);
-    __publicField$4(this, "_ready", false);
+    __publicField$6(this, "_readyPromise", null);
+    __publicField$6(this, "_ready", false);
     this._readyPromise = new Promise((resolve) => {
       this.loadMarketData(source, tickerId, timeframe, limit, sDate, eDate).then((data) => {
         const marketData = data.reverse();
@@ -1411,13 +1570,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;
@@ -1431,7 +1599,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 = {};
@@ -1462,13 +1630,30 @@ class PineTS {
   }
 }
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
 class Core {
   constructor(context) {
     this.context = context;
-    __publicField$3(this, "color", {
+    __publicField$5(this, "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",
@@ -1500,7 +1685,7 @@ class Core {
     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) {
@@ -1517,11 +1702,9 @@ class Core {
     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;
   }
 }
 
@@ -1579,75 +1762,95 @@ class Input {
   }
 }
 
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
 class PineMath {
   constructor(context) {
     this.context = context;
-    __publicField$2(this, "_cache", {});
+    __publicField$4(this, "_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(...source) {
+    const arg = source.map((e) => Array.isArray(e) ? e[0] : e);
+    return Math.min(...arg);
   }
-  min(...args) {
-    return Math.min(...args);
+  //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;
   }
-  sin(a) {
-    return Math.sin(a);
+  sin(source) {
+    return Math.sin(source[0]);
   }
-  cos(a) {
-    return Math.cos(a);
+  cos(source) {
+    return Math.cos(source[0]);
   }
-  tan(a) {
-    return Math.tan(a);
+  tan(source) {
+    return Math.tan(source[0]);
   }
-  asin(a) {
-    return Math.asin(a);
+  acos(source) {
+    return Math.acos(source[0]);
   }
-  acos(a) {
-    return Math.acos(a);
+  asin(source) {
+    return Math.asin(source[0]);
   }
-  atan(a) {
-    return Math.atan(a);
+  atan(source) {
+    return Math.atan(source[0]);
   }
-  avg(...args) {
+  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;
@@ -1656,13 +1859,14 @@ class PineMath {
   }
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+const TIMEFRAMES = ["1", "3", "5", "15", "30", "45", "60", "120", "180", "240", "D", "W", "M"];
 class PineRequest {
   constructor(context) {
     this.context = context;
-    __publicField$1(this, "_cache", {});
+    __publicField$3(this, "_cache", {});
   }
   param(source, index, name) {
     if (!this.context.params[name]) this.context.params[name] = [];
@@ -1678,8 +1882,42 @@ class PineRequest {
       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;
   }
 }
 
@@ -1700,6 +1938,7 @@ class TechnicalAnalysis {
     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);
@@ -1715,9 +1954,21 @@ class TechnicalAnalysis {
     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]);
   }
@@ -1906,6 +2157,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++) {
@@ -2024,7 +2304,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);
@@ -2144,13 +2424,212 @@ function calculateSupertrend(high, low, close, factor, atrPeriod) {
   return [supertrend, direction];
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+class PineArrayObject {
+  constructor(array) {
+    this.array = array;
+  }
+}
+class PineArray {
+  constructor(context) {
+    this.context = context;
+    __publicField$2(this, "_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);
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
 class Context {
-  constructor(marketData) {
-    this.marketData = marketData;
-    __publicField(this, "data", {
+  constructor({
+    marketData,
+    source,
+    tickerId,
+    timeframe,
+    limit,
+    sDate,
+    eDate
+  }) {
+    __publicField$1(this, "data", {
       open: [],
       high: [],
       low: [],
@@ -2160,23 +2639,43 @@ class Context {
       hlc3: [],
       ohlc4: []
     });
-    __publicField(this, "math");
-    __publicField(this, "ta");
-    __publicField(this, "input");
-    __publicField(this, "request");
-    __publicField(this, "core");
-    __publicField(this, "idx", 0);
-    __publicField(this, "params", {});
-    __publicField(this, "const", {});
-    __publicField(this, "var", {});
-    __publicField(this, "let", {});
-    __publicField(this, "result");
-    __publicField(this, "plots", {});
-    __publicField(this, "timeframe", "");
+    __publicField$1(this, "cache", {});
+    __publicField$1(this, "useTACache", false);
+    __publicField$1(this, "NA", NaN);
+    __publicField$1(this, "math");
+    __publicField$1(this, "ta");
+    __publicField$1(this, "input");
+    __publicField$1(this, "request");
+    __publicField$1(this, "array");
+    __publicField$1(this, "core");
+    __publicField$1(this, "lang");
+    __publicField$1(this, "idx", 0);
+    __publicField$1(this, "params", {});
+    __publicField$1(this, "const", {});
+    __publicField$1(this, "var", {});
+    __publicField$1(this, "let", {});
+    __publicField$1(this, "result");
+    __publicField$1(this, "plots", {});
+    __publicField$1(this, "marketData");
+    __publicField$1(this, "source");
+    __publicField$1(this, "tickerId");
+    __publicField$1(this, "timeframe", "");
+    __publicField$1(this, "limit");
+    __publicField$1(this, "sDate");
+    __publicField$1(this, "eDate");
+    __publicField$1(this, "pineTSCode");
+    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),
@@ -2212,12 +2711,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));
@@ -2236,6 +2736,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);
@@ -2248,6 +2749,9 @@ class Context {
   //#endregion
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 const BINANCE_API_URL = "https://api.binance.com/api/v3";
 const timeframe_to_binance = {
   "1": "1m",
@@ -2270,6 +2774,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",
@@ -2283,15 +2789,119 @@ const timeframe_to_binance = {
   M: "1M"
   // 1 month
 };
+class CacheManager {
+  constructor(cacheDuration = 5 * 60 * 1e3) {
+    __publicField(this, "cache");
+    __publicField(this, "cacheDuration");
+    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 {
+  constructor() {
+    __publicField(this, "cacheManager");
+    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}`;
       }
@@ -2308,13 +2918,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]),
@@ -2322,6 +2932,7 @@ class BinanceProvider {
           ignore: item[11]
         };
       });
+      this.cacheManager.set(cacheParams, data);
       return data;
     } catch (error) {
       console.error("Error in binance.klines:", error);
@@ -2332,6 +2943,7 @@ class BinanceProvider {
 
 const Provider = {
   Binance: new BinanceProvider()
+  //TODO : add other providers (polygon, etc.)
 };
 
 export { Context, PineTS, Provider };