@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/lib/indicators/utils.d.ts

@@ -0,0 +1,259 @@
+export declare function numericExtent(values: readonly number[]): [number, number];
+export declare function collectNumbers(value: unknown, collected?: number[]): number[];
+export declare function emaSeries(values: readonly number[], period: number): number[];
+export declare function smaSeries(values: readonly number[], period: number): number[];
+export interface PriceBar {
+    open?: number;
+    close: number;
+    high: number;
+    low: number;
+    volume: number;
+    date?: Date;
+}
+export interface KdjSeriesResult {
+    k: number[];
+    d: number[];
+    j: number[];
+}
+export interface DmiSeriesResult {
+    plusDI: number[];
+    minusDI: number[];
+    adx: number[];
+}
+export interface BrarSeriesResult {
+    ar: number[];
+    br: number[];
+}
+export interface MtmSeriesResult {
+    mtm: number[];
+    signal: number[];
+}
+export interface EmvSeriesResult {
+    emv: number[];
+    signal: number[];
+}
+export interface TrixSeriesResult {
+    trix: number[];
+    signal: number[];
+}
+export interface DmaSeriesResult {
+    ddd: number[];
+    ama: number[];
+}
+export interface PsySeriesResult {
+    psy: number[];
+    signal: number[];
+}
+export interface CrSeriesResult {
+    cr: number[];
+    ma1: number[];
+    ma2: number[];
+    ma3: number[];
+    ma4: number[];
+}
+export declare function bbiSeries(bars: readonly PriceBar[]): number[];
+export declare function sarSeries(bars: readonly PriceBar[], afStep?: number, afMax?: number): number[];
+export declare function obvSeries(bars: readonly PriceBar[]): number[];
+export declare function wrSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function vrSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function emaSeriesSkipNaN(values: readonly number[], period: number): number[];
+export declare function smaSeriesSkipNaN(values: readonly number[], period: number): number[];
+export declare function wilderSeries(values: readonly number[], period: number): number[];
+export declare function wilderSeriesSkipNaN(values: readonly number[], period: number): number[];
+export declare function aoColorSeries(values: readonly number[]): Array<string | undefined>;
+export declare function kdjSeries(bars: readonly PriceBar[], period?: number, m1?: number, m2?: number): KdjSeriesResult;
+export declare function cciSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function dmiSeries(bars: readonly PriceBar[], period?: number): DmiSeriesResult;
+export declare function biasSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function brarSeries(bars: readonly PriceBar[], period?: number): BrarSeriesResult;
+export declare function mtmSeries(bars: readonly PriceBar[], period?: number, signalPeriod?: number): MtmSeriesResult;
+export declare function emvSeries(bars: readonly PriceBar[], period?: number): EmvSeriesResult;
+export declare function aoSeries(bars: readonly PriceBar[]): number[];
+export declare function rocSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function trixSeries(bars: readonly PriceBar[], period?: number, signalPeriod?: number): TrixSeriesResult;
+export declare function dmaSeries(bars: readonly PriceBar[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number): DmaSeriesResult;
+export declare function pvtSeries(bars: readonly PriceBar[]): number[];
+export declare function psySeries(bars: readonly PriceBar[], period?: number, signalPeriod?: number): PsySeriesResult;
+export declare function crSeries(bars: readonly PriceBar[], period?: number, m1?: number, m2?: number, m3?: number, m4?: number): CrSeriesResult;
+export declare function rsiSeries(values: readonly number[], period: number): number[];
+export interface MacdSeriesResult {
+    macd: number[];
+    signal: number[];
+    histogram: number[];
+}
+export declare function macdSeries(values: readonly number[], fastPeriod: number, slowPeriod: number, signalPeriod: number): MacdSeriesResult;
+export interface BollingerSeriesResult {
+    upper: number[];
+    middle: number[];
+    lower: number[];
+}
+export declare function bollingerSeries(values: readonly number[], period: number, multiplier: number): BollingerSeriesResult;
+export declare function trueRangeSeries(bars: readonly PriceBar[]): number[];
+export declare function atrSeries(bars: readonly PriceBar[], period: number): number[];
+export declare function wmaSeries(values: readonly number[], period: number): number[];
+export declare function vwmaSeries(bars: readonly PriceBar[], period: number): number[];
+export declare function hmaSeries(values: readonly number[], period: number): number[];
+export declare function demaSeries(values: readonly number[], period: number): number[];
+export declare function temaSeries(values: readonly number[], period: number): number[];
+export interface MARibbonSeriesResult {
+    [key: string]: number[];
+}
+export declare function maRibbonSeries(values: readonly number[], type?: "SMA" | "EMA", periods?: readonly number[]): MARibbonSeriesResult;
+export interface IchimokuSeriesResult {
+    tenkan: number[];
+    kijun: number[];
+    senkouA: number[];
+    senkouB: number[];
+    chikou: number[];
+}
+export declare function ichimokuSeries(bars: readonly PriceBar[], tenkanPeriod?: number, kijunPeriod?: number, senkouBPeriod?: number, displacement?: number): IchimokuSeriesResult;
+export interface SupertrendSeriesResult {
+    supertrend: number[];
+    direction: number[];
+    upperBand: number[];
+    lowerBand: number[];
+}
+export declare function supertrendSeries(bars: readonly PriceBar[], period?: number, multiplier?: number): SupertrendSeriesResult;
+export interface KeltnerSeriesResult {
+    upper: number[];
+    middle: number[];
+    lower: number[];
+}
+export declare function keltnerSeries(bars: readonly PriceBar[], period?: number, atrPeriod?: number, multiplier?: number): KeltnerSeriesResult;
+export interface DonchianSeriesResult {
+    upper: number[];
+    middle: number[];
+    lower: number[];
+}
+export declare function donchianSeries(bars: readonly PriceBar[], period?: number): DonchianSeriesResult;
+export declare function chaikinVolSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function stdDevSeries(values: readonly number[], period?: number): number[];
+export declare function historicalVolSeries(values: readonly number[], period?: number, annualize?: boolean): number[];
+export declare function choppinessIndexSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function cmfSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function mfiSeries(bars: readonly PriceBar[], period?: number): number[];
+export declare function volOscSeries(bars: readonly PriceBar[], shortPeriod?: number, longPeriod?: number): number[];
+export interface VwapSeriesResult {
+    vwap: number[];
+    upper1: number[];
+    lower1: number[];
+    upper2: number[];
+    lower2: number[];
+    upper3: number[];
+    lower3: number[];
+}
+export declare function vwapSeries(bars: readonly PriceBar[], anchor?: "session" | "week" | "month", showBands?: boolean, multiplier?: number): VwapSeriesResult;
+export declare function anchoredVwapSeries(bars: readonly PriceBar[], anchorTime: number, showBands?: boolean, multiplier?: number): VwapSeriesResult;
+export interface AlligatorSeriesResult {
+    jaw: number[];
+    teeth: number[];
+    lips: number[];
+}
+export declare function alligatorSeries(bars: readonly PriceBar[], jawPeriod?: number, jawShift?: number, teethPeriod?: number, teethShift?: number, lipsPeriod?: number, lipsShift?: number): AlligatorSeriesResult;
+export interface FractalsSeriesResult {
+    bearish: number[];
+    bullish: number[];
+}
+export declare function fractalsSeries(bars: readonly PriceBar[]): FractalsSeriesResult;
+export interface GatorSeriesResult {
+    upper: number[];
+    lower: number[];
+}
+export declare function gatorSeries(bars: readonly PriceBar[], jawPeriod?: number, jawShift?: number, teethPeriod?: number, teethShift?: number, lipsPeriod?: number, lipsShift?: number): GatorSeriesResult;
+export declare function acSeries(bars: readonly PriceBar[]): number[];
+export interface PivotSeriesResult {
+    pp: number[];
+    r1: number[];
+    s1: number[];
+    r2: number[];
+    s2: number[];
+    r3: number[];
+    s3: number[];
+}
+export declare function pivotStandardSeries(bars: readonly PriceBar[], type?: "standard" | "fibonacci" | "camarilla" | "woodie" | "demark"): PivotSeriesResult;
+export declare function pivotHighLowSeries(bars: readonly PriceBar[], lookback?: number, type?: "standard" | "fibonacci"): PivotSeriesResult;
+export declare function synthesizeTicksFromBar(bar: PriceBar, tickSize: number): Array<{
+    symbol: string;
+    timestamp: number;
+    price: number;
+    size: number;
+    side: "buy" | "sell";
+}>;
+export interface TPOBlock {
+    price: number;
+    letter: string;
+    volume: number;
+    timeStart: number;
+    timeEnd: number;
+}
+export interface MarketProfileData {
+    tpoBlocks: TPOBlock[];
+    poc: number;
+    valueAreaHigh: number;
+    valueAreaLow: number;
+    initialBalanceHigh: number;
+    initialBalanceLow: number;
+    profileHigh: number;
+    profileLow: number;
+}
+export declare function computeMarketProfile(ticks: Array<{
+    timestamp: number;
+    price: number;
+    size: number;
+    side: "buy" | "sell";
+}>, sessionStart: number, sessionEnd: number, tickSize: number, tpoPeriodMinutes?: number): MarketProfileData;
+export interface VolumeProfileLevel {
+    price: number;
+    volume: number;
+    buyVolume: number;
+    sellVolume: number;
+}
+export interface VolumeProfileData {
+    priceLevels: VolumeProfileLevel[];
+    poc: number;
+    valueAreaHigh: number;
+    valueAreaLow: number;
+    highVolumeNodes: number[];
+    lowVolumeNodes: number[];
+}
+export declare function computeVolumeProfile(data: Array<{
+    timestamp: number;
+    price: number;
+    size: number;
+    side: "buy" | "sell";
+}> | PriceBar[], priceTickSize: number, range?: {
+    from: number;
+    to: number;
+}): VolumeProfileData;
+export interface FootprintLevel {
+    price: number;
+    bidVolume: number;
+    askVolume: number;
+    delta: number;
+    deltaPercent: number;
+    totalVolume: number;
+}
+export interface FootprintBar {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    priceLevels: FootprintLevel[];
+}
+export declare function computeFootprintBars(data: Array<{
+    timestamp: number;
+    price: number;
+    size: number;
+    side: "buy" | "sell";
+}> | PriceBar[], barIntervalMs: number, priceTickSize: number): FootprintBar[];
+export interface DeltaProfileData {
+    cumulativeDelta: number[];
+    barDelta: number[];
+    deltaSMA: number[];
+    divergenceSignals: {
+        index: number;
+        type: "bullish" | "bearish";
+    }[];
+}
+export declare function computeDeltaProfile(footprintBars: FootprintBar[], smaPeriod?: number): DeltaProfileData;

package/dist/dts/lib/pinescript/PineCompiler.d.ts

@@ -0,0 +1,34 @@
+import { ASTNode } from "./ast";
+export interface IndicatorPlugin {
+    id: string;
+    name: string;
+    version: string;
+    compute: (input: {
+        bars: any[];
+    }, params: any) => Record<string, number[]>;
+    outputSchema: any;
+    defaultParams: any;
+    paramSchema: any;
+    dependencies?: string[];
+}
+export declare const pinePlugins: Map<string, IndicatorPlugin>;
+export declare function registerPinePlugin(plugin: IndicatorPlugin): void;
+export declare function getPinePlugin(id: string): IndicatorPlugin | undefined;
+export declare function evaluatePineAST(nodes: ASTNode[], bars: {
+    open: number[];
+    high: number[];
+    low: number[];
+    close: number[];
+    volume: number[];
+}): {
+    studyInfo: {
+        name: string;
+        overlay: boolean;
+    };
+    plots: {
+        name: string;
+        values: number[];
+        color: string;
+    }[];
+};
+export declare function compilePineToPlugin(scriptText: string): IndicatorPlugin;

package/dist/dts/lib/pinescript/ast.d.ts

@@ -0,0 +1,73 @@
+export type ASTNode = {
+    type: "StudyDeclaration";
+    name: string;
+    overlay: boolean;
+} | {
+    type: "Assignment";
+    variable: string;
+    expression: ExpressionNode;
+} | {
+    type: "Plot";
+    expression: ExpressionNode;
+    title?: string;
+    color?: string;
+} | {
+    type: "PlotShape";
+    expression: ExpressionNode;
+    title: string;
+    style: string;
+    location: string;
+    color: string;
+    size: string;
+} | {
+    type: "HLine";
+    price: number;
+    title: string;
+    color: string;
+} | {
+    type: "InputDecl";
+    variable: string;
+    defaultValue: number | string;
+    title: string;
+} | {
+    type: "IfStatement";
+    condition: ExpressionNode;
+    thenBlock: ASTNode[];
+    elseBlock: ASTNode[];
+} | {
+    type: "ForStatement";
+    variable: string;
+    start: ExpressionNode;
+    end: ExpressionNode;
+    body: ASTNode[];
+};
+export type ExpressionNode = {
+    type: "Literal";
+    value: number | string | boolean;
+} | {
+    type: "Identifier";
+    name: string;
+} | {
+    type: "BinaryExpression";
+    operator: string;
+    left: ExpressionNode;
+    right: ExpressionNode;
+} | {
+    type: "UnaryExpression";
+    operator: string;
+    argument: ExpressionNode;
+} | {
+    type: "FunctionCall";
+    name: string;
+    arguments: ExpressionNode[];
+};
+export interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface SourceNode {
+    location: SourceLocation;
+    start: SourceLocation;
+    end: SourceLocation;
+}

package/dist/dts/lib/pinescript/compile.d.ts

@@ -0,0 +1,40 @@
+import { parseScript, type CompileError } from './pineParse';
+import { createSeriesEnv, type PineBars, type SeriesEnv } from './pineEnv';
+export { parseScript, createSeriesEnv, type CompileError, type PineBars };
+/**
+ * Một `alertcondition()` đã đánh giá. `condition` là series 0/1 thật — không
+ * phải stub: đây chính là điều kiện mà script tuyên bố.
+ */
+export interface AlertSpec {
+    title: string;
+    message: string;
+    condition: number[];
+}
+export interface CompileResult {
+    output: Record<string, number[]>;
+    errors: CompileError[];
+    alerts: AlertSpec[];
+    /**
+     * `overlay=` from the `study`/`indicator`/`strategy` declaration, already parsed by the
+     * grammar (`grammar.ts:46`). The widget needs it to decide whether the output series joins
+     * the price pane or gets its own pane; until this existed, the host hardcoded `"price"` and
+     * a non-overlay script was drawn in the wrong place. Defaults to `false` (Pine's own default)
+     * when the declaration omits the keyword.
+     */
+    overlay?: boolean;
+}
+export { callFunction, MAX_FOR_ITERATIONS, MAX_WHILE_ITERATIONS, MAX_CALL_DEPTH } from './pineBuiltins';
+/**
+ * Thực thi AST đã parse với một `env` cho sẵn.
+ *
+ * F1: `pine.worker.ts` từng GIỮ MỘT BẢN SAO của toàn bộ evaluator này. Hai
+ * bản lệch nhau ngay từ A9: bản trong worker không hiểu `boolLiteral`
+ * (`parseFloat(true)` = NaN -> 0) nên `ta.tr(true)` cho kết quả khác hẳn giữa
+ * editor và chart, và nó cũng không hiểu kênh chuỗi nên `str.*` sẽ chết âm thầm
+ * trong editor. Gộp về một hàm là cách chặn họ tái phát: giờ không còn bản sao
+ * nào để lệch.
+ *
+ * Ném exception ra ngoài (kể cả timeout) — cả `compile` lẫn worker đều tự bắt.
+ */
+export declare function runProgram(ast: any[], env: SeriesEnv, length: number, outputs: Record<string, number[]>, alerts?: AlertSpec[]): void;
+export declare function compile(source: string, bars?: PineBars): CompileResult;

package/dist/dts/lib/pinescript/grammar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * NGUỒN THẬT DUY NHẤT của grammar VnScript.
+ *
+ * `compile.ts` và `pine.worker.ts` đều gọi `peggy.generate(GRAMMAR_SOURCE)` — tức
+ * grammar được **biên dịch lúc chạy**, không có bước generate file.
+ *
+ * ⚠️ W1.2: `grammar.pegjs` từng tồn tại cạnh file này nhưng **không module nào
+ * import** (grep toàn repo: 0 kết quả ngoài chính nó). Nó là bản sao chết đã khiến
+ * việc tìm lỗi parse rất dễ đi nhầm — sửa file đó không có tác dụng gì. Đã xoá.
+ * Nếu muốn đổi grammar, sửa **file này**.
+ */
+export declare const GRAMMAR_SOURCE = "{\n  // VnScript Grammar \u2014 PEG.js\n  // Phase A subset: study/indicator/strategy, plot, plotshape, hline, if/else, for, input(), 10+ ta.* functions\n  // Error recovery via expected() + structured location() on all nodes\n  //\n  // W-01 (PINE Stage 3): grammar tra ve DONG PHANG, khong long khoa.\n  //\n  // Do do la chu dich, khong phai tai nang:\n  //   * `ifBlock = Statement+` nuot TAT CA statement con lai cua script vao khoi,\n  //     vi `Statement` khong biet \"het khoi o dau\". Do o @ 216a8cd: script\n  //     `if c` + `x = 1` + `else` + `x = -1` + `plot(x)` cho `output = {}`\n  //     va `errors = []` \u2014 ve ra KHONG co gi va KHONG bao loi.\n  //   * Muon long trong grammar thi can truyen \"do thu le cua khoi cha\" cho moi\n  //     rule, ma peggy 5 KHONG co rule co tham so (`Block$(ind)` khong hop le \u2014\n  //     xem `node_modules/peggy/lib/parser.js:2083`), va action trong PEG luon\n  //     chay SAU khi match nen khong gan bien truoc khi parse khoi duoc.\n  //   * Bang chung chay lai duoc: `scripts/probe-grammar-caps.mjs`.\n  //\n  // Vay grammar o day chi tach DONG: moi rule ket thuc bang `_EOL` de KHONG an\n  // newline, nho do `indent` cua dong con nguyen cho `buildBlocks`.\n  // (`pineBlocks.ts` la tang long khoi.)\n  //\n  // \u26A0\uFE0F `Script` phai la rule DINH NGHIA DAU TIEN (sau initializer). peggy chay\n  // `parse()` tu rule dau tien, va `startRule` KHONG c\u1EE9u \u0111\u01B0\u1EE3c rule sau \u2014 thu\n  // cho ra `Can't start parsing from rule \"X\"`. Do la ly do `_EOL` (va moi\n  // rule phu tro khac) deu nam SAU `Script`.\n}\n\n// `Script` phai la rule DAU TIEN. `_EOL` dinh nghia sau no.\nScript\n  = s:SourceLine* {\n      return s\n    }\n\n// Het dong: xoa khoang trang cuoi dong roi newline (hoac EOF). KHONG gom\n// `[ \\t]*` phia truoc newline vao `indent` cua dong sau \u2014 do la thu le\n// cua dong sau, thuoc ve `SourceLine` tiep theo.\n_EOL\n  = [ \\t]* ( \"\\r\"? \"\\n\" / !. )\n\n// `SourceLine` GIU `indent`. Moi alternative cua `Statement` DA ket thuc bang\n// `_EOL`, nen `SourceLine` khong them `_EOL` lan nua \u2014 neu them, no se doi\n// newline thu hai ngay dau dong sau (do la loi da gap).\n//\n// Nh\u00E1nh 3 (d\u00F2ng tr\u1ED1ng) fix 2026-10-11 \u2014 xem pineDefaultTemplate.test.ts.\n// Ph\u1EA3i \u0103n newline: _EOL kh\u1EDBp zero-width \u1EDF EOF n\u00EAn peggy t\u1EEB ch\u1ED1i grammar l\u00FAc generate.\nSourceLine\n  = ws:$([ \\t]*) node:(CommentLine / Statement) {\n      return { indent: ws.length, node: node }\n    }\n  / ws:$([ \\t]*) CommentLineRest {\n      return { indent: ws.length, node: null }\n    }\n  / ws:$([ \\t]*) \"\\r\"? \"\\n\" {\n      return { indent: ws.length, node: null }\n    }\n\n// Dong comment: ca noi dung bo qua, node = null nen `buildBlocks` bo qua.\nCommentLine\n  = \"//\" [^\\n]* !. { return null }\n\nCommentLineRest\n  = \"//\" [^\\n]* ( \"\\r\"? \"\\n\" / !. )\n\nStatement\n  = s:studyDecl _EOL { return s }\n  / s:inputCall _EOL { return s }\n  / s:funcDeclBlock { return s }\n  / s:funcDecl _EOL { return s }\n  / s:varDecl _EOL { return s }\n  / s:plotCall _EOL { return s }\n  / s:plotshapeCall _EOL { return s }\n  / s:hlineCall _EOL { return s }\n  / s:alertconditionCall _EOL { return s }\n  / s:assignment _EOL { return s }\n  / s:tupleAssignment _EOL { return s }\n  / s:ifStatement _EOL { return s }\n  / s:forStatement _EOL { return s }\n  / s:whileStatement _EOL { return s }\n  / s:elseBlock _EOL { return s }\n\ncomment\n  = \"//\" [^\\n]* \"\\n\"? { return null }\n\n\n// W1.2: Pine v5 doi tu \"study\" thanh \"indicator\" va them \"strategy\".\n// Nguoi dung quen TradingView se viet indicator(...) \u2014 neu grammar chi nhan\n// \"study\" thi script hop le bi tu choi. Ca ba tu khoa nhan chung mot shape.\nstudyDecl\n  = kw:(\"indicator\" / \"strategy\" / \"study\") _ \"(\" _ title:stringLiteral _ rest:( _ \",\" _ \"overlay\" _ \"=\" _ overlayVal:boolLiteral { return overlayVal } )? _ \")\" {\n      return { type: \"StudyDeclaration\", kind: kw, name: title, overlay: rest ?? false, loc: location() }\n    }\n\n// W1.2: Pine v5 co \"var\"/\"const\" truoc khai bao bien. To khoa \"while\" va \"not\"\n// VAN chua ho tro \u2014 da bo khoi Monaco de tranh to mau mot tu khoa parser se tu choi.\n//\n// \u26A0 PINE-01 (2026-10-12): `var` nay **tu choi san** thay vi \"parse xong roi im lang\n// tinh sai\". Do evaluator chay vector tren TOAN bo series (xem `compile.ts`\n// `executeNodes`), nen `x := x + close` tinh `close` o moi bar cung mot luc \u2014 KHONG\n// doc gia tri `x` o bar truoc. Do la het `var x = 0` + `x := x + close` cho\n// [10,20,30,40,50,60] trong khi Pine that cho [10,30,60,100,150,210], va\n// `errors = []`. Do la dung lop \"sai ma im lang\" ma repo nay da 3 lan patch\n// (S4-B01/S4-B05/S4-B09) \u2014 nen `var` phai fail-closed cho den khi co\n// evaluator chay TUAN TU (noi lon cua Stage 3), khong phai \"them guard chong guard\".\n//\n// Loi nam O DAY chu khong phai trong `compile.ts`: ca `compile()` LAN worker\n// (`pine.worker.ts:47`) deu goi `p.parse`, nen mot loi nem tu action nay se co\n// `location()` va ca hai duong deu bao dung dong \u2014 truoc day mot guard chi o\n// `compile()` se bi worker bo qua (dung lop A9/F1 da gap 3 lan).\nvarDecl\n  = declKind:(\"var\" / \"const\")? _ name:identifier _ op:assignOp _ expr:expression {\n      if (declKind === \"var\") {\n        const e = new Error(\"var is not supported yet: Pine's var keeps its value across bars, but this engine evaluates every statement across the whole series at once. Drop the var keyword, or wait for sequential evaluation.\")\n        e.location = location()\n        throw e\n      }\n      return { type: \"Assignment\", declKind: declKind ?? null, kind: op, variable: name, expression: expr, loc: location() }\n    }\n\n// W-01: `=` khai bao, `:=` gan lai. `:=` truoc day bi tu choi trong khi\n// moi gan lai ma khong bao gi \u2014 mot script viet theo thoi quen Viet Nam\n// (TradingView) chi can mot dau hai cham la chay.\nassignOp\n  = \":=\" { return \"reassign\" }\n  / \"=\" { return \"assign\" }\n\nassignment\n  = name:identifier _ op:assignOp _ expr:expression {\n      return { type: \"Assignment\", kind: op, variable: name, expression: expr, loc: location() }\n    }\n\n// W-05: khoi tach gia tri. KHONG phai array literal; day la phep gan nhieu bien\n// tu MOT bieu thuc tra ve nhieu gia tri.\n//\n// Vi sao can: Pine tra `ta.bb` ra 3 dai (middle/upper/lower) va `ta.macd` ra 3\n// gia tri (macd/signal/hist). Do khong co `[]` o tang Statement, cau hinh\n// `[m, u, l] = ta.bb(close, 20, 2)` that bang parse error (do: probe\n// `probe-pine-stage4.mjs` case S4-01) - ngh\u0129a la nguoi dung Viet Nam viet theo\n// thoi quen TradingView khong chay duoc.\n//\n// KHONG phai `close[1]`: `historyOffset` nam trong `primary` (tang bieu thuc,\n// duoi day ~200 dong), con rule nay nam trong `Statement`. Hai tang PEG roi nhau\n// nen khong va cham. R-01 cua plan Stage 3 bao \"va cham dau mo ngoac vuong la rui\n// ro so 1\" - do la CHAN DOAN SAI; rui ro that la quen them alternative vao\n// `Statement`.\ntupleAssignment\n  = \"[\" _ names:tupleNameList _ \"]\" _ op:assignOp _ expr:expression {\n      return { type: \"TupleAssignment\", kind: op, variables: names, expression: expr, loc: location() }\n    }\n\n// Danh sach ten ben trong ngoac vuong. `&\"]\"` dam bao danh sach rong khong khop:\n// `[] = f()` phai la LOI (khong phai im lang giu 0 bien) - xem AC-1.3.\ntupleNameList\n  = &\"]\" \"\" { return [] }\n  / head:identifier tail:( _ \",\" _ p:identifier { return p })* { return [head, ...tail] }\n\n// W-01: UDF `f(x) => expr`. PHAI GAN CUOI danh sach Statement: `funcDecl`\n// mo bang `identifier` nen no an het moi rule bat dau bang identifier khac\n// (`study`, `plot`, ...) neu thu truoc no.\nfuncDecl\n  = name:identifier _ \"(\" _ params:paramList _ \")\" _ \"=>\" _ body:expression {\n      return { type: \"FuncDecl\", name: name, params: params, body: body, loc: location() }\n    }\n\n// W-08: than KHOI. `f(x) =>` roi xuong dong, cac dong thut le sau la than.\n//\n// CANH BAO THAT, DA DO (AC-4.13b / R-01 cua plan Stage 4):\n// `f(x) =>` + newline + `  x * 2` (bieu thuc o DONG KE TIEP) DA CHAY DUOC tu\n// truoc W-08, vi `_` la whitespace va no AN newline ngay sau `=>`. Neu khoi thi\n// rule nay that, no se AN dang bieu thuc do va pha script dang chay.\n//\n// Dap ung la lookahead `&StatementBodyFirstLine`: rule khoi chi duoc dung khi\n// dong dau tien cua than that su la mot Statement HOP LE. `x*2` khong phai\n// Statement (khong co dau bang hay `:=` sau `x`) nen lookahead that, PEG\n// fallback ve dang bieu thuc. Rule khoi DONG TRUOC, va dong dau tien phai parse\n// duoc truoc khi rule khoi duoc chap nhan.\n//\n// V\u00EC sao `\"=>\" _EOL` ch\u1EE9 kh\u00F4ng ph\u1EA3i `\"=>\" _ _EOL`: `_` l\u00E0 whitespace v\u00E0 n\u00F3\n// \u0102N newline, n\u00EAn `_EOL` s\u1EBD kh\u00F4ng bao gi\u1EDD kh\u1EDBp. \u0110\u00E2y l\u00E0 l\u00FD do r\u1EA5t nh\u1ECF nh\u01B0ng l\u1EA1i\n// l\u00E0 th\u1EE9 gian nh\u1EA5t \u0111\u1EC3 l\u00E0m rule n\u00E0y ch\u1EBFt im l\u1EB7ng.\n//\n// \u26A0 B\u1EAAY C\u1EE6A TEMPLATE LITERAL, \u0111\u00E3 tr\u00FAng tr\u1EF1c ti\u1EBFp m\u1ED9t l\u1EA7n trong ch\u00EDnh W-08 n\u00E0y:\n// `GRAMMAR_SOURCE` l\u00E0 template literal, n\u00EAn m\u1ED9t chu\u1ED7i BACKSLASH + T/R/N trong\n// COMMENT l\u00E0 ESCAPE TH\u1EACT v\u00E0 s\u1EBD c\u1EAFt ngang d\u00F2ng. Comment vi\u1EBFt sai khi\u1EBFn PEGGY b\u00E1o\n// l\u1ED7i t\u1EA1i m\u1ED9t D\u00D2NG C\u1EE6A CH\u00CDNH GRAMMAR, v\u00E0 **m\u1ECDi** l\u1EC7nh \u0111\u1EC1u \u0111\u1ECF \u2014 k\u1EC3 c\u1EA3 l\u1EC7nh r\u1ED7ng.\n// \u0110\u00FAng \u0111\u1EBFn m\u1EE9c ng\u01B0\u1EDDi \u0111\u1ECDc comment th\u1EA5y ho\u00E0n to\u00E0n \u0111\u00FAng, ch\u1EC9 c\u00F3 compiler m\u1EDBi sai.\n// V\u00EC v\u1EADy trong file n\u00E0y: comment d\u00F9ng `\\``` \u0111\u1EC3 hi\u1EC7n backtick (quy \u01B0\u1EDBc s\u1EB5n c\u00F3\n// c\u1EE7a file), v\u00E0 KH\u00D4NG vi\u1EBFt escape backslash trong comment.\n// V\u00EC sao alternative n\u00E0y KH\u00D4NG c\u00F3 `_EOL` \u1EDF cu\u1ED1i (kh\u00E1c m\u1ECDi rule kh\u00E1c):\n// `funcDeclBlock` \u0111\u00E3 T\u1EF0 \u0102N newline ngay sau `=>` b\u00EAn trong n\u00F3. N\u1EBFu th\u00EAm `_EOL` \u1EDF\n// \u0111\u00E2y th\u00EC parser ph\u1EA3i \u0111\u00F2i m\u1ED9t newline TH\u1EE8 HAI ngay tr\u01B0\u1EDBc d\u00F2ng \u0111\u1EA7u c\u1EE7a th\u00E2n, m\u00E0\n// d\u00F2ng \u0111\u00F3 l\u00E0 `  plot(x)` \u2014 kh\u00F4ng c\u00F3 newline \u21D2 rule ch\u1EBFt, v\u00E0 m\u1ECDi UDF th\u00E2n kh\u1ED1i \u0111\u1EC1u\n// r\u01A1i v\u1EC1 d\u1EA1ng bi\u1EC3u th\u1EE9c r\u1ED3i b\u00E1o parse error. \u0110\u00E3 tr\u00FAng l\u1ED7i n\u00E0y m\u1ED9t l\u1EA7n.\n// \u26A0 `&` phai BO C\u1EA2 C\u00C1P TRONG NGO\u1EB6C: `&A B` trong PEGGY l\u00E0 `(&A) B` \u2014 predicate\n// ch\u1EC9 ph\u1EE7 `A`, c\u00F2n `B` l\u00E0 ph\u1EA7n t\u1EED B\u1EAET BU\u1ED8C ph\u1EA3i kh\u1EDBp t\u1EA1i v\u1ECB tr\u00ED CH\u01AFA consume.\n// V\u1EDBi `&[ \t]+ StatementStart` th\u00EC `StatementStart` ph\u1EA3i kh\u1EDBp ngay tr\u01B0\u1EDBc kho\u1EA3ng\n// tr\u1EAFng \u21D2 lu\u00F4n h\u1ECFng, m\u1ECDi th\u00E2n kh\u1ED1i r\u01A1i v\u1EC1 d\u1EA1ng bi\u1EC3u th\u1EE9c. \u0110o l\u1EA1i b\u1EB1ng grammar\n// peggy t\u1ED1i gi\u1EA3n tr\u01B0\u1EDBc khi tin.\nfuncDeclBlock\n  = name:identifier _ \"(\" _ params:paramList _ \")\" _ \"=>\" _EOL &([ \\t]+ StatementStart) {\n      return { type: \"FuncDeclBlock\", name: name, params: params, body: [], loc: location() }\n    }\n\n// Token mo dau mot STATEMENT \u2014 dung lam lookahead cho `funcDeclBlock`.\n//\n// V\u00EC sao KH\u00D4NG d\u00F9ng `&` v\u1EDBi ch\u00EDnh rule `Statement`: `expression` trong grammar\n// nay \u0102N newline (do `_` l\u00E0 whitespace), n\u00EAn `Statement` th\u1EED parse `if a > 1`\n// r\u1ED3i nu\u1ED1t lu\u00F4n `\\n    ` tr\u01B0\u1EDBc khi va `plot(a)` v\u00E0 H\u1ECENG \u2014 lookahead fail d\u00F9\n// d\u00F2ng \u0111\u00F3 l\u00E0 statement h\u1EE3p l\u1EC7. \u0110o \u0111\u01B0\u1EE3c: `StatementBodyFirstLine` kh\u1EDBp\n// `  plot(x)` nh\u01B0ng KH\u00D4NG kh\u1EDBp `  if a > 1\\n    plot(a)`.\n//\n// N\u00EAn ta li\u1EC7t k\u00EA \u0111\u00FAng c\u00E1c token m\u1EDF \u0111\u1EA7u statement thay v\u00EC parse statement:\n//   * t\u1EEB kho\u00E1 / l\u1EC7nh: if, for, while, plot, plotshape, hline, alertcondition,\n//     input, var, const\n//   * `[` \u2014 m\u1EDF \u0111\u1EA7u tuple destructuring (W-05)\n//   * `identifier` theo sau `=` ho\u1EB7c `:=` \u2014 \u0111\u00E2y l\u00E0 ph\u00E9p g\u00E1n, KH\u00D4NG ph\u1EA3i\n//     bi\u1EC3u th\u1EE9c. Ch\u00EDnh \u0111i\u1EC1u n\u00E0y ph\u00E2n `  x = 1` (statement, v\u00E0o kho\u00E1) v\u1EDBi\n//     `  x * 2` (bi\u1EC3u th\u1EE9c, ph\u1EA3i r\u01A1i v\u1EC1 d\u1EA1ng bi\u1EC3u th\u1EE9c \u2014 AC-4.13b).\nStatementStart\n  = (\"if\" / \"for\" / \"while\" / \"plot\" / \"plotshape\" / \"hline\" / \"alertcondition\" / \"input\" / \"var\" / \"const\" / \"[\")\n  / identifier _ \":\" \"=\"\n  / identifier _ \"=\"\n  / identifier _ \"(\" _ \")\" _ \"=>\"\n\n// `f()` (khong tham so) va `f(a)` / `f(a, b)`.\n//\n// `\"\"` phai co TIA-NHIN `\")\"` o truoc. Khong co no thi `\"\"` luon khop rong\n// o ngay sau `(`, roi `\")\"` that tai `f(a)`. Do la thu tu PEG bat buoc:\n// khong co lookahead thi khong phan bi duoc \"khong co tham so\" voi \"co tham so\".\nparamList\n  = &\")\" \"\" { return [] }\n  / head:identifier tail:( _ \",\" _ p:identifier { return p })* { return [head, ...tail] }\n\nplotCall\n  = \"plot\" _ \"(\" _ expr:expression _ args:plotArgs? _ \")\" {\n      return { type: \"Plot\", expression: expr, title: args?.title ?? \"Plot\", color: args?.color ?? \"#2196F3\", loc: location() }\n    }\n\nplotArgs\n  = rest:( \",\" _ arg:plotArg { return arg })* {\n      const r = {}\n      for (const a of rest ?? []) Object.assign(r, a)\n      return r\n    }\n\nplotArg\n  = \"title\" _ \"=\" _ val:stringLiteral { return { title: val } }\n  / \"color\" _ \"=\" _ val:colorLiteral { return { color: val } }\n  // W1.2: chuoi mau la MOT dang hop le (color=\"#ff9800\"). Thieu nhanh nay thi\n  // template mac dinh cua PineEditorPanel FAIL parse tai plot() \u2014 da probe thuc te.\n  / \"color\" _ \"=\" _ val:stringLiteral { return { color: val } }\n  / \"color\" _ \"=\" _ val:identifier { return { color: val } }\n\nplotshapeCall\n  = \"plotshape\" _ \"(\" _ expr:expression _ rest:plotshapeArgs? _ \")\" {\n      return {\n        type: \"PlotShape\", expression: expr,\n        title: rest?.title ?? \"Shape\", style: rest?.style ?? \"shape.labelup\",\n        location: rest?.location ?? \"location.bottom\", color: rest?.color ?? \"#4CAF50\",\n        size: rest?.size ?? \"size.small\", loc: location()\n      }\n    }\n\nplotshapeArgs\n  = rest:( \",\" _ arg:plotshapeArg { return arg })* {\n      const r = {}\n      for (const a of rest ?? []) Object.assign(r, a)\n      return r\n    }\n\nplotshapeArg\n  = \"title\" _ \"=\" _ val:stringLiteral { return { title: val } }\n  / \"style\" _ \"=\" _ val:identifier { return { style: val } }\n  / \"location\" _ \"=\" _ val:identifier { return { location: val } }\n  / \"color\" _ \"=\" _ val:colorLiteral { return { color: val } }\n  // W1.2: chuoi mau, cung hop le nhu colorLiteral \u2014 dong nhat voi plotArg.\n  / \"color\" _ \"=\" _ val:stringLiteral { return { color: val } }\n  / \"color\" _ \"=\" _ val:identifier { return { color: val } }\n  / \"size\" _ \"=\" _ val:identifier { return { size: val } }\n\nhlineCall\n  = \"hline\" _ \"(\" _ price:numberLiteral _ rest:hlineArgs? _ \")\" {\n      return { type: \"HLine\", price, title: rest?.title ?? \"Line\", color: rest?.color ?? \"#FF9800\", loc: location() }\n    }\n\nhlineArgs\n  = rest:( \",\" _ arg:hlineArg { return arg })* {\n      const r = {}\n      for (const a of rest ?? []) Object.assign(r, a)\n      return r\n    }\n\nhlineArg\n  = \"title\" _ \"=\" _ val:stringLiteral { return { title: val } }\n  / \"color\" _ \"=\" _ val:colorLiteral { return { color: val } }\n  / \"color\" _ \"=\" _ val:stringLiteral { return { color: val } }\n  / \"color\" _ \"=\" _ val:identifier { return { color: val } }\n\ninputCall\n  = name:identifier _ \"=\" _ \"input\" _ \"(\" _ defVal:expression _ rest:inputArgs? _ \")\" {\n      return { type: \"InputDecl\", variable: name, defaultValue: defVal, title: rest?.title ?? name, loc: location() }\n    }\n\n// A9: alertcondition l\u00E0 STATEMENT c\u1EE7a Pine, kh\u00F4ng ph\u1EA3i h\u00E0m \u2014 n\u00F3 kh\u00F4ng tr\u1EA3 v\u1EC1\n// series \u0111\u1EC3 plot, n\u00F3 tuy\u00EAn b\u1ED1 m\u1ED9t \u0111i\u1EC1u ki\u1EC7n. \u0110i\u1EC1u ki\u1EC7n \u0111\u01B0\u1EE3c \u0111\u00E1nh gi\u00E1 th\u1EADt trong\n// executeNodes (compile.ts) v\u00E0 tr\u1EA3 v\u1EC1 trong CompileResult.alerts.\nalertconditionCall\n  = \"alertcondition\" _ \"(\" _ cond:expression _ rest:alertconditionArgs? _ \")\" {\n      return { type: \"AlertCondition\", condition: cond, title: rest?.title ?? \"Alert\", message: rest?.message ?? \"\", loc: location() }\n    }\n\nalertconditionArgs\n  = rest:( \",\" _ arg:alertconditionArg { return arg })* {\n      const r = {}\n      for (const a of rest ?? []) Object.assign(r, a)\n      return r\n    }\n\nalertconditionArg\n  = \"title\" _ \"=\" _ val:stringLiteral { return { title: val } }\n  / \"message\" _ \"=\" _ val:stringLiteral { return { message: val } }\n\ninputArgs\n  = rest:( \",\" _ arg:inputArg { return arg })* {\n      const r = {}\n      for (const a of rest ?? []) Object.assign(r, a)\n      return r\n    }\n\ninputArg\n  = \"title\" _ \"=\" _ val:stringLiteral { return { title: val } }\n\n// W-01: `if` / `for` / `while` / `else` KHONG con mang khoi. `buildBlocks`\n// (`pineBlocks.ts`) long khoi theo thu le. `thenBlock`/`body` se duoc gan khi\n// builder gap dong sau co thu le sau hon.\nifStatement\n  = \"if\" _ cond:expression {\n      return { type: \"IfStatement\", condition: cond, thenBlock: [], elseBlock: [], loc: location() }\n    }\n\nforStatement\n  = \"for\" _ name:identifier _ \"=\" _ start:expression _ \"to\" _ end:expression {\n      return { type: \"ForStatement\", variable: name, start: start, end: end, body: [], loc: location() }\n    }\n\n// W-01: `while`. `vnscript-grammar.ts` truoc day BIEN `while` khoi danh sach\n// keyword de tranh to mau mot tu khoa parser se tu choi. Bay parser chap nhan.\nwhileStatement\n  = \"while\" _ cond:expression {\n      return { type: \"WhileStatement\", condition: cond, body: [], loc: location() }\n    }\n\n// `else` la DONG RIENG (khong phai con cua `if` trong grammar) \u2014 `buildBlocks`\n// gop no vao `elseBlock` cua khoi `if` ngay tren, cung cap thu le.\nelseBlock\n  = \"else\" {\n      return { type: \"ElseBlock\", body: [], loc: location() }\n    }\n\nexpression\n  = ternary\n\n// W-01: toan tu 3 nhanh. Phai thu TRUOC `logicalOr` \u2014 `comparison` khong chap\n// nhan `?` nen neu thu sau, toan bieu thuc se that tai day.\nternary\n  = cond:logicalOr _ \"?\" _ whenTrue:expression _ \":\" _ whenFalse:expression {\n      return { type: \"Conditional\", condition: cond, whenTrue: whenTrue, whenFalse: whenFalse, loc: location() }\n    }\n  / logicalOr\n\nlogicalOr\n  = head:logicalAnd tail:( _ \"or\" _ expr:logicalAnd { return expr })* {\n      return tail.reduce((acc, expr) => ({ type: \"BinaryExpression\", operator: \"or\", left: acc, right: expr, loc: location() }), head)\n    }\n\nlogicalAnd\n  = head:comparison tail:( _ \"and\" _ expr:comparison { return expr })* {\n      return tail.reduce((acc, expr) => ({ type: \"BinaryExpression\", operator: \"and\", left: acc, right: expr, loc: location() }), head)\n    }\n\ncomparison\n  = head:addition tail:( _ op:compOp _ expr:addition { return { op, expr } })? {\n      if (!tail) return head\n      return { type: \"BinaryExpression\", operator: tail.op, left: head, right: tail.expr, loc: location() }\n    }\n\ncompOp\n  = \">=\" / \"<=\" / \"!=\" / \"==\" / \">\" / \"<\"\n\naddition\n  = head:multiplication tail:( _ op:addOp _ expr:multiplication { return { op, expr } })* {\n      return tail.reduce((acc, el) => ({ type: \"BinaryExpression\", operator: el.op, left: acc, right: el.expr, loc: location() }), head)\n    }\n\naddOp\n  = \"+\" / \"-\"\n\nmultiplication\n  = head:unary tail:( _ op:mulOp _ expr:unary { return { op, expr } })* {\n      return tail.reduce((acc, el) => ({ type: \"BinaryExpression\", operator: el.op, left: acc, right: el.expr, loc: location() }), head)\n    }\n\nmulOp\n  = \"*\" / \"/\"\n\n// W-01: `not` la TOAN TU, phai thu truoc `primary` \u2014 `identifier` se an `not`\n// roi goi no nhu ham, evaluator bao \"Unknown function: not\".\nunary\n  = \"not\" _ expr:unary { return { type: \"UnaryExpression\", operator: \"not\", argument: expr, loc: location() } }\n  / \"-\" _ expr:unary { return { type: \"UnaryExpression\", operator: \"-\", argument: expr, loc: location() } }\n  / primary\n\nprimary\n  = functionCall\n  / id:identifier off:historyOffset {\n      if (!off) return { type: \"Identifier\", name: id }\n      return { type: \"HistoryOffset\", offset: off.offset, source: { type: \"Identifier\", name: id }, loc: location() }\n    }\n  / \"(\" _ expr:expression _ \")\" { return expr }\n  // A9: boolLiteral ph\u1EA3i TH\u1EEC TR\u01AF\u1EDAC identifier. identifier kh\u1EDBm \"true\"/\"false\"\n  // n\u00EAn nh\u00E1nh boolLiteral \u1EDF d\u01B0\u1EDBi b\u1ECB ch\u1EBFt v\u0129nh vi\u1EC5n: ta.tr(false) b\u00E1o\n  // \"Undefined variable: false\" cho d\u00F9 boolLiteral c\u00F3 trong grammar.\n  / bool:boolLiteral { return { type: \"Literal\", value: bool } }\n  // W-01: `na` la LITERAL, phai thu TRUOC identifier \u2014 `identifier` an `na`\n  // nen `plot(na)` bao \"Undefined variable: na\". `!identifierChar` chan\n  // `nanny` bi cat thanh `na` + \"nny\".\n  / \"na\" !identifierChar { return { type: \"Literal\", value: NaN } }\n  / id:identifier { return { type: \"Identifier\", name: id } }\n  / num:numberLiteral { return { type: \"Literal\", value: num } }\n  // F1: KH\u00D4NG c\u1EA7n d\u1EDDi stringLiteral l\u00EAn tr\u01B0\u1EDBc identifier nh\u01B0 boolLiteral. \u0110\u00E3\n  // probe th\u1EADt (kh\u00F4ng suy \u0111o\u00E1n): plot('hello') v\u00E0 plot(\"hello\") \u0111\u1EC1u parse ra\n  // node Literal value \"hello\". L\u00FD do: identifier b\u1EAFt bu\u1ED9c m\u1EDF \u0111\u1EA7u b\u1EB1ng ch\u1EEF c\u00E1i\n  // ho\u1EB7c g\u1EA1ch d\u01B0\u1EDBi, c\u00F2n stringLiteral m\u1EDF \u0111\u1EA7u b\u1EB1ng d\u1EA5u nh\u00E1y \u0111\u01A1n ho\u1EB7c nh\u00E1y k\u00E9p.\n  // Hai t\u1EADp k\u00FD t\u1EF1 \u0111\u1EA7u r\u1EDDi nhau n\u00EAn kh\u00F4ng th\u1EC3 nu\u1ED1t nhau. Nh\u00E1nh chu\u1ED7i \u0111\u00E3 lu\u00F4n s\u1ED1ng;\n  // n\u00F3 ch\u1EBFt \u1EDF T\u1EA6NG \u0110\u00C1NH GI\u00C1 (evalExpr g\u1ECDi parseFloat), kh\u00F4ng ph\u1EA3i \u1EDF grammar.\n  / str:stringLiteral { return { type: \"Literal\", value: str } }\n\n// W-01: `close[1]`, `ta.sma(close,14)[2]` \u2014 lich su mot gia tri truoc.\nidentifierChar\n  = [a-zA-Z0-9_.]\n\nfunctionCall\n  = name:identifier _ \"(\" _ args:argumentList? _ \")\" off:historyOffset? {\n      const call = { type: \"FunctionCall\", name: name, arguments: args ?? [], loc: location() }\n      if (!off) return call\n      return { type: \"HistoryOffset\", offset: off.offset, source: call, loc: location() }\n    }\n\n// W-01: lich su. `numberLiteral` la `[0-9]+(\".\"[0-9]+)?` nen `[1.5]` la\n// offset 1.5 (Pine cung vay) chu khong phai `[1]` roi `.5`.\nhistoryOffset\n  = \"[\" _ n:numberLiteral _ \"]\" {\n      return { offset: n }\n    }\n\nargumentList\n  = head:expression tail:( _ \",\" _ expr:expression { return expr })* {\n      return [head, ...tail]\n    }\n\nidentifier\n  = name:$([a-zA-Z_][a-zA-Z0-9_.]*) { return name }\n\nliteral\n  = numberLiteral\n  / stringLiteral\n  / boolLiteral\n\nnumberLiteral\n  = value:$([0-9]+(\".\"[0-9]+)?) { return parseFloat(value) }\n\n// GR1: escape sequences inside a literal string.\n// Pine v6 reference, Concepts > Strings > Escape sequences:\n//   - the backslash is the escape character. Characters that are special in a\n//     string definition (a quote, a backslash) become LITERAL when prefixed by\n//     a backslash, so an escaped backslash yields a single backslash.\n//   - \\n is U+000A and \\t is U+0009; unprefixed n and t stay literal.\n//   - \"If a backslash applied to a character does not form a supported escape\n//     sequence, the character's meaning does not change.\" The page's own\n//     example title begins with a backslash followed by T, and its note says\n//     the value also includes the backslash before T while T still appears\n//     literally in the displayed text.\n//     => an unsupported escape keeps BOTH the backslash and the character.\n//     This is also the conservative choice: nothing is silently deleted, and a\n//     Windows path or a regex-ish string round-trips intact.\n//\n// PINE_ESCAPES_BEYOND_DOCS: the page names only n and t plus the two characters\n// that were already special. Carriage return and \\uXXXX are NOT documented;\n// they are implemented because the task requires them, and both are additive --\n// a backslash was inert before GR1, so nothing that parsed before changes\n// except by deliberately using one of these two. A script that relies on\n  // \\u being LITERAL will diverge from real Pine. Flagged, not assumed away.\n//\n// The one intentional change to previously-parsing input: a lone trailing\n// backslash immediately before the closing quote is now a parse error, because\n// in Pine that backslash escapes the delimiter and the literal never closes.\nstringLiteral\n  = \"'\" chars:sqParts \"'\" { return chars }\n  / '\"' chars:dqParts '\"' { return chars }\n\nsqParts\n  = parts:sqChar* { return parts.join(\"\") }\n\ndqParts\n  = parts:dqChar* { return parts.join(\"\") }\n\n// The delimiter is excluded from the plain-char class. PEG repetition does not\n// backtrack, so a class that also matched the closing quote would be eaten by\n// the star and the rule could never terminate. The old rule spelled the same\n// exclusion out as a negated class; this keeps that property explicitly.\nsqChar\n  = \"\\\\\" seq:escape { return seq }\n  / ch:[^\\\\'] { return ch }\n\ndqChar\n  = \"\\\\\" seq:escape { return seq }\n  / ch:[^\\\\\"] { return ch }\n\n// Ordered choice: a \\u NOT followed by four hex digits fails this whole\n// alternative and falls through to the final catch-all, so it stays literal\n// instead of half-decoding.\nescape\n  = \"n\" { return \"\\n\" }\n  / \"t\" { return \"\\t\" }\n  / \"r\" { return \"\\r\" }\n  / \"\\\\\" { return \"\\\\\" }\n  / \"'\" { return \"'\" }\n  / '\"' { return '\"' }\n  / \"u\" hex:$([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]) { return String.fromCharCode(parseInt(hex, 16)) }\n  / ch:. { return \"\\\\\" + ch }\n\nboolLiteral\n  = \"true\" { return true }\n  / \"false\" { return false }\n\ncolorLiteral\n  = \"#\" chars:$([0-9a-fA-F]+) { return \"#\" + chars }\n\n_ \"whitespace\"\n  = [ \\t\\r\\n]*\n";

package/dist/dts/lib/pinescript/pine.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/lib/pinescript/pineBlocks.d.ts

@@ -0,0 +1,54 @@
+/**
+ * pineBlocks — W-01 (PINE Stage 3): LONG KHOI CAU LENH THEO THU LE.
+ *
+ * VÌ SAO FILE NÀY TỒN TẠI (và vì sao grammar KHÔNG tự lồng khoá):
+ *
+ * `grammar.ts` trước đây để `ifBlock = Statement+`. Vì `Statement` không biết
+ * "hết khoá ở đâu", **mọi** statement còn lại của script bị nuốt vào khoá. Đo
+ * thật ở `216a8cd` (`docs/upgrade-standard/plans/PLAN_PINE_STAGE3_2026-10-09.md`
+ * §2.2): script `if c` / `  x = 1` / `else` / `  x = -1` / `plot(x)` cho
+ * `output = {}` và `errors = []` — tức **vẽ ra không có gì và không báo lỗi**.
+ *
+ * Ba ràng buộc về công cụ đo được, không đoán
+ * (`scripts/probe-grammar-caps.mjs` chạy lại được):
+ *   1. peggy 5 **không có rule có tham số** (`Block$(ind)` không hợp lệ — xem
+ *      `node_modules/peggy/lib/parser.js:2083`).
+ *   2. `startRule` **phải là rule định nghĩa đầu tiên**.
+ *   3. Action trong PEG **luôn chạy sau** khi match, nên không gán được biến
+ *      "độ thụt lẽ của khoá cha" *trước* khi khoá được parse.
+ *
+ * ⇒ Tách hai tầng: **grammar chỉ tách DÒNG** (indent + statement),
+ * **tầng này lồng khoá**. Tầng builder là code thuần, test được bằng vitest, và
+ * không phải tranh đấu với cơ chế backtracking của PEG — nơi một predicate sai
+ * sẽ hỏng âm thầm toàn bộ khoá.
+ *
+ * Hợp đồng đầu vào: `lines: SourceLine[]` — mỗi phần tử là
+ * `{ indent: number, node: object | null }`. `node === null` là dòng comment.
+ */
+import type { CompileError } from './pineParse';
+/** Một dòng nguồn: độ thụt lẽ (số space/tab) + node đã parse. */
+export interface SourceLine {
+    indent: number;
+    node: Record<string, unknown> | null;
+}
+/**
+ * Ghép các dòng phẳng thành cây, kết thúc khoá khi thụt lẽ **không còn lớn
+ * hơn** khoá cha.
+ *
+ * Vì sao `<=` chứ không phải `<`: hai khoá ngang cấp phải là hai khoá anh em,
+ * và một dòng quay lại đúng cấp `if` là **thoát** khoá đó. Đây cũng là chỗ
+ * `else` (cùng cấp với `if`) được xử lý: `buildBlocks` gom nó thành
+ * `elseBlock` của khoá `if` ngay trước, chứ không nhét vào `thenBlock`.
+ */
+export declare function buildBlocks(lines: SourceLine[]): Record<string, unknown>[];
+/**
+ * Lỗi cấu trúc khoá. Tách riêng để `parseScript` đổi thành `CompileError` có
+ * `line`/`column` — evaluator chỉ bắt `Error`, nên nếu để lọt thì thông điệp
+ * "else without if" sẽ mất vị trí và người dùng phải tự dò script.
+ */
+export declare class PineBlockError extends Error {
+    readonly line?: number;
+    readonly column?: number;
+    constructor(message: string, line?: number, column?: number);
+    toCompileError(): CompileError;
+}

package/dist/dts/lib/pinescript/pineBuiltins.d.ts

@@ -0,0 +1,47 @@
+import { type SeriesEnv } from './pineEnv';
+export declare const MAX_FOR_ITERATIONS = 1000;
+/**
+ * W-03: trần vòng lặp của `while`.
+ *
+ * `TIMEOUT_MS = 1000` **không** đủ làm trần: một vòng `while` rẻ (chỉ cộng hai
+ * số) có thể chạy hàng triệu lần mà vẫn không hết 1s trên máy nhanh — tức
+ * timeout **không bảo đảm** chống treo. Một hằng đếm được thì có.
+ */
+export declare const MAX_WHILE_ITERATIONS = 10000;
+/**
+ * W-03: trần độ sâu đệ quy của UDF.
+ *
+ * Đo được: `f(x) => f(x)` trước khi có hằng này cho **"Maximum call stack
+ * size exceeded"** — tức `RangeError`, không phải `CompileError`, nên editor hiện
+ * một thông báo không liên quan tới script. `checkTimeout()` không cứu được vì cả
+ * vòng đệ quy nằm trong MỘT lần gọi `evalExpr` — timer không có cơ hội chạy.
+ */
+export declare const MAX_CALL_DEPTH = 100;
+export declare function evalBinaryExpr(left: number[], op: string, right: number[], length: number): number[];
+/**
+ * Dispatcher duy nhất của Pine. `pine.worker.ts` import hàm này thay vì giữ
+ * một bản sao — trước đây hai bản sao lệch nhau theo thời gian và editor báo
+ * lỗi cho script chạy được.
+ */
+export declare function callFunction(name: string, args: number[][], length: number, env: SeriesEnv): number[];
+/**
+ * W-05: những builtin mà Pine trả **nhiều** giá trị, nên script phải destructure.
+ *
+ * Danh sách này là hợp đồng với `evalTupleExpr` (`compile.ts`). Thêm tên vào đây
+ * mà quên implement trong `callTupleFunction` ⇒ nhãn nằm, không có hành vi.
+ */
+export declare const MULTI_VALUE_BUILTINS: Set<string>;
+/**
+ * Đánh giá builtin theo hình **tuple**: luôn trả `number[][]`.
+ *
+ * Vì sao KHÔNG đổi `callFunction` cho ra `number[][]`: `callFunction` là hợp
+ * đồng công khai với `pine.worker.ts` và có **12 call site thật** trong
+ * `pineFailClosed.test.ts` (đo: `git grep -c callFunction`). Đổi chữ ký nghĩa
+ * là sửa 13+ chỗ để rồi mỗi chỗ lại là một chỗ có thể sai. Thay vào đó hàm này
+ * là lớp **thêm**, còn `callFunction` giữ nguyên và gọi xuống đây cho phần
+ * một-giá-trị.
+ *
+ * Mọi builtin chưa biết trả về `[callFunction(...)]` — mảng **một** phần tử —
+ * để phía gán bắt được lệch số và báo lỗi thay vì âm thầm lấy `[0]`.
+ */
+export declare function callTupleFunction(name: string, args: number[][], length: number, env: SeriesEnv): number[][];

package/dist/dts/lib/pinescript/pineEnv.d.ts

@@ -0,0 +1,46 @@
+/**
+ * pineEnv — nhóm ENV tách từ `compile.ts` (W-05, PINE Stage 2).
+ *
+ * Lá trong DAG: không import `compile`, `pineParse`, `pineMath` hay worker.
+ * `SeriesEnv` được export vì `compile.ts` cần nó trong chữ ký `callFunction` /
+ * `runProgram` (back-import, không phải shim `export-from` trần).
+ */
+/**
+ * Series đang có trong môi trường lúc đánh giá. Pine cho phép builtin tự đọc
+ * series chuẩn (`ta.atr(14)` = ATR của high/low/close) nên dispatcher cần `env`,
+ * không chỉ các tham số vị trí.
+ */
+export type SeriesEnv = Map<string, number[]>;
+/**
+ * Builtin không có series ở tham số đầu: tham số đầu là số (period / cờ), hoặc
+ * builtin tự đọc series ngầm định. Nếu không, lỗi "requires at least 1
+ * argument" của `ta.sma` sẽ chặn nhầm `ta.atr(14)`.
+ */
+export declare const NO_SOURCE_ARG: Set<string>;
+/**
+ * Series chuẩn theo tên. Không có series (lượt validate của editor) → mảng
+ * NaN, KHÔNG phải mảng 0: 0 là giá thật và sẽ vẽ ra đường bằng 0 (Rule 15).
+ */
+export declare function series(env: SeriesEnv, name: string, length: number): number[];
+export interface PineBars {
+    open: number[];
+    high: number[];
+    low: number[];
+    close: number[];
+    volume: number[];
+    time?: number[];
+}
+/**
+ * Dựng môi trường series chuẩn. Dùng bởi `compile` VÀ `pine.worker` — nếu hai bên
+ * khai báo khác nhau, editor báo "Undefined variable: hlc3" cho script mà chart vẫn
+ * chạy được.
+ *
+ * W1.2: tên biến series chuẩn của Pine. Khi KHÔNG có `bars` (lượt validate của
+ * editor gọi `compile(source)` — PineEditorPanel.tsx:137) các tên này phải vẫn
+ * "đã định nghĩa", nếu không mọi script dùng dữ liệu giá đều báo
+ * "Undefined variable: close" — kể cả template mặc định.
+ * Mảng RỖNG, không phải số 0: đây là lượt kiểm tra cú pháp/ký hiệu, không có dữ
+ * liệu thì không được bịa giá trị (AGENTS.md Rule 15). NaN ở đâu đó tương
+ * đương "chưa có giá trị" — mảng rỗng nói đúng hơn.
+ */
+export declare function createSeriesEnv(bars?: PineBars): SeriesEnv;

package/dist/dts/lib/pinescript/pineMath.d.ts

@@ -0,0 +1,13 @@
+/**
+ * pineMath — nhóm MATH tách từ `compile.ts` (W-05, PINE Stage 2).
+ *
+ * Lá trong DAG: thuần tính toán, không import `compile`, `pineParse`,
+ * `pineEnv` hay worker.
+ */
+/** RMA (Wilder). Cùng công thức với `wilderSeries` — `src/lib/indicators/utils.ts:328`. */
+export declare function rma(src: number[], period: number, length: number): number[];
+/**
+ * Parabolic SAR (Wilder). Cùng thuật toán với `sarSeries` ở
+ * `src/lib/indicators/utils.ts:153`; test khoá lại bằng cách so hai kết quả.
+ */
+export declare function parabolicSar(high: number[], low: number[], close: number[], start: number, inc: number, max: number, length: number): number[];