openpinescript 0.0.0-stage → 0.1.0

package/dist/types/runtime/v1/stdlib/ui.d.ts

@@ -0,0 +1,196 @@
+/**
+ * runtime/v1/stdlib/ui.ts
+ * Implements "Full" Plotting Support (Colors, Styles, Shapes, Fills)
+ */
+import { Context } from "../context.js";
+export declare const color_red = "#FF5252";
+export declare const color_green = "#4CAF50";
+export declare const color_blue = "#2196F3";
+export declare const color_orange = "#FF9800";
+export declare const color_teal = "#009688";
+export declare const color_navy = "#3F51B5";
+export declare const color_white = "#FFFFFF";
+export declare const color_black = "#000000";
+export declare const color_gray = "#9E9E9E";
+export declare const color_purple = "#9C27B0";
+export declare function plot(ctx: Context, series: number, title?: string, color?: string, linewidth?: number, style?: number, transp?: any, trackprice?: any, histbase?: any, offset?: any, join?: any, editable?: any, show_last?: any, display?: any, format?: any, precision?: any, force_overlay?: any, linestyle?: any): string;
+export declare function plotshape(ctx: Context, series: boolean | number, title?: string, style?: string, location?: string, color?: string, transp?: any, offset?: any, text?: any, textcolor?: any, editable?: any, size?: any, show_last?: any, display?: any, format?: any, precision?: any, force_overlay?: any): void;
+export declare function plotchar(ctx: Context, series: boolean | number, title?: string, char?: string, location?: string, color?: string, transp?: any, offset?: any, text?: any, textcolor?: any, editable?: any, size?: any, show_last?: any, display?: any, format?: any, precision?: any, force_overlay?: any): void;
+export declare function hline(ctx: Context, price: number, title?: string, color?: string, linestyle?: number, linewidth?: number, editable?: any, display?: any, force_overlay?: any): string;
+export declare function plotbar(ctx: Context, open: number, high: number, low: number, close: number, title?: string, color?: string, transp?: any, editable?: any, show_last?: any, display?: any, format?: any, precision?: any, force_overlay?: any): void;
+export declare function plotcandle(ctx: Context, open: number, high: number, low: number, close: number, title?: string, color?: string, transp?: any, wickcolor?: any, editable?: any, show_last?: any, bordercolor?: any, display?: any, format?: any, precision?: any, force_overlay?: any): void;
+export declare function plotarrow(ctx: Context, series: number, title?: string, colorup?: string, colordown?: string, _minheight?: number, _maxheight?: number): void;
+export declare function bgcolor(ctx: Context, color: string, transp?: number, offset?: any, editable?: any, show_last?: any, title?: any, display?: any, force_overlay?: any): void;
+export declare function barcolor(ctx: Context, color: string, offset?: any, editable?: any, show_last?: any, title?: any, display?: any): void;
+export declare function fill(ctx: Context, plot1: string, plot2: string, color?: string, title?: string, editable?: boolean, fillgaps?: boolean, transp?: any, display?: any, force_overlay?: any, show_last?: any, top_value?: any, bottom_value?: any, top_color?: any, bottom_color?: any): void;
+export declare const line = "line";
+export declare const histogram = "histogram";
+export declare const columns = "columns";
+export declare const circles = "circles";
+export declare const areabr = "areabr";
+export declare const linebr = "linebr";
+export declare const stepline = "stepline";
+export declare const area = "area";
+export declare const dotted = "dotted";
+export declare const dashed = "dashed";
+export declare const solid = "solid";
+export declare const location: {
+    abovebar: string;
+    belowbar: string;
+    top: string;
+    bottom: string;
+    absolute: string;
+};
+export declare const shape: {
+    xcross: string;
+    cross: string;
+    triangleup: string;
+    triangledown: string;
+    flag: string;
+    circle: string;
+    arrowup: string;
+    arrowdown: string;
+    labelup: string;
+    labeldown: string;
+    square: string;
+    diamond: string;
+};
+export declare const size: {
+    auto: string;
+    tiny: string;
+    small: string;
+    normal: string;
+    large: string;
+    huge: string;
+};
+/**
+ * color(col, transp) — the v1-v3 spelling. v4 renamed it to color.new().
+ * Applies a transparency percentage (0 = opaque, 100 = invisible) to a hex
+ * colour, returning #RRGGBBAA.
+ *
+ * `color(na)` is `na`. It used to build the string "NaNff" from the NaN, so a
+ * label drawn with `color = color(na)` carried a colour no renderer can parse,
+ * where `color = na` carries `na` (NaN, which serialises as null) and is drawn
+ * with no fill. On TradingView the ▲/▼ labels of harness_trader_club, drawn
+ * with `color(na)`, show as bare text with no background (seen on the chart;
+ * Pine Logs do not carry colours).
+ */
+export declare function color(col: any, transp?: any): string | number;
+/**
+ * `tickerid(prefix, ticker, session, adjustment)` — builds a ticker id string.
+ *
+ * The FUNCTION, not the variable: `syminfo.tickerid` is the current chart's id
+ * and lives in ./syminfo.ts. Pine keeps functions and variables in separate
+ * namespaces, so v1–v4 spell both of them `tickerid`; v5 renames this one to
+ * `ticker.new` and leaves the variable alone.
+ *
+ * `session` and `adjustment` are accepted and IGNORED. Both select a different
+ * data feed on TradingView — extended hours, dividend adjustment — and this
+ * engine has one feed, the bars it was handed. Accepting them keeps
+ * `tickerid("BATS", "AAPL", session.regular)` (a v4 documentation example)
+ * running against the chart's own data, which is what it would produce anyway
+ * for a regular-session request; asking for `session.extended` gets the same
+ * bars, which is a divergence rather than a refusal because the ticker id is
+ * usually handed straight to `security()`, where an unknown symbol already
+ * reports itself.
+ */
+export declare function tickerid(prefix: any, ticker: any, _session?: any, _adjustment?: any): string;
+/**
+ * alertcondition(condition, title, message) — stub.
+ *
+ * There is no alert delivery system to integrate with locally, so the fired
+ * condition is recorded into the context instead of dispatched, which keeps it
+ * inspectable. Signature-compatible so real scripts run. See R-10.
+ */
+export declare function alertcondition(ctx: Context, condition: any, title?: any, message?: any): void;
+/**
+ * `alert(message, freq)` — the v4 script-alert call.
+ *
+ * ── How it differs from alertcondition() above ─────────────────────────────
+ *
+ * `alertcondition()` DECLARES an alert a user can then configure from the
+ * chart UI; `alert()` FIRES one at the moment it is called, with a message that
+ * may be computed on the bar. Both land in `ctx.alerts` here, because there is
+ * no delivery system to integrate with locally — recording keeps them
+ * inspectable, which is what a backtest can actually use.
+ *
+ * ── Realtime only, deliberately ────────────────────────────────────────────
+ *
+ * The v4 manual is explicit that an `alert()` call only triggers on realtime
+ * bars — it is the property that separates it from Pine Logs, which run on
+ * history too. Firing on every historical bar would make a backtest report
+ * thousands of alerts TradingView would never have sent, so `is_realtime`
+ * gates it.
+ *
+ * `freq` is recorded rather than enforced (the constants live in
+ * ./alerts.ts — see the note there on why they cannot sit in this file): the three frequencies differ in how
+ * many times a single realtime bar may re-fire as it updates, and that depends
+ * on a tick feed the host supplies rather than on anything decidable here.
+ *
+ * Source: https://www.tradingview.com/pine-script-docs/v4/essential/alerts/
+ *
+ * @returns {void}
+ */
+export declare function alert(ctx: Context, message: any, freq?: any): void;
+/**
+ * currency.* — the account currency the strategy reports in. Host-provided;
+ * NONE means "same as the symbol". See R-15.
+ */
+export declare const currency: {
+    NONE: string;
+    USD: string;
+    EUR: string;
+    GBP: string;
+    JPY: string;
+    CHF: string;
+    AUD: string;
+    CAD: string;
+    NZD: string;
+    HKD: string;
+    SGD: string;
+    INR: string;
+    RUB: string;
+    ZAR: string;
+    TRY: string;
+    KRW: string;
+    BRL: string;
+    CNY: string;
+    DKK: string;
+    ILS: string;
+    MYR: string;
+    NOK: string;
+    PHP: string;
+    PLN: string;
+    SEK: string;
+    THB: string;
+    MXN: string;
+    ARS: string;
+    BTC: string;
+    ETH: string;
+    HUF: string;
+    CZK: string;
+    RON: string;
+    RSD: string;
+    ISK: string;
+    IDR: string;
+    TWD: string;
+    VND: string;
+    PKR: string;
+    BDT: string;
+    LKR: string;
+    KWD: string;
+    BHD: string;
+    QAR: string;
+    SAR: string;
+    AED: string;
+    EGP: string;
+    NGN: string;
+    KES: string;
+    MAD: string;
+    TND: string;
+    CLP: string;
+    COP: string;
+    PEN: string;
+    VES: string;
+    USDT: string;
+};

