pinets 0.1.0

package/dist/pinets.dev.es.js

@@ -0,0 +1,2338 @@
+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);
+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());
+    // Map original names to transformed names
+    __publicField$5(this, "paramIdCounter", 0);
+    __publicField$5(this, "tempVarCounter", 0);
+    this.pushScope("glb");
+  }
+  get nextParamIdArg() {
+    return {
+      type: "Identifier",
+      name: `'p${this.paramIdCounter++}'`
+    };
+  }
+  pushScope(type) {
+    this.scopes.push(/* @__PURE__ */ new Map());
+    this.scopeTypes.push(type);
+    this.scopeCounts.set(type, (this.scopeCounts.get(type) || 0) + 1);
+  }
+  popScope() {
+    this.scopes.pop();
+    this.scopeTypes.pop();
+  }
+  getCurrentScopeType() {
+    return this.scopeTypes[this.scopeTypes.length - 1];
+  }
+  getCurrentScopeCount() {
+    return this.scopeCounts.get(this.getCurrentScopeType()) || 1;
+  }
+  addContextBoundVar(name, isRootParam = false) {
+    this.contextBoundVars.add(name);
+    if (isRootParam) {
+      this.rootParams.add(name);
+    }
+  }
+  addArrayPatternElement(name) {
+    this.arrayPatternElements.add(name);
+  }
+  isContextBound(name) {
+    return this.contextBoundVars.has(name);
+  }
+  isArrayPatternElement(name) {
+    return this.arrayPatternElements.has(name);
+  }
+  isRootParam(name) {
+    return this.rootParams.has(name);
+  }
+  addLoopVariable(originalName, transformedName) {
+    this.loopVars.add(originalName);
+    this.loopVarNames.set(originalName, transformedName);
+  }
+  getLoopVariableName(name) {
+    return this.loopVarNames.get(name);
+  }
+  isLoopVariable(name) {
+    return this.loopVars.has(name);
+  }
+  addVariable(name, kind) {
+    if (this.isContextBound(name)) {
+      return name;
+    }
+    const currentScope = this.scopes[this.scopes.length - 1];
+    const scopeType = this.scopeTypes[this.scopeTypes.length - 1];
+    const scopeCount = this.scopeCounts.get(scopeType) || 1;
+    const newName = `${scopeType}${scopeCount}_${name}`;
+    currentScope.set(name, newName);
+    this.varKinds.set(newName, kind);
+    return newName;
+  }
+  getVariable(name) {
+    if (this.loopVars.has(name)) {
+      const transformedName = this.loopVarNames.get(name);
+      if (transformedName) {
+        return [transformedName, "let"];
+      }
+    }
+    if (this.isContextBound(name)) {
+      return [name, "let"];
+    }
+    for (let i = this.scopes.length - 1; i >= 0; i--) {
+      const scope = this.scopes[i];
+      if (scope.has(name)) {
+        const scopedName = scope.get(name);
+        const kind = this.varKinds.get(scopedName) || "let";
+        return [scopedName, kind];
+      }
+    }
+    return [name, "let"];
+  }
+  generateTempVar() {
+    return `temp_${++this.tempVarCounter}`;
+  }
+}
+
+//!!!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",
+  name: "undefined"
+};
+function transformArrayIndex(node, scopeManager) {
+  if (node.computed && node.property.type === "Identifier") {
+    if (scopeManager.isLoopVariable(node.property.name)) {
+      return;
+    }
+    if (!scopeManager.isContextBound(node.property.name)) {
+      const [scopedName, kind] = scopeManager.getVariable(node.property.name);
+      node.property = {
+        type: "MemberExpression",
+        object: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: CONTEXT_NAME
+          },
+          property: {
+            type: "Identifier",
+            name: kind
+          },
+          computed: false
+        },
+        property: {
+          type: "Identifier",
+          name: scopedName
+        },
+        computed: false
+      };
+      node.property = {
+        type: "MemberExpression",
+        object: node.property,
+        property: {
+          type: "Literal",
+          value: 0
+        },
+        computed: true
+      };
+    }
+  }
+  if (node.computed && node.object.type === "Identifier") {
+    if (scopeManager.isLoopVariable(node.object.name)) {
+      return;
+    }
+    if (!scopeManager.isContextBound(node.object.name)) {
+      const [scopedName, kind] = scopeManager.getVariable(node.object.name);
+      node.object = {
+        type: "MemberExpression",
+        object: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: CONTEXT_NAME
+          },
+          property: {
+            type: "Identifier",
+            name: kind
+          },
+          computed: false
+        },
+        property: {
+          type: "Identifier",
+          name: scopedName
+        },
+        computed: false
+      };
+    }
+    if (node.property.type === "MemberExpression") {
+      const memberNode = node.property;
+      if (!memberNode._indexTransformed) {
+        transformArrayIndex(memberNode, scopeManager);
+        memberNode._indexTransformed = true;
+      }
+    }
+  }
+}
+function transformMemberExpression(memberNode, originalParamName, scopeManager) {
+  if (memberNode.object && memberNode.object.type === "Identifier" && memberNode.object.name === "Math") {
+    return;
+  }
+  const isIfStatement = scopeManager.getCurrentScopeType() == "if";
+  const isElseStatement = scopeManager.getCurrentScopeType() == "els";
+  const isForStatement = scopeManager.getCurrentScopeType() == "for";
+  if (!isIfStatement && !isElseStatement && !isForStatement && memberNode.object && memberNode.object.type === "Identifier" && scopeManager.isContextBound(memberNode.object.name) && !scopeManager.isRootParam(memberNode.object.name)) {
+    return;
+  }
+  if (!memberNode._indexTransformed) {
+    transformArrayIndex(memberNode, scopeManager);
+    memberNode._indexTransformed = true;
+  }
+}
+function transformVariableDeclaration(varNode, scopeManager) {
+  varNode.declarations.forEach((decl) => {
+    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";
+    if (isContextProperty) {
+      if (decl.id.name) {
+        scopeManager.addContextBoundVar(decl.id.name);
+      }
+      if (decl.id.properties) {
+        decl.id.properties.forEach((property) => {
+          if (property.key.name) {
+            scopeManager.addContextBoundVar(property.key.name);
+          }
+        });
+      }
+      decl.init.object.name = CONTEXT_NAME;
+      return;
+    }
+    if (isSubContextProperty) {
+      if (decl.id.name) {
+        scopeManager.addContextBoundVar(decl.id.name);
+      }
+      if (decl.id.properties) {
+        decl.id.properties.forEach((property) => {
+          if (property.key.name) {
+            scopeManager.addContextBoundVar(property.key.name);
+          }
+        });
+      }
+      decl.init.object.object.name = CONTEXT_NAME;
+      return;
+    }
+    if (isArrowFunction) {
+      decl.init.params.forEach((param) => {
+        if (param.type === "Identifier") {
+          scopeManager.addContextBoundVar(param.name);
+        }
+      });
+    }
+    const newName = scopeManager.addVariable(decl.id.name, varNode.kind);
+    const kind = varNode.kind;
+    if (decl.init && !isArrowFunction) {
+      if (decl.init.type === "CallExpression" && decl.init.callee.type === "MemberExpression" && decl.init.callee.object && decl.init.callee.object.type === "Identifier" && scopeManager.isContextBound(decl.init.callee.object.name)) {
+        transformCallExpression(decl.init, scopeManager);
+      } else {
+        walk.recursive(
+          decl.init,
+          { parent: decl.init },
+          {
+            Identifier(node, state) {
+              node.parent = state.parent;
+              transformIdentifier(node, scopeManager);
+              const isBinaryOperation = node.parent && node.parent.type === "BinaryExpression";
+              const isConditional = node.parent && node.parent.type === "ConditionalExpression";
+              if (node.type === "Identifier" && (isBinaryOperation || isConditional)) {
+                Object.assign(node, {
+                  type: "MemberExpression",
+                  object: {
+                    type: "Identifier",
+                    name: node.name
+                  },
+                  property: {
+                    type: "Literal",
+                    value: 0
+                  },
+                  computed: true
+                });
+              }
+            },
+            CallExpression(node, state, c) {
+              if (node.callee.type === "Identifier") {
+                node.callee.parent = node;
+              }
+              node.arguments.forEach((arg) => {
+                if (arg.type === "Identifier") {
+                  arg.parent = node;
+                }
+              });
+              transformCallExpression(node, scopeManager);
+              node.arguments.forEach((arg) => c(arg, { parent: node }));
+            },
+            BinaryExpression(node, state, c) {
+              if (node.left.type === "Identifier") {
+                node.left.parent = node;
+              }
+              if (node.right.type === "Identifier") {
+                node.right.parent = node;
+              }
+              c(node.left, { parent: node });
+              c(node.right, { parent: node });
+            },
+            MemberExpression(node, state, c) {
+              if (node.object.type === "Identifier") {
+                node.object.parent = node;
+              }
+              if (node.property.type === "Identifier") {
+                node.property.parent = node;
+              }
+              transformArrayIndex(node, scopeManager);
+              if (node.object) {
+                c(node.object, { parent: node });
+              }
+            }
+          }
+        );
+      }
+    }
+    const targetVarRef = {
+      type: "MemberExpression",
+      object: {
+        type: "MemberExpression",
+        object: {
+          type: "Identifier",
+          name: CONTEXT_NAME
+        },
+        property: {
+          type: "Identifier",
+          name: kind
+        },
+        computed: false
+      },
+      property: {
+        type: "Identifier",
+        name: newName
+      },
+      computed: false
+    };
+    const isArrayPatternVar = scopeManager.isArrayPatternElement(decl.id.name);
+    const isArrayInit = !isArrayPatternVar && decl.init && decl.init.type === "MemberExpression" && decl.init.computed && decl.init.property && (decl.init.property.type === "Literal" || decl.init.property.type === "MemberExpression");
+    if (decl.init?.property?.type === "MemberExpression") {
+      if (!decl.init.property._indexTransformed) {
+        transformArrayIndex(decl.init.property, scopeManager);
+        decl.init.property._indexTransformed = true;
+      }
+    }
+    const assignmentExpr = {
+      type: "ExpressionStatement",
+      expression: {
+        type: "AssignmentExpression",
+        operator: "=",
+        left: targetVarRef,
+        right: decl.init ? isArrowFunction || isArrayPatternVar ? decl.init : {
+          type: "CallExpression",
+          callee: {
+            type: "MemberExpression",
+            object: {
+              type: "Identifier",
+              name: CONTEXT_NAME
+            },
+            property: {
+              type: "Identifier",
+              name: "init"
+            },
+            computed: false
+          },
+          arguments: isArrayInit ? [targetVarRef, decl.init.object, decl.init.property] : [targetVarRef, decl.init]
+        } : {
+          type: "Identifier",
+          name: "undefined"
+        }
+      }
+    };
+    if (isArrayPatternVar) {
+      assignmentExpr.expression.right.object.property.name += "?.[0]";
+    }
+    if (isArrowFunction) {
+      scopeManager.pushScope("fn");
+      walk.recursive(decl.init.body, scopeManager, {
+        BlockStatement(node, state, c) {
+          node.body.forEach((stmt) => c(stmt, state));
+        },
+        IfStatement(node, state, c) {
+          state.pushScope("if");
+          c(node.consequent, state);
+          if (node.alternate) {
+            state.pushScope("els");
+            c(node.alternate, state);
+            state.popScope();
+          }
+          state.popScope();
+        },
+        VariableDeclaration(node, state) {
+          transformVariableDeclaration(node, state);
+        },
+        Identifier(node, state) {
+          transformIdentifier(node, state);
+        },
+        AssignmentExpression(node, state) {
+          transformAssignmentExpression(node, state);
+        }
+      });
+      scopeManager.popScope();
+    }
+    Object.assign(varNode, assignmentExpr);
+  });
+}
+function transformIdentifier(node, scopeManager) {
+  if (node.name !== CONTEXT_NAME) {
+    if (node.name === "Math" || node.name === "NaN" || node.name === "undefined" || node.name === "Infinity" || node.name === "null" || node.name.startsWith("'") && node.name.endsWith("'") || node.name.startsWith('"') && node.name.endsWith('"') || node.name.startsWith("`") && node.name.endsWith("`")) {
+      return;
+    }
+    if (scopeManager.isLoopVariable(node.name)) {
+      return;
+    }
+    if (scopeManager.isContextBound(node.name) && !scopeManager.isRootParam(node.name)) {
+      return;
+    }
+    const isNamespaceMember = node.parent && node.parent.type === "MemberExpression" && node.parent.object === node && scopeManager.isContextBound(node.name);
+    const isParamCall = node.parent && node.parent.type === "CallExpression" && node.parent.callee && node.parent.callee.type === "MemberExpression" && node.parent.callee.property.name === "param";
+    node.parent && node.parent.type === "AssignmentExpression" && node.parent.left === node;
+    const isNamespaceFunctionArg = node.parent && node.parent.type === "CallExpression" && node.parent.callee && node.parent.callee.type === "MemberExpression" && scopeManager.isContextBound(node.parent.callee.object.name);
+    const isArrayAccess = node.parent && node.parent.type === "MemberExpression" && node.parent.computed;
+    const isArrayIndexInNamespaceCall = node.parent && node.parent.type === "MemberExpression" && node.parent.computed && node.parent.property === node && node.parent.parent && node.parent.parent.type === "CallExpression" && node.parent.parent.callee && node.parent.parent.callee.type === "MemberExpression" && scopeManager.isContextBound(node.parent.parent.callee.object.name);
+    const isFunctionCall = node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
+    if (isNamespaceMember || isParamCall || isNamespaceFunctionArg || isArrayIndexInNamespaceCall || isFunctionCall) {
+      if (isFunctionCall) {
+        return;
+      }
+      const [scopedName2, kind2] = scopeManager.getVariable(node.name);
+      Object.assign(node, {
+        type: "MemberExpression",
+        object: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: CONTEXT_NAME
+          },
+          property: {
+            type: "Identifier",
+            name: kind2
+          },
+          computed: false
+        },
+        property: {
+          type: "Identifier",
+          name: scopedName2
+        },
+        computed: false
+      });
+      return;
+    }
+    const [scopedName, kind] = scopeManager.getVariable(node.name);
+    const memberExpr = {
+      type: "MemberExpression",
+      object: {
+        type: "MemberExpression",
+        object: {
+          type: "Identifier",
+          name: CONTEXT_NAME
+        },
+        property: {
+          type: "Identifier",
+          name: kind
+        },
+        computed: false
+      },
+      property: {
+        type: "Identifier",
+        name: scopedName
+      },
+      computed: false
+    };
+    const hasArrayAccess = node.parent && node.parent.type === "MemberExpression" && node.parent.computed && node.parent.object === node;
+    if (!hasArrayAccess && !isArrayAccess) {
+      Object.assign(node, {
+        type: "MemberExpression",
+        object: memberExpr,
+        property: {
+          type: "Literal",
+          value: 0
+        },
+        computed: true
+      });
+    } else {
+      Object.assign(node, memberExpr);
+    }
+  }
+}
+function transformAssignmentExpression(node, scopeManager) {
+  if (node.left.type === "Identifier") {
+    const [varName, kind] = scopeManager.getVariable(node.left.name);
+    const memberExpr = {
+      type: "MemberExpression",
+      object: {
+        type: "MemberExpression",
+        object: {
+          type: "Identifier",
+          name: CONTEXT_NAME
+        },
+        property: {
+          type: "Identifier",
+          name: kind
+        },
+        computed: false
+      },
+      property: {
+        type: "Identifier",
+        name: varName
+      },
+      computed: false
+    };
+    node.left = {
+      type: "MemberExpression",
+      object: memberExpr,
+      property: {
+        type: "Literal",
+        value: 0
+      },
+      computed: true
+    };
+  }
+  walk.recursive(
+    node.right,
+    { parent: node.right, inNamespaceCall: false },
+    {
+      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);
+          }
+        }
+      },
+      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 }));
+      }
+    }
+  );
+}
+function transformArrowFunctionParams(node, scopeManager, isRootFunction = false) {
+  node.params.forEach((param) => {
+    if (param.type === "Identifier") {
+      scopeManager.addContextBoundVar(param.name, isRootFunction);
+    }
+  });
+}
+function transformReturnStatement(node, scopeManager) {
+  const curScope = scopeManager.getCurrentScopeType();
+  if (node.argument) {
+    if (node.argument.type === "ArrayExpression") {
+      node.argument.elements = node.argument.elements.map((element) => {
+        if (element.type === "Identifier") {
+          if (scopeManager.isContextBound(element.name) && !scopeManager.isRootParam(element.name)) {
+            return {
+              type: "MemberExpression",
+              object: element,
+              property: {
+                type: "Literal",
+                value: 0
+              },
+              computed: true
+            };
+          }
+          const [scopedName, kind] = scopeManager.getVariable(element.name);
+          return {
+            type: "MemberExpression",
+            object: {
+              type: "MemberExpression",
+              object: {
+                type: "MemberExpression",
+                object: {
+                  type: "Identifier",
+                  name: CONTEXT_NAME
+                },
+                property: {
+                  type: "Identifier",
+                  name: kind
+                },
+                computed: false
+              },
+              property: {
+                type: "Identifier",
+                name: scopedName
+              },
+              computed: false
+            },
+            property: {
+              type: "Literal",
+              value: 0
+            },
+            computed: true
+          };
+        } else if (element.type === "MemberExpression") {
+          if (element.computed && element.object.type === "Identifier" && scopeManager.isContextBound(element.object.name) && !scopeManager.isRootParam(element.object.name)) {
+            return element;
+          }
+          transformMemberExpression(element, "", scopeManager);
+          return element;
+        }
+        return element;
+      });
+      node.argument = {
+        type: "ArrayExpression",
+        elements: [node.argument]
+      };
+    } else if (node.argument.type === "BinaryExpression") {
+      walk.recursive(node.argument, scopeManager, {
+        Identifier(node2, state) {
+          transformIdentifier(node2, state);
+          if (node2.type === "Identifier") {
+            addArrayAccess(node2);
+          }
+        },
+        MemberExpression(node2) {
+          transformMemberExpression(node2, "", scopeManager);
+        }
+      });
+    } else if (node.argument.type === "ObjectExpression") {
+      node.argument.properties = node.argument.properties.map((prop) => {
+        if (prop.shorthand) {
+          const [scopedName, kind] = scopeManager.getVariable(prop.value.name);
+          return {
+            type: "Property",
+            key: {
+              type: "Identifier",
+              name: prop.key.name
+            },
+            value: {
+              type: "MemberExpression",
+              object: {
+                type: "MemberExpression",
+                object: {
+                  type: "Identifier",
+                  name: CONTEXT_NAME
+                },
+                property: {
+                  type: "Identifier",
+                  name: kind
+                },
+                computed: false
+              },
+              property: {
+                type: "Identifier",
+                name: scopedName
+              },
+              computed: false
+            },
+            kind: "init",
+            method: false,
+            shorthand: false,
+            computed: false
+          };
+        }
+        return prop;
+      });
+    } else if (node.argument.type === "Identifier") {
+      const [scopedName, kind] = scopeManager.getVariable(node.argument.name);
+      node.argument = {
+        type: "MemberExpression",
+        object: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: CONTEXT_NAME
+          },
+          property: {
+            type: "Identifier",
+            name: kind
+          },
+          computed: false
+        },
+        property: {
+          type: "Identifier",
+          name: scopedName
+        },
+        computed: false
+      };
+      node.argument = {
+        type: "MemberExpression",
+        object: node.argument,
+        property: {
+          type: "Literal",
+          value: 0
+        },
+        computed: true
+      };
+    }
+    if (curScope === "fn") {
+      node.argument = {
+        type: "CallExpression",
+        callee: {
+          type: "MemberExpression",
+          object: { type: "Identifier", name: CONTEXT_NAME },
+          property: { type: "Identifier", name: "precision" }
+        },
+        arguments: [node.argument]
+      };
+    }
+  }
+}
+function transformIdentifierForParam(node, scopeManager) {
+  if (node.type === "Identifier") {
+    if (scopeManager.isLoopVariable(node.name)) {
+      return node;
+    }
+    if (scopeManager.isRootParam(node.name)) {
+      const [scopedName2, kind2] = scopeManager.getVariable(node.name);
+      return {
+        type: "MemberExpression",
+        object: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: CONTEXT_NAME
+          },
+          property: {
+            type: "Identifier",
+            name: kind2
+          },
+          computed: false
+        },
+        property: {
+          type: "Identifier",
+          name: scopedName2
+        },
+        computed: false
+      };
+    }
+    if (scopeManager.isContextBound(node.name)) {
+      return node;
+    }
+    const [scopedName, kind] = scopeManager.getVariable(node.name);
+    return {
+      type: "MemberExpression",
+      object: {
+        type: "MemberExpression",
+        object: {
+          type: "Identifier",
+          name: CONTEXT_NAME
+        },
+        property: {
+          type: "Identifier",
+          name: kind
+        },
+        computed: false
+      },
+      property: {
+        type: "Identifier",
+        name: scopedName
+      },
+      computed: false
+    };
+  }
+  return node;
+}
+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;
+    }
+    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
+    };
+  }
+  return node;
+}
+function transformBinaryExpression(node, scopeManager, namespace) {
+  const transformedLeft = transformOperand(node.left, scopeManager, namespace);
+  const transformedRight = transformOperand(node.right, scopeManager, namespace);
+  const binaryExpr = {
+    type: "BinaryExpression",
+    operator: node.operator,
+    left: transformedLeft,
+    right: transformedRight,
+    start: node.start,
+    end: node.end
+  };
+  walk.recursive(binaryExpr, scopeManager, {
+    CallExpression(node2, scopeManager2) {
+      if (!node2._transformed) {
+        transformCallExpression(node2, scopeManager2);
+      }
+    },
+    MemberExpression(node2) {
+      transformMemberExpression(node2, "", scopeManager);
+    }
+  });
+  return {
+    type: "CallExpression",
+    callee: {
+      type: "MemberExpression",
+      object: {
+        type: "Identifier",
+        name: namespace
+      },
+      property: {
+        type: "Identifier",
+        name: "param"
+      },
+      computed: false
+    },
+    arguments: [binaryExpr, UNDEFINED_ARG, scopeManager.nextParamIdArg],
+    _transformed: true,
+    _isParamCall: true
+  };
+}
+function transformFunctionArgument(arg, namespace, scopeManager) {
+  if (arg.type === "BinaryExpression") {
+    return transformBinaryExpression(arg, scopeManager, namespace);
+  }
+  const isArrayAccess = arg.type === "MemberExpression" && arg.computed && arg.property;
+  if (isArrayAccess) {
+    const transformedObject = arg.object.type === "Identifier" && scopeManager.isContextBound(arg.object.name) && !scopeManager.isRootParam(arg.object.name) ? arg.object : transformIdentifierForParam(arg.object, scopeManager);
+    const transformedProperty = arg.property.type === "Identifier" && !scopeManager.isContextBound(arg.property.name) && !scopeManager.isLoopVariable(arg.property.name) ? transformIdentifierForParam(arg.property, scopeManager) : arg.property;
+    return {
+      type: "CallExpression",
+      callee: {
+        type: "MemberExpression",
+        object: {
+          type: "Identifier",
+          name: namespace
+        },
+        property: {
+          type: "Identifier",
+          name: "param"
+        },
+        computed: false
+      },
+      arguments: [transformedObject, transformedProperty, scopeManager.nextParamIdArg],
+      _transformed: true,
+      _isParamCall: true
+    };
+  }
+  if (arg.type === "ObjectExpression") {
+    arg.properties = arg.properties.map((prop) => {
+      if (prop.value.name) {
+        const [scopedName, kind] = scopeManager.getVariable(prop.value.name);
+        return {
+          type: "Property",
+          key: {
+            type: "Identifier",
+            name: prop.key.name
+          },
+          value: {
+            type: "MemberExpression",
+            object: {
+              type: "MemberExpression",
+              object: {
+                type: "Identifier",
+                name: CONTEXT_NAME
+              },
+              property: {
+                type: "Identifier",
+                name: kind
+              },
+              computed: false
+            },
+            property: {
+              type: "Identifier",
+              name: scopedName
+            },
+            computed: false
+          },
+          kind: "init",
+          method: false,
+          shorthand: false,
+          computed: false
+        };
+      }
+      return prop;
+    });
+  }
+  if (arg.type === "Identifier") {
+    if (scopeManager.isContextBound(arg.name) && !scopeManager.isRootParam(arg.name)) {
+      return {
+        type: "CallExpression",
+        callee: {
+          type: "MemberExpression",
+          object: {
+            type: "Identifier",
+            name: namespace
+          },
+          property: {
+            type: "Identifier",
+            name: "param"
+          },
+          computed: false
+        },
+        arguments: [arg, UNDEFINED_ARG, scopeManager.nextParamIdArg],
+        _transformed: true,
+        _isParamCall: true
+      };
+    }
+  }
+  if (arg?.type === "CallExpression") {
+    transformCallExpression(arg, scopeManager);
+  }
+  return {
+    type: "CallExpression",
+    callee: {
+      type: "MemberExpression",
+      object: {
+        type: "Identifier",
+        name: namespace
+      },
+      property: {
+        type: "Identifier",
+        name: "param"
+      },
+      computed: false
+    },
+    arguments: [arg.type === "Identifier" ? transformIdentifierForParam(arg, scopeManager) : arg, UNDEFINED_ARG, scopeManager.nextParamIdArg],
+    _transformed: true,
+    _isParamCall: true
+  };
+}
+function transformCallExpression(node, scopeManager) {
+  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;
+    node.arguments = node.arguments.map((arg) => {
+      if (arg._isParamCall) {
+        return arg;
+      }
+      return transformFunctionArgument(arg, namespace, scopeManager);
+    });
+    node._transformed = true;
+  } else if (node.callee && node.callee.type === "Identifier") {
+    node.arguments = node.arguments.map((arg) => {
+      if (arg._isParamCall) {
+        return arg;
+      }
+      return transformFunctionArgument(arg, CONTEXT_NAME, scopeManager);
+    });
+    node._transformed = true;
+  }
+  node.arguments.forEach((arg) => {
+    walk.recursive(arg, scopeManager, {
+      CallExpression(node2, state) {
+        if (!node2._transformed) {
+          transformCallExpression(node2, state);
+        }
+      },
+      MemberExpression(node2) {
+        transformMemberExpression(node2, "", scopeManager);
+      }
+    });
+  });
+}
+function transformFunctionDeclaration(node, scopeManager) {
+  node.params.forEach((param) => {
+    if (param.type === "Identifier") {
+      scopeManager.addContextBoundVar(param.name, false);
+    }
+  });
+  if (node.body && node.body.type === "BlockStatement") {
+    scopeManager.pushScope("fn");
+    walk.recursive(node.body, scopeManager, {
+      BlockStatement(node2, state, c) {
+        node2.body.forEach((stmt) => c(stmt, state));
+      },
+      ReturnStatement(node2, state) {
+        transformReturnStatement(node2, state);
+      },
+      VariableDeclaration(node2, state) {
+        transformVariableDeclaration(node2, state);
+      },
+      Identifier(node2, state) {
+        transformIdentifier(node2, state);
+      },
+      CallExpression(node2, state) {
+        transformCallExpression(node2, state);
+        node2.arguments.forEach((arg) => {
+          if (arg.type === "BinaryExpression") {
+            walk.recursive(arg, state, {
+              CallExpression(node3, state2) {
+                transformCallExpression(node3, state2);
+              },
+              MemberExpression(node3) {
+                transformMemberExpression(node3, "", state);
+              }
+            });
+          }
+        });
+      },
+      MemberExpression(node2) {
+        transformMemberExpression(node2, "", scopeManager);
+      },
+      AssignmentExpression(node2, state) {
+        transformAssignmentExpression(node2, state);
+      },
+      ForStatement(node2, state, c) {
+        transformForStatement(node2, state, c);
+      },
+      IfStatement(node2, state, c) {
+        transformIfStatement(node2, state, c);
+      },
+      BinaryExpression(node2, state, c) {
+        walk.recursive(node2, state, {
+          CallExpression(node3, state2) {
+            transformCallExpression(node3, state2);
+          },
+          MemberExpression(node3) {
+            transformMemberExpression(node3, "", state);
+          }
+        });
+      }
+    });
+    scopeManager.popScope();
+  }
+}
+function addArrayAccess(node, scopeManager) {
+  Object.assign(node, {
+    type: "MemberExpression",
+    object: {
+      type: "Identifier",
+      name: node.name,
+      start: node.start,
+      end: node.end
+    },
+    property: {
+      type: "Literal",
+      value: 0
+    },
+    computed: true,
+    _indexTransformed: true
+  });
+}
+function transformForStatement(node, scopeManager, c) {
+  if (node.init && node.init.type === "VariableDeclaration") {
+    const decl = node.init.declarations[0];
+    const originalName = decl.id.name;
+    scopeManager.addLoopVariable(originalName, originalName);
+    node.init = {
+      type: "VariableDeclaration",
+      kind: node.init.kind,
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: {
+            type: "Identifier",
+            name: originalName
+          },
+          init: decl.init
+        }
+      ]
+    };
+    if (decl.init) {
+      walk.recursive(decl.init, scopeManager, {
+        Identifier(node2, state) {
+          if (!scopeManager.isLoopVariable(node2.name)) {
+            scopeManager.pushScope("for");
+            transformIdentifier(node2, state);
+            scopeManager.popScope();
+          }
+        },
+        MemberExpression(node2) {
+          scopeManager.pushScope("for");
+          transformMemberExpression(node2, "", scopeManager);
+          scopeManager.popScope();
+        }
+      });
+    }
+  }
+  if (node.test) {
+    walk.recursive(node.test, scopeManager, {
+      Identifier(node2, state) {
+        if (!scopeManager.isLoopVariable(node2.name) && !node2.computed) {
+          scopeManager.pushScope("for");
+          transformIdentifier(node2, state);
+          if (node2.type === "Identifier") {
+            node2.computed = true;
+            addArrayAccess(node2);
+          }
+          scopeManager.popScope();
+        }
+      },
+      MemberExpression(node2) {
+        scopeManager.pushScope("for");
+        transformMemberExpression(node2, "", scopeManager);
+        scopeManager.popScope();
+      }
+    });
+  }
+  if (node.update) {
+    walk.recursive(node.update, scopeManager, {
+      Identifier(node2, state) {
+        if (!scopeManager.isLoopVariable(node2.name)) {
+          scopeManager.pushScope("for");
+          transformIdentifier(node2, state);
+          scopeManager.popScope();
+        }
+      }
+    });
+  }
+  scopeManager.pushScope("for");
+  c(node.body, scopeManager);
+  scopeManager.popScope();
+}
+function transformExpression(node, scopeManager) {
+  walk.recursive(node, scopeManager, {
+    MemberExpression(node2) {
+      transformMemberExpression(node2, "", scopeManager);
+    },
+    CallExpression(node2, state) {
+      transformCallExpression(node2, state);
+    },
+    Identifier(node2, state) {
+      transformIdentifier(node2, state);
+      const isIfStatement = scopeManager.getCurrentScopeType() === "if";
+      const isContextBound = scopeManager.isContextBound(node2.name) && !scopeManager.isRootParam(node2.name);
+      if (isContextBound && isIfStatement) {
+        addArrayAccess(node2);
+      }
+    }
+  });
+}
+function transformIfStatement(node, scopeManager, c) {
+  if (node.test) {
+    scopeManager.pushScope("if");
+    transformExpression(node.test, scopeManager);
+    scopeManager.popScope();
+  }
+  scopeManager.pushScope("if");
+  c(node.consequent, scopeManager);
+  scopeManager.popScope();
+  if (node.alternate) {
+    scopeManager.pushScope("els");
+    c(node.alternate, scopeManager);
+    scopeManager.popScope();
+  }
+}
+function transformNestedArrowFunctions(ast) {
+  walk.recursive(ast, null, {
+    VariableDeclaration(node, state, c) {
+      if (node.declarations && node.declarations.length > 0) {
+        const declarations = node.declarations;
+        declarations.forEach((decl) => {
+          if (decl.init && decl.init.type === "ArrowFunctionExpression") {
+            const isRootFunction = decl.init.start === 0;
+            if (!isRootFunction) {
+              const functionDeclaration = {
+                type: "FunctionDeclaration",
+                id: decl.id,
+                // Use the variable name as function name
+                params: decl.init.params,
+                body: decl.init.body.type === "BlockStatement" ? decl.init.body : {
+                  type: "BlockStatement",
+                  body: [
+                    {
+                      type: "ReturnStatement",
+                      argument: decl.init.body
+                    }
+                  ]
+                },
+                async: decl.init.async,
+                generator: false
+              };
+              Object.assign(node, functionDeclaration);
+            }
+          }
+        });
+      }
+      if (node.body && node.body.body) {
+        node.body.body.forEach((stmt) => c(stmt, state));
+      }
+    }
+  });
+}
+function preProcessContextBoundVars(ast, scopeManager) {
+  walk.simple(ast, {
+    VariableDeclaration(node) {
+      node.declarations.forEach((decl) => {
+        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");
+        if (isContextProperty || isSubContextProperty) {
+          if (decl.id.name) {
+            scopeManager.addContextBoundVar(decl.id.name);
+          }
+          if (decl.id.properties) {
+            decl.id.properties.forEach((property) => {
+              if (property.key.name) {
+                scopeManager.addContextBoundVar(property.key.name);
+              }
+            });
+          }
+        }
+      });
+    }
+  });
+}
+function transpile(fn) {
+  let code = typeof fn === "function" ? fn.toString() : fn;
+  const ast = acorn.parse(code.trim(), {
+    ecmaVersion: "latest",
+    sourceType: "module"
+  });
+  transformNestedArrowFunctions(ast);
+  const scopeManager = new ScopeManager();
+  let originalParamName;
+  preProcessContextBoundVars(ast, scopeManager);
+  walk.simple(ast, {
+    FunctionDeclaration(node) {
+      transformFunctionDeclaration(node, scopeManager);
+    },
+    ArrowFunctionExpression(node) {
+      const isRootFunction = node.start === 0;
+      if (isRootFunction && node.params && node.params.length > 0) {
+        originalParamName = node.params[0].name;
+        node.params[0].name = CONTEXT_NAME;
+      }
+      transformArrowFunctionParams(node, scopeManager, isRootFunction);
+    },
+    VariableDeclaration(node) {
+      node.declarations.forEach((decl) => {
+        if (decl.id.type === "ArrayPattern") {
+          const tempVarName = scopeManager.generateTempVar();
+          const tempVarDecl = {
+            type: "VariableDeclaration",
+            kind: node.kind,
+            declarations: [
+              {
+                type: "VariableDeclarator",
+                id: {
+                  type: "Identifier",
+                  name: tempVarName
+                },
+                init: decl.init
+              }
+            ]
+          };
+          decl.id.elements?.forEach((element) => {
+            if (element.type === "Identifier") {
+              scopeManager.addArrayPatternElement(element.name);
+            }
+          });
+          const individualDecls = decl.id.elements.map((element, index) => ({
+            type: "VariableDeclaration",
+            kind: node.kind,
+            declarations: [
+              {
+                type: "VariableDeclarator",
+                id: element,
+                init: {
+                  type: "MemberExpression",
+                  object: {
+                    type: "Identifier",
+                    name: tempVarName
+                  },
+                  property: {
+                    type: "Literal",
+                    value: index
+                  },
+                  computed: true
+                }
+              }
+            ]
+          }));
+          Object.assign(node, {
+            type: "BlockStatement",
+            body: [tempVarDecl, ...individualDecls]
+          });
+        }
+      });
+    },
+    ForStatement(node) {
+    }
+  });
+  walk.recursive(ast, scopeManager, {
+    BlockStatement(node, state, c) {
+      node.body.forEach((stmt) => c(stmt, state));
+    },
+    ReturnStatement(node, state) {
+      transformReturnStatement(node, state);
+    },
+    VariableDeclaration(node, state) {
+      transformVariableDeclaration(node, state);
+    },
+    Identifier(node, state) {
+      transformIdentifier(node, state);
+    },
+    CallExpression(node, state) {
+      transformCallExpression(node, state);
+    },
+    MemberExpression(node) {
+      transformMemberExpression(node, originalParamName, scopeManager);
+    },
+    AssignmentExpression(node, state) {
+      transformAssignmentExpression(node, state);
+    },
+    FunctionDeclaration(node, state) {
+      return;
+    },
+    ForStatement(node, state, c) {
+      transformForStatement(node, state, c);
+    },
+    IfStatement(node, state, c) {
+      transformIfStatement(node, state, c);
+    }
+  });
+  const transformedCode = astring.generate(ast);
+  const _wraperFunction = new Function("", `return ${transformedCode}`);
+  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);
+class PineTS {
+  constructor(source, tickerId, timeframe, limit, sDate, eDate) {
+    this.source = source;
+    this.tickerId = tickerId;
+    this.timeframe = timeframe;
+    this.limit = limit;
+    this.sDate = sDate;
+    this.eDate = eDate;
+    __publicField$4(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", []);
+    //#endregion
+    //#region run context
+    __publicField$4(this, "_periods");
+    //#endregion
+    //public fn: Function;
+    __publicField$4(this, "_readyPromise", null);
+    __publicField$4(this, "_ready", false);
+    this._readyPromise = new Promise((resolve) => {
+      this.loadMarketData(source, tickerId, timeframe, limit, sDate, eDate).then((data) => {
+        const marketData = data.reverse();
+        this._periods = marketData.length;
+        this.data = marketData;
+        const _open = marketData.map((d) => d.open);
+        const _close = marketData.map((d) => d.close);
+        const _high = marketData.map((d) => d.high);
+        const _low = marketData.map((d) => d.low);
+        const _volume = marketData.map((d) => d.volume);
+        const _hlc3 = marketData.map((d) => (d.high + d.low + d.close) / 3);
+        const _hl2 = marketData.map((d) => (d.high + d.low) / 2);
+        const _ohlc4 = marketData.map((d) => (d.high + d.low + d.open + d.close) / 4);
+        const _openTime = marketData.map((d) => d.openTime);
+        const _closeTime = marketData.map((d) => d.closeTime);
+        this.open = _open;
+        this.close = _close;
+        this.high = _high;
+        this.low = _low;
+        this.volume = _volume;
+        this.hl2 = _hl2;
+        this.hlc3 = _hlc3;
+        this.ohlc4 = _ohlc4;
+        this.openTime = _openTime;
+        this.closeTime = _closeTime;
+        this._ready = true;
+        resolve(true);
+      });
+    });
+  }
+  get periods() {
+    return this._periods;
+  }
+  async loadMarketData(source, tickerId, timeframe, limit, sDate, eDate) {
+    if (Array.isArray(source)) {
+      return source;
+    } else {
+      return source.getMarketData(tickerId, timeframe, limit, sDate, eDate);
+    }
+  }
+  async ready() {
+    if (this._ready) return true;
+    if (!this._readyPromise) throw new Error("PineTS is not ready");
+    return this._readyPromise;
+  }
+  async run(fn, n) {
+    await this.ready();
+    if (!n) n = this._periods;
+    const context = new Context(this.data);
+    context.timeframe = this.timeframe;
+    const transformer = transpile.bind(this);
+    let transformedFn = transformer(fn);
+    const contextVarNames = ["const", "var", "let", "params"];
+    for (let i = this._periods - n, idx = n - 1; i < this._periods; i++, idx--) {
+      context.idx = i;
+      context.data.close = this.close.slice(idx);
+      context.data.open = this.open.slice(idx);
+      context.data.high = this.high.slice(idx);
+      context.data.low = this.low.slice(idx);
+      context.data.volume = this.volume.slice(idx);
+      context.data.hl2 = this.hl2.slice(idx);
+      context.data.hlc3 = this.hlc3.slice(idx);
+      context.data.ohlc4 = this.ohlc4.slice(idx);
+      context.data.openTime = this.openTime.slice(idx);
+      context.data.closeTime = this.closeTime.slice(idx);
+      const result = await transformedFn(context);
+      if (typeof result === "object") {
+        if (typeof context.result !== "object") {
+          context.result = {};
+        }
+        for (let key in result) {
+          if (context.result[key] === void 0) {
+            context.result[key] = [];
+          }
+          const val = Array.isArray(result[key]) ? result[key][0] : result[key];
+          context.result[key].push(val);
+        }
+      } else {
+        if (!Array.isArray(context.result)) {
+          context.result = [];
+        }
+        context.result.push(result);
+      }
+      for (let ctxVarName of contextVarNames) {
+        for (let key in context[ctxVarName]) {
+          if (Array.isArray(context[ctxVarName][key])) {
+            const val = context[ctxVarName][key][0];
+            context[ctxVarName][key].unshift(val);
+          }
+        }
+      }
+    }
+    return context;
+  }
+}
+
+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);
+class Core {
+  constructor(context) {
+    this.context = context;
+    __publicField$3(this, "color", {
+      white: "white",
+      lime: "lime",
+      green: "green",
+      red: "red",
+      maroon: "maroon",
+      black: "black",
+      gray: "gray",
+      blue: "blue"
+    });
+  }
+  extractPlotOptions(options) {
+    const _options = {};
+    for (let key in options) {
+      if (Array.isArray(options[key])) {
+        _options[key] = options[key][0];
+      } else {
+        _options[key] = options[key];
+      }
+    }
+    return _options;
+  }
+  indicator(title, shorttitle, options) {
+  }
+  //in the current implementation, plot functions are only used to collect data for the plots array and map it to the market data
+  plotchar(series, title, options) {
+    if (!this.context.plots[title]) {
+      this.context.plots[title] = { data: [], options: this.extractPlotOptions(options), title };
+    }
+    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)
+    });
+  }
+  plot(series, title, options) {
+    if (!this.context.plots[title]) {
+      this.context.plots[title] = { data: [], options: this.extractPlotOptions(options), title };
+    }
+    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)
+    });
+  }
+  na(series) {
+    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;
+    }
+  }
+}
+
+class Input {
+  constructor(context) {
+    this.context = context;
+  }
+  param(source, index = 0) {
+    if (Array.isArray(source)) {
+      return [source[index]];
+    }
+    return [source];
+  }
+  any(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  int(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  float(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  bool(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  string(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  timeframe(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  time(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  price(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  session(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  source(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  symbol(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  text_area(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  enum(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : value;
+  }
+  color(value, { title, group } = {}) {
+    return Array.isArray(value) ? value[0] : 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 PineMath {
+  constructor(context) {
+    this.context = context;
+    __publicField$2(this, "_cache", {});
+  }
+  param(source, index = 0) {
+    if (Array.isArray(source)) {
+      return source[index];
+    }
+    return source;
+  }
+  abs(n) {
+    return Math.abs(n);
+  }
+  pow(a, b) {
+    return Math.pow(a, b);
+  }
+  sqrt(a) {
+    return Math.sqrt(a);
+  }
+  log(a) {
+    return Math.log(a);
+  }
+  ln(a) {
+    return Math.log(a);
+  }
+  exp(a) {
+    return Math.exp(a);
+  }
+  floor(a) {
+    return Math.floor(a);
+  }
+  ceil(a) {
+    return Math.ceil(a);
+  }
+  round(a) {
+    return Math.round(a);
+  }
+  random() {
+    return Math.random();
+  }
+  max(...args) {
+    return Math.max(...args);
+  }
+  min(...args) {
+    return Math.min(...args);
+  }
+  sin(a) {
+    return Math.sin(a);
+  }
+  cos(a) {
+    return Math.cos(a);
+  }
+  tan(a) {
+    return Math.tan(a);
+  }
+  asin(a) {
+    return Math.asin(a);
+  }
+  acos(a) {
+    return Math.acos(a);
+  }
+  atan(a) {
+    return Math.atan(a);
+  }
+  avg(...args) {
+    return args.reduce((a, b) => {
+      const aVal = Array.isArray(a) ? a[0] : a;
+      const bVal = Array.isArray(b) ? b[0] : b;
+      return aVal + bVal;
+    }, 0) / args.length;
+  }
+}
+
+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 PineRequest {
+  constructor(context) {
+    this.context = context;
+    __publicField$1(this, "_cache", {});
+  }
+  param(source, index, name) {
+    if (!this.context.params[name]) this.context.params[name] = [];
+    if (Array.isArray(source)) {
+      if (index) {
+        this.context.params[name] = source.slice(index);
+      } else {
+        this.context.params[name] = source.slice(0);
+      }
+      return [source[index], name];
+    } else {
+      this.context.params[name][0] = source;
+      return [source, name];
+    }
+  }
+  async security(symbol, timeframe, expression) {
+    throw new Error("Not implemented");
+  }
+}
+
+class TechnicalAnalysis {
+  constructor(context) {
+    this.context = context;
+  }
+  get tr() {
+    const val = this.context.math.max(
+      this.context.data.high[0] - this.context.data.low[0],
+      this.context.math.abs(this.context.data.high[0] - this.context.data.close[1]),
+      this.context.math.abs(this.context.data.low[0] - this.context.data.close[1])
+    );
+    return val;
+  }
+  param(source, index, name) {
+    if (!this.context.params[name]) this.context.params[name] = [];
+    if (Array.isArray(source)) {
+      if (index) {
+        this.context.params[name] = source.slice(index);
+        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];
+    }
+  }
+  ema(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const result = ema(source.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  sma(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const result = sma(source.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  vwma(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const volume = this.context.data.volume;
+    const result = vwma(source.slice(0).reverse(), volume.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  wma(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const result = wma(source.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  hma(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const result = hma(source.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  rma(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const result = rma(source.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  change(source, _length = 1) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = change(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  rsi(source, _period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const result = rsi(source.slice(0).reverse(), period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  atr(_period) {
+    const period = Array.isArray(_period) ? _period[0] : _period;
+    const high = this.context.data.high.slice().reverse();
+    const low = this.context.data.low.slice().reverse();
+    const close = this.context.data.close.slice().reverse();
+    const result = atr(high, low, close, period);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  mom(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = mom(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  roc(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = roc(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  dev(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = dev(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  variance(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = variance(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  highest(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = highest(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  lowest(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = lowest(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  median(source, _length) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const result = median(source.slice(0).reverse(), length);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  stdev(source, _length, _bias = true) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const bias = Array.isArray(_bias) ? _bias[0] : _bias;
+    const result = stdev(source.slice(0).reverse(), length, bias);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  linreg(source, _length, _offset) {
+    const length = Array.isArray(_length) ? _length[0] : _length;
+    const offset = Array.isArray(_offset) ? _offset[0] : _offset;
+    const result = linreg(source.slice(0).reverse(), length, offset);
+    const idx = this.context.idx;
+    return this.context.precision(result[idx]);
+  }
+  supertrend(_factor, _atrPeriod) {
+    const factor = Array.isArray(_factor) ? _factor[0] : _factor;
+    const atrPeriod = Array.isArray(_atrPeriod) ? _atrPeriod[0] : _atrPeriod;
+    const high = this.context.data.high.slice().reverse();
+    const low = this.context.data.low.slice().reverse();
+    const close = this.context.data.close.slice().reverse();
+    const [supertrend, direction] = calculateSupertrend(high, low, close, factor, atrPeriod);
+    const idx = this.context.idx;
+    return [[this.context.precision(supertrend[idx]), direction[idx]]];
+  }
+}
+function atr(high, low, close, period) {
+  const tr = new Array(high.length);
+  tr[0] = high[0] - low[0];
+  for (let i = 1; i < high.length; i++) {
+    const hl = high[i] - low[i];
+    const hc = Math.abs(high[i] - close[i - 1]);
+    const lc = Math.abs(low[i] - close[i - 1]);
+    tr[i] = Math.max(hl, hc, lc);
+  }
+  const atr2 = new Array(high.length).fill(NaN);
+  let sum = 0;
+  for (let i = 0; i < period; i++) {
+    sum += tr[i];
+  }
+  atr2[period - 1] = sum / period;
+  for (let i = period; i < tr.length; i++) {
+    atr2[i] = (atr2[i - 1] * (period - 1) + tr[i]) / period;
+  }
+  return atr2;
+}
+function ema(source, period) {
+  const result = new Array(source.length).fill(NaN);
+  const alpha = 2 / (period + 1);
+  let sum = 0;
+  for (let i = 0; i < period; i++) {
+    sum += source[i] || 0;
+  }
+  result[period - 1] = sum / period;
+  for (let i = period; i < source.length; i++) {
+    result[i] = source[i] * alpha + result[i - 1] * (1 - alpha);
+  }
+  return result;
+}
+function rsi(source, period) {
+  const result = new Array(source.length).fill(NaN);
+  const gains = new Array(source.length).fill(0);
+  const losses = new Array(source.length).fill(0);
+  for (let i = 1; i < source.length; i++) {
+    const diff = source[i] - source[i - 1];
+    gains[i] = diff > 0 ? diff : 0;
+    losses[i] = diff < 0 ? -diff : 0;
+  }
+  let avgGain = 0;
+  let avgLoss = 0;
+  for (let i = 1; i <= period; i++) {
+    avgGain += gains[i];
+    avgLoss += losses[i];
+  }
+  avgGain /= period;
+  avgLoss /= period;
+  result[period] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  for (let i = period + 1; i < source.length; i++) {
+    avgGain = (avgGain * (period - 1) + gains[i]) / period;
+    avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+    result[i] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  }
+  return result;
+}
+function rma(source, period) {
+  const result = new Array(source.length).fill(NaN);
+  const alpha = 1 / period;
+  let sum = 0;
+  for (let i = 0; i < period; i++) {
+    sum += source[i] || 0;
+  }
+  result[period - 1] = sum / period;
+  for (let i = period; i < source.length; i++) {
+    const currentValue = source[i] || 0;
+    result[i] = currentValue * alpha + result[i - 1] * (1 - alpha);
+  }
+  return result;
+}
+function sma(source, period) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = period - 1; i < source.length; i++) {
+    let sum = 0;
+    for (let j = 0; j < period; j++) {
+      sum += source[i - j] || 0;
+    }
+    result[i] = sum / period;
+  }
+  return result;
+}
+function vwma(source, volume, period) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = period - 1; i < source.length; i++) {
+    let sumVol = 0;
+    let sumVolPrice = 0;
+    for (let j = 0; j < period; j++) {
+      sumVol += volume[i - j];
+      sumVolPrice += source[i - j] * volume[i - j];
+    }
+    result[i] = sumVolPrice / sumVol;
+  }
+  return result;
+}
+function hma(source, period) {
+  const halfPeriod = Math.floor(period / 2);
+  const wma1 = wma(source, halfPeriod);
+  const wma2 = wma(source, period);
+  const rawHma = wma1.map((value, index) => 2 * value - wma2[index]);
+  const sqrtPeriod = Math.floor(Math.sqrt(period));
+  const result = wma(rawHma, sqrtPeriod);
+  return result;
+}
+function wma(source, period) {
+  const result = new Array(source.length);
+  for (let i = period - 1; i < source.length; i++) {
+    let numerator = 0;
+    let denominator = 0;
+    for (let j = 0; j < period; j++) {
+      numerator += source[i - j] * (period - j);
+      denominator += period - j;
+    }
+    result[i] = numerator / denominator;
+  }
+  for (let i = 0; i < period - 1; i++) {
+    result[i] = NaN;
+  }
+  return result;
+}
+function change(source, length = 1) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length; i < source.length; i++) {
+    result[i] = source[i] - source[i - length];
+  }
+  return result;
+}
+function mom(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length; i < source.length; i++) {
+    result[i] = source[i] - source[i - length];
+  }
+  return result;
+}
+function roc(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length; i < source.length; i++) {
+    result[i] = (source[i] - source[i - length]) / source[i - length] * 100;
+  }
+  return result;
+}
+function dev(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  const smaValues = sma(source, length);
+  for (let i = length - 1; i < source.length; i++) {
+    let sumDeviation = 0;
+    for (let j = 0; j < length; j++) {
+      sumDeviation += Math.abs(source[i - j] - smaValues[i]);
+    }
+    result[i] = sumDeviation / length;
+  }
+  return result;
+}
+function variance(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length - 1; i < source.length; i++) {
+    let sum = 0;
+    let sumSquares = 0;
+    for (let j = 0; j < length; j++) {
+      sum += source[i - j];
+      sumSquares += source[i - j] * source[i - j];
+    }
+    const mean = sum / length;
+    result[i] = sumSquares / length - mean * mean;
+  }
+  return result;
+}
+function highest(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length - 1; i < source.length; i++) {
+    let max = -Infinity;
+    for (let j = 0; j < length; j++) {
+      const value = source[i - j];
+      if (isNaN(value)) {
+        max = max === -Infinity ? NaN : max;
+      } else {
+        max = Math.max(max, value);
+      }
+    }
+    result[i] = max;
+  }
+  return result;
+}
+function lowest(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length - 1; i < source.length; i++) {
+    let min = Infinity;
+    for (let j = 0; j < length; j++) {
+      const value = source[i - j];
+      if (isNaN(value)) {
+        min = min === Infinity ? NaN : min;
+      } else {
+        min = Math.min(min, value);
+      }
+    }
+    result[i] = min;
+  }
+  return result;
+}
+function median(source, length) {
+  const result = new Array(source.length).fill(NaN);
+  for (let i = length - 1; i < source.length; i++) {
+    const window = source.slice(i - length + 1, i + 1);
+    const sorted = window.slice().sort((a, b) => a - b);
+    const mid = Math.floor(length / 2);
+    result[i] = length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  }
+  return result;
+}
+function stdev(source, length, biased = true) {
+  const result = new Array(source.length).fill(NaN);
+  const smaValues = sma(source, length);
+  for (let i = length - 1; i < source.length; i++) {
+    let sum = 0;
+    for (let j = 0; j < length; j++) {
+      sum += Math.pow(source[i - j] - smaValues[i], 2);
+    }
+    const divisor = biased ? length : length - 1;
+    result[i] = Math.sqrt(sum / divisor);
+  }
+  return result;
+}
+function linreg(source, length, offset) {
+  const size = source.length;
+  const output = new Array(size).fill(NaN);
+  for (let i = length - 1; i < size; i++) {
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumXX = 0;
+    const n = length;
+    for (let j = 0; j < length; j++) {
+      const x = j;
+      const y = source[i - length + 1 + j];
+      sumX += x;
+      sumY += y;
+      sumXY += x * y;
+      sumXX += x * x;
+    }
+    const denominator = n * sumXX - sumX * sumX;
+    if (denominator === 0) {
+      output[i] = NaN;
+      continue;
+    }
+    const slope = (n * sumXY - sumX * sumY) / denominator;
+    const intercept = (sumY - slope * sumX) / n;
+    const linRegValue = intercept + slope * (length - 1 - offset);
+    output[i] = linRegValue;
+  }
+  return output;
+}
+function calculateSupertrend(high, low, close, factor, atrPeriod) {
+  const length = high.length;
+  const supertrend = new Array(length).fill(NaN);
+  const direction = new Array(length).fill(0);
+  const atrValues = atr(high, low, close, atrPeriod);
+  const upperBand = new Array(length).fill(NaN);
+  const lowerBand = new Array(length).fill(NaN);
+  for (let i = 0; i < length; i++) {
+    const hl2 = (high[i] + low[i]) / 2;
+    const atrValue = atrValues[i];
+    if (!isNaN(atrValue)) {
+      upperBand[i] = hl2 + factor * atrValue;
+      lowerBand[i] = hl2 - factor * atrValue;
+    }
+  }
+  let prevUpperBand = upperBand[atrPeriod];
+  let prevLowerBand = lowerBand[atrPeriod];
+  let prevSupertrend = close[atrPeriod] <= prevUpperBand ? prevUpperBand : prevLowerBand;
+  let prevDirection = close[atrPeriod] <= prevUpperBand ? -1 : 1;
+  supertrend[atrPeriod] = prevSupertrend;
+  direction[atrPeriod] = prevDirection;
+  for (let i = atrPeriod + 1; i < length; i++) {
+    let currentUpperBand = upperBand[i];
+    if (currentUpperBand < prevUpperBand || close[i - 1] > prevUpperBand) {
+      upperBand[i] = currentUpperBand;
+    } else {
+      upperBand[i] = prevUpperBand;
+    }
+    let currentLowerBand = lowerBand[i];
+    if (currentLowerBand > prevLowerBand || close[i - 1] < prevLowerBand) {
+      lowerBand[i] = currentLowerBand;
+    } else {
+      lowerBand[i] = prevLowerBand;
+    }
+    if (prevSupertrend === prevUpperBand) {
+      if (close[i] > upperBand[i]) {
+        direction[i] = 1;
+        supertrend[i] = lowerBand[i];
+      } else {
+        direction[i] = -1;
+        supertrend[i] = upperBand[i];
+      }
+    } else {
+      if (close[i] < lowerBand[i]) {
+        direction[i] = -1;
+        supertrend[i] = upperBand[i];
+      } else {
+        direction[i] = 1;
+        supertrend[i] = lowerBand[i];
+      }
+    }
+    prevUpperBand = upperBand[i];
+    prevLowerBand = lowerBand[i];
+    prevSupertrend = supertrend[i];
+  }
+  return [supertrend, direction];
+}
+
+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);
+class Context {
+  constructor(marketData) {
+    this.marketData = marketData;
+    __publicField(this, "data", {
+      open: [],
+      high: [],
+      low: [],
+      close: [],
+      volume: [],
+      hl2: [],
+      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", "");
+    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)
+    };
+  }
+  //#region [Runtime functions] ===========================
+  /**
+   * this function is used to initialize the target variable with the source array
+   * this array will represent a time series and its values will be shifted at runtime in order to mimic Pine script behavior
+   * @param trg - the target variable name : used internally to maintain the series in the execution context
+   * @param src - the source data, can be an array or a single value
+   * @param idx - the index of the source array, used to get a sub-series of the source data
+   * @returns the target array
+   */
+  init(trg, src, idx = 0) {
+    if (!trg) {
+      if (Array.isArray(src)) {
+        trg = [this.precision(src[src.length - this.idx - 1 + idx])];
+      } else {
+        trg = [this.precision(src)];
+      }
+    } else {
+      if (!Array.isArray(src) || Array.isArray(src[0])) {
+        trg[0] = Array.isArray(src?.[0]) ? src[0] : this.precision(src);
+      } else {
+        trg[0] = this.precision(src[src.length - this.idx - 1 + idx]);
+      }
+    }
+    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
+   */
+  precision(n, decimals = 10) {
+    if (typeof n !== "number" || isNaN(n)) return n;
+    return Number(n.toFixed(decimals));
+  }
+  /**
+   * This function is used to apply special transformation to internal PineTS parameters and handle them as time-series
+   * @param source - the source data, can be an array or a single value
+   * @param index - the index of the source array, used to get a sub-series of the source data
+   * @param name - the name of the parameter, used as a unique identifier in the current execution context, this allows us to properly handle the param as a series
+   * @returns the current value of the param
+   */
+  param(source, index, name) {
+    if (typeof source === "string") return source;
+    if (!Array.isArray(source) && typeof source === "object") return source;
+    if (!this.params[name]) this.params[name] = [];
+    if (Array.isArray(source)) {
+      if (index) {
+        this.params[name] = source.slice(index);
+        return this.params[name];
+      }
+      this.params[name] = source.slice(0);
+      return this.params[name];
+    } else {
+      this.params[name][0] = source;
+      return this.params[name];
+    }
+  }
+  //#endregion
+}
+
+const BINANCE_API_URL = "https://api.binance.com/api/v3";
+const timeframe_to_binance = {
+  "1": "1m",
+  // 1 minute
+  "3": "3m",
+  // 3 minutes
+  "5": "5m",
+  // 5 minutes
+  "15": "15m",
+  // 15 minutes
+  "30": "30m",
+  // 30 minutes
+  "45": null,
+  // 45 minutes (not directly supported by Binance, needs custom handling)
+  "60": "1h",
+  // 1 hour
+  "120": "2h",
+  // 2 hours
+  "180": null,
+  // 3 hours (not directly supported by Binance, needs custom handling)
+  "240": "4h",
+  // 4 hours
+  "1D": "1d",
+  // 1 day
+  D: "1d",
+  // 1 day
+  "1W": "1w",
+  // 1 week
+  W: "1w",
+  // 1 week
+  "1M": "1M",
+  // 1 month
+  M: "1M"
+  // 1 month
+};
+class BinanceProvider {
+  async getMarketData(tickerId, timeframe, limit, sDate, eDate) {
+    try {
+      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) {
+        url += `&limit=${limit}`;
+      }
+      if (sDate) {
+        url += `&startTime=${sDate}`;
+      }
+      if (eDate) {
+        url += `&endTime=${eDate}`;
+      }
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const result = await response.json();
+      const data = result.map((item) => {
+        return {
+          openTime: parseInt(item[0]) / 1e3,
+          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,
+          quoteAssetVolume: parseFloat(item[7]),
+          numberOfTrades: parseInt(item[8]),
+          takerBuyBaseAssetVolume: parseFloat(item[9]),
+          takerBuyQuoteAssetVolume: parseFloat(item[10]),
+          ignore: item[11]
+        };
+      });
+      return data;
+    } catch (error) {
+      console.error("Error in binance.klines:", error);
+      return [];
+    }
+  }
+}
+
+const Provider = {
+  Binance: new BinanceProvider()
+};
+
+export { Context, PineTS, Provider };
+//# sourceMappingURL=pinets.dev.es.js.map