pinets 0.9.13 → 0.9.15

package/dist/types/Context.class.d.ts

@@ -132,7 +132,35 @@ export declare class Context {
      * @param value - The value to set
      */
     set(target: any, value: any): void;
+    /**
+     * Resolve an iterable for `for x in collection` codegen.
+     * Handles PineArrayObject (unwrap to inner JS array) and plain JS arrays uniformly.
+     * Returns the value itself if it's already iterable (Map, Set, etc.).
+     *
+     * Centralizing this here means the transpiler can emit a uniform shape regardless of
+     * whether the iterable is a built-in returning a plain array (e.g. box.all) or a UDT
+     * field holding a PineArrayObject — and future collection types only need to update
+     * this helper, not the codegen.
+     */
+    iter(source: any): any;
+    /**
+     * Resolve an iterable yielding [index, value] tuples for `for [i, x] in collection`
+     * destructuring codegen. PineArrayObject's [Symbol.iterator] yields scalar values, so
+     * we must explicitly call `.entries()` on the underlying array.
+     */
+    entries(source: any): IterableIterator<[number, any]>;
     private _callStack;
+    /**
+     * Cumulative call-path stack. Each entry is the full path from the root to
+     * the current call, formed by joining the syntactic call-site ids with '|'.
+     *
+     * Pine semantics is per-call-PATH (not per-syntactic-call-site): a function
+     * with internal `var` state, called via two distinct paths through a wrapper,
+     * must keep state independent per path. Keying lctx by the path (rather than
+     * the immediate site id) makes `$$.var.*` slots and `$$.id + '_taN'` ta
+     * callsite ids correctly path-scoped without any transpiler changes.
+     */
+    private _pathStack;
     /**
      * Pushes a call ID onto the stack
      * @param id - The call ID
@@ -143,7 +171,8 @@ export declare class Context {
      */
     popId(): void;
     /**
-     * Returns the current call ID from the top of the stack
+     * Returns the current call PATH (cumulative ids joined by '|') from the top
+     * of the stack. Used as the lctx key for the current function call.
      */
     peekId(): string;
     /**

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

@@ -1,4 +1,3 @@
-import { PineTypeObject } from './PineTypeObject';
 import type { IndicatorOptions } from '../types/PineTypes';
 export declare function parseIndicatorOptions(args: any[]): Partial<IndicatorOptions>;
 /**
@@ -84,8 +83,5 @@ export declare class Core {
     int(series: any): number;
     float(series: any): number;
     string(series: any): any;
-    Type(definition: Record<string, string | [string, any]>): {
-        new: (...args: any[]) => PineTypeObject;
-        copy: (object: PineTypeObject) => PineTypeObject;
-    };
+    Type(definition: Record<string, string | [string, any]>): any;
 }

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

@@ -2,7 +2,19 @@ export declare class PineTypeObject {
     private _definition;
     context: any;
     get __def__(): Record<string, string>;
-    constructor(_definition: Record<string, string>, context: any);
+    /**
+     * Back-reference to the UDT factory that produced this instance.
+     * Used by `request.security_lower_tf`'s pure-builtin fast path to
+     * detect UDTs whose field defaults are all bare price builtins
+     * (e.g. `type candle { float o = open; float h = high; … }`) — when
+     * detected, the secondary's per-LTF-bar values can be synthesised
+     * directly from the candle stream without running any user script.
+     * Optional and nullable: instances created outside `Type().new` (or
+     * for legacy / direct constructions) leave this undefined and the
+     * fast path simply doesn't engage.
+     */
+    _udt?: any;
+    constructor(_definition: Record<string, string>, context: any, _udt?: any);
     copy(): PineTypeObject;
     toString(): string;
 }

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

@@ -20,5 +20,11 @@ export declare class Str {
     match(source: string, pattern: string): RegExpMatchArray;
     split(source: string, separator: string): PineArrayObject;
     substring(source: string, begin_pos: number, end_pos: number): string;
+    /**
+     * Format a UNIX millisecond timestamp using Java SimpleDateFormat-style tokens
+     * (yyyy, MM, dd, HH, mm, ss, EEE, EEEE, MMM, MMMM, a, h, S, Z, etc.).
+     * Text inside single quotes is treated as a literal; '' produces a literal '.
+     */
+    format_time(time: any, format?: string, timezone?: string): string;
     format(message: string, ...args: any[]): string;
 }