package/dist/types/runtime/v1/stdlib/v6_members.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Built-ins that arrived with v6, or in the monthly releases after it, and
+ * that have no implementation to inherit.
+ *
+ * Declared as object literals for the reason ./late_members.ts gives: each
+ * joins a namespace that is older than it (`plot`, `syminfo`, `timeframe`),
+ * and the generator turns an object literal straight into dotted keys that
+ * `createStdlib` merges onto the namespace of the same name.
+ *
+ * Every name here is listed in V6_ONLY_NAMES (./renames6.ts), which keeps it
+ * out of every earlier version's view — the runtime is one implementation, and
+ * the views are what make a name a v6 name.
+ *
+ * Sources, by month: https://www.tradingview.com/pine-script-docs/release-notes/
+ */
+import { Context } from "../context.js";
+/** September 2025: `plot()`'s `linestyle` — "affects only style values that draw lines". */
+export declare const plot: {
+    linestyle_solid: string;
+    linestyle_dashed: string;
+    linestyle_dotted: string;
+};
+export declare const syminfo: {
+    /**
+     * November 2024: "the smallest number of contracts, shares, lots, or units
+     * the exchange allows for trading the symbol". Host-declared, like the rest
+     * of `syminfo` — see Context.provideSymbolInfo.
+     * @getter
+     */
+    mincontract: (ctx: Context) => number;
+    /**
+     * November 2024: "the ticker ID of the script's main context, even inside
+     * a request.*() expression". A requested expression runs in a sub-context
+     * that reports the REQUESTED symbol; `main` is the chart's context.
+     * @getter
+     */
+    main_tickerid: (ctx: Context) => string;
+    /**
+     * November 2025: the 12-character ISIN, "or an empty string if none is
+     * available". Host-declared.
+     * @getter
+     */
+    isin: (ctx: Context) => string;
+    /**
+     * July 2025: for a continuous futures symbol, "the ticker ID of the
+     * underlying contract. Otherwise returns na." Host-declared.
+     * @getter
+     */
+    current_contract: (ctx: Context) => any;
+};
+export declare const timeframe: {
+    /**
+     * November 2024: "the timeframe of the script's main context, even inside
+     * a request.*() expression" — the chart's period, multiplier and all.
+     * @getter
+     */
+    main_period: (ctx: Context) => string;
+};
+/**
+ * February 2025: "bid is the highest price a buyer will pay now; ask is the
+ * lowest price a seller will accept now. Both are available only on the "1T"
+ * timeframe and are na elsewhere." A quote is not in an OHLCV bar, so the host
+ * supplies it — Context.provideQuote.
+ * @getter
+ */
+export declare function bid(ctx: Context): number;
+/** @getter */
+export declare function ask(ctx: Context): number;

