pinets 0.9.27 → 0.9.28

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

@@ -31,6 +31,7 @@ import { toradians } from './methods/toradians';
 import { __eq } from './methods/__eq';
 import { __ge } from './methods/__ge';
 import { __gt } from './methods/__gt';
+import { __idiv } from './methods/__idiv';
 import { __le } from './methods/__le';
 import { __lt } from './methods/__lt';
 import { __neq } from './methods/__neq';
@@ -68,6 +69,7 @@ declare const methods: {
     __eq: typeof __eq;
     __ge: typeof __ge;
     __gt: typeof __gt;
+    __idiv: typeof __idiv;
     __le: typeof __le;
     __lt: typeof __lt;
     __neq: typeof __neq;
@@ -108,6 +110,7 @@ export declare class PineMath {
     __eq: ReturnType<typeof methods.__eq>;
     __ge: ReturnType<typeof methods.__ge>;
     __gt: ReturnType<typeof methods.__gt>;
+    __idiv: ReturnType<typeof methods.__idiv>;
     __le: ReturnType<typeof methods.__le>;
     __lt: ReturnType<typeof methods.__lt>;
     __neq: ReturnType<typeof methods.__neq>;

package/dist/types/namespaces/math/methods/__idiv.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pine integer division — the `/` (and `%`, via the transpiler) operator applied
+ * to two **integer** operands. In Pine, `int / int` yields an `int`: the result
+ * is truncated toward zero (`11 / 2 === 5`, `-11 / 2 === -5`), whereas JavaScript
+ * `/` is always float division (`5.5`).
+ *
+ * The transpiler rewrites a `/` BinaryExpression to this helper ONLY when BOTH
+ * operands are provably `int` at compile time (see TypeInferencePass). Any float
+ * operand keeps native `/`, so genuine float division (`4.0 / 2.0`, `close / 2`)
+ * is untouched.
+ *
+ * Semantics:
+ * - `na` (NaN) in either operand propagates → NaN.
+ * - Division by zero follows the same rule as native `/`: `Math.trunc` preserves
+ *   `1 / 0 → Infinity` and `0 / 0 → NaN`, matching PineTS's existing div-by-zero
+ *   behavior (truncation only changes finite results).
+ * - Non-numeric operands fall back to native `/` (defensive; should not occur
+ *   given the compile-time int guard).
+ */
+export declare function __idiv(context: any): (a: any, b: any) => number;

package/dist/types/namespaces/math/methods/__intDiv.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pine Script integer division (`int / int → int`).
+ *
+ * TradingView truncates the quotient toward zero when BOTH operands are of
+ * type `int` (Java semantics: `11 / 2 == 5`, `-7 / 2 == -3`). Plain JS `/`
+ * always yields a float, which breaks idioms like `pivots(high, depth / 2)`
+ * where the result feeds a series history offset.
+ *
+ * The pine2js codegen emits this helper only when both operands are
+ * statically provable ints (declared `int` vars/params, int literals,
+ * `input.int`, int-result expressions). Anything unprovable keeps plain `/`.
+ *
+ * - `na` in either operand propagates (`NaN`).
+ * - Division by zero returns `na` (`NaN`) instead of JS `Infinity`.
+ */
+export declare function __intDiv(context: any): (a: any, b: any) => number;

package/dist/types/transpiler/analysis/TypeInferencePass.d.ts

@@ -0,0 +1,2 @@
+import ScopeManager from './ScopeManager';
+export declare function runTypeInferencePass(ast: any, _scopeManager: ScopeManager): void;

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

@@ -35,5 +35,5 @@ export declare class Lexer {
     isIdentifierStart(ch: any): boolean;
     isIdentifierChar(ch: any): boolean;
     getCurrentIndent(): number;
-    addToken(type: any, value: any, indent?: any): void;
+    addToken(type: any, value: any, indent?: any, raw?: any): void;
 }

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

@@ -29,5 +29,6 @@ export declare class Token {
     line: number;
     column: number;
     indent: number;
-    constructor(type: string, value: any, line: number, column: number, indent?: number);
+    raw: string;
+    constructor(type: string, value: any, line: number, column: number, indent?: number, raw?: string);
 }

package/dist/types/transpiler/utils/ASTFactory.d.ts

@@ -21,6 +21,7 @@ export declare const ASTFactory: {
     createMathEqCall(left: any, right: any): any;
     createMathNeqCall(left: any, right: any): any;
     createMathCompareCall(method: string, left: any, right: any): any;
+    createMathIntDivCall(left: any, right: any): any;
     createWrapperFunction(body: any): any;
     createVariableDeclaration(name: string, init: any): any;
     createAwaitExpression(argument: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.27",
+    "version": "0.9.28",
     "description": "Run Pine Script anywhere. PineTS is an open-source transpiler and runtime that brings Pine Script logic to Node.js and the browser with 1:1 syntax compatibility. Reliably write, port, and run indicators or strategies on your own infrastructure.",
     "keywords": [
         "Pine Script",