@supersolutions/super-chart-superscript 0.0.0 → 0.1.0

package/dist/chunk-PAWYIS77.js

@@ -0,0 +1,1214 @@
+// packages/superscript/src/runtime/builtins.ts
+import { ta } from "@supersolutions/super-chart-core";
+function asSeries(v, n) {
+  if (typeof v !== "number")
+    return v;
+  return new Array(n).fill(Number.isFinite(v) ? v : null);
+}
+function finiteOrNa(r) {
+  return Number.isFinite(r) ? r : NaN;
+}
+function mapValue(v, f) {
+  if (typeof v === "number")
+    return Number.isNaN(v) ? NaN : finiteOrNa(f(v));
+  return v.map((x) => {
+    if (x == null)
+      return null;
+    const r = f(x);
+    return Number.isFinite(r) ? r : null;
+  });
+}
+function zipValue(a, b, f, n) {
+  if (typeof a === "number" && typeof b === "number")
+    return Number.isNaN(a) || Number.isNaN(b) ? NaN : finiteOrNa(f(a, b));
+  const out = new Array(n).fill(null);
+  for (let i = 0; i < n; i++) {
+    const x = typeof a === "number" ? a : a[i];
+    const y = typeof b === "number" ? b : b[i];
+    if (x == null || y == null || Number.isNaN(x) || Number.isNaN(y))
+      continue;
+    const r = f(x, y);
+    out[i] = Number.isFinite(r) ? r : null;
+  }
+  return out;
+}
+var S = (v, ctx) => asSeries(v, ctx.n);
+var N = (v) => v;
+var src = (name = "src") => ({ name, kind: "series" });
+var len = (min = 1, name = "len") => ({ name, kind: "length", min });
+function def(name, params, groups, impl, note) {
+  const b = { name, params, groups, impl };
+  if (note !== void 0)
+    b.note = note;
+  return b;
+}
+var unary = (name, f) => def(name, [src("x")], ["math"], (a) => mapValue(a[0], f));
+var LIST = [
+  def("sma", [src(), len()], ["ma"], (a, c) => ta.sma(S(a[0], c), N(a[1]))),
+  def("ema", [src(), len()], ["ma"], (a, c) => ta.ema(S(a[0], c), N(a[1]))),
+  def("wma", [src(), len()], ["ma"], (a, c) => ta.wma(S(a[0], c), N(a[1]))),
+  def("rma", [src(), len()], ["ma"], (a, c) => ta.rma(S(a[0], c), N(a[1]))),
+  def("hma", [src(), len(2)], ["ma"], (a, c) => ta.hma(S(a[0], c), N(a[1]))),
+  def("vwma", [src(), len()], ["ma", "volume"], (a, c) => ta.vwma(S(a[0], c), c.series("volume"), N(a[1]))),
+  def("rsi", [src(), len()], ["osc"], (a, c) => ta.rsi(S(a[0], c), N(a[1]))),
+  def("stoch", [len()], ["osc"], (a, c) => ta.stochK(c.series("high"), c.series("low"), c.series("close"), N(a[0])), "%K over close/high/low"),
+  def("cci", [len()], ["osc"], (a, c) => ta.cci(c.series("high"), c.series("low"), c.series("close"), N(a[0])), "over hlc3"),
+  def("mfi", [len()], ["osc", "volume"], (a, c) => ta.mfi(c.series("high"), c.series("low"), c.series("close"), c.series("volume"), N(a[0])), "over hlc3"),
+  def("roc", [src(), len()], ["osc"], (a, c) => ta.roc(S(a[0], c), N(a[1]))),
+  def("mom", [src(), len()], ["osc"], (a, c) => ta.mom(S(a[0], c), N(a[1]))),
+  def("stdev", [src(), len()], ["vol"], (a, c) => ta.stdev(S(a[0], c), N(a[1]))),
+  def("dev", [src(), len()], ["vol"], (a, c) => ta.dev(S(a[0], c), N(a[1]))),
+  def("atr", [len()], ["vol"], (a, c) => ta.atr(c.series("high"), c.series("low"), c.series("close"), N(a[0]))),
+  def("tr", [], ["vol"], (_a, c) => ta.trueRange(c.series("high"), c.series("low"), c.series("close"))),
+  def("obv", [], ["volume"], (_a, c) => ta.obv(c.series("close"), c.series("volume"))),
+  def("vwap", [], ["volume"], (_a, c) => ta.vwap(c.series("high"), c.series("low"), c.series("close"), c.series("volume")), "cumulative from the first bar, no session reset"),
+  def(
+    "sar",
+    [{ name: "start", kind: "number", default: 0.02 }, { name: "inc", kind: "number", default: 0.02 }, { name: "max", kind: "number", default: 0.2 }],
+    ["trend"],
+    (a, c) => ta.sar(c.series("high"), c.series("low"), N(a[0]), N(a[1]), N(a[2]))
+  ),
+  def("linreg", [src(), len(), { name: "offset", kind: "count", default: 0 }], ["trend"], (a, c) => ta.linreg(S(a[0], c), N(a[1]), N(a[2]))),
+  def("correlation", [src("a"), src("b"), len()], ["trend"], (a, c) => ta.correlation(S(a[0], c), S(a[1], c), N(a[2]))),
+  def("highest", [src(), len()], ["range"], (a, c) => ta.highest(S(a[0], c), N(a[1]))),
+  def("lowest", [src(), len()], ["range"], (a, c) => ta.lowest(S(a[0], c), N(a[1]))),
+  def("sum", [src(), len()], ["range"], (a, c) => ta.sum(S(a[0], c), N(a[1]))),
+  def("cum", [src()], ["range"], (a, c) => ta.cum(S(a[0], c))),
+  def("change", [src(), { name: "len", kind: "length", min: 1, default: 1 }], ["range"], (a, c) => ta.change(S(a[0], c), N(a[1]))),
+  def("crossover", [src("a"), src("b")], ["signal"], (a, c) => ta.crossover(S(a[0], c), S(a[1], c))),
+  def("crossunder", [src("a"), src("b")], ["signal"], (a, c) => ta.crossunder(S(a[0], c), S(a[1], c))),
+  def("cross", [src("a"), src("b")], ["signal"], (a, c) => ta.cross(S(a[0], c), S(a[1], c))),
+  def("barssince", [src("cond")], ["signal"], (a, c) => ta.barssince(S(a[0], c))),
+  def("valuewhen", [src("cond"), src(), { name: "occurrence", kind: "count", default: 0 }], ["signal"], (a, c) => ta.valuewhen(S(a[0], c), S(a[1], c), N(a[2]))),
+  def("pivothigh", [src(), { name: "left", kind: "count" }, { name: "right", kind: "count" }], ["pivot"], (a, c) => ta.pivot(S(a[0], c), N(a[1]), N(a[2]), "high")),
+  def("pivotlow", [src(), { name: "left", kind: "count" }, { name: "right", kind: "count" }], ["pivot"], (a, c) => ta.pivot(S(a[0], c), N(a[1]), N(a[2]), "low")),
+  unary("abs", Math.abs),
+  unary("sign", Math.sign),
+  unary("round", Math.round),
+  unary("floor", Math.floor),
+  unary("ceil", Math.ceil),
+  unary("sqrt", Math.sqrt),
+  unary("log", Math.log),
+  unary("log10", Math.log10),
+  unary("exp", Math.exp),
+  def("pow", [src("a"), src("b")], ["math"], (a, c) => zipValue(a[0], a[1], Math.pow, c.n)),
+  def("max", [src("a"), src("b")], ["math"], (a, c) => zipValue(a[0], a[1], Math.max, c.n)),
+  def("min", [src("a"), src("b")], ["math"], (a, c) => zipValue(a[0], a[1], Math.min, c.n)),
+  def("nz", [src("x"), { name: "replacement", kind: "series", default: 0 }], ["math"], (a, c) => {
+    const x = a[0];
+    const r = a[1];
+    if (typeof x === "number")
+      return Number.isFinite(x) ? x : r;
+    return x.map((v, i) => v != null ? v : typeof r === "number" ? Number.isFinite(r) ? r : null : r[i]);
+  }),
+  def("na", [src("x")], ["math"], (a, c) => {
+    const x = a[0];
+    if (typeof x === "number")
+      return Number.isFinite(x) ? 0 : 1;
+    return x.map((v) => v == null ? 1 : 0);
+  })
+];
+var BUILTINS = new Map(LIST.map((b) => [b.name, b]));
+var PINE_ALIASES = new Map([
+  ...[
+    "sma",
+    "ema",
+    "wma",
+    "rma",
+    "hma",
+    "vwma",
+    "rsi",
+    "roc",
+    "mom",
+    "stdev",
+    "dev",
+    "atr",
+    "tr",
+    "sar",
+    "linreg",
+    "correlation",
+    "highest",
+    "lowest",
+    "cum",
+    "change",
+    "crossover",
+    "crossunder",
+    "cross",
+    "barssince",
+    "valuewhen",
+    "pivothigh",
+    "pivotlow"
+  ].map((n) => [`ta.${n}`, n]),
+  ...["abs", "sign", "round", "floor", "ceil", "sqrt", "log", "log10", "exp", "pow", "max", "min", "sum"].map((n) => [`math.${n}`, n])
+]);
+var PINE_ARG_NAMES = /* @__PURE__ */ new Map([["source", "src"], ["length", "len"]]);
+var PINE_COLORS = new Map([
+  ["aqua", "#00BCD4"],
+  ["black", "#363A45"],
+  ["blue", "#2196F3"],
+  ["fuchsia", "#E040FB"],
+  ["gray", "#787B86"],
+  ["green", "#4CAF50"],
+  ["lime", "#00E676"],
+  ["maroon", "#880E4F"],
+  ["navy", "#311B92"],
+  ["olive", "#808000"],
+  ["orange", "#FF9800"],
+  ["purple", "#9C27B0"],
+  ["red", "#FF5252"],
+  ["silver", "#B2B5BE"],
+  ["teal", "#00897B"],
+  ["white", "#FFFFFF"],
+  ["yellow", "#FFEB3B"]
+].map(([k, v]) => [`color.${k}`, v]));
+var SERIES_NAMES = ["open", "high", "low", "close", "volume", "hl2", "hlc3", "ohlc4", "bar_index", "time"];
+function signature(b) {
+  const ps = b.params.map((p) => p.default !== void 0 && b.name !== "nz" ? `${p.name}=${p.default}` : p.name);
+  return `${b.name}(${ps.join(",")})${b.note !== void 0 ? ` (${b.note})` : ""}`;
+}
+var GROUPS = [
+  ["ma", "Moving averages"],
+  ["osc", "Oscillators"],
+  ["vol", "Volatility", "Bollinger via basis=sma(close,len) and stdev(close,len)."],
+  ["volume", "Volume"],
+  ["trend", "Trend"],
+  ["range", "Ranges/aggregates"],
+  ["signal", "Signals"],
+  ["pivot", "Pivots"],
+  ["math", "Math"]
+];
+function builtinReferenceLines() {
+  return GROUPS.map(([g, label, extra]) => {
+    const fns = LIST.filter((b) => b.groups.includes(g)).map(signature).join(", ");
+    return `${label}: ${fns}.${extra !== void 0 ? ` ${extra}` : ""}`;
+  });
+}
+
+// packages/superscript/src/runtime/diagnostics.ts
+var BRAND = Symbol.for("zzyzx.superscript.error");
+var SuperScriptError = class extends Error {
+  code;
+  line;
+  col;
+  endCol;
+  hint;
+  diagnostics;
+  constructor(diagnostic, diagnostics = [diagnostic]) {
+    super(`${diagnostic.message} (line ${diagnostic.line}, col ${diagnostic.col})${diagnostic.hint !== void 0 ? `; ${diagnostic.hint}` : ""}`);
+    this.name = "SuperScriptError";
+    this.code = diagnostic.code;
+    this.line = diagnostic.line;
+    this.col = diagnostic.col;
+    this.endCol = diagnostic.endCol;
+    if (diagnostic.hint !== void 0)
+      this.hint = diagnostic.hint;
+    this.diagnostics = diagnostics;
+    Object.defineProperty(this, BRAND, { value: true });
+  }
+};
+function isSuperScriptError(e) {
+  return typeof e === "object" && e !== null && e[BRAND] === true;
+}
+var DiagnosticThrow = class extends Error {
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.diagnostic = diagnostic;
+  }
+};
+function diag(severity, code, message, at, hint) {
+  const d = { severity, code, message, line: at.line, col: at.col, endCol: at.endCol };
+  if (hint !== void 0)
+    d.hint = hint;
+  return d;
+}
+function fail(code, message, at, hint) {
+  throw new DiagnosticThrow(diag("error", code, message, at, hint));
+}
+function formatDiagnostics(diagnostics, source) {
+  const lines = source?.split("\n");
+  return diagnostics.map((d) => {
+    let s = `line ${d.line}, col ${d.col}: ${d.severity} ${d.code}: ${d.message}`;
+    if (d.hint !== void 0)
+      s += ` (${d.hint})`;
+    const text = lines?.[d.line - 1];
+    if (text !== void 0) {
+      s += `
+  ${text.replace(/\r$/, "")}
+  ${" ".repeat(Math.max(d.col - 1, 0))}${"^".repeat(Math.max(d.endCol - d.col, 1))}`;
+    }
+    return s;
+  }).join("\n");
+}
+function closest(word, candidates) {
+  let best;
+  let bestD = 3;
+  const w = word.toLowerCase();
+  for (const c of candidates) {
+    const d = distance(w, c.toLowerCase(), bestD);
+    if (d < bestD) {
+      bestD = d;
+      best = c;
+    }
+  }
+  return best;
+}
+function distance(a, b, cap) {
+  if (Math.abs(a.length - b.length) >= cap)
+    return cap;
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    prev = cur;
+  }
+  return prev[b.length];
+}
+
+// packages/superscript/src/runtime/language.ts
+var TOKEN = /([ \t\r\f\v]+)|(\/\/[^\n]*)|(\n)|((?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)|("[^"\n]*"|'[^'\n]*')|(["'])|([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)|(#[0-9A-Fa-f]{3,8}(?![0-9A-Za-z_]))|(:=|\+=|-=|\*=|\/=|=>|==|!=|<=|>=|&&|\|\||[()[\],=+\-*/%<>!?:])/y;
+var DIRECTIVE_LINE = /[ \t]*@[^\n]*/y;
+function lex(source, diags) {
+  const tokens = [];
+  let line = 1;
+  let lineStart = 0;
+  let pos = 0;
+  let atLineStart = true;
+  while (pos < source.length) {
+    if (atLineStart) {
+      atLineStart = false;
+      DIRECTIVE_LINE.lastIndex = pos;
+      if (DIRECTIVE_LINE.exec(source) !== null) {
+        pos = DIRECTIVE_LINE.lastIndex;
+        continue;
+      }
+    }
+    const col = pos - lineStart + 1;
+    TOKEN.lastIndex = pos;
+    const m = TOKEN.exec(source);
+    if (m === null) {
+      const ch = String.fromCodePoint(source.codePointAt(pos) ?? 0);
+      diags.push(diag(
+        "error",
+        "UNEXPECTED_CHAR",
+        `unexpected character '${ch}'`,
+        { line, col, endCol: col + 1 },
+        ch === "^" ? "use pow(a, b) for powers" : ch === ";" ? "put one statement per line" : void 0
+      ));
+      pos += ch.length;
+      continue;
+    }
+    const text = m[0];
+    pos = TOKEN.lastIndex;
+    const at = { line, col, endCol: col + text.length };
+    if (m[1] !== void 0 || m[2] !== void 0)
+      continue;
+    if (m[3] !== void 0) {
+      tokens.push({ k: "nl", v: "\n", ...at });
+      line++;
+      lineStart = pos;
+      atLineStart = true;
+    } else if (m[4] !== void 0) {
+      tokens.push({ k: "num", v: text, ...at });
+    } else if (m[5] !== void 0) {
+      tokens.push({ k: "str", v: text.slice(1, -1), ...at });
+    } else if (m[6] !== void 0) {
+      diags.push(diag("error", "UNTERMINATED_STRING", "this string is never closed", at));
+      const end = source.indexOf("\n", pos);
+      pos = end < 0 ? source.length : end;
+    } else if (m[7] !== void 0) {
+      tokens.push({ k: "id", v: text, ...at });
+    } else if (m[8] !== void 0) {
+      tokens.push({ k: "color", v: text, ...at });
+    } else {
+      tokens.push({ k: "op", v: text, ...at });
+    }
+  }
+  return tokens;
+}
+var CONTINUES = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%", "<", ">", "<=", ">=", "==", "!=", "&&", "||", "?", ":", "=", ","]);
+function statements(tokens, diags) {
+  const out = [];
+  let cur = [];
+  const open = [];
+  for (const t of tokens) {
+    if (t.k === "nl") {
+      const prev = cur[cur.length - 1];
+      const cont = prev !== void 0 && (prev.k === "op" && CONTINUES.has(prev.v) || prev.k === "id" && (prev.v === "and" || prev.v === "or" || prev.v === "not"));
+      if (open.length > 0 || cont)
+        continue;
+      if (cur.length > 0)
+        out.push(cur);
+      cur = [];
+      continue;
+    }
+    if (t.k === "op" && (t.v === "(" || t.v === "["))
+      open.push(t);
+    else if (t.k === "op" && (t.v === ")" || t.v === "]") && open.length > 0)
+      open.pop();
+    cur.push(t);
+  }
+  if (open.length > 0) {
+    const o = open[0];
+    diags.push(diag("error", "UNBALANCED", `'${o.v}' is never closed`, o));
+  } else if (cur.length > 0) {
+    out.push(cur);
+  }
+  return out;
+}
+var CONTROL = /* @__PURE__ */ new Set(["if", "else", "for", "while", "switch", "return", "break", "continue"]);
+var TYPE_WORDS = /* @__PURE__ */ new Set(["float", "int", "bool", "string", "color", "series", "simple", "const"]);
+var REASSIGN = /* @__PURE__ */ new Set([":=", "+=", "-=", "*=", "/="]);
+var DECLARATIONS = /* @__PURE__ */ new Set(["indicator", "study", "strategy"]);
+var IGNORED_CALLS = /* @__PURE__ */ new Set(["plotshape", "plotchar", "plotarrow", "plotcandle", "plotbar", "bgcolor", "barcolor", "fill", "alertcondition", "alert"]);
+var IGNORED_PREFIXES = ["strategy.", "label.", "line.", "box.", "table.", "linefill.", "polyline.", "log.", "runtime."];
+var INPUTS = /* @__PURE__ */ new Set(["input", "input.int", "input.float"]);
+var COSMETIC_KW = /* @__PURE__ */ new Set(["editable", "display", "trackprice", "show_last", "join", "transp", "force_overlay", "format", "precision"]);
+var INPUT_COSMETIC_KW = /* @__PURE__ */ new Set(["tooltip", "group", "inline", "confirm", "display", "options"]);
+var PLOT_STYLES = /* @__PURE__ */ new Map([
+  ["plot.style_line", "line"],
+  ["plot.style_linebr", "line"],
+  ["plot.style_stepline", "line"],
+  ["plot.style_area", "line"],
+  ["plot.style_histogram", "histogram"],
+  ["plot.style_columns", "histogram"],
+  ["plot.style_circles", "circle"],
+  ["plot.style_cross", "circle"]
+]);
+var HLINE_STYLES = /* @__PURE__ */ new Map([
+  ["hline.style_dashed", "dashed"],
+  ["hline.style_dotted", "dotted"],
+  ["hline.style_solid", "solid"]
+]);
+var PREC = /* @__PURE__ */ new Map([["or", 1], ["||", 1], ["and", 2], ["&&", 2], ["==", 3], ["!=", 3], ["<", 4], ["<=", 4], [">", 4], [">=", 4], ["+", 5], ["-", 5], ["*", 6], ["/", 6], ["%", 6]]);
+var span = (a, b, fallback) => a.line === b.line && b.endCol >= a.col ? { line: a.line, col: a.col, endCol: b.endCol } : fallback;
+var MAX_NESTING = 200;
+var Parser = class {
+  constructor(toks, inputs) {
+    this.toks = toks;
+    this.inputs = inputs;
+  }
+  pos = 0;
+  depth = 0;
+  peek(o = 0) {
+    return this.toks[this.pos + o];
+  }
+  atEnd() {
+    return this.pos >= this.toks.length;
+  }
+  isOp(v, o = 0) {
+    const t = this.peek(o);
+    return t !== void 0 && t.k === "op" && t.v === v;
+  }
+  isId(v, o = 0) {
+    const t = this.peek(o);
+    return t !== void 0 && t.k === "id" && t.v === v;
+  }
+  next() {
+    const t = this.toks[this.pos];
+    if (t === void 0) {
+      const last = this.toks[this.toks.length - 1];
+      fail("UNEXPECTED_TOKEN", "unexpected end of the statement", { line: last.line, col: last.endCol, endCol: last.endCol + 1 });
+    }
+    this.pos++;
+    return t;
+  }
+  expect(v) {
+    const t = this.peek();
+    if (t === void 0 || t.k !== "op" || t.v !== v) {
+      if (t === void 0) {
+        const last = this.toks[this.toks.length - 1];
+        fail("UNEXPECTED_TOKEN", `expected '${v}' at the end of the statement`, { line: last.line, col: last.endCol, endCol: last.endCol + 1 });
+      }
+      fail("UNEXPECTED_TOKEN", `expected '${v}', found '${t.v}'`, t);
+    }
+    this.pos++;
+    return t;
+  }
+  /** Nothing may follow a complete statement. */
+  end() {
+    const t = this.peek();
+    if (t !== void 0) {
+      fail(
+        "TRAILING_TOKENS",
+        `unexpected '${t.v === "\n" ? "\\n" : t.v}' after the end of the statement`,
+        t,
+        t.k === "op" && t.v === "^" ? "use pow(a, b) for powers" : "put one statement per line; is an operator or a comma missing?"
+      );
+    }
+  }
+  /** Count one level of recursion; a script nested past MAX_NESTING is a diagnostic, not a stack overflow. */
+  enter(at) {
+    if (++this.depth > MAX_NESTING) {
+      const where = at ?? this.toks[this.toks.length - 1];
+      fail("UNSUPPORTED", `this expression is nested more than ${MAX_NESTING} levels deep`, where, "split it into several named steps");
+    }
+  }
+  expr() {
+    this.enter(this.peek());
+    const c = this.binary(1);
+    if (this.isOp("?")) {
+      const q = this.next();
+      const a = this.expr();
+      this.expect(":");
+      const b = this.expr();
+      this.depth--;
+      return { k: "tern", c, a, b, at: span(c.at, b.at, q) };
+    }
+    this.depth--;
+    return c;
+  }
+  binary(min) {
+    let l = this.unary();
+    for (; ; ) {
+      const t = this.peek();
+      if (t === void 0 || t.k !== "op" && t.k !== "id")
+        return l;
+      const p = PREC.get(t.v);
+      if (p === void 0 || p < min)
+        return l;
+      this.pos++;
+      const r = this.binary(p + 1);
+      l = { k: "bin", op: t.v === "and" ? "&&" : t.v === "or" ? "||" : t.v, l, r, at: span(l.at, r.at, t) };
+    }
+  }
+  unary() {
+    const t = this.peek();
+    if (t !== void 0 && (t.k === "op" && (t.v === "-" || t.v === "+" || t.v === "!") || t.k === "id" && t.v === "not")) {
+      this.pos++;
+      this.enter(t);
+      const arg = this.unary();
+      this.depth--;
+      return { k: "unary", op: t.v === "!" ? "not" : t.v, arg, at: span(t, arg.at, t) };
+    }
+    return this.postfix();
+  }
+  postfix() {
+    let e = this.primary();
+    while (this.isOp("[")) {
+      const open = this.next();
+      const offset = this.expr();
+      const close = this.expect("]");
+      e = { k: "index", target: e, offset, at: span(e.at, close, open) };
+    }
+    return e;
+  }
+  primary() {
+    const t = this.next();
+    switch (t.k) {
+      case "num":
+        return { k: "num", v: parseFloat(t.v), text: t.v, at: t };
+      case "str":
+        return { k: "str", v: t.v, at: t };
+      case "color":
+        return { k: "color", v: t.v, at: t };
+      case "op":
+        if (t.v === "(") {
+          const e = this.expr();
+          this.expect(")");
+          return e;
+        }
+        if (REASSIGN.has(t.v))
+          fail("REASSIGNMENT", `'${t.v}' is not supported`, t, reassignHint(t.v));
+        return fail("UNEXPECTED_TOKEN", `unexpected '${t.v}'`, t);
+      case "id": {
+        if (t.v === "true" || t.v === "false")
+          return { k: "num", v: t.v === "true" ? 1 : 0, text: t.v, at: t };
+        if (this.isOp("("))
+          return this.call(t);
+        if (t.v === "na")
+          return { k: "na", at: t };
+        const color = PINE_COLORS.get(t.v);
+        if (color !== void 0)
+          return { k: "color", v: color, at: t };
+        return { k: "id", name: t.v, at: t };
+      }
+      default:
+        return fail("UNEXPECTED_TOKEN", "unexpected end of line", t);
+    }
+  }
+  call(name) {
+    const node = { k: "call", name: name.v, args: [], kw: [], at: name };
+    if (INPUTS.has(name.v))
+      node.input = this.inputs.count++;
+    this.expect("(");
+    if (this.isOp(")")) {
+      this.next();
+      return node;
+    }
+    for (; ; ) {
+      const t = this.peek();
+      if (t !== void 0 && t.k === "id" && this.isOp("=", 1)) {
+        this.pos += 2;
+        node.kw.push({ name: t.v, value: this.expr(), at: t });
+      } else {
+        const e = this.expr();
+        if (node.kw.length > 0)
+          fail("UNEXPECTED_TOKEN", "a positional argument cannot follow a keyword argument", e.at);
+        node.args.push(e);
+      }
+      if (this.isOp(",")) {
+        this.next();
+        continue;
+      }
+      this.expect(")");
+      return node;
+    }
+  }
+};
+function reassignHint(op) {
+  return op === ":=" ? "SuperScript bindings are single-assignment series, so Pine's recursive `x := f(x[1])` cannot be expressed; bind a new name instead" : `write it out: x2 = x ${op[0]} \u2026`;
+}
+function directives(source) {
+  const title = /@title[ \t]+([^\n]+)/.exec(source);
+  const overlay = /(^|\n)[ \t]*(\/\/[ \t]*)?@overlay\b/.test(source);
+  const d = { overlay };
+  if (title !== null)
+    d.title = title[1].replace(/\r$/, "").trim();
+  return d;
+}
+function parse(source) {
+  const diagnostics = [];
+  const dir = directives(source);
+  const program = { statements: [], title: dir.title ?? "SuperScript", overlay: dir.overlay, inputIds: [], poisoned: /* @__PURE__ */ new Set(), diagnostics };
+  const inputs = { count: 0 };
+  const assignedInputs = /* @__PURE__ */ new Map();
+  const tokens = lex(source, diagnostics);
+  const badLines = new Set(diagnostics.map((d) => d.line));
+  for (const toks of statements(tokens, diagnostics)) {
+    const first = inputs.count;
+    if (toks.some((t) => badLines.has(t.line))) {
+      const target = toks.find((t, i) => t.k === "id" && toks[i + 1]?.k === "op" && toks[i + 1].v === "=");
+      if (target !== void 0)
+        program.poisoned.add(target.v);
+      continue;
+    }
+    try {
+      const st = statement(toks, new Parser(toks, inputs), program, dir, diagnostics);
+      if (st === null)
+        continue;
+      program.statements.push(st);
+      if (st.k === "assign" && st.value.k === "call" && st.value.input !== void 0)
+        assignedInputs.set(st.value.input, st.name);
+    } catch (e) {
+      if (!(e instanceof DiagnosticThrow))
+        throw e;
+      diagnostics.push(e.diagnostic);
+      inputs.count = first;
+      const target = toks.find((t, i) => t.k === "id" && toks[i + 1]?.k === "op" && (toks[i + 1].v === "=" || REASSIGN.has(toks[i + 1].v)));
+      if (target !== void 0)
+        program.poisoned.add(target.v);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < inputs.count; i++) {
+    let id = assignedInputs.get(i) ?? `in${i}`;
+    if (used.has(id))
+      id = `${id}_${i}`;
+    used.add(id);
+    program.inputIds.push(id);
+  }
+  return program;
+}
+function statement(toks, p, program, dir, diags) {
+  const arrow = toks.find((t) => t.k === "op" && t.v === "=>");
+  if (arrow !== void 0)
+    fail("FUNCTION_DEF", "function definitions are not supported", arrow, "inline the expression, or bind it to a name");
+  let t0 = toks[0];
+  if (t0.k === "id" && CONTROL.has(t0.v)) {
+    fail("CONTROL_FLOW", `'${t0.v}' is not supported`, t0, "SuperScript works on whole series: use cond ? a : b instead of if/else, and sum()/highest()/\u2026 instead of loops");
+  }
+  while (t0.k === "id" && (t0.v === "var" || t0.v === "varip" || TYPE_WORDS.has(t0.v)) && p.peek(1)?.k === "id") {
+    diags.push(diag("warning", "IGNORED_KEYWORD", `'${t0.v}' is ignored`, t0, t0.v.startsWith("var") ? "SuperScript bindings are series; var has no effect" : void 0));
+    p.next();
+    t0 = p.peek();
+  }
+  const t1 = p.peek(1);
+  if (t0.k === "id" && t1 !== void 0 && t1.k === "op" && REASSIGN.has(t1.v)) {
+    fail("REASSIGNMENT", `'${t1.v}' is not supported`, t1, reassignHint(t1.v));
+  }
+  if (t0.k === "id" && t1 !== void 0 && t1.k === "op" && t1.v === "=") {
+    if (SERIES_NAMES.includes(t0.v))
+      fail("BUILTIN_REASSIGNED", `'${t0.v}' is a built-in series and cannot be assigned`, t0, "bind a new name");
+    if (t0.v.includes(".") || t0.v === "na" || t0.v === "true" || t0.v === "false")
+      fail("UNEXPECTED_TOKEN", `'${t0.v}' cannot be assigned`, t0);
+    p.next();
+    p.next();
+    const value2 = p.expr();
+    p.end();
+    return { k: "assign", name: t0.v, value: value2, at: t0 };
+  }
+  if (t0.k === "id" && p.isOp("(", 1)) {
+    if (t0.v === "plot")
+      return plotStatement(p, diags);
+    if (t0.v === "hline")
+      return hlineStatement(p, diags);
+    if (DECLARATIONS.has(t0.v)) {
+      const call = p.primary();
+      p.end();
+      if (call.k === "call")
+        declaration(call, program, dir, diags);
+      return null;
+    }
+    if (IGNORED_CALLS.has(t0.v) || IGNORED_PREFIXES.some((x) => t0.v.startsWith(x))) {
+      diags.push(diag("warning", "IGNORED_STATEMENT", `${t0.v}() is not supported and is ignored`, t0));
+      return null;
+    }
+  }
+  const value = p.expr();
+  p.end();
+  diags.push(diag("warning", "UNUSED_EXPRESSION", "this expression is computed but not used", value.at, "bind it (x = \u2026) or draw it (plot(\u2026))"));
+  return { k: "expr", value, at: value.at };
+}
+function declaration(call, program, dir, diags) {
+  if (call.name === "strategy") {
+    diags.push(diag("warning", "IGNORED_STATEMENT", "strategy() is not supported; orders are ignored and the script runs as an indicator", call.at));
+  }
+  let title;
+  const a0 = call.args[0];
+  if (a0 !== void 0 && a0.k === "str")
+    title = a0.v;
+  const kw = call.kw.find((k) => k.name === "title")?.value;
+  if (kw !== void 0 && kw.k === "str")
+    title = kw.v;
+  if (dir.title === void 0 && title !== void 0)
+    program.title = title;
+  const ov = call.kw.find((k) => k.name === "overlay")?.value;
+  if (ov !== void 0 && ov.k === "num" && ov.v === 1)
+    program.overlay = true;
+}
+function colorOf(e, diags) {
+  if (e.k === "str" || e.k === "color")
+    return e.v;
+  if (e.k === "call" && e.name === "color.new") {
+    fail("UNSUPPORTED", "color.new() is not supported", e.at, 'write the colour with its alpha as "#rrggbbaa"');
+  }
+  diags.push(diag("warning", "IGNORED_KEYWORD", 'a colour must be a constant such as "#ff6d00" or color.red; the default colour is used', e.at));
+  return void 0;
+}
+function stringOf(e, what, diags) {
+  if (e.k === "str")
+    return e.v;
+  diags.push(diag("warning", "IGNORED_KEYWORD", `${what} must be a string; ignored`, e.at));
+  return void 0;
+}
+function plotStatement(p, diags) {
+  const call = p.primary();
+  p.end();
+  if (call.k !== "call")
+    return fail("UNEXPECTED_TOKEN", "expected plot(\u2026)", call.at);
+  const [value, title, color, lineWidth, style] = call.args;
+  if (value === void 0)
+    fail("ARITY", "plot() needs a value to draw", call.at);
+  if (call.args.length > 5)
+    fail("ARITY", "plot() takes at most 5 positional arguments (value, title, color, linewidth, style)", call.args[5].at);
+  const st = { k: "plot", value, style: {}, at: call.at };
+  const setType = (e) => {
+    const s = e.k === "str" ? e.v : e.k === "id" ? e.name : "";
+    const mapped = s === "line" || s === "histogram" || s === "circle" ? s : PLOT_STYLES.get(s);
+    if (mapped === void 0)
+      diags.push(diag("warning", "UNKNOWN_KEYWORD", `unknown plot type '${s}'; drawn as a line`, e.at, 'type="line", "histogram" or "circle"'));
+    else
+      st.style.type = mapped;
+  };
+  if (title !== void 0)
+    st.title = stringOf(title, "the title", diags);
+  if (color !== void 0)
+    st.style.color = colorOf(color, diags);
+  if (lineWidth !== void 0)
+    st.lineWidth = lineWidth;
+  if (style !== void 0)
+    setType(style);
+  const seen = /* @__PURE__ */ new Set();
+  for (const kw of call.kw) {
+    if (seen.has(kw.name))
+      fail("DUPLICATE_ARGUMENT", `'${kw.name}' is given twice`, kw.at);
+    seen.add(kw.name);
+    switch (kw.name) {
+      case "title":
+        st.title = stringOf(kw.value, "the title", diags);
+        break;
+      case "color":
+        st.style.color = colorOf(kw.value, diags);
+        break;
+      case "type":
+      case "style":
+        setType(kw.value);
+        break;
+      case "lineWidth":
+      case "linewidth":
+        st.lineWidth = kw.value;
+        break;
+      case "histbase":
+        st.histbase = kw.value;
+        break;
+      default:
+        if (!COSMETIC_KW.has(kw.name))
+          diags.push(diag("warning", "UNKNOWN_KEYWORD", `unknown plot() keyword '${kw.name}' is ignored`, kw.at, "plot(value, title=, color=, type=, lineWidth=, histbase=)"));
+    }
+  }
+  if (st.title === void 0)
+    delete st.title;
+  if (st.style.color === void 0)
+    delete st.style.color;
+  return st;
+}
+function hlineStatement(p, diags) {
+  const call = p.primary();
+  p.end();
+  if (call.k !== "call")
+    return fail("UNEXPECTED_TOKEN", "expected hline(\u2026)", call.at);
+  const [value, title, color] = call.args;
+  if (value === void 0)
+    fail("ARITY", "hline() needs a price", call.at);
+  if (call.args.length > 3)
+    fail("ARITY", "hline() takes at most 3 positional arguments (price, title, color)", call.args[3].at);
+  const st = { k: "hline", value, style: { lineStyle: "dashed" }, at: call.at };
+  if (title !== void 0)
+    st.title = stringOf(title, "the title", diags);
+  if (color !== void 0)
+    st.style.color = colorOf(color, diags);
+  for (const kw of call.kw) {
+    switch (kw.name) {
+      case "title":
+        st.title = stringOf(kw.value, "the title", diags);
+        break;
+      case "color":
+        st.style.color = colorOf(kw.value, diags);
+        break;
+      case "linestyle":
+      case "lineStyle": {
+        const v = kw.value.k === "id" ? HLINE_STYLES.get(kw.value.name) : kw.value.k === "str" ? kw.value.v : void 0;
+        if (v === "solid" || v === "dashed" || v === "dotted")
+          st.style.lineStyle = v;
+        else
+          diags.push(diag("warning", "UNKNOWN_KEYWORD", "unknown line style; dashed is used", kw.value.at));
+        break;
+      }
+      case "linewidth":
+      case "lineWidth":
+        st.lineWidth = kw.value;
+        break;
+      default:
+        if (!COSMETIC_KW.has(kw.name))
+          diags.push(diag("warning", "UNKNOWN_KEYWORD", `unknown hline() keyword '${kw.name}' is ignored`, kw.at));
+    }
+  }
+  if (st.title === void 0)
+    delete st.title;
+  if (st.style.color === void 0)
+    delete st.style.color;
+  return st;
+}
+var Poisoned = class extends Error {
+};
+var hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+var Evaluator = class {
+  constructor(program, bars, params, check2) {
+    this.program = program;
+    this.bars = bars;
+    this.params = params;
+    this.check = check2;
+    this.n = bars.length;
+    this.poisoned = new Set(program.poisoned);
+  }
+  n;
+  cache = /* @__PURE__ */ new Map();
+  vars = /* @__PURE__ */ new Map();
+  poisoned;
+  inputs = [];
+  diagnostics = [];
+  series(name) {
+    return this.base(name);
+  }
+  base(name) {
+    const hit = this.cache.get(name);
+    if (hit !== void 0)
+      return hit;
+    const f = (v) => v == null || !Number.isFinite(v) ? null : v;
+    const b = this.bars;
+    let s;
+    switch (name) {
+      case "open":
+        s = b.map((x) => f(x.open));
+        break;
+      case "high":
+        s = b.map((x) => f(x.high));
+        break;
+      case "low":
+        s = b.map((x) => f(x.low));
+        break;
+      case "close":
+        s = b.map((x) => f(x.close));
+        break;
+      case "volume":
+        s = b.map((x) => f(x.volume));
+        break;
+      case "hl2":
+        s = b.map((x) => f((x.high + x.low) / 2));
+        break;
+      case "hlc3":
+        s = b.map((x) => f((x.high + x.low + x.close) / 3));
+        break;
+      case "ohlc4":
+        s = b.map((x) => f((x.open + x.high + x.low + x.close) / 4));
+        break;
+      case "bar_index":
+        s = b.map((_x, i) => i);
+        break;
+      default:
+        s = b.map((x) => f(x.timestamp));
+    }
+    this.cache.set(name, s);
+    return s;
+  }
+  run() {
+    const plots = [];
+    for (const st of this.program.statements) {
+      try {
+        switch (st.k) {
+          case "assign":
+            this.vars.set(st.name, this.eval(st.value));
+            this.poisoned.delete(st.name);
+            break;
+          case "plot": {
+            const values = asSeries(this.eval(st.value), this.n);
+            const style = { ...st.style };
+            if (st.lineWidth !== void 0)
+              style.lineWidth = this.constant(st.lineWidth, "lineWidth");
+            if (st.histbase !== void 0)
+              style.histbase = this.constant(st.histbase, "histbase");
+            plots.push({ id: `p${plots.length}`, title: st.title ?? `plot ${plots.length + 1}`, values, style });
+            break;
+          }
+          case "hline": {
+            const price = this.eval(st.value);
+            if (typeof price !== "number")
+              fail("EXPECTED_CONSTANT", "hline() draws a constant price; use plot() for a series", st.value.at);
+            const style = { ...st.style };
+            if (st.lineWidth !== void 0)
+              style.lineWidth = this.constant(st.lineWidth, "linewidth");
+            plots.push({ id: `p${plots.length}`, title: st.title ?? "", values: asSeries(price, this.n), style, kind: "hline" });
+            break;
+          }
+          default:
+            this.eval(st.value);
+        }
+      } catch (e) {
+        if (st.k === "assign")
+          this.poisoned.add(st.name);
+        if (e instanceof Poisoned)
+          continue;
+        if (!(e instanceof DiagnosticThrow))
+          throw e;
+        if (!this.check)
+          throw new SuperScriptError(e.diagnostic);
+        this.diagnostics.push(e.diagnostic);
+      }
+    }
+    return { plots, inputs: this.inputs, diagnostics: this.diagnostics };
+  }
+  constant(e, what) {
+    const v = this.eval(e);
+    if (typeof v !== "number" || !Number.isFinite(v))
+      fail("EXPECTED_CONSTANT", `${what} must be a constant number`, e.at);
+    return v;
+  }
+  eval(e) {
+    switch (e.k) {
+      case "num":
+        return Number.isFinite(e.v) ? e.v : NaN;
+      case "str":
+        return fail("TYPE", "a string is only allowed as a title or a colour", e.at);
+      case "color":
+        return fail("TYPE", "a colour is only allowed as a plot()/hline() colour", e.at);
+      case "na":
+        return asSeries(NaN, this.n);
+      case "id":
+        return this.identifier(e.name, e.at);
+      case "index": {
+        const target = this.eval(e.target);
+        const off = this.eval(e.offset);
+        if (typeof off !== "number") {
+          fail("BAD_OFFSET", "a history offset must be a constant (a number, an input, or arithmetic on them)", e.offset.at, "offsets that vary bar by bar are not supported");
+        }
+        if (!Number.isInteger(off) || off < 0) {
+          fail("BAD_OFFSET", `a history offset must be a whole number >= 0, got ${off}`, e.offset.at, off < 0 ? "a negative offset would read future bars" : void 0);
+        }
+        return shift(asSeries(target, this.n), off);
+      }
+      case "unary": {
+        const v = this.eval(e.arg);
+        if (e.op === "-")
+          return typeof v === "number" ? -v : v.map((x) => x == null ? null : -x);
+        if (e.op === "+")
+          return v;
+        return typeof v === "number" ? Number.isNaN(v) ? NaN : v === 0 ? 1 : 0 : v.map((x) => x == null ? null : x === 0 ? 1 : 0);
+      }
+      case "bin": {
+        const l = this.eval(e.l);
+        const r = this.eval(e.r);
+        return zipValue(l, r, BINARY[e.op], this.n);
+      }
+      case "tern": {
+        const c = this.eval(e.c);
+        const a = this.eval(e.a);
+        const b = this.eval(e.b);
+        if (typeof c === "number") {
+          if (Number.isNaN(c))
+            return typeof a === "number" && typeof b === "number" ? NaN : asSeries(NaN, this.n);
+          return c !== 0 ? a : b;
+        }
+        const as = asSeries(a, this.n);
+        const bs = asSeries(b, this.n);
+        return c.map((cv, i) => cv == null ? null : cv !== 0 ? as[i] : bs[i]);
+      }
+      case "call":
+        return this.call(e);
+    }
+  }
+  identifier(name, at) {
+    const bound = this.vars.get(name);
+    if (bound !== void 0)
+      return bound;
+    if (this.poisoned.has(name))
+      throw new Poisoned();
+    if (SERIES_NAMES.includes(name))
+      return this.base(name);
+    if (name === "ta.tr")
+      return BUILTINS.get("tr").impl([], this);
+    if (name === "ta.obv")
+      return BUILTINS.get("obv").impl([], this);
+    if (name === "ta.vwap")
+      return fail("PINE_MISMATCH", "Pine's ta.vwap resets every session; SuperScript's vwap() is cumulative from the first bar", at, "write vwap() if that is what you want");
+    if (BUILTINS.has(name) || PINE_ALIASES.has(name))
+      return fail("TYPE", `'${name}' is a function: call it as ${name}(\u2026)`, at);
+    if (name.startsWith("color."))
+      return fail("TYPE", "a colour is only allowed as a plot()/hline() colour", at);
+    const guess = closest(name, [...SERIES_NAMES, ...this.vars.keys(), "na"]);
+    return fail("UNKNOWN_IDENTIFIER", `unknown identifier '${name}'`, at, guess !== void 0 ? `did you mean '${guess}'?` : void 0);
+  }
+  call(e) {
+    const name = e.name;
+    if (e.input !== void 0)
+      return this.input(e, e.input);
+    if (name === "plot" || name === "hline")
+      return fail("STATEMENT", `${name}() is a statement: put it on its own line`, e.at);
+    if (name.startsWith("input."))
+      return fail("UNSUPPORTED", `${name}() is not supported`, e.at, "only numeric inputs: input(), input.int(), input.float()");
+    if (name.startsWith("request."))
+      return fail("UNSUPPORTED", `${name}() is not supported`, e.at, "a script sees only the chart's own symbol and timeframe");
+    if (name === "color.new" || name.startsWith("color."))
+      return fail("TYPE", "a colour is only allowed as a plot()/hline() colour", e.at);
+    const pine = this.pineAdapter(e);
+    if (pine !== void 0)
+      return pine;
+    const b = BUILTINS.get(PINE_ALIASES.get(name) ?? name);
+    if (b === void 0) {
+      const guess = closest(name, [...BUILTINS.keys(), ...PINE_ALIASES.keys()]);
+      return fail("UNKNOWN_FUNCTION", `unknown function '${name}'`, e.at, guess !== void 0 ? `did you mean '${guess}'?` : void 0);
+    }
+    return this.callBuiltin(b, this.bind(b, e));
+  }
+  /** Pine calls whose SuperScript form takes different arguments: accepted only when the meaning is the same. */
+  pineAdapter(e) {
+    const isId = (x, id) => x !== void 0 && x.k === "id" && x.name === id;
+    const [a0, a1, a2, a3] = e.args;
+    switch (e.name) {
+      case "ta.cci":
+      case "ta.mfi": {
+        const target = e.name.slice(3);
+        if (e.args.length === 2 && e.kw.length === 0 && isId(a0, "hlc3"))
+          return this.callBuiltin(BUILTINS.get(target), [this.argument(BUILTINS.get(target), 0, a1)]);
+        return fail("PINE_MISMATCH", `SuperScript's ${target}(len) always uses hlc3`, e.at, target === "cci" ? "write cci(len) for hlc3, or (src - sma(src,len)) / (0.015 * dev(src,len)) for another source" : `write ${target}(len)`);
+      }
+      case "ta.stoch":
+        if (e.args.length === 4 && e.kw.length === 0 && isId(a0, "close") && isId(a1, "high") && isId(a2, "low"))
+          return this.callBuiltin(BUILTINS.get("stoch"), [this.argument(BUILTINS.get("stoch"), 0, a3)]);
+        return fail("PINE_MISMATCH", "SuperScript's stoch(len) is %K of close within high/low", e.at, "write stoch(len)");
+      case "ta.vwap":
+        return fail("PINE_MISMATCH", "Pine's ta.vwap resets every session; SuperScript's vwap() is cumulative from the first bar", e.at, "write vwap() if that is what you want");
+      default:
+        return void 0;
+    }
+  }
+  /** Positional and keyword arguments to one value per parameter (defaults filled). */
+  bind(b, e) {
+    const shown = `${b.name}(${b.params.map((p) => p.name).join(", ")})`;
+    if (e.args.length > b.params.length) {
+      fail("ARITY", `${b.name}() takes ${b.params.length === 0 ? "no arguments" : `at most ${b.params.length} (${b.params.map((p) => p.name).join(", ")})`}, got ${e.args.length}`, e.args[b.params.length].at, `write ${shown}`);
+    }
+    const given = b.params.map((_p, i) => e.args[i]);
+    for (const kw of e.kw) {
+      const pname = PINE_ARG_NAMES.get(kw.name) ?? kw.name;
+      const i = b.params.findIndex((p) => p.name === pname);
+      if (i < 0)
+        fail("UNKNOWN_ARGUMENT", `${b.name}() has no argument '${kw.name}'`, kw.at, `write ${shown}`);
+      if (given[i] !== void 0)
+        fail("DUPLICATE_ARGUMENT", `'${b.params[i].name}' is given twice`, kw.at);
+      given[i] = kw.value;
+    }
+    return b.params.map((p, i) => {
+      const g = given[i];
+      if (g === void 0) {
+        if (p.default !== void 0)
+          return p.default;
+        return fail("ARITY", `${b.name}() needs ${p.name}`, e.at, `write ${shown}`);
+      }
+      return this.argument(b, i, g);
+    });
+  }
+  argument(b, i, e) {
+    const p = b.params[i];
+    const v = this.eval(e);
+    if (p.kind === "series")
+      return v;
+    if (typeof v !== "number") {
+      const lengthOnly = b.params.length === 1 && (b.name === "cci" || b.name === "mfi" || b.name === "stoch" || b.name === "atr");
+      return fail(
+        "EXPECTED_CONSTANT",
+        `${b.name}()'s ${p.name} must be a constant (a number, an input, or arithmetic on them), not a series`,
+        e.at,
+        lengthOnly ? `SuperScript's ${b.name}() takes only the length: ${b.name}(len)` : void 0
+      );
+    }
+    if (p.kind === "number") {
+      if (!Number.isFinite(v))
+        fail("EXPECTED_CONSTANT", `${b.name}()'s ${p.name} must be a finite number`, e.at);
+      return v;
+    }
+    const min = p.kind === "count" ? 0 : p.min ?? 1;
+    if (!Number.isInteger(v) || v < min) {
+      fail("BAD_LENGTH", `${b.name}()'s ${p.name} must be a whole number >= ${min}, got ${Number.isNaN(v) ? "na" : v}`, e.at);
+    }
+    return v;
+  }
+  callBuiltin(b, args) {
+    return b.impl(args, this);
+  }
+  input(e, index) {
+    const at = e.at;
+    const [d, t] = e.args;
+    if (d === void 0)
+      fail("ARITY", `${e.name}() needs a default value`, at, `write ${e.name}(14, title="Length")`);
+    if (e.args.length > 2)
+      fail("ARITY", `${e.name}() takes at most 2 positional arguments (default, title)`, e.args[2].at, "pass minval=, maxval=, step= by keyword");
+    const num = (x, what) => {
+      const v = this.eval(x);
+      if (typeof v !== "number" || !Number.isFinite(v))
+        fail("EXPECTED_CONSTANT", `${e.name}()'s ${what} must be a constant number`, x.at);
+      return v;
+    };
+    const defval = num(d, "default");
+    let title;
+    if (t !== void 0) {
+      if (t.k !== "str")
+        fail("TYPE", `${e.name}()'s second argument is its title and must be a string`, t.at);
+      title = t.v;
+    }
+    const input = {
+      id: this.program.inputIds[index] ?? `in${index}`,
+      title: "",
+      defval,
+      type: e.name === "input.float" ? "float" : e.name === "input.int" ? "int" : d.k === "num" && /[.eE]/.test(d.text) ? "float" : Number.isInteger(defval) ? "int" : "float"
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const kw of e.kw) {
+      if (seen.has(kw.name))
+        fail("DUPLICATE_ARGUMENT", `'${kw.name}' is given twice`, kw.at);
+      seen.add(kw.name);
+      switch (kw.name) {
+        case "title":
+          if (title !== void 0)
+            fail("DUPLICATE_ARGUMENT", "the title is given twice", kw.at);
+          if (kw.value.k !== "str")
+            fail("TYPE", "title must be a string", kw.value.at);
+          title = kw.value.v;
+          break;
+        case "defval":
+          fail("DUPLICATE_ARGUMENT", "the default is given twice", kw.at);
+          break;
+        case "minval":
+          input.min = num(kw.value, "minval");
+          break;
+        case "maxval":
+          input.max = num(kw.value, "maxval");
+          break;
+        case "step":
+          input.step = num(kw.value, "step");
+          break;
+        default:
+          if (!INPUT_COSMETIC_KW.has(kw.name))
+            fail("UNKNOWN_ARGUMENT", `${e.name}() has no argument '${kw.name}'`, kw.at, `write ${e.name}(14, title="Length", minval=1, maxval=100, step=1)`);
+      }
+    }
+    input.title = title ?? input.id;
+    if (input.type === "int" && !Number.isInteger(input.defval))
+      input.type = "float";
+    this.inputs[index] = input;
+    return resolveParam(input, index, this.params);
+  }
+};
+var BINARY = {
+  "+": (x, y) => x + y,
+  "-": (x, y) => x - y,
+  "*": (x, y) => x * y,
+  "/": (x, y) => x / y,
+  "%": (x, y) => x % y,
+  "<": (x, y) => x < y ? 1 : 0,
+  "<=": (x, y) => x <= y ? 1 : 0,
+  ">": (x, y) => x > y ? 1 : 0,
+  ">=": (x, y) => x >= y ? 1 : 0,
+  "==": (x, y) => x === y ? 1 : 0,
+  "!=": (x, y) => x !== y ? 1 : 0,
+  "&&": (x, y) => x !== 0 && y !== 0 ? 1 : 0,
+  "||": (x, y) => x !== 0 || y !== 0 ? 1 : 0
+};
+function shift(s, n) {
+  if (n <= 0)
+    return s;
+  return s.map((_v, i) => i - n >= 0 ? s[i - n] : null);
+}
+function resolveParam(input, index, params) {
+  let v;
+  if (Array.isArray(params))
+    v = params[index];
+  else if (params !== void 0 && hasOwn(params, input.id))
+    v = params[input.id];
+  if (typeof v !== "number" || !Number.isFinite(v))
+    return input.defval;
+  if (input.type === "int")
+    v = Math.round(v);
+  if (input.min !== void 0)
+    v = Math.max(v, input.min);
+  if (input.max !== void 0)
+    v = Math.min(v, input.max);
+  return v;
+}
+function check(program) {
+  const ev = new Evaluator(program, [], void 0, true).run();
+  const diagnostics = [...program.diagnostics, ...ev.diagnostics];
+  if (diagnostics.every((d) => d.severity !== "error") && ev.plots.length === 0) {
+    diagnostics.push(diag("warning", "NO_PLOTS", "the script draws nothing", { line: 1, col: 1, endCol: 1 }, "add plot(\u2026)"));
+  }
+  diagnostics.sort((a, b) => a.line !== b.line ? a.line - b.line : a.col - b.col);
+  return { plots: ev.plots, inputs: ev.inputs, diagnostics };
+}
+function evaluate(program, bars, params) {
+  return new Evaluator(program, bars, params, false).run();
+}
+
+export {
+  BUILTINS,
+  PINE_ALIASES,
+  PINE_ARG_NAMES,
+  builtinReferenceLines,
+  SuperScriptError,
+  isSuperScriptError,
+  diag,
+  formatDiagnostics,
+  parse,
+  check,
+  evaluate
+};