package/dist/types/runtime/v1/timeframes.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Timeframe arithmetic: which PERIOD a timestamp belongs to, and how to build
+ * higher-timeframe candles out of lower-timeframe ones.
+ *
+ * ── Why this is not in stdlib/ ──────────────────────────────────────────────
+ *
+ * Everything under runtime/v1/stdlib/ is scanned by
+ * scripts/common/generate-metadata.ts and every exported name there becomes a
+ * Pine BUILT-IN. `periodIndex` is not a Pine name and must not become one, so
+ * it lives one level up, where the generator does not look. `stdlib/chart.ts`
+ * and `context.ts` both import it.
+ *
+ * ── The specification format ────────────────────────────────────────────────
+ *
+ * From the manual: a timeframe string is a count and a unit — "S" seconds, no
+ * suffix minutes, "D" days, "W" weeks, "M" months — so "1", "60", "240", "D",
+ * "3D", "W", "12M" are all valid, and a bare unit means one of it.
+ */
+/** Seconds in one period of `spec`, or NaN. "The typical number of seconds". */
+export declare function specSeconds(spec: string): number;
+/**
+ * One spelling for each timeframe: "1D" is "D", "1W" is "W", "d" is "D". A
+ * minute count keeps its number ("1", "60"), and what is not a timeframe is
+ * returned as it came.
+ */
+export declare function canonicalTimeframe(spec: string): string;
+/**
+ * The end of the bar's timeframe, given its opening time.
+ *
+ * Here rather than in stdlib/time.ts, which uses it, because
+ * stdlib/mtf.ts needs it too and every export under stdlib/ is a Pine
+ * built-in.
+ *
+ * Pine reports a bar's CLOSING time as the instant the next bar of the same
+ * timeframe opens, so this is calendar arithmetic rather than a fixed offset:
+ * a month is not 30 days and a week is not always 7 × 24 h across a DST
+ * boundary. Days/weeks/months are advanced on the UTC calendar for the same
+ * reason every other accessor in this file reads UTC — see the header.
+ *
+ * Resolution strings follow TradingView's spelling: "1"/"5"/"60" are minutes,
+ * "30S" is seconds, and "D"/"W"/"M" carry an optional multiplier ("2W").
+ */
+export declare function periodEnd(openTime: number, resolution: string): number;
+/**
+ * Which period of `spec` the instant `t` falls in.
+ *
+ * Two bars share a period index exactly when they belong to the same bar of
+ * that timeframe. That is all a caller needs, so the origin does not matter as
+ * long as it is stable — except for weeks and months, where it decides which
+ * DAY a bar starts on and is therefore visible.
+ *
+ * Seconds, minutes and days divide the epoch evenly and are grouped modularly.
+ * Weeks are grouped from a Monday. Months are grouped by the CALENDAR, because
+ * they are not a fixed length: "1M" is 28 to 31 days, and a nominal 30-day
+ * window drifts a whole month out of step inside two years.
+ *
+ * Returns NaN for a spec that is not a timeframe, which no bar can match.
+ */
+export declare function periodIndex(t: number, spec: string): number;
+/** One OHLCV bar — the same shape `SecurityCandle` has in context.ts. */
+export interface Candle {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    /** Set on a DERIVED candle whose last chart bar is known: when it ends. See `DerivedSeries`. */
+    closeTime?: number;
+}
+/**
+ * Fold consecutive bars into the bars of a HIGHER timeframe.
+ *
+ * A higher-timeframe bar IS the aggregate of the lower-timeframe bars inside
+ * it: it opens where the first one opened, closes where the last one closed,
+ * spans their extremes, and carries their total volume. Nothing here is an
+ * approximation — this is the relationship between the two series.
+ *
+ * `bars` must be in ascending time order and must contain ONLY bars the script
+ * has already seen. Aggregating the whole dataset would hand a script the
+ * future: the last group would close before its final bar had arrived.
+ */
+export declare function aggregate(bars: readonly Candle[], spec: string): Candle[];
+/**
+ * A higher-timeframe series that grows one chart bar at a time, giving what
+ * `aggregate` gives over the same bars without folding them all again.
+ *
+ * Only the LAST chart bar can change between two calls (a live re-tick
+ * overwrites it), so the fold is undone for that bar and redone from it:
+ * `before` is the last candle as it stood before that bar was folded in, or
+ * null when that bar opened the candle.
+ */
+export declare class DerivedSeries {
+    private readonly spec;
+    private readonly chartMs?;
+    readonly candles: Candle[];
+    /** How many chart bars are folded in. */
+    upto: number;
+    private before;
+    private valid;
+    /** The bar before the last one folded: if it is not there now, `bars` is another run's. */
+    private anchor;
+    /** Where the current session began, once a gap has shown there is one; null until then. */
+    private session;
+    private prevT;
+    private curKey;
+    /** The three of them as they stood before the last bar was folded, to undo it. */
+    private saved;
+    private readonly spanMs;
+    private readonly intraday;
+    /**
+     * `chartMs` is the chart's own bar length. With it, an intraday spec (minutes,
+     * hours) is anchored at the first bar of each SESSION, which the engine
+     * infers: a gap between consecutive chart bars longer than both one chart
+     * interval and the requested span starts a new one. A stock's hourly bars then
+     * open at 09:30, 10:30, ... as TradingView's do
+     * (conformance/v5/parity/harness_security_session.AAPL.5.csv), where clock
+     * buckets would open at 09:00. A 24/7 series has no such gap, so its buckets
+     * stay on the clock; so does the first session of the series, whose start is
+     * not known. Days, weeks and months are calendar buckets either way.
+     */
+    constructor(spec: string, chartMs?: number);
+    /** The bucket of a bar at `t`; moves the session state on. */
+    private keyOf;
+    /** The bucket a bar at `t` WOULD be in, leaving the state alone. */
+    private peekKey;
+    /**
+     * Folds `bars[0 .. seen)`, of which those before `upto - 1` are as they were.
+     *
+     * `nextTime` is the open of the chart bar after the last one folded, when the
+     * caller knows it (a history run: the dataset is in hand). The last candle is
+     * then complete if that bar falls in another bucket (or after a session gap),
+     * and ends with its own last bar, which `closeTime` records: 15:55 + 5 minutes
+     * for a session's last hourly or daily bar, instead of a clock end that comes
+     * later. Where it is not known (the live bar), `closeTime` stays unset and the
+     * calendar end applies.
+     */
+    extend(bars: readonly Candle[], seen: number, nextTime?: number): void;
+}