package/dist/types/namespaces/box/BoxHelper.d.ts

@@ -10,9 +10,11 @@ export declare class BoxHelper {
     private _resolvePoint;
     private _resolve;
     /**
-     * Resolve a color value, preserving NaN (na) so renderers can detect "no color".
-     * The regular `_resolve(val) || fallback` pattern treats NaN as falsy and replaces
-     * it with the default, losing the explicit `border_color = na` intent.
+     * Resolve a color value, preserving na markers so renderers can detect "no color".
+     * Pine emits na either as NaN (from `bgcolor = na`) or as null (from
+     * `bgcolor = color(na)` — `color(na)` returns null per PineColor.any). Both
+     * must survive — replacing them with a default would force renderers to paint
+     * a visible color where the script asked for none.
      */
     private _resolveColor;
     private _createBox;
@@ -22,7 +24,7 @@ export declare class BoxHelper {
      */
     private _enforceMaxCount;
     new(...args: any[]): BoxObject;
-    any(...args: any[]): BoxObject;
+    any(...args: any[]): BoxObject | null;
     set_left(id: BoxObject, left: number): void;
     set_right(id: BoxObject, right: number): void;
     set_top(id: BoxObject, top: number): void;

package/dist/types/namespaces/label/LabelHelper.d.ts

@@ -17,7 +17,7 @@ export declare class LabelHelper {
     private _createLabel;
     private _enforceMaxCount;
     new(...args: any[]): LabelObject;
-    any(...args: any[]): LabelObject;
+    any(...args: any[]): LabelObject | null;
     set_x(id: LabelObject, x: number): void;
     set_y(id: LabelObject, y: number): void;
     set_xy(id: LabelObject, x: number, y: number): void;

package/dist/types/namespaces/line/LineHelper.d.ts

@@ -18,7 +18,7 @@ export declare class LineHelper {
     private _createLine;
     private _enforceMaxCount;
     new(...args: any[]): LineObject;
-    any(...args: any[]): LineObject;
+    any(...args: any[]): LineObject | null;
     set_x1(id: LineObject, x: number): void;
     set_y1(id: LineObject, y: number): void;
     set_x2(id: LineObject, x: number): void;

package/dist/types/namespaces/linefill/LinefillHelper.d.ts

@@ -12,7 +12,7 @@ export declare class LinefillHelper {
      */
     private _resolve;
     new(line1: LineObject, line2: LineObject, color: any): LinefillObject;
-    any(...args: any[]): LinefillObject;
+    any(...args: any[]): LinefillObject | null;
     set_color(id: LinefillObject, color: any): void;
     get_line1(id: LinefillObject): LineObject | undefined;
     get_line2(id: LinefillObject): LineObject | undefined;

package/dist/types/namespaces/polyline/PolylineHelper.d.ts

@@ -11,8 +11,9 @@ export declare class PolylineHelper {
      */
     private _resolve;
     /**
-     * Resolve a color value, preserving NaN (na = no color) instead of
-     * letting it fall through to a default via the || operator.
+     * Resolve a color value, preserving na markers (NaN from `na`, null from
+     * `color(na)`) so renderers can detect "no color" instead of forcing a
+     * default via the `||` operator.
      */
     private _resolveColor;
     /**
@@ -21,7 +22,7 @@ export declare class PolylineHelper {
     private _extractPoints;
     new(...args: any[]): PolylineObject;
     private _enforceMaxCount;
-    any(...args: any[]): PolylineObject;
+    any(...args: any[]): PolylineObject | null;
     delete(id: PolylineObject): void;
     get all(): PolylineObject[];
     /**

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

@@ -1 +1 @@
-export declare function security(context: any): (symbol: any, timeframe: any, expression: any, gaps?: boolean | any[], lookahead?: boolean | any[], ignore_invalid_symbol?: boolean, currency?: any, calc_bars_count?: any) => Promise<any>;
+export declare function security(context: any): (...rawArgs: any[]) => Promise<any>;

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

@@ -7,4 +7,4 @@ import { PineArrayObject } from '../../array/PineArrayObject';
  * @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<number | PineArrayObject | any[][]>;
+export declare function security_lower_tf(context: any): (...rawArgs: any[]) => Promise<number | PineArrayObject | any[][]>;

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

@@ -0,0 +1,31 @@
+/**
+ * `@silentInSecondary` — method decorator.
+ *
+ * Marks a helper method as a no-op when invoked on a secondary context
+ * (i.e. the auxiliary PineTS instance that `request.security` /
+ * `request.security_lower_tf` spawns to compute the captured expression
+ * at another symbol/timeframe).
+ *
+ * Drawings, plots, alerts and similar side-effect-only operations are
+ * never observable from a secondary context — its sole job is to populate
+ * `secContext.params[expression_name]` with the value of the captured
+ * expression bar-by-bar. Silencing those operations on secondaries cuts
+ * the per-bar work substantially without changing the captured value
+ * (the only output that callers ever read).
+ *
+ * Constructor-style methods (e.g. `label.new`, `line.new`, `box.new`)
+ * return `null`; setters / mutators / deletes return `undefined`. The
+ * existing helper code is null-safe end-to-end:
+ *   - `get_*` methods already return `NaN`/`""` when the receiver is null.
+ *   - The transpiler emits method calls on UDT-typed receivers as
+ *     `obj?.method?.(...)`, so `null?.set_x1?.(...)` short-circuits.
+ *   - Built-in setters like `LineHelper.set_x1(id, x)` already guard
+ *     `if (id && !id._deleted) ...` and no-op on null.
+ *
+ * Pre-condition: target classes use the conventional
+ *   `constructor(private context: any) {}`
+ * shape, so `this.context.isSecondaryContext` is uniformly accessible.
+ * (`Core.ts` `AlertHelper`, `Plots.ts` `PlotHelper`/`HlineHelper`/
+ * `FillHelper`, and the drawing helpers all conform.)
+ */
+export declare function silentInSecondary(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;

package/dist/types/namespaces/table/TableHelper.d.ts

@@ -8,7 +8,7 @@ export declare class TableHelper {
     syncToPlot(): void;
     private _resolve;
     new(...args: any[]): TableObject;
-    any(...args: any[]): TableObject;
+    any(...args: any[]): TableObject | null;
     cell(...args: any[]): void;
     delete(id: TableObject): void;
     clear(...args: any[]): void;

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

@@ -1,5 +1,23 @@
 import ScopeManager from './ScopeManager';
 export declare function transformNestedArrowFunctions(ast: any): void;
+/**
+ * Pre-walk the AST to populate the UDT registry on the ScopeManager.
+ *
+ * Two registries are populated:
+ *   1. UDT type names — collected from `const X = Type({field: ['type', default], ...})`
+ *      which pine2js emits from Pine `type X` declarations. The field-type metadata
+ *      is stored alongside (V2 data model) for future use-site type-aware rewrites.
+ *
+ *   2. UDT instance variables — variables initialized via `<X>.new(...)` or
+ *      `<X>.copy(...)` where X ∈ udtTypeNames. Each instance is tagged with its
+ *      UDT type name (V2 shape).
+ *
+ * The instance check intentionally consults `isUdtTypeName(X)` rather than just
+ * "X is an Identifier", so built-in factory calls like `array.from(...)`,
+ * `polyline.new(...)`, `chart.point.from_index(...)` are excluded — those are
+ * handled by their own runtime layers and must NOT be treated as UDT instances.
+ */
+export declare function preProcessUdtRegistry(ast: any, scopeManager: ScopeManager): void;
 export declare function preProcessContextBoundVars(ast: any, scopeManager: ScopeManager): void;
 export declare function transformArrowFunctionParams(node: any, scopeManager: ScopeManager, isRootFunction?: boolean): void;
 export declare function runAnalysisPass(ast: any, scopeManager: ScopeManager): string | undefined;

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

@@ -22,6 +22,72 @@ export declare class ScopeManager {
     private reservedNames;
     private userFunctions;
     private userMethods;
+    /**
+     * Regular user-declared functions (i.e. NOT methods). Tracked separately
+     * from `userFunctions` so a UFCS-style direct call to a method-only
+     * declaration (`foo(receiver, args)` where `foo` was declared as
+     * `method foo(...)`) can be retargeted to the prefixed JS name.
+     *
+     * If a Pine name has both a regular function and a method form, the
+     * regular function takes precedence for direct `name(args)` calls and
+     * the method is reachable via dot-syntax `obj.name(args)`.
+     */
+    private regularUserFunctions;
+    /**
+     * Registry of user-defined UDT type names → their field map (fieldName → fieldType).
+     * Populated from `const X = Type({fieldA: ['type', default], ...})` declarations
+     * (which pine2js emits from Pine `type X` declarations).
+     *
+     * V2 data model: stores field-type metadata. V1 logic only consults
+     * `isUdtTypeName` for now; field metadata is ready for future use-site
+     * type-aware rewrites (nested UDT chains, mixed scalar/array fields, etc.).
+     */
+    private udtTypeNames;
+    /**
+     * Registry of user variables that hold UDT instances → the UDT type name.
+     * Populated from `let bar = X.new(...)` / `bar = X.copy(...)` where
+     * `X ∈ udtTypeNames`. Stores the type name (V2 shape) so future passes
+     * can do typed-field lookups via `getUdtTypeFields(typeName)` without
+     * a refactor. V1 logic only consults `isUdtInstance`.
+     */
+    private udtInstances;
+    /**
+     * Registry of user-defined function names → UDT type they return.
+     * Populated by inspecting each FunctionDeclaration's return paths during
+     * the UDT pre-pass. A function is registered only when ALL return paths
+     * unambiguously produce the SAME UDT type.
+     *
+     * Used by the instance populator so that `bar = makeBar()` registers
+     * `bar` as a UDT instance when `makeBar` is known to return one.
+     */
+    private functionReturnTypes;
+    /**
+     * Registry of user-defined function names → tuple of UDT type names they
+     * return. Each slot holds either the UDT type name at that position, or
+     * `undefined` when that position is not (unambiguously) a UDT instance.
+     *
+     * Populated when ALL return paths of a function are ArrayExpressions of
+     * the SAME length and each position resolves to the SAME UDT (or to
+     * something non-UDT, which becomes `undefined`).
+     *
+     * Used by the instance populator so that `[a, b] = makeBars()` registers
+     * `a` and `b` as UDT instances at their respective tuple positions.
+     */
+    private functionReturnTupleTypes;
+    /**
+     * Registry of user-defined function names → map of {paramName → UDT type}.
+     * Populated from `<funcName>.__pineParamTypes__ = {...}` markers emitted
+     * by pine2js codegen for parameters that carried a Pine type annotation
+     * (e.g. `readField(BAR b)`). Filtered to UDT-known types so non-UDT
+     * annotations like `int` / `float` / `string` never enter the map.
+     *
+     * Consumed by `transformFunctionDeclaration`: when entering a function's
+     * body, each typed param is temporarily registered as a UDT instance
+     * (`markVariableAsUdtInstance`) so the use-site rewrite for `b.field[N]`
+     * fires inside the body. The registration is removed when leaving the
+     * function scope, keeping the global registry clean.
+     */
+    private functionParamUdtTypes;
     get nextParamIdArg(): any;
     get nextCacheIdArg(): any;
     getNextTACallId(): any;
@@ -33,10 +99,53 @@ export declare class ScopeManager {
     pushScope(type: string): void;
     popScope(): void;
     getCurrentScopeType(): string;
+    /**
+     * True when any active scope on the stack is a function scope.
+     * Different from `getCurrentScopeType() === 'fn'`, which only matches
+     * the immediate scope — code inside a nested `if`/`for`/`while` inside
+     * a function body still needs the function-scope context (e.g. for
+     * call-path-keyed param/ta-callsite ids).
+     */
+    isInsideFunctionScope(): boolean;
     getCurrentScopeCount(): number;
     addLocalSeriesVar(name: string): void;
     removeLocalSeriesVar(name: string): void;
     isLocalSeriesVar(name: string): boolean;
+    addUdtTypeName(typeName: string, fields?: Record<string, string>): void;
+    isUdtTypeName(name: string): boolean;
+    getUdtTypeFields(typeName: string): Record<string, string> | undefined;
+    markVariableAsUdtInstance(varName: string, typeName: string): void;
+    getVariableUdtType(varName: string): string | undefined;
+    isUdtInstance(varName: string): boolean;
+    /**
+     * Record a user-defined function as returning a specific UDT type.
+     * Idempotent — re-registering with the same type is a no-op; conflicting
+     * registrations (different type) drop back to "unknown" by removing the
+     * entry, so an ambiguous function never falsely promotes a caller.
+     */
+    setFunctionReturnType(funcName: string, typeName: string): void;
+    getFunctionReturnType(funcName: string): string | undefined;
+    /**
+     * Record a user-defined function as returning a tuple whose positions
+     * carry specific UDT types (or `undefined` for non-UDT positions).
+     * Idempotent — re-registering with the same shape is a no-op; conflicting
+     * registrations (different length OR different type at any position) drop
+     * the entry, so an ambiguous function never falsely promotes a caller.
+     */
+    setFunctionReturnTupleType(funcName: string, tupleTypes: (string | undefined)[]): void;
+    getFunctionReturnTupleType(funcName: string): (string | undefined)[] | undefined;
+    /**
+     * Record a user-defined function's UDT-typed parameters. The argument
+     * is a `paramName → UDT type` map filtered down to UDT-known types only.
+     */
+    setFunctionParamUdtTypes(funcName: string, paramTypes: Record<string, string>): void;
+    getFunctionParamUdtTypes(funcName: string): Record<string, string> | undefined;
+    /**
+     * Remove a previously-registered UDT instance entry. Used to roll back
+     * scope-local registrations (e.g. UDT-typed function parameters) when
+     * leaving the function body, so the global registry stays clean.
+     */
+    unmarkVariableAsUdtInstance(varName: string): void;
     addContextBoundVar(name: string, isRootParam?: boolean): void;
     removeContextBoundVar(name: any): void;
     addArrayPatternElement(name: string): void;
@@ -52,6 +161,8 @@ export declare class ScopeManager {
     isUserFunction(name: string): boolean;
     addUserMethod(name: string): void;
     isUserMethod(name: string): boolean;
+    addRegularUserFunction(name: string): void;
+    isRegularUserFunction(name: string): boolean;
     addVariable(name: string, kind: string): string;
     getVariable(name: string): [string, string];
     /**

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

@@ -16,27 +16,45 @@ export declare class CodeGenerator {
     generate(ast: any): string;
     private preProcessAST;
     /**
-     * Scan the program body for variable declarations and assignments whose
-     * names collide with Pine namespace/built-in names (e.g., `fill`, `size`,
-     * `color`, `line`). Rename them with a `_$N` suffix so they don't shadow
-     * the namespace destructured from `$.pine`.
+     * Scan the program body for declarations whose names would collide with
+     * either Pine namespaces or JavaScript reserved keywords. Rename them
+     * with a `_$N` suffix.
      *
-     * Only renames **user variables** — function parameters are handled
-     * separately in generateFunctionDeclaration().
+     * Two collision classes, one rename pass:
      *
-     * Renaming rules:
-     * - Variable declaration target (let fill = ...) → renamed
-     * - Assignment target (fill := ...) → renamed
-     * - Bare identifier read (return fill) → renamed
-     * - Call callee (fill(...)) → NOT renamed (namespace call)
-     * - MemberExpression object (size.tiny) → NOT renamed (namespace access)
-     * - MemberExpression property (array.size) → NOT renamed (method name)
-     * - Object property key ({size: ...}) → NOT renamed (named arg key)
+     *  1. Pine namespace collisions (NAMESPACE_COLLISION_NAMES — e.g. `fill`,
+     *     `size`, `color`, `line`): user variable would shadow the namespace
+     *     destructured from `$.pine`. The CALL SITE `fill(...)` is the
+     *     namespace, NOT the renamed variable, so callees are NOT renamed.
+     *
+     *  2. JS reserved keyword collisions (JS_RESERVED_WORDS — e.g. `delete`,
+     *     `super`, `static`): the generated JS would fail to parse
+     *     (`function delete()` → "Unexpected keyword 'delete'"). The CALL SITE
+     *     `delete(arg)` IS the user function, so callees MUST be renamed.
+     *
+     * The walker checks the original name's source list at each call site to
+     * pick the right behavior.
+     *
+     * Renaming rules (common):
+     * - Variable declaration target (let fill = ...)  → renamed
+     * - Function declaration name (function delete()) → renamed (class 2 only)
+     * - Assignment target (fill := ...)               → renamed
+     * - Bare identifier read (return fill)            → renamed
+     * - MemberExpression object (size.tiny)           → NOT renamed
+     * - MemberExpression property (obj.delete)        → NOT renamed
+     * - Object property key ({size: ...})             → NOT renamed
      */
     private renameConflictingVariables;
     /**
-     * Walk the AST and collect variable declarations / assignment targets
-     * whose names conflict with CONFLICTING_NAMES.
+     * True if `name` requires renaming — either a Pine namespace collision
+     * or a JS reserved keyword (which would make the generated JS invalid).
+     */
+    private isReservedName;
+    /**
+     * Walk the AST and collect declarations whose names conflict with either
+     * Pine namespaces (NAMESPACE_COLLISION_NAMES) or JS reserved keywords
+     * (JS_RESERVED_WORDS). Both collision classes are renamed with the same
+     * `_$N` suffix scheme.
      */
     private collectConflictingVarNames;
     /**
@@ -58,6 +76,7 @@ export declare class CodeGenerator {
     generateStatement(node: any): void;
     generateTypeDefinition(node: any): void;
     private renameIdentifiersInAST;
+    private renameParamRefsInBody;
     generateFunctionDeclaration(node: any): void;
     generateVariableDeclaration(node: any): void;
     generateExpressionStatement(node: any): void;

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

@@ -14,6 +14,14 @@ export declare class Lexer {
     tokenize(): Token[];
     handleNewline(): void;
     handleIndentation(): void;
+    /**
+     * True when the most recently emitted token (skipping NEWLINE / COMMENT
+     * — those are layout, not content) is a token that requires a right-
+     * hand-side and therefore implies the next non-blank line is a
+     * continuation, not a new block. Mirrors the set the parser's
+     * `peekOperatorEx` already crosses NEWLINE for.
+     */
+    private isContinuationFromPrevToken;
     readComment(): void;
     readString(): void;
     readColorLiteral(): void;

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

@@ -4,12 +4,21 @@ export declare class Parser {
     private tokens;
     private pos;
     private functionNames;
+    private paramScopes;
     private noLineContinuation;
     constructor(tokens: Token[]);
     peek(offset?: number): Token;
+    private isCurrentFunctionParam;
     advance(): Token;
     match(type: any, value?: any): boolean;
     expect(type: any, value?: any): Token;
+    private static readonly CONTEXTUAL_KEYWORDS;
+    /**
+     * Consume an identifier OR a contextual keyword used as an identifier.
+     * Used in positions where Pine permits soft keywords as names — most notably
+     * UDT field names like `int type = 0`.
+     */
+    expectIdentifierOrContextual(): Token;
     matchEx(type: any, value?: any, allowLineContinuation?: boolean): boolean;
     peekOperatorEx(validOps: string[]): any;
     skipNewlines(allowIndent?: boolean): void;

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

@@ -3,6 +3,7 @@ export declare const NAMESPACES_LIKE: string[];
 export declare const ASYNC_METHODS: string[];
 export declare const FACTORY_METHODS: string[];
 export declare const NAMESPACE_COLLISION_NAMES: Set<string>;
+export declare const JS_RESERVED_WORDS: Set<string>;
 export declare const CONTEXT_DATA_VARS: string[];
 export declare const CONTEXT_PINE_VARS: string[];
 export declare const CONTEXT_CORE_VARS: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.13",
+    "version": "0.9.15",
     "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",