pinets 0.5.0 → 0.7.0

package/dist/types/namespaces/matrix/methods/fill.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function fill(context: Context): (id: PineMatrixObject, value: any, from_row?: number, to_row?: number, from_col?: number, to_col?: number) => void;

package/dist/types/namespaces/matrix/methods/get.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function get(context: Context): (id: PineMatrixObject, row: number, col: number) => any;

package/dist/types/namespaces/matrix/methods/inv.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function inv(context: Context): (id: PineMatrixObject) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/is_antidiagonal.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_antidiagonal(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_antisymmetric.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_antisymmetric(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_binary.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_binary(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_diagonal.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_diagonal(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_identity.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_identity(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_square.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_square(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_stochastic.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_stochastic(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_symmetric.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_symmetric(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_triangular.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_triangular(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/is_zero.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function is_zero(context: Context): (id: PineMatrixObject) => boolean;

package/dist/types/namespaces/matrix/methods/kron.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function kron(context: Context): (id: PineMatrixObject, id2: PineMatrixObject) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/max.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function max(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/median.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function median(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/min.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function min(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/mode.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function mode(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/mult.d.ts

@@ -0,0 +1,4 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+import { PineArrayObject } from '../../array/PineArrayObject';
+export declare function mult(context: Context): (id: PineMatrixObject, id2: PineMatrixObject | number | PineArrayObject) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/new.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function new_fn(context: Context): (rows: number, cols: number, initial_value: any) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/param.d.ts

@@ -0,0 +1 @@
+export declare function param(context: any): (source: any, index?: number) => any;

package/dist/types/namespaces/matrix/methods/pinv.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function pinv(context: Context): (id: PineMatrixObject) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/pow.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function pow(context: Context): (id: PineMatrixObject, power: number) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/rank.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function rank(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/remove_col.d.ts

@@ -0,0 +1,4 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+import { PineArrayObject } from '../../array/PineArrayObject';
+export declare function remove_col(context: Context): (id: PineMatrixObject, column_index: number) => PineArrayObject;

package/dist/types/namespaces/matrix/methods/remove_row.d.ts

@@ -0,0 +1,4 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+import { PineArrayObject } from '../../array/PineArrayObject';
+export declare function remove_row(context: Context): (id: PineMatrixObject, row_index: number) => PineArrayObject;

package/dist/types/namespaces/matrix/methods/reshape.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function reshape(context: Context): (id: PineMatrixObject, rows: number, cols: number) => void;

package/dist/types/namespaces/matrix/methods/reverse.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function reverse(context: Context): (id: PineMatrixObject) => void;

package/dist/types/namespaces/matrix/methods/row.d.ts

@@ -0,0 +1,4 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+import { PineArrayObject } from '../../array/PineArrayObject';
+export declare function row(context: Context): (id: PineMatrixObject, row: number) => PineArrayObject;

package/dist/types/namespaces/matrix/methods/rows.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function rows(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/set.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function set(context: Context): (id: PineMatrixObject, row: number, col: number, value: any) => void;

package/dist/types/namespaces/matrix/methods/sort.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function sort(context: Context): (id: PineMatrixObject, column?: number, order?: string) => void;

package/dist/types/namespaces/matrix/methods/submatrix.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function submatrix(context: Context): (id: PineMatrixObject, from_row: number, to_row: number, from_col: number, to_col: number) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/sum.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function sum(context: Context): (id: PineMatrixObject, id2: PineMatrixObject | number) => PineMatrixObject;

package/dist/types/namespaces/matrix/methods/swap_columns.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function swap_columns(context: Context): (id: PineMatrixObject, col1: number, col2: number) => void;

package/dist/types/namespaces/matrix/methods/swap_rows.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function swap_rows(context: Context): (id: PineMatrixObject, row1: number, row2: number) => void;

package/dist/types/namespaces/matrix/methods/trace.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function trace(context: Context): (id: PineMatrixObject) => number;

package/dist/types/namespaces/matrix/methods/transpose.d.ts

@@ -0,0 +1,3 @@
+import { PineMatrixObject } from '../PineMatrixObject';
+import { Context } from '../../../Context.class';
+export declare function transpose(context: Context): (id: PineMatrixObject) => PineMatrixObject;

package/dist/types/namespaces/request/methods/security_lower_tf.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Requests the results of an expression from a specified symbol on a timeframe lower than or equal to the chart's timeframe.
+ * It returns an array containing one element for each lower-timeframe bar within the chart bar.
+ * On a 5-minute chart, requesting data using a timeframe argument of "1" typically returns an array with five elements representing
+ * the value of the expression on each 1-minute bar, ordered by time with the earliest value first.
+ * @param context
+ * @returns
+ */
+export declare function security_lower_tf(context: any): (symbol: any, timeframe: any, expression: any, ignore_invalid_symbol?: boolean | any[], currency?: any, ignore_invalid_timeframe?: boolean | any[], calc_bars_count?: number | any[]) => Promise<any>;

package/dist/types/namespaces/request/request.index.d.ts

@@ -1,14 +1,17 @@
 import { param } from './methods/param';
 import { security } from './methods/security';
+import { security_lower_tf } from './methods/security_lower_tf';
 declare const methods: {
     param: typeof param;
     security: typeof security;
+    security_lower_tf: typeof security_lower_tf;
 };
 export declare class PineRequest {
     private context;
     private _cache;
     param: ReturnType<typeof methods.param>;
     security: ReturnType<typeof methods.security>;
+    security_lower_tf: ReturnType<typeof methods.security_lower_tf>;
     constructor(context: any);
 }
 export default PineRequest;

package/dist/types/namespaces/ta/methods/atr.d.ts

@@ -1 +1,2 @@
-export declare function atr(context: any): (_period: any, _callId?: string) => any;
+import { Series } from '../../../Series';
+export declare function atr(context: any): (length: number) => Series;

package/dist/types/namespaces/ta/methods/pivothigh.d.ts

@@ -1 +1 @@
-export declare function pivothigh(context: any): (source: any, _leftbars: any, _rightbars: any) => any;
+export declare function pivothigh(context: any): (source: any, _leftbars: any, _rightbars: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/pivotlow.d.ts

@@ -1 +1 @@
-export declare function pivotlow(context: any): (source: any, _leftbars: any, _rightbars: any) => any;
+export declare function pivotlow(context: any): (source: any, _leftbars: any, _rightbars: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/tr.d.ts

@@ -1 +1,2 @@
-export declare function tr(context: any): (handle_na?: boolean, _callId?: string) => number;
+import { Context } from '../../../Context.class';
+export declare function tr(context: Context): (handle_na?: boolean, _callId?: string) => number;

package/dist/types/namespaces/utils.d.ts

@@ -0,0 +1,12 @@
+import { Series } from '../Series';
+export type PineTypeMap<T> = {
+    [K in keyof T]-?: T[K] extends number ? 'number' : T[K] extends string ? 'string' : T[K] extends boolean ? 'boolean' : T[K] extends Series ? 'series' : T[K] extends Array<any> ? 'array' : never;
+};
+/**
+ * This function is used to parse the arguments for a Pine params.
+ * @param args - The arguments to parse.
+ * @param signatures - The signatures to parse, each signature is an array of argument names.
+ * @param types - The types to parse, each type is a string representing the type of the argument.
+ * @returns The parsed arguments, the arguments are parsed according to the signatures and types.
+ */
+export declare function parseArgsForPineParams<T>(args: any[], signatures: any[], types: Record<string, string>): Partial<T> & T;

package/dist/types/transpiler/index.d.ts

@@ -1,4 +1,4 @@
-export declare function transpile(fn: string | Function, options?: {
+export declare function transpile(source: string | Function, options?: {
     debug: boolean;
     ln?: boolean;
 }): Function;

package/dist/types/transpiler/pineToJS/ast.d.ts

@@ -0,0 +1,167 @@
+export declare class ASTNode {
+    type: string;
+    constructor(type: string);
+}
+export declare class Program extends ASTNode {
+    body: any[];
+    constructor(body: any[]);
+}
+export declare class ExpressionStatement extends ASTNode {
+    expression: any;
+    constructor(expression: any);
+}
+export declare enum VariableDeclarationKind {
+    VAR = "var",
+    LET = "let",
+    CONST = "const"
+}
+export declare class VariableDeclaration extends ASTNode {
+    declarations: any[];
+    kind: VariableDeclarationKind;
+    constructor(declarations: any[], kind?: VariableDeclarationKind);
+}
+export declare class VariableDeclarator extends ASTNode {
+    id: any;
+    init: any;
+    varType: any;
+    constructor(id: any, init: any, varType?: any);
+}
+export declare class FunctionDeclaration extends ASTNode {
+    id: any;
+    params: any[];
+    body: any;
+    returnType: any;
+    constructor(id: any, params: any[], body: any, returnType?: any);
+}
+export declare class TypeDefinition extends ASTNode {
+    name: string;
+    fields: any[];
+    constructor(name: string, fields: any[]);
+}
+export declare class IfStatement extends ASTNode {
+    test: any;
+    consequent: any;
+    alternate: any | null;
+    _line: number;
+    constructor(test: any, consequent: any, alternate?: any | null);
+}
+export declare class ForStatement extends ASTNode {
+    init: any;
+    test: any;
+    update: any;
+    body: any;
+    isForIn: boolean;
+    constructor(init: any, test: any, update: any, body: any);
+}
+export declare class WhileStatement extends ASTNode {
+    test: any;
+    body: any;
+    constructor(test: any, body: any);
+}
+export declare class BlockStatement extends ASTNode {
+    body: any[];
+    constructor(body: any[]);
+}
+export declare class ReturnStatement extends ASTNode {
+    argument: any;
+    constructor(argument: any);
+}
+export declare class Identifier extends ASTNode {
+    name: string;
+    varType: string;
+    returnType: any;
+    isMethod: boolean;
+    constructor(name: string);
+}
+export declare class Literal extends ASTNode {
+    value: any;
+    raw: string;
+    constructor(value: any, raw?: string);
+}
+export declare class BinaryExpression extends ASTNode {
+    operator: string;
+    left: any;
+    right: any;
+    constructor(operator: string, left: any, right: any);
+}
+export declare class UnaryExpression extends ASTNode {
+    operator: string;
+    argument: any;
+    prefix: boolean;
+    constructor(operator: string, argument: any, prefix?: boolean);
+}
+export declare class AssignmentExpression extends ASTNode {
+    operator: string;
+    left: any;
+    right: any;
+    constructor(operator: string, left: any, right: any);
+}
+export declare class UpdateExpression extends ASTNode {
+    operator: string;
+    argument: any;
+    prefix: boolean;
+    constructor(operator: string, argument: any, prefix?: boolean);
+}
+export declare class CallExpression extends ASTNode {
+    callee: any;
+    args: any[];
+    arguments: any[];
+    constructor(callee: any, args: any[]);
+}
+export declare class MemberExpression extends ASTNode {
+    object: any;
+    property: any;
+    computed: boolean;
+    constructor(object: any, property: any, computed?: boolean);
+}
+export declare class ConditionalExpression extends ASTNode {
+    test: any;
+    consequent: any;
+    alternate: any;
+    needsIIFE: boolean;
+    consequentStmts: any[];
+    alternateStmts: any[];
+    constructor(test: any, consequent: any, alternate: any);
+}
+export declare class ArrayExpression extends ASTNode {
+    elements: any[];
+    constructor(elements: any[]);
+}
+export declare class ObjectExpression extends ASTNode {
+    properties: any[];
+    constructor(properties: any[]);
+}
+export declare class Property extends ASTNode {
+    key: any;
+    value: any;
+    kind: string;
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    constructor(key: any, value: any);
+}
+export declare class ArrayPattern extends ASTNode {
+    elements: any[];
+    constructor(elements: any[]);
+}
+export declare class AssignmentPattern extends ASTNode {
+    left: any;
+    right: any;
+    constructor(left: any, right: any);
+}
+export declare class ArrowFunctionExpression extends ASTNode {
+    params: any[];
+    body: any;
+    expression: boolean;
+    constructor(params: any[], body: any, expression?: boolean);
+}
+export declare class SwitchExpression extends ASTNode {
+    discriminant: any;
+    cases: any[];
+    constructor(discriminant: any, cases: any[]);
+}
+export declare class SwitchCase extends ASTNode {
+    test: any;
+    consequent: any;
+    constructor(test: any, consequent: any);
+}

package/dist/types/transpiler/pineToJS/codegen.d.ts

@@ -0,0 +1,53 @@
+export declare class CodeGenerator {
+    private indent;
+    private indentStr;
+    private output;
+    private sourceCode;
+    private sourceLines;
+    private lastCommentedLine;
+    private includeSourceComments;
+    constructor(options?: {
+        indentStr?: string;
+        sourceCode?: string;
+        includeSourceComments?: boolean;
+    });
+    generate(ast: any): string;
+    writeSourceComment(startLine: any, endLine?: any): void;
+    write(str: any): void;
+    writeLine(str?: string): void;
+    increaseIndent(): void;
+    decreaseIndent(): void;
+    generateProgram(node: any): void;
+    generateStatement(node: any): void;
+    generateTypeDefinition(node: any): void;
+    generateFunctionDeclaration(node: any): void;
+    generateVariableDeclaration(node: any): void;
+    generateExpressionStatement(node: any): void;
+    generateIfStatement(node: any): void;
+    generateIfStatementWithAssignment(condExpr: any, varName: any): void;
+    generateNestedIfWithAssignments(node: any, varName: any): void;
+    generateNestedIfAlternatesWithAssignments(alternate: any, varName: any): void;
+    generateForStatement(node: any): void;
+    generateWhileStatement(node: any): void;
+    generateReturnStatement(node: any): void;
+    generateBlockStatement(node: any, addIndent?: boolean): void;
+    generateExpression(node: any): void;
+    generateLiteral(node: any): void;
+    generateBinaryExpression(node: any): void;
+    generateUnaryExpression(node: any): void;
+    generateAssignmentExpression(node: any): void;
+    generateUpdateExpression(node: any): void;
+    generateCallExpression(node: any): void;
+    generateMemberExpression(node: any): void;
+    generateConditionalExpression(node: any): void;
+    generateIIFEConditional(node: any): void;
+    generateIIFEIfBlock(node: any): void;
+    generateNestedIfWithReturns(node: any): void;
+    generateNestedIfAlternates(alternate: any): void;
+    generateNestedIfAsExpression(node: any): void;
+    generateArrayExpression(node: any): void;
+    generateObjectExpression(node: any): void;
+    generateSwitchExpression(node: any): void;
+    generateSequenceExpression(node: any): void;
+    needsParentheses(node: any): boolean;
+}

package/dist/types/transpiler/pineToJS/lexer.d.ts

@@ -0,0 +1,31 @@
+import { Token } from './tokens';
+export declare class Lexer {
+    private source;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    private indentStack;
+    private atLineStart;
+    private parenDepth;
+    private bracketDepth;
+    private braceDepth;
+    constructor(source: string);
+    tokenize(): Token[];
+    handleNewline(): void;
+    handleIndentation(): void;
+    readComment(): void;
+    readString(): void;
+    readColorLiteral(): void;
+    readNumber(): void;
+    readIdentifier(): void;
+    readOperatorOrPunctuation(): boolean;
+    peek(offset?: number): string;
+    advance(): string;
+    skipWhitespaceInline(): void;
+    isDigit(ch: any): boolean;
+    isIdentifierStart(ch: any): boolean;
+    isIdentifierChar(ch: any): boolean;
+    getCurrentIndent(): number;
+    addToken(type: any, value: any, indent?: any): void;
+}

package/dist/types/transpiler/pineToJS/parser.d.ts

@@ -0,0 +1,45 @@
+import { Token } from './tokens';
+import { Program, VariableDeclaration, FunctionDeclaration, TypeDefinition, IfStatement, ForStatement, WhileStatement, BlockStatement, CallExpression, ArrayExpression, SwitchExpression } from './ast';
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    peek(offset?: number): Token;
+    advance(): Token;
+    match(type: any, value?: any): boolean;
+    expect(type: any, value?: any): Token;
+    skipNewlines(): void;
+    parse(): Program;
+    parseStatement(): any;
+    isFunctionDeclaration(): boolean;
+    parseTypeDefinition(): TypeDefinition;
+    parseVarDeclaration(): VariableDeclaration;
+    parseTypedVarDeclaration(): VariableDeclaration;
+    parseFunctionDeclaration(): FunctionDeclaration;
+    parseMethodDeclaration(): FunctionDeclaration;
+    parseFunctionBody(): BlockStatement;
+    parseStatementOrSequence(): any;
+    parseIfStatement(): IfStatement;
+    parseForStatement(): ForStatement;
+    parseWhileStatement(): WhileStatement;
+    parseBlock(): BlockStatement;
+    isTupleDestructuring(): boolean;
+    parseTupleDestructuring(): VariableDeclaration;
+    parseExpression(): any;
+    parseTernary(): any;
+    parseLogicalOr(): any;
+    parseLogicalAnd(): any;
+    parseEquality(): any;
+    parseComparison(): any;
+    parseAdditive(): any;
+    parseMultiplicative(): any;
+    parseUnary(): any;
+    parsePostfix(): any;
+    parseCallExpression(callee: any): CallExpression;
+    parsePrimary(): any;
+    parseArrayLiteral(): ArrayExpression;
+    parseIfExpression(): any;
+    needsIIFE(consequentStmts: any, alternateStmts: any): any;
+    parseSwitchExpression(): SwitchExpression;
+    getBlockValue(statements: any): any;
+}

package/dist/types/transpiler/pineToJS/pineToJS.index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Extract Pine Script version from source code
+ * Looks for //@version=X comment on its own line (can be anywhere in the file)
+ * The line must start with // and contain only @version=X (with optional whitespace)
+ * Returns the version number or null if not found
+ */
+export declare function extractPineScriptVersion(sourceCode: string): number | null;
+export declare function pineToJS(sourceCode: string, options?: any): {
+    success: boolean;
+    version: number;
+    error: string;
+    code?: undefined;
+    ast?: undefined;
+    tokens?: undefined;
+    stack?: undefined;
+} | {
+    success: boolean;
+    version: number;
+    code: string;
+    ast: import("./ast").Program;
+    tokens: import("./tokens").Token[];
+    error?: undefined;
+    stack?: undefined;
+} | {
+    success: boolean;
+    version: number;
+    error: any;
+    stack: any;
+    code?: undefined;
+    ast?: undefined;
+    tokens?: undefined;
+};

package/dist/types/transpiler/pineToJS/tokens.d.ts

@@ -0,0 +1,34 @@
+export declare const TokenType: {
+    NUMBER: string;
+    STRING: string;
+    BOOLEAN: string;
+    IDENTIFIER: string;
+    KEYWORD: string;
+    OPERATOR: string;
+    LPAREN: string;
+    RPAREN: string;
+    LBRACKET: string;
+    RBRACKET: string;
+    LBRACE: string;
+    RBRACE: string;
+    COMMA: string;
+    DOT: string;
+    COLON: string;
+    SEMICOLON: string;
+    INDENT: string;
+    DEDENT: string;
+    NEWLINE: string;
+    COMMENT: string;
+    EOF: string;
+};
+export declare const Keywords: Set<string>;
+export declare const MultiCharOperators: string[];
+export declare class Token {
+    type: string;
+    value: any;
+    line: number;
+    column: number;
+    indent: number;
+    constructor(type: string, value: any, line: number, column: number, indent?: number);
+    toString(): string;
+}