package/dist/types/runtime/v1/zones.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Named time zones, without a time-zone database.
+ *
+ * `Intl.DateTimeFormat` already carries one, so the offset of a zone at a given
+ * instant can be recovered by formatting that instant IN the zone and reading
+ * the result back as if it were UTC: the difference is the offset. That handles
+ * daylight saving without a table, because ICU already knows.
+ *
+ * Not in runtime/v1/stdlib/, where every exported name would become a Pine
+ * built-in — see the header of ./timeframes.ts for the same reason.
+ */
+/**
+ * The UTC instant of a wall-clock reading in `zone`.
+ *
+ * The inverse of `asIfUtc`, and iterated once: the offset that applies is the
+ * one at the ANSWER, not at the guess, and near a daylight-saving boundary
+ * those differ by an hour. One correction is enough for every real zone.
+ */
+export declare function utcFromZoned(year: number, month: number, day: number, hour: number, minute: number, second: number, zone: string | undefined): number;
+/**
+ * An instant re-expressed so its UTC fields ARE the wall clock in `zone`.
+ *
+ * The forward direction of `utcFromZoned`, and the one the calendar accessors
+ * need: `hour(t, "America/New_York")` wants the hour a New York clock shows at
+ * `t`, which is `new Date(zonedFields(t, "America/New_York")).getUTCHours()`.
+ *
+ * The result is NOT a real instant and must not be compared with one. It exists
+ * to be read field by field.
+ */
+export declare function zonedFields(ms: number, zone: string | undefined): number;

