pinets 0.9.23 → 0.9.24

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

@@ -29,6 +29,10 @@ import { tan } from './methods/tan';
 import { todegrees } from './methods/todegrees';
 import { toradians } from './methods/toradians';
 import { __eq } from './methods/__eq';
+import { __ge } from './methods/__ge';
+import { __gt } from './methods/__gt';
+import { __le } from './methods/__le';
+import { __lt } from './methods/__lt';
 import { __neq } from './methods/__neq';
 declare const methods: {
     abs: typeof abs;
@@ -62,6 +66,10 @@ declare const methods: {
     todegrees: typeof todegrees;
     toradians: typeof toradians;
     __eq: typeof __eq;
+    __ge: typeof __ge;
+    __gt: typeof __gt;
+    __le: typeof __le;
+    __lt: typeof __lt;
     __neq: typeof __neq;
 };
 export declare class PineMath {
@@ -98,6 +106,10 @@ export declare class PineMath {
     todegrees: ReturnType<typeof methods.todegrees>;
     toradians: ReturnType<typeof methods.toradians>;
     __eq: ReturnType<typeof methods.__eq>;
+    __ge: ReturnType<typeof methods.__ge>;
+    __gt: ReturnType<typeof methods.__gt>;
+    __le: ReturnType<typeof methods.__le>;
+    __lt: ReturnType<typeof methods.__lt>;
     __neq: ReturnType<typeof methods.__neq>;
     constructor(context: any);
 }

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

@@ -1 +1 @@
-export declare function __eq(context: any): (a: any, b: any) => boolean;
+export declare function __eq(context: any): (a: any, b: any) => number | boolean;

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

@@ -0,0 +1,8 @@
+/**
+ * Pine Script na-aware "greater than or equal" (`>=`).
+ *
+ * - If either operand is `na`, the result is `na` (matching TradingView).
+ * - Values equal within an absolute 1e-10 tolerance are treated as equal, so
+ *   `>=` is true — matching TradingView's relational tolerance.
+ */
+export declare function __ge(context: any): (a: any, b: any) => number | boolean;

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

@@ -0,0 +1,8 @@
+/**
+ * Pine Script na-aware "greater than" (`>`).
+ *
+ * - If either operand is `na`, the result is `na` (matching TradingView).
+ * - Values equal within an absolute 1e-10 tolerance are treated as equal, so
+ *   `>` is false — matching TradingView's relational tolerance.
+ */
+export declare function __gt(context: any): (a: any, b: any) => number | boolean;

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

@@ -0,0 +1,8 @@
+/**
+ * Pine Script na-aware "less than or equal" (`<=`).
+ *
+ * - If either operand is `na`, the result is `na` (matching TradingView).
+ * - Values equal within an absolute 1e-10 tolerance are treated as equal, so
+ *   `<=` is true — matching TradingView's relational tolerance.
+ */
+export declare function __le(context: any): (a: any, b: any) => number | boolean;

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

@@ -0,0 +1,10 @@
+/**
+ * Pine Script na-aware "less than" (`<`).
+ *
+ * - If either operand is `na`, the result is `na` (matching TradingView:
+ *   `na(na < 1)` is `true`). na is falsy, so branch/ternary outcomes are
+ *   unchanged.
+ * - Values equal within an absolute 1e-10 tolerance are treated as equal, so
+ *   `<` is false — matching TradingView's relational tolerance.
+ */
+export declare function __lt(context: any): (a: any, b: any) => number | boolean;

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

@@ -1,13 +1,16 @@
 /**
  * Pine Script na-aware inequality comparison.
  *
- * In Pine Script, any comparison involving `na` returns `false`:
- *   na != na   → false
- *   1  != na   → false
- *   na != 1    → false
+ * In Pine Script, any comparison involving `na` evaluates to `na` (NOT a
+ * usable boolean) — verified against TradingView (`na(na != na)` is `true`):
+ *   na != na   → na
+ *   1  != na   → na
+ *   na != 1    → na
  *
- * This cannot be implemented as `!__eq(a, b)` because __eq(na, na) returns
- * false, and !false = true — which is wrong. Both == and != must independently
- * return false when either operand is na.
+ * This cannot be implemented as `!__eq(a, b)`: `__eq(na, na)` is `na` and
+ * `!na` would be `true` — wrong. Both `==` and `!=` must independently
+ * propagate `na` when either operand is na. `na` is falsy, so branch/ternary
+ * outcomes are unchanged; the difference is only observable via `na()`/`nz()`
+ * or arithmetic on the result.
  */
-export declare function __neq(context: any): (a: any, b: any) => boolean;
+export declare function __neq(context: any): (a: any, b: any) => number | boolean;

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

@@ -20,6 +20,7 @@ export declare const ASTFactory: {
     createSetCall(target: any, value: any): any;
     createMathEqCall(left: any, right: any): any;
     createMathNeqCall(left: any, right: any): any;
+    createMathCompareCall(method: string, 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.23",
+    "version": "0.9.24",
     "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",