openpinescript 0.0.0-stage → 0.1.0

package/dist/types/transpiler/v5/ToJsVisitor.d.ts

@@ -0,0 +1,1101 @@
+/**
+ * Pine Script v5 → JavaScript emitter.
+ *
+ * v5 inherits every guard v3 added and every declaration form v4 added. The
+ * migration guide relaxes none of them, so nothing here undoes anything.
+ *
+ * What v5 adds falls into four groups:
+ *
+ *   NAMES (runtime/v1/stdlib/renames5.ts + the V5_VIEW registry)
+ *     The §4a namespace migration — `sma` → `ta.sma`, `abs` → `math.abs`,
+ *     `security` → `request.security`, `tostring` → `str.tostring` — plus the
+ *     §4b renames that keep their namespace (`study` → `indicator`) and the §4c
+ *     removals (`iff`, `offset`, `transp=`). Those are lookups and rejections,
+ *     driven from a data table, not emit rules.
+ *
+ *   SYNTAX (this file)
+ *     `while`, `switch`, and `for … in`. None is a v4 construct — an early
+ *     draft of the delta spec said otherwise about the first two and was wrong
+ *     — so v4 emits nothing for them and v5 emits all three here.
+ *
+ *   RESERVED WORDS (this file)
+ *     Twelve of the thirteen words v5 will not let a script NAME anything (the
+ *     thirteenth, `in`, is a lexer keyword — see RESERVED below). Enforced on the
+ *     identifier rather than in the lexer, because `text` is simultaneously a
+ *     live namespace (`text.align_left`) and a forbidden variable name — a
+ *     distinction a token cannot draw.
+ *
+ *   KEYWORD ARGUMENTS (this file)
+ *     §4b renamed parameters without renaming their functions:
+ *     `study(resolution=)` became `indicator(timeframe=)`, `strategy.entry(long=)`
+ *     became `direction=`. Where the RUNTIME still spells one the old way — it is
+ *     one implementation across versions — the emitter translates. Where it has
+ *     taken the new name (`strategy.entry`'s `direction`), there is nothing to
+ *     translate, and v1–v4's `long=` is mapped the other way, in the runtime
+ *     (`V4_RENAMED_PARAMS`). tests/v5/transpiler/keyword_aliases.test.ts fails
+ *     if an alias targets a name the runtime does not have.
+ *
+ * ── What is NOT implemented at v5 ───────────────────────────────────────────
+ *
+ * User-defined types (`type`), methods (`method`), and libraries
+ * (`import`/`export`). Each needs a type system this engine does not have:
+ * `p.x` is currently always a namespace member, and telling it apart from a
+ * field access requires knowing that `p` came from `Point.new()`.
+ *
+ * `type` is absent from the GRAMMAR, so a script using it fails with "parsing
+ * failed" — the same verdict v1 gives `:=` and v4 gives `while`. The other three
+ * DO parse, because the inherited grammar can read what follows the keyword on
+ * its own, so they are rejected by NAME instead — see UNSUPPORTED below. Either
+ * way the script is refused rather than compiled into something it does not say.
+ */
+import type { PineVersion } from "../common/version.js";
+import { V4ToJsVisitor } from "../v4/ToJsVisitor.js";
+import type { StdlibEntry } from "../../runtime/v1/stdlib/metadata.js";
+import type { ParseTree } from "antlr4ng";
+import { parse as parseV5 } from "../../parser/v5/index.js";
+import { While_exprContext, For_in_exprContext, Call_suffixContext, Switch_exprContext, Switch_caseContext, Fun_callContext, Var_defsContext, Var_assignContext, IdContext, StmtContext, Type_def_stmtContext, Enum_def_stmtContext, Method_def_stmtContext, Export_stmtContext, Import_stmtContext, Fun_headContext, Pine_scriptContext, Fun_def_singlelineContext, Fun_def_multilineContext } from "../../parser/v5/generated/PineV5Parser.js";
+/** One declaration of an overloaded function name. */
+/**
+ * A type as overloads compare it: no whitespace, and no library alias on any
+ * part — `lib.Point` and `Point`, `array<lib.Point>` and `array<Point>`, are
+ * the same type to a library's own declarations.
+ */
+export declare function normaliseType(t: string): string;
+/**
+ * `float` or `int` for an arithmetic expression whose type its text settles:
+ * a price series or a decimal literal makes it float, as does `/`; integer
+ * literals alone keep it int. Anything with a call or another name is
+ * unknown — a runtime value cannot tell `22.0` from `22`, so the guess has to
+ * be made here or not at all.
+ */
+export declare function numericTypeOf(text: string): "int" | "float" | null;
+interface FnOverload {
+    /** Fewest arguments a call may pass — parameters without a default. */
+    min: number;
+    /** Most — every parameter. */
+    max: number;
+    /** Each parameter's DECLARED type, or null where none is written. */
+    types: Array<string | null>;
+}
+/** Anything carrying a source position (see the v1 base for why it is structural). */
+interface SourceLocated {
+    start?: {
+        line: number;
+        column: number;
+    } | null;
+}
+/** Construction options — how a v5 script reaches code outside itself. */
+export interface V5Options {
+    /**
+     * Library sources, keyed by the path an `import` names
+     * (`"someuser/somelib/1"`). Supplied by the host; see the field of the same
+     * name on the visitor for why they cannot be fetched.
+     */
+    readonly libraries?: Readonly<Record<string, string>>;
+    /**
+     * Apply the checks TradingView's chart editor makes and its compile endpoint
+     * does not (an indicator with no output, `request.*()` in a conditional at
+     * v5, `color.new()` with no transparency, a colour for `input.string`).
+     * Off for bare transpiles, so fixtures need not be complete scripts.
+     */
+    readonly editorRules?: boolean;
+    /** Disambiguates emitted source locations. Set when compiling a library. */
+    readonly locationTag?: string;
+    /** Disambiguates the names a script DECLARES. Set when compiling a library. */
+    readonly nameScope?: string;
+    /** The library paths being compiled above this one, outermost first. Set when compiling a library. */
+    readonly libraryChain?: readonly string[];
+}
+/** One field of a user-defined type. */
+interface TypeField {
+    readonly name: string;
+    /** Its `= …` initialiser, or null — an undeclared default is `na`. */
+    readonly defaultExpr: any | null;
+}
+/** One member of an `enum` declaration. */
+interface EnumField {
+    readonly name: string;
+    /**
+     * Its `= "title"` expression, or null.
+     *
+     * "If the programmer does not specify a field's title, its title is the
+     * 'string' representation of its name."
+     */
+    readonly titleExpr: any | null;
+}
+/**
+ * Keyword arguments v5 renamed, per CALLEE.
+ *
+ * §4b renamed these parameters without renaming their functions. The runtime
+ * still spells most of them the v1–v4 way — it is one implementation across versions,
+ * and `Context.call` matches a keyword argument by looking its written name up
+ * in the registry entry's parameter list — so an unmatched key is DROPPED
+ * SILENTLY. A v5 script writing `indicator(timeframe="D")` would therefore have
+ * had its timeframe ignored and fallen back to the chart's.
+ *
+ * Scoped per callee rather than applied globally because the new names are
+ * ordinary words: `source` is a parameter of half the `input.*` family, and
+ * rewriting it everywhere would corrupt those calls to fix `nz`.
+ */
+export declare const KEYWORD_ALIASES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+export declare class V5ToJsVisitor extends V4ToJsVisitor {
+    protected readonly version: PineVersion;
+    /**
+     * v5's view of the stdlib: v4's, minus the spellings v5 renamed away, plus
+     * the namespaces it introduced and the aliases it created.
+     *
+     * Subtracting matters as much as adding — leaving `sma` in beside `ta.sma`
+     * would accept both dialects, and a script written half in each compiles here
+     * and fails on TradingView.
+     */
+    protected get registry(): Record<string, StdlibEntry>;
+    /**
+     * The callee whose arguments are currently being emitted, innermost last.
+     *
+     * `visitKw_arg` needs to know which function a keyword belongs to before it
+     * can decide whether to translate its name, and the grammar gives it no way
+     * up to the call. A stack rather than a single field because arguments nest:
+     * `strategy.entry("L", direction=strategy.long, qty=nz(q, replacement=1))`.
+     */
+    private calleeStack;
+    /** Declared type name → its fields, in declaration order. */
+    protected userTypes: Map<string, TypeField[]>;
+    /**
+     * `enum Name` declarations, name → its fields in declaration order.
+     *
+     * Collected in the same pre-pass as `userTypes`, and for the same reason: a
+     * member may be READ above the line that declares its enum, inside any
+     * function body, and a single-pass emitter cannot know that yet.
+     */
+    protected userEnums: Map<string, EnumField[]>;
+    /**
+     * Names declared with `method`.
+     *
+     * Kept apart from `userFunctions` — which already contains them, since a
+     * method's body IS a function definition — because only a method may be
+     * called as `receiver.name(…)`. A plain function of the same name may not,
+     * and answering that question wrongly turns a typo into a silent field read.
+     */
+    protected userMethods: Set<string>;
+    /**
+     * method name → the receiver type of each declaration of it, in file order.
+     *
+     * A single entry is the ordinary case and changes nothing. Two or more is an
+     * OVERLOAD SET: "User-defined methods can override and overload existing
+     * built-in and user-defined methods with the same identifier ... The
+     * underlying type of each variable determines which overload of `getType()`
+     * the compiler will use."
+     */
+    protected methodOverloads: Map<string, string[]>;
+    /**
+     * method name → every declaration's receiver AND full signature, in file
+     * order. A receiver may carry several: "User-defined methods can override and
+     * overload existing built-in and user-defined methods", told apart the way
+     * any overload is — by required-parameter count, then by type.
+     */
+    protected methodSignatures: Map<string, Array<{
+        receiver: string;
+        sig: FnOverload;
+    }>>;
+    /** type name → field name → the field's declared type, where one is written. */
+    protected userFieldTypes: Map<string, Map<string, string>>;
+    /**
+     * Declared types of the names in scope while a function or method body is
+     * emitted, innermost last: its parameters, then its typed or constructed
+     * locals. Script-scope names come from `scopes.staticTypes`.
+     */
+    protected localTypes: Array<Map<string, string | null>>;
+    /** `import … as alias` → the library path it names. */
+    protected importAliases: Map<string, string>;
+    /** Library path → the names that library exports. */
+    protected libraryExports: Map<string, Set<string>>;
+    /**
+     * `<path>::<TypeName>` → that type's field names, in declaration order.
+     *
+     * Needed because `ml.Pair.new(1, 2)` has to map POSITIONAL arguments onto
+     * fields, and the field order lives in the library rather than here.
+     */
+    protected libraryTypeFields: Map<string, string[]>;
+    /**
+     * An imported library's exported METHOD name → the alias that owns it.
+     *
+     * Importing a library brings its methods into scope on values of its types,
+     * so `pair.total()` has to resolve even though `total` is declared in another
+     * file. Without this the call fell through to `Context.builtinMethod`, which
+     * correctly reported that a plain object has no built-in methods — a true
+     * statement about the wrong question.
+     */
+    protected libraryMethods: Map<string, string>;
+    /**
+     * Sources for `import`, keyed by the path a script writes.
+     *
+     * A library lives on TradingView, and this engine cannot fetch one — so the
+     * host supplies them, the same way it supplies higher-timeframe candles for
+     * `security()`. An import with no source is REFUSED rather than stubbed:
+     * a library that silently resolves to nothing produces a script full of `na`
+     * that still runs.
+     */
+    protected readonly libraries: Readonly<Record<string, string>>;
+    /**
+     * Appended to every source location this visitor emits.
+     *
+     * Empty for a script, `@<alias>` for a library compiled into one. Call ids
+     * key per-call-site state — `ta.sma@L12:C4` is what keeps two `ta.sma` calls
+     * from sharing one rolling window — and a library's line 12 has nothing to do
+     * with the importing script's. Without the tag they collide silently, and two
+     * unrelated indicators quietly share a buffer.
+     */
+    protected readonly locationTag: string;
+    /**
+     * Inserted into every name this script DECLARES. Empty for a script,
+     * `$lib$<alias>$` for a library compiled into one.
+     *
+     * ── Why the IIFE is not enough ────────────────────────────────────────────
+     *
+     * A library's body is wrapped in an immediately-invoked function, so its
+     * `let opsv2_len` is lexically its own. That is only half the isolation: a
+     * variable is also a SERIES, registered in `ctx.vars` under its emitted name,
+     * and `ctx.new_var` looks that registry up BY NAME. Two scripts each
+     * declaring `len` therefore shared one series — the second write overwrote
+     * the first, and the library's functions, closing over their own `let`, read
+     * the importing script's value.
+     *
+     * It was worth 220 instead of 26 in the first library this engine ran, and
+     * nothing about the emitted JavaScript looked wrong.
+     *
+     * Built-ins are NOT scoped: `close` must stay `opsv2_close`, which is what
+     * the sandbox binds. Only names the script itself binds are rewritten, so the
+     * declaration and every read of it move together.
+     */
+    protected readonly nameScope: string;
+    /** The libraries being compiled above this visitor, so an import back into one is named as a cycle. */
+    protected readonly libraryChain: readonly string[];
+    constructor(options?: V5Options);
+    /**
+     * The emitted name of an identifier — scoped when this script declares it.
+     *
+     * The single place that decision is made, so the JS binding, the series
+     * registry key and every read of it can never disagree.
+     */
+    protected localName(text: string): string;
+    protected funcName(pineName: string): string;
+    protected getLocId(ctx: SourceLocated): string;
+    /** Names this script marks `export`. Non-empty only in a library. */
+    protected exportedNames: Set<string>;
+    /** Does this script declare itself a library? Set at the entry point. */
+    protected get declaresLibrary(): boolean;
+    /** Is this visitor compiling a library INTO another script? */
+    protected get isImportedLibrary(): boolean;
+    /**
+     * Types and methods are collected BEFORE anything is emitted.
+     *
+     * Both are whole-script facts a single pass cannot have: `p.x` has to know
+     * that `p` might be an object, and `r.area()` has to know that `area` is a
+     * method, and either can appear above its declaration inside a function body
+     * (which runs at call time, so it is not a forward reference).
+     *
+     * The same reasoning, and the same shape, as `collectFunctionNames` in the v1
+     * base.
+     */
+    visitPine_script(ctx: Pine_scriptContext): string;
+    /**
+     * v5 `request.*()` is static unless the declaration says
+     * `dynamic_requests = true`. (v6 has its own, explicit-opt-out rule.)
+     */
+    private editorRules;
+    private v5StaticRequests;
+    /**
+     * Whole-script rules TradingView's chart editor applies (its compile
+     * endpoint does not): an `indicator()` must display something.
+     */
+    protected enforceEditorRules(root: any): void;
+    /** An `indicator()` must display something (log.* counts: a log-only script loads). */
+    protected enforceIndicatorOutput(root: any): void;
+    /** Call-site rules the chart editor applies at v5 and v6 alike. */
+    protected enforceEditorCallRules(name: string, ctx: any): void;
+    /** Walks the whole tree for `type` and `method` declarations. */
+    protected collectDeclarations(root: any): void;
+    /** A type declaration's fields, in declaration order. */
+    protected fieldsOf(ctx: Type_def_stmtContext): TypeField[];
+    /**
+     * Is `root` a variable or parameter bound in a scope that contains this
+     * call? A local or parameter counts inside its own span; a script-scope
+     * binding (recorded with a null span) counts everywhere, which is safe
+     * because the caller asks only for a name the namespace does not define,
+     * and the namespace path would fail on it anyway. A namespace is never
+     * shadowed by a name this script does not actually declare.
+     */
+    protected shadowsNamespace(root: string, ctx: any): boolean;
+    /** Is `name` something this script binds — and therefore a possible receiver? */
+    protected isReceiverName(name: string): boolean;
+    /**
+     * Rejects a v1–v4 spelling with the name — or the construct — that replaced it.
+     *
+     * Hooked on identifiers and calls rather than driven off the registry,
+     * because a missing registry entry is not by itself an error: `visitId` emits
+     * any identifier it does not recognise, since most identifiers are the
+     * script's own variables. So `sma` at v5 would just emit `opsv2_sma` and read
+     * as `undefined` — an indicator that is silently `na` on a chart that still
+     * draws.
+     */
+    protected enforceRenamedInV5(name: string, ctx: SourceLocated): void;
+    /** Rejects a declaration or reference that names one of v5's reserved words. */
+    protected enforceNotReserved(name: string, ctx: SourceLocated): void;
+    /**
+     * Rejects a v5 feature this engine does not implement, by name.
+     *
+     * Reported as "not implemented" rather than as a Pine error, because it is
+     * not one: TradingView accepts all four. Saying so is the difference between
+     * an author knowing to rewrite the script and an author hunting for a typo.
+     * The message reaches the script's author, so it names no repository path;
+     * the known gaps are in docs/common/VERSIONS.md §7.
+     */
+    protected enforceSupported(name: string, ctx: SourceLocated): void;
+    visitId(ctx: IdContext): string;
+    /**
+     * `p.x`, `p.inner.x` → nested `ctx.field` reads, or null if `text` is not a
+     * field access at all.
+     *
+     * A namespace ALWAYS wins. `strategy.long` stays a namespace member even in a
+     * script that happens to bind a variable called `strategy`, because Pine
+     * would reject that script and reading it the other way would silently give
+     * `na` instead.
+     */
+    protected emitFieldChain(text: string): string | null;
+    /**
+     * `p.x := expr` — a field WRITE, and `p.x += expr` with it.
+     *
+     * Not routed through the inherited `visitVar_assign`: that emits
+     * `<name> = ctx.new_var(…)`, and the name it would build here is a
+     * `ctx.field(…)` read, which is not assignable. The declared-before-assigned
+     * guard is skipped too, deliberately — a field is not a script-scope
+     * variable, and `p.x` is declared by `type Point`, not by an `=` statement.
+     */
+    visitVar_assign(ctx: Var_assignContext): string;
+    /**
+     * The tuple form, `[a, b, c] = ta.bb(...)`.
+     *
+     * Overridden only to get the diagnostic right. The inherited implementation
+     * finds the callee and — when the name is absent from this version's registry
+     * but present in the runtime union — reports "added in a later version",
+     * which is exactly backwards for `[a, b, c] = bb(close, 20, 2)` at v5.
+     */
+    visitVar_defs(ctx: Var_defsContext): string;
+    /** The name of the first function CALL in a subtree, if there is one. */
+    private firstCallee;
+    /**
+     * v5 renames `study()` to `indicator()`, keeps `strategy()`, and adds
+     * `library()` — a script that declares functions for others to import and
+     * plots nothing itself.
+     */
+    protected detectDirective(node: ParseTree): 'indicator' | 'strategy' | 'library' | undefined;
+    /**
+     * An `indicator()` script is in indicator mode, so `strategy.*` is fatal —
+     * the same rule the base applies to `study()`, under v5's spelling of it.
+     *
+     * A LIBRARY is not refused. The manual's Libraries page restricts what an
+     * exported function may use (no non-const globals, no `input.*()`) and says
+     * nothing against `strategy.*`, and published libraries call it —
+     * `strategy.position_size`, `strategy.closedtrades`, `strategy.entry` — to
+     * be imported by strategies, whose broker they then read.
+     */
+    protected enforceStrategyContext(name: string, ctx: SourceLocated): void;
+    /**
+     * A call to a function's own NAME is recursion only when it can reach this
+     * definition. The manual forbids recursion ("cannot contain calls to
+     * themselves within their bodies") but allows overloads, and an overload
+     * calling its sibling is the documented way to share code:
+     *
+     *     export getHexString(series float r, series float g, series float b, series float t = 0.0) => …
+     *     export getHexString(series color source) =>
+     *         getHexString(color.r(source), color.g(source), color.b(source), color.t(source))
+     *
+     * So a call counts only when its argument count fits this definition and no
+     * sibling overload's — `f(int x) => f(x)` beside `f(float x, int y)` still
+     * calls itself, and would overflow the stack. Siblings of the same arity are
+     * told apart by type, which is not known here, so they are let through. A
+     * method `alert(string message, string key)` that calls the built-in
+     * `alert(message)` does not call itself either.
+     */
+    protected enforceNoRecursion(name: string, body: ParseTree, ctx: SourceLocated): void;
+    visitFun_call(ctx: Fun_callContext): string;
+    /** The call itself, before any `.method()` chained onto its result. */
+    protected emitBaseCall(ctx: Fun_callContext): string;
+    /**
+     * The LAST link of a chain is what a destructuring unpacks.
+     *
+     *     [sampleMean, highBand, lowBand] =
+     *         sourceArray.maintainQueue(sourceInput, newSample).calcBB(multiplier, newSample)
+     *
+     * `maintainQueue` returns the array; `calcBB` returns "a tuple containing the
+     * basis, upper band, and lower band respectively". The base reads the call's
+     * own `id`, which here is the receiver plus the FIRST method — so the arity
+     * check asked `maintainQueue` and was told, correctly, that it returns no
+     * tuple.
+     *
+     * A trailing FIELD suffix is not a callee, so it is skipped: `f().x` unpacks
+     * nothing, and naming `x` would produce a message about a function that does
+     * not exist.
+     */
+    /**
+     * v5 widens where a `[a, b] = …` may take its values from:
+     *
+     *   - an `if` or `switch` whose branches end in tuples (manual: "If the
+     *     final statement is a conditional structure … the function returns that
+     *     structure's result", and the same holds for a declaration);
+     *   - a METHOD call — `[lv, t] = this.eventHorizon(close)` — and a library
+     *     function, whose definitions this script cannot see;
+     *   - a function ending in a call or a `switch`, whose width is not written;
+     *   - `ta.vwap(source, anchor, stdev_mult)`, which "will calculate the
+     *     standard deviation bands … and return a [vwap, upper_band,
+     *     lower_band] tuple".
+     *
+     * It still refuses what it can prove wrong: a built-in that returns one
+     * value, a width that disagrees with the definition's, and a function every
+     * one of whose exits is plainly a single value.
+     */
+    protected checkTupleSource(ctx: any, ids: string[]): void;
+    /**
+     * v5's declaration rule reads the initialiser the way the language does:
+     *
+     *   - `x = arr.last().x` and `float y = verts.get(i).y` read a FIELD called
+     *     `x`/`y` off a value. A field after a dot is not the variable.
+     *   - `result = if cond` + a branch that declares its own `result` reads
+     *     that branch's local, not the one being declared.
+     */
+    protected enforceNoSelfReference(name: string, value: ParseTree, ctx: SourceLocated): void;
+    /** Is `root` a namespace, user type, enum or library alias — a qualifier, not a variable? */
+    protected isQualifierRoot(root: string): boolean;
+    /**
+     * `(expr).field` and `(expr).method()` — see `atom` in PineV5Parser.g4.
+     * The receiver is a value, so it folds through the same `emitChainedMethod`
+     * a call's result does.
+     */
+    visitAtom(ctx: any): string;
+    /** The first call in an expression, the way the base check finds it. */
+    private firstCallOf;
+    protected destructuringCallee(call: Fun_callContext): string;
+    /**
+     * `a.f().g()` — the chained method calls hanging off a call's result.
+     *
+     * Folded here rather than inside each emit path, because every one of them
+     * returns a VALUE and the chain applies to the value, whatever produced it:
+     * a built-in call, a method call, a UDT constructor, a library function.
+     *
+     * The receiver of a chained call is an expression, so it cannot go through
+     * `emitMethodCall`, which resolves a receiver NAME to a local. Dispatch is
+     * otherwise identical, and `Context.builtinMethod` was already receiving a
+     * value rather than a name.
+     */
+    protected emitCallChain(base: string, ctx: Fun_callContext): string;
+    /** One `.method(args)` — or `.field` — applied to an already-emitted receiver. */
+    protected emitChainedMethod(receiver: string, ctx: Call_suffixContext, receiverType?: string | null): string;
+    /** A chained call to a user method, `overload` or the plain name. */
+    private emitUserChainedCall;
+    /**
+     * A dotted callee whose root is NOT a built-in namespace.
+     *
+     * Three things can be, and they are checked in this order:
+     *
+     *   Point.new(…)   a user type's constructor
+     *   lib.f(…)       a function from an imported library
+     *   p.area(…)      a method call, on a user type or on a built-in collection
+     *
+     * Returns null when none applies, so the caller falls through to the ordinary
+     * namespace path. A real namespace always wins — see `emitFieldChain`.
+     */
+    protected emitDottedCall(name: string, ctx: Fun_callContext): string | null;
+    /**
+     * `label.all.size()` — a method called on a namespace member's VALUE.
+     *
+     * `id` is greedy, so the whole of `label.all.size` arrives as one dotted
+     * name and the ordinary namespace path asks the registry for a function of
+     * that name. There is none: `label.all` is an ARRAY, and `size` is a method
+     * on it.
+     *
+     * So the longest registry-known PREFIX is taken as the receiver and whatever
+     * follows is applied to it — the same split `emitChainedMethod` performs on a
+     * dotted call suffix, arrived at from the other side. Returns null when no
+     * prefix resolves, which leaves the existing "has no member" diagnostic to
+     * report the name the script actually wrote.
+     */
+    protected emitNamespaceValueMethod(name: string, ctx: Fun_callContext): string | null;
+    /** `label.all` → `opsv2_label.opsv2_all`, the way visitId prefixes a dotted read. */
+    protected namespacedName(dotted: string): string;
+    /** `Point.new(…)` and `Point.copy(p)` — the two calls a TYPE answers. */
+    protected emitTypeCall(typeName: string, member: string, ctx: Fun_callContext): string | null;
+    /**
+     * Maps a `Type.new(…)` argument list onto field names.
+     *
+     * Positional arguments take fields in declaration order; keyword arguments
+     * name them. Both are checked, because neither mistake is visible at run
+     * time: an unknown field name would just add a property nothing reads, and a
+     * ninth positional argument to an eight-field type would be dropped.
+     */
+    protected constructorFields(typeName: string, fields: readonly string[], ctx: Fun_callContext): Map<string, string>;
+    /**
+     * `receiver.name(args)`.
+     *
+     * A USER method becomes `name(receiver, args)`, which is what it already is —
+     * see `visitMethod_def_stmt`. Anything else is a BUILT-IN method, and which
+     * namespace owns it depends on what the receiver turns out to be at run time,
+     * so that dispatch is deferred to `Context.builtinMethod`.
+     *
+     * `.copy()` is intercepted first because three different namespaces spell it
+     * — `array.copy`, `matrix.copy`, and a UDT's shallow copy — and only the
+     * value knows which it is.
+     */
+    protected emitMethodCall(receiver: string, method: string, ctx: Fun_callContext): string;
+    /**
+     * `<value>.method(args)` where the receiver is an already-emitted VALUE of a
+     * known type — an enum member — rather than a name.
+     */
+    protected emitValueMethodCall(receiver: string, receiverType: string, method: string, ctx: Fun_callContext): string;
+    /** Runs `emit` with `name` on the callee stack, so visitKw_arg can see it. */
+    private withCallee;
+    /**
+     * Function OVERLOADING — several definitions of one name.
+     *
+     * SOURCING. From the v5 release notes:
+     *
+     *     // Two parameters
+     *     mult(x1, x2) => x1 * x2
+     *     // Three parameters
+     *     mult(x1, x2, x3) => x1 * x2 * x3
+     *     plot(mult(7, 4))
+     *     plot(mult(7, 4, 2))
+     *
+     * and, for the harder case, "When overloads have the same number of
+     * parameters, all parameters in each overload must be explicitly typified,
+     * and their type combinations must be unique".
+     *
+     * ── What it was doing instead ───────────────────────────────────────────────
+     *
+     * Both definitions were emitted as `function opsv2_$fn_mult(…)`, so the second
+     * simply replaced the first in JavaScript. `mult(7, 4)` then called the
+     * three-parameter body with one argument missing and plotted `na` on every
+     * bar — no error anywhere, because a redeclared function is legal JavaScript.
+     */
+    protected functionOverloads: Map<string, FnOverload[]>;
+    /** The arity range and declared parameter types of one definition. */
+    protected overloadOf(inner: Fun_def_singlelineContext | Fun_def_multilineContext): FnOverload;
+    /**
+     * The suffix that separates one overload's emitted name from its siblings.
+     *
+     * Arity alone where the arities differ, and the declared types as well where
+     * they do not — which the manual requires to be unique, so the pair always
+     * is. A name with a single definition gets no suffix at all, so nothing about
+     * an ordinary script's output changes.
+     */
+    protected overloadSuffix(o: FnOverload): string;
+    /** The definition currently being emitted, when its name is overloaded. */
+    private emittingOverload;
+    /** The function or method whose body is being emitted, overloaded or not. */
+    private enclosingDefinition;
+    private withOverload;
+    visitFun_def_singleline(ctx: Fun_def_singlelineContext): string;
+    visitFun_def_multiline(ctx: Fun_def_multilineContext): string;
+    /**
+     * The STATIC type of a call argument, as far as it can be known here.
+     *
+     * Literals carry their own type, and a variable carries whatever type its
+     * declaration wrote down. Anything else is null — unknown — and an overload
+     * set that cannot be resolved from what is known says so rather than picking
+     * one, because picking wrong calls a body written for another type and
+     * returns a plausible wrong number.
+     */
+    protected argumentType(expr: ParseTree | null): string | null;
+    /** Does an argument of type `arg` fit a parameter declared `param`? */
+    private fits;
+    /**
+     * An enum member may not stand in for a member of a DIFFERENT enum.
+     *
+     * SOURCING. From the manual's Enums page: "Scripts cannot compare members of
+     * different enums or use such members in expressions requiring a specific
+     * enum type, EVEN IF THE FIELDS HAVE IDENTICAL NAMES AND TITLES." A parameter
+     * declared `OscType selection` is such an expression.
+     *
+     * TradingView's own `v5-language-enums-05` is written to show the refusal —
+     * it declares `OscType` and `OscType2` with identical fields, passes an
+     * `OscType2` where an `OscType` belongs, and comments the plot "Raises a
+     * compilation error because only members of `OscType` are allowed." This
+     * engine compiled it and plotted `na` on every bar instead, which is the
+     * worse of the two answers: the script looks like it ran.
+     *
+     * ⚠ The COMPARISON half of that sentence — `OscType.rsi == OscType2.rsi` —
+     * is not refused here. It is the same rule and needs the same type
+     * information on both operands of a binary expression; no corpus script
+     * witnesses it, so it is left as a stated gap rather than a guess. The
+     * runtime keeps the two members distinct regardless, which
+     * tests/v5/transpiler/enums.test.ts asserts.
+     */
+    private checkEnumArguments;
+    protected callFunctionName(pineName: string, ctx: Fun_callContext): string;
+    /**
+     * v5 keeps the mutable-argument restriction for ONE member of the family.
+     *
+     * SOURCING. The manual's Other timeframes and data page states it only of
+     * `request.security_lower_tf`: its `expression` parameter "accepts most of the
+     * same arguments discussed in that section, excluding direct references to
+     * collections and mutable variables declared in the script's main scope". It
+     * is said of that function as a DIFFERENCE from `request.security()`, which
+     * the same page restricts only INSIDE A LOOP — "all parameters defining parts
+     * of the requested context can accept arguments that depend on variables from
+     * the loop's header or mutable variables that change within the loop's local
+     * scope. However, a request.*() call's evaluated expression cannot depend on
+     * the values of those variables."
+     *
+     * TradingView's own `v5-writing-limitations-10` settles it. That script passes
+     * the global `var x = 0`, mutated by 300 `if` blocks, straight into
+     * `request.security()`, and its comment names the only error as "compilation
+     * error since the scope count is now 602". The blanket v3 guard rejected it
+     * one rule too early, for a reason v5 does not have.
+     *
+     * v3 and v4 are untouched: nothing in either archive lifts the rule there.
+     */
+    protected securityRestrictsMutableArgs(ctx: Fun_callContext): boolean;
+    /**
+     * `strategy.long` / `strategy.short` passed as `when` is rejected. They are
+     * direction constants, not conditions: v4 let the mistake through, where
+     * `strategy.entry("L", strategy.long, when = strategy.long)` read as true.
+     * Migration guide to v5 (https://www.tradingview.com/pine-script-docs/migration-guides/to-pine-version-5/):
+     * "strategy.long" cannot be passed to `when`; use `direction`.
+     */
+    protected enforceWhenIsBool(name: string, ctx: Fun_callContext): void;
+    /**
+     * `strategy.exit()` with no exit condition is rejected (§4d).
+     *
+     * Positional form is admitted from the fifth argument on: the parameter order
+     * is `(id, from_entry, qty, qty_percent, profit, …)`, so a fifth positional
+     * argument IS `profit`. Checking the count rather than the names is the only
+     * option there — a positional argument carries no name to check.
+     */
+    protected enforceExitCondition(ctx: Fun_callContext): void;
+    /**
+     * The collection constructors that take a TYPE ARGUMENT.
+     *
+     * `array.new<float>(0)` is v5's spelling of `array.new_float(0)`, and this
+     * engine implements the per-type constructors — so the type argument is not
+     * decoration here, it selects the function. `matrix.new<float>` and
+     * `map.new<string, int>` have one implementation each, so their type
+     * arguments are parsed and discarded.
+     *
+     * Returns null when this call is not a typed constructor, so the caller can
+     * fall through to the ordinary path.
+     */
+    protected emitTypedConstructor(name: string, ctx: Fun_callContext): string | null;
+    /** Emits `ctx.call("name@L:C", ctx.builtin("name"), …args)` for a built-in. */
+    private emitCall;
+    /**
+     * The RUNTIME's name for a keyword the script spelled the v5 way, or null.
+     *
+     * Consulted from `visitId` rather than from `visitKw_arg`, which is where it
+     * started. `emitSecurity` builds its keyword object itself — it has to, so it
+     * can defer the `expression` argument as a thunk — and reads each key by
+     * visiting the id directly, so a translation living in `visitKw_arg` was
+     * bypassed for exactly the call that needs it most:
+     * `request.security(…, timeframe="D")` silently fell back to the chart's
+     * timeframe. `visitId` is the one point both paths go through.
+     */
+    protected keywordAliasFor(written: string): string | undefined;
+    /** v5's `stmt` gained four alternatives; the base knows two. */
+    visitStmt(ctx: StmtContext): string;
+    /**
+     * `type Name` + fields → a FACTORY FUNCTION.
+     *
+     *     type Point
+     *         float x
+     *         float y = 0.0
+     *
+     * becomes
+     *
+     *     function opsv2_$type_Point(_a) {
+     *       const _o = { __type: "Point" };
+     *       _o.x = ctx.fieldValue(_a.x !== undefined ? _a.x : (NaN));
+     *       _o.y = ctx.fieldValue(_a.y !== undefined ? _a.y : (0.0));
+     *       return _o;
+     *     }
+     *
+     * A function DECLARATION rather than an object template, for two reasons.
+     * Declarations hoist, so a type may be used above the line that declares it
+     * inside any function body. And a default has to be RE-EVALUATED per
+     * instance: `type Bag\n    array<float> xs = array.new<float>(0)` must give
+     * every Bag its own array, and a shared template would give them all one.
+     *
+     * Fields are stored UNPREFIXED. They live inside an object of their own, so
+     * there is nothing in the sandbox for them to collide with, and `p.x` reads
+     * better in a debugger than `p.opsv2_x`.
+     */
+    visitType_def_stmt(ctx: Type_def_stmtContext): string;
+    /**
+     * `enum Name` + fields → one frozen object of MEMBER objects.
+     *
+     *     enum OscType
+     *         rsi = "Relative Strength Index"
+     *         mfi = "Money Flow Index"
+     *
+     * becomes
+     *
+     *     const opsv2_$enum_OscType = ctx.declareEnum("OscType", {
+     *       "rsi": "Relative Strength Index", "mfi": "Money Flow Index",
+     *     });
+     *
+     * whose members are the STRINGS `"OscType.rsi"` and `"OscType.mfi"`. See
+     * `Context.declareEnum` for why a member is a string rather than an object —
+     * in one line, because `x == OscType.rsi` compares a Series to the member,
+     * and JavaScript compares two objects by reference while it coerces an object
+     * against a primitive.
+     *
+     * The enum NAME is part of every member, which keeps the rule the manual
+     * states: "Scripts cannot compare members of different enums ... even if the
+     * fields have identical names and titles."
+     *
+     * ── The title default ──────────────────────────────────────────────────
+     *
+     * "If the programmer does not specify a field's title, its title is the
+     * 'string' representation of its name."
+     */
+    visitEnum_def_stmt(ctx: Enum_def_stmtContext): string;
+    /** An enum declaration's fields, in declaration order. */
+    protected enumFieldsOf(ctx: Enum_def_stmtContext): EnumField[];
+    /** The emitted name of an enum's member table. */
+    protected enumFactory(enumName: string): string;
+    /** The emitted name of a type's factory. */
+    protected typeFactory(typeName: string): string;
+    /**
+     * `method name(Receiver self, …) => …`.
+     *
+     * Emitted as an ordinary function, because that is what it is: Pine's
+     * `r.area()` and `area(r)` are the same call, and the receiver is simply the
+     * first argument. Only the CALL SITES differ, and `visitFun_call` handles
+     * those.
+     *
+     * ── The one limitation ────────────────────────────────────────────────────
+     *
+     * Pine dispatches on the receiver's declared type, so two methods may share a
+     * name if their receivers differ. This engine dispatches on the NAME alone,
+     * because it does not track types — so a second method of the same name would
+     * emit a second JavaScript function of the same name and silently win. It is
+     * rejected instead.
+     */
+    visitMethod_def_stmt(ctx: Method_def_stmtContext): string;
+    /**
+     * A method's receiver type — the declared type of its FIRST parameter.
+     *
+     * "Since user-defined methods require explicit type specification for their
+     *  first parameter (the receiver object)", this is always written down, and
+     * it is the whole basis of overload resolution. A parameter with no declared
+     * type is recorded as `?`, which no overload set can be resolved against and
+     * which reads correctly in the diagnostic.
+     */
+    protected receiverTypeOf(inner: Fun_def_singlelineContext | Fun_def_multilineContext): string;
+    /**
+     * The JavaScript name for one method.
+     *
+     * Unqualified while the name has a single declaration, so nothing about a
+     * script without overloads changes; qualified by receiver type as soon as it
+     * has more than one, because two JavaScript functions of the same name are
+     * one function and the second silently wins.
+     */
+    protected methodFunctionName(name: string, receiver: string | null, sig?: FnOverload | null): string;
+    /** The signature of the method definition currently being emitted. */
+    protected emittingMethodSig: FnOverload | null;
+    /** The receiver type of the method definition currently being emitted. */
+    protected emittingMethodFor: string | null;
+    /**
+     * A method's definition takes the qualified name; every other definition
+     * keeps its own. Only `visitMethod_def_stmt` sets `emittingMethodFor`, and a
+     * definition cannot nest inside another, so the flag cannot leak.
+     */
+    protected definitionFunctionName(pineName: string): string;
+    private withMethodReceiver;
+    /**
+     * Which overload of `name` a receiver spelled `expression` resolves to.
+     *
+     * Returns null when `name` is not overloaded — the caller then takes its
+     * ordinary path. Throws when it IS overloaded and the receiver's type cannot
+     * be proved, because guessing would dispatch to a body written for another
+     * type and return a plausible wrong answer.
+     */
+    protected resolveOverload(name: string, receiverType: string | null, ctx: SourceLocated, argCount?: number | null): string | null;
+    /**
+     * The declared type of `name` where the code being emitted sits: a
+     * parameter or typed local of the enclosing function, else a script-scope
+     * declaration.
+     */
+    protected typeOfName(name: string): string | null;
+    /** Script-scope types settled by an initialiser, beyond the scope pass's. */
+    protected scriptTypes: Map<string, string>;
+    /** The type of `receiver.field1.field2…`, following declared field types. */
+    protected typeOfPath(receiver: string, fields: readonly string[]): string | null;
+    /**
+     * A type stated by a local's initialiser: `P.new(…)`, `lib.P.new(…)`,
+     * `array.new<T>(…)` and its `map`/`matrix` siblings, `xs.copy()`. Anything
+     * else is unknown rather than guessed.
+     */
+    protected typeOfInitialiser(expr: ParseTree | null): string | null;
+    /**
+     * After the last declaration of an overloaded name, a function under the
+     * PLAIN name that picks the overload at run time — by argument count, then
+     * by the arguments' own types (Context.pickOverload).
+     *
+     * Calls the emitter can resolve go straight to their overload and never
+     * reach it. It serves the rest: a receiver whose type is not written down
+     * where it is used, and a library's export, which is published under the
+     * plain name and so was "not defined" whenever the name was overloaded.
+     */
+    protected emitOverloadDispatcher(name: string): string;
+    /** How many declarations of each overloaded name have been emitted so far. */
+    private emittedOverloads;
+    /**
+     * Every declaration of `name`, functions and methods together: they share
+     * one JavaScript name, so they are one overload set. A library declaring
+     * `export dot(Vec2 a, Vec2 b, …)` and `export method dot(float[] a, …)`
+     * emitted both as the same function, and the second replaced the first.
+     */
+    protected overloadTotal(name: string): number;
+    /** How many arguments a call passes, positional and keyword. */
+    protected argumentCount(args: any | null): number;
+    /**
+     * A local's declared type — `Point p = …`, or one its initialiser states —
+     * recorded for the method calls later in the same function body.
+     */
+    visitVar_def(ctx: any): string;
+    /**
+     * TradingView does not evaluate a plain local whose value nothing reads, so
+     * an out-of-bounds `array.get` in one raises no error (probes: pe6 in
+     * conformance/common/tradingview-findings.md, v6-dead-local; the same read
+     * used errors: pe6b, v6-dead-local-used). Only what the probes showed is
+     * skipped: a non-`var` local inside a block, never named elsewhere in that
+     * block (a loop body re-runs, so earlier statements count), whose value is
+     * not the block's result and whose initialiser is built from nothing but
+     * reads and `array.get` / `.get`. Anything else is evaluated as before.
+     */
+    protected isDeadLocal(ctx: any): boolean;
+    /** Is `name` (or a field path rooted at it) written anywhere under `node`, bar `skip`? */
+    protected mentionsName(node: any, name: string, skip: any): boolean;
+    /**
+     * Is the value of this statement thrown away? A block's last statement is its
+     * value, so it is only discarded when the construct holding the block is
+     * itself a statement whose own value is discarded. Unknown shapes say no.
+     */
+    protected valueDiscarded(content: any): boolean;
+    /** Reads, operators and `array.get` / `.get` only: nothing that can have an effect. */
+    protected isPureRead(node: any): boolean;
+    /** The dispatcher, when `name`'s last declaration has just been emitted. */
+    protected afterDefinition(name: string): string;
+    /** `name/receiverType` for every method ALREADY EMITTED — the duplicate check above. */
+    private definedMethods;
+    /**
+     * `export` in front of a function, method or type.
+     *
+     * The declaration is emitted unchanged; the keyword only records that the
+     * name is part of a library's public surface. Outside a library it is an
+     * error, which is TradingView's rule and is worth enforcing: `export` in an
+     * indicator is a script that thinks it is something it is not.
+     */
+    visitExport_stmt(ctx: Export_stmtContext): string;
+    /** The name a `fun_def_stmt` binds, whichever of its two forms it takes. */
+    protected definitionName(def: any): string;
+    /**
+     * `f(float x, int n = 2)` — v5 parameters carry a type and may carry a
+     * default.
+     *
+     * The TYPE is parsed and discarded: this engine evaluates everything as a
+     * series, so an annotation cannot change a result, and rejecting a script for
+     * carrying one would be worse than ignoring it. The DEFAULT is not — it maps
+     * straight onto a JavaScript default parameter, which has the semantics Pine
+     * describes (evaluated per call, only when the argument is absent).
+     */
+    /** v5 parameters are a rule of their own, and may carry a default. */
+    protected paramNames(ctx: Fun_headContext): string[];
+    visitFun_head(ctx: Fun_headContext): string;
+    /**
+     * `import user/library/version as alias`.
+     *
+     * The library is compiled INLINE, into an immediately-invoked function whose
+     * result is the namespace object the alias refers to:
+     *
+     *     const opsv2_$lib$mylib = (() => {
+     *       function opsv2_$fn_f(opsv2_x) { … }
+     *       return { "f": opsv2_$fn_f };
+     *     })();
+     *
+     * ── Why inline, and why an IIFE ───────────────────────────────────────────
+     *
+     * Inline, because there is nowhere else to put it: the emitted script is one
+     * JavaScript function body that the runtime re-invokes per bar, and a library
+     * has to be inside that scope to reach `ctx`.
+     *
+     * An IIFE, because a library has its own script scope. Two scripts that both
+     * declare `len = 14` at top level are not sharing a variable, and emitted
+     * flat they would be — `let opsv2_len` twice in one scope is a redeclaration
+     * error, and with `var` it is worse: it silently works and they overwrite
+     * each other.
+     *
+     * The library's body therefore re-runs per bar exactly as the importing
+     * script's does, which is what Pine specifies: a library's top-level code is
+     * script-scope code.
+     */
+    visitImport_stmt(ctx: Import_stmtContext): string;
+    /**
+     * `alias.EnumName` → its field names, for every enum an import exports.
+     *
+     * Keyed by the ALIAS rather than the path, because that is what a read
+     * spells: two aliases of one library are two namespaces to the script.
+     */
+    protected libraryEnums: Map<string, string[]>;
+    /** The emitted name of an imported library's namespace object. */
+    protected libraryNamespace(alias: string): string;
+    /**
+     * Parses a library's source, and says which version it was parsed as.
+     *
+     * A seam rather than an inline `parseV5`: a v6 script can import a library
+     * written in either version, and each must be read by its OWN grammar — a v5
+     * library binding a variable called `once` is legal and must stay so. v5
+     * itself only ever had v5 libraries, so this reads everything as v5, exactly
+     * as before.
+     */
+    protected parseLibrary(source: string): {
+        parsed: ReturnType<typeof parseV5>;
+        version: PineVersion;
+    };
+    /** The visitor a library parsed as `version` is compiled with. See parseLibrary. */
+    protected createLibraryVisitor(_version: PineVersion, options: V5Options): V5ToJsVisitor;
+    /**
+     * The JavaScript an exported name is reached by, on the library's own
+     * visitor — a type's factory, an enum's, or a function. A seam because v6
+     * adds a fourth kind of export, the constant.
+     */
+    protected exportedMemberJs(name: string, types: ReadonlyMap<string, unknown>, enums: ReadonlyMap<string, unknown>): string;
+    /**
+     * Compiles a library's source with a visitor of its own.
+     *
+     * A fresh visitor, not this one: a library has its own types, its own
+     * methods, its own scope analysis and its own set of exported names, and
+     * threading two scripts' worth of that through one instance is how a library
+     * would end up able to see the importing script's declarations.
+     *
+     * Nested imports are allowed — the child gets the same library table. An
+     * import back into a library already being compiled (itself, or a cycle
+     * through others) is refused by `libraryChain`, and the depth is bounded so a
+     * long chain of distinct libraries cannot exhaust the stack either.
+     */
+    protected compileLibrary(path: string, alias: string, source: string, ctx: SourceLocated): {
+        js: string;
+        exports: Set<string>;
+        types: Map<string, string[]>;
+        methods: Set<string>;
+        members: string[];
+        enums: Map<string, string[]>;
+    };
+    /**
+     * `alias.f(args)` — a call into an imported library.
+     *
+     * Only EXPORTED names resolve. A library's private helpers are inside the
+     * IIFE and unreachable from here, so an unexported name would emit a property
+     * read that is `undefined` at run time; naming it at compile time is the
+     * whole point of the export list.
+     */
+    protected emitLibraryCall(alias: string, path: string, member: string, ctx: Fun_callContext): string;
+    /** `alias.Type.new(…)` and `alias.Type.copy(obj)` — a library's type. */
+    protected emitLibraryTypeCall(alias: string, path: string, typeName: string, member: string, ctx: Fun_callContext): string;
+    /**
+     * v5's `global_stmt_content` / `local_stmt_content` gained `while_expr`, and
+     * the global one gained `switch_expr` directly rather than through the
+     * `arith_expr` wrapper. The statement dispatcher has to route both;
+     * everything else falls through to the inherited implementation.
+     */
+    protected visitContent(ctx: any): string;
+    /** `arith_expr` gained `switch_expr` and `for_in_expr`; the base knows three. */
+    visitArith_expr(ctx: any): string;
+    /**
+     * `for item in xs` and `for [index, item] in xs`.
+     *
+     * Emitted as a real JavaScript `for … of` over `Context.forIn`, for the same
+     * reason `while` is emitted as a real `while`: `break` and `continue` cannot
+     * cross a function boundary, and Pine allows both here.
+     *
+     * The whole thing still sits inside an IIFE, because — unlike `while` — a
+     * `for … in` is an EXPRESSION. The manual's syntax block opens with
+     * `[variables = | :=]`, and its body ends with a `return_expression`, so the
+     * loop has a value: the last one its body produced. `captureLoopResult`
+     * rewrites the block's trailing `return` into an assignment to `_res`, which
+     * is exactly what `visitFor_expr` does for the numeric form — the two loops
+     * differ in how they step, not in what they evaluate to.
+     *
+     * ── Why the pair comes from the runtime rather than the emitter ───────────
+     *
+     * `item` means something different per collection — an element of an array, a
+     * ROW of a matrix, the VALUE half of a map entry — and the emitter cannot
+     * know which it has: `xs` is an expression, and this engine does not track
+     * element types. `Context.forIn` decides at runtime, where the value is,
+     * and hands back a uniform `[key, value]`. It also owns the two size rules,
+     * which differ between maps and the rest.
+     */
+    visitFor_in_expr(ctx: For_in_exprContext): string;
+    /**
+     * `while cond` + block. A STATEMENT: it evaluates to nothing.
+     *
+     * Emitted as a real JavaScript `while` rather than an IIFE, so `break` and
+     * `continue` inside it are legal — the same reason `visitIf_expr` drops the
+     * IIFE for a statement-`if` inside a loop. `loopDepth` is raised for exactly
+     * that: it is what makes a nested statement-`if` emit as a plain `if`.
+     *
+     * The trailing return that a block normally ends with is SUPPRESSED, because
+     * there is no function boundary here to contain it — a `return` would leave
+     * the enclosing user function, or be a syntax error at script scope.
+     */
+    visitWhile_expr(ctx: While_exprContext): string;
+    /**
+     * `switch` — an EXPRESSION, in both of its forms.
+     *
+     *     switch expr          each label is compared to `expr`
+     *         1 => "one"
+     *         => "other"       a label-less arm is the default
+     *
+     *     switch               each label is a condition in its own right
+     *         x > 5 => "big"
+     *
+     * Emitted as an IIFE, because the arms have to be able to evaluate to
+     * something and a `return` needs a function to belong to. The subject is
+     * bound to a temporary first so it is evaluated ONCE — Pine evaluates it once,
+     * and re-evaluating a `ta.*` call per arm would advance its history several
+     * times a bar and quietly desynchronise it.
+     */
+    /**
+     * The loop depth at each enclosing `switch`. A `switch` is emitted as an
+     * arrow function, so a `break` in one of its arms that belongs to a loop
+     * OUTSIDE it cannot be a JavaScript `break`: Pine allows
+     *
+     *     for i = 0 to n
+     *         switch kind
+     *             1 =>
+     *                 if found
+     *                     break
+     *
+     * and the emitted `break` was an "Illegal break statement". It is thrown as
+     * a loop signal instead, which that loop's body catches (captureLoopResult).
+     */
+    protected switchLoopFloors: number[];
+    visitLoop_break(ctx: any): string;
+    visitLoop_continue(ctx: any): string;
+    visitSwitch_expr(ctx: Switch_exprContext): string;
+    /**
+     * What a switch evaluates to when no arm matches. `na` at v5; a seam for the
+     * same reason as `ifFallthrough` in the v1 base.
+     */
+    protected switchFallthrough(_ctx: Switch_exprContext): string;
+    /**
+     * One arm's body, as a JavaScript block that RETURNS the arm's value.
+     *
+     * An indented block already ends in a `return` — that is what
+     * `visitLocal_stmts_list` does with a block's last statement. A single-line
+     * body does not, and cannot simply be wrapped in one either: `1 => x = 2`
+     * emits a declaration, and `return let x = …` is a syntax error. A trailing
+     * binding evaluates to the bound name, which is the same rule a function body
+     * follows — so this is exactly `singleLineBody`.
+     */
+    protected caseBody(arm: Switch_caseContext): string;
+}
+export {};