package/dist/types/transpiler/common/index.d.ts

@@ -0,0 +1,51 @@
+import { PineVersion } from "./version.js";
+import { LanguageProfile } from "./profiles/index.js";
+/** Versions with a working pipeline, ascending. */
+export declare const IMPLEMENTED_VERSIONS: readonly PineVersion[];
+export interface TranspileOptions {
+    /**
+     * Force a version, ignoring any //@version annotation. Used by the
+     * cross-version test matrix to run one source under every version.
+     */
+    version?: PineVersion;
+    /**
+     * Sources for the libraries a v5 script `import`s, keyed by path
+     * (`"someuser/somelib/1"`).
+     *
+     * A library lives on TradingView and this engine has no way to fetch one, so
+     * the host provides it — the same arrangement as `Context.provideSecurityData`
+     * for higher-timeframe candles. An import with no source is refused rather
+     * than stubbed out.
+     */
+    libraries?: Readonly<Record<string, string>>;
+    /**
+     * Apply the checks TradingView's chart editor makes (v5/v6 only). `Session`
+     * sets it; a bare transpile leaves it off so fixtures can be partial scripts.
+     */
+    editorRules?: boolean;
+}
+export interface CompileResult {
+    js: string;
+    version: PineVersion;
+    profile: LanguageProfile;
+}
+/**
+ * Transpiles Pine Script and reports which version was applied.
+ * @throws UnsupportedVersionError   annotation names a version outside 1–5
+ * @throws UnimplementedVersionError version is recognised but not built yet
+ */
+export declare function compileScript(source: string, opts?: TranspileOptions): CompileResult;
+/**
+ * Transpiles Pine Script to JavaScript.
+ *
+ * The version comes from the `//@version` annotation; a script without one is
+ * Pine Script v1. Use `compileScript` when you also need the resolved version.
+ */
+export declare function transpile(source: string, opts?: TranspileOptions): string;
+/**
+ * The hint for an error found after the transpiler, on the compile dry run: ""
+ * unless the source has no `//@version` line and parses as v5 or v6.
+ */
+export declare function noVersionHint(source: string): string;
+export { detectVersion } from "./version.js";
+export type { PineVersion } from "./version.js";

package/dist/types/transpiler/common/libraries.d.ts

@@ -0,0 +1,29 @@
+export interface ImportsOptions {
+    /**
+     * The version the script will be compiled as, when the host forces one
+     * (`TranspileOptions.version`) instead of letting `//@version` decide.
+     */
+    readonly version?: number;
+}
+/**
+ * The import paths written in one source, in order, without duplicates.
+ * Only v5 has `import`: a script annotated v1–v4 (or forced to one), or with a
+ * version this engine does not know, imports nothing as far as the host is
+ * concerned.
+ */
+export declare function importsOf(source: string, opts?: ImportsOptions): string[];
+/**
+ * Every library path the script needs that is not in `supplied`, following
+ * imports through the supplied ones. Empty means every library the script
+ * reaches has a source; whether they then compile -- a library that does not
+ * declare `library()`, one that exports nothing, libraries that import each
+ * other in a cycle, a chain deeper than the compiler allows -- is a compile
+ * error that names the library.
+ *
+ * A source that does not parse yields the imports error recovery could still
+ * read. For a supplied library that means its later imports may go unasked:
+ * that library cannot compile whatever else is supplied, and the compile says
+ * so by name ("parsing the library 'x/Y/1' failed"), which is the error the
+ * author has to fix first.
+ */
+export declare function requiredLibraries(source: string, supplied?: Readonly<Record<string, string>>, opts?: ImportsOptions): string[];

package/dist/types/transpiler/common/parseErrors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Parse errors a person can act on.
+ *
+ * ANTLR's messages describe the parser's state — `token recognition error at:
+ * '$'`, `no viable alternative at input 'if…<BEGIN>…'` — and say nothing about
+ * what went wrong in the script. Four causes are common enough to name:
+ *
+ *   - a string literal broken across two lines
+ *   - `$` in a name
+ *   - a script with no `//@version` line whose body is newer than v1
+ *   - a file that ends in the middle of a statement (a truncated paste)
+ *
+ * The parser's own text is kept in `original`; `line` and `column` are never
+ * touched. The visitor's errors get the same treatment for the one case that
+ * is about the end of the file: see `explainEndOfFile`.
+ */
+import type { ParserError } from "../../parser/v1/index.js";
+export interface ParseErrorContext {
+    /** The source has no `//@version` line at all. */
+    noVersionLine: boolean;
+    /** True when the body parses as v5 or v6, evaluated only if asked. */
+    parsesAsNewer: () => boolean;
+}
+export declare function explainParseErrors(source: string, errors: readonly ParserError[], ctx: ParseErrorContext): ParserError[];
+/**
+ * What to add to ANY error in a script with no `//@version` line that parses
+ * as v5 or v6: the script was read as v1 and the error is very likely only
+ * that. A parse error, a transpile error ("Undeclared identifier 'indicator'")
+ * and a built-in the dry run finds missing all start here.
+ */
+export declare const NO_VERSION_HINT: string;
+/**
+ * The visitor's "Undeclared identifier 'x'" and "'ns' has no member 'x'" are
+ * ordinary errors in the middle of a file. At the very end they are a script
+ * cut off in the middle of a word: nothing but whitespace follows the name.
+ * Returns the sentence to append, or null.
+ */
+export declare function explainEndOfFile(source: string, message: string): string | null;