@alphacharts/script 0.0.0-stage → 0.1.0

package/dist/sandbox-p2HPP8yl.js

@@ -0,0 +1,2416 @@
+import { a as e, d as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./builtins-BXxWK58s.js";
+import { SOURCE_NAMES as l, StudyEngine as u, describeJoin as d, resolveParams as f } from "@alphacharts/indicators";
+//#region src/diag.ts
+var p = class {
+	text;
+	starts = [0];
+	constructor(e) {
+		this.text = e;
+		for (let t = 0; t < e.length; t++) e.charCodeAt(t) === 10 && this.starts.push(t + 1);
+	}
+	at(e) {
+		let t = 0, n = this.starts.length - 1;
+		for (; t < n;) {
+			let r = t + n + 1 >>> 1;
+			this.starts[r] <= e ? t = r : n = r - 1;
+		}
+		return {
+			line: t + 1,
+			column: e - this.starts[t] + 1
+		};
+	}
+}, m = class {
+	max;
+	list = [];
+	map;
+	errors = 0;
+	constructor(e, t = 50) {
+		this.max = t, this.map = new p(e);
+	}
+	get errorCount() {
+		return this.errors;
+	}
+	error(e, t) {
+		this.add("error", e, t);
+	}
+	warn(e, t) {
+		this.add("warning", e, t);
+	}
+	add(e, t, n) {
+		if (this.errors > this.max) return;
+		e === "error" && (this.errors++, this.errors > this.max && (t = `too many errors; stopped after ${this.max}`));
+		let r = Math.max(n.to, n.from), i = this.map.at(n.from), a = this.map.at(r);
+		this.list.push({
+			severity: e,
+			message: t,
+			line: i.line,
+			column: i.column,
+			endLine: a.line,
+			endColumn: a.column,
+			from: n.from,
+			to: r
+		});
+	}
+}, h = class extends Error {
+	span;
+	kind;
+	constructor(e, t = null, n = "build") {
+		super(e), this.span = t, this.kind = n, this.name = "ScriptError";
+	}
+};
+function g(e) {
+	return `${e.line}:${e.column}: ${e.severity}: ${e.message}`;
+}
+//#endregion
+//#region src/parser.ts
+var _ = /* @__PURE__ */ new Set([
+	"int",
+	"float",
+	"bool",
+	"string",
+	"color"
+]), v = /* @__PURE__ */ new Set([
+	":=",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%="
+]), y = 100, b = class extends Error {}, x = class {
+	t;
+	rep;
+	p = 0;
+	depth = 0;
+	constructor(e, t) {
+		this.t = e, this.rep = t;
+	}
+	get tok() {
+		return this.t[this.p];
+	}
+	kind() {
+		return this.t[this.p].kind;
+	}
+	peek(e = 1) {
+		return this.t[Math.min(this.p + e, this.t.length - 1)];
+	}
+	next() {
+		let e = this.tok;
+		return e.kind !== "eof" && this.p++, e;
+	}
+	isOp(e, t = this.tok) {
+		return t.kind === "op" && t.text === e;
+	}
+	isKw(e, t = this.tok) {
+		return t.kind === "kw" && t.text === e;
+	}
+	fail(e, t = this.tok) {
+		throw this.rep.error(e, t.from === t.to && this.tok.kind === "newline" ? {
+			from: t.from,
+			to: t.from
+		} : t), new b();
+	}
+	expectOp(e, t = `"${e}"`) {
+		return this.isOp(e) || this.fail(`expected ${t}, found ${this.describe()}`), this.next();
+	}
+	describe(e = this.tok) {
+		switch (e.kind) {
+			case "eof": return "end of input";
+			case "newline": return "end of line";
+			case "indent": return "an unexpected indent";
+			case "dedent": return "end of block";
+			case "str": return "a string";
+			case "num": return `"${e.text}"`;
+			default: return `"${e.text}"`;
+		}
+	}
+	program() {
+		let e = [];
+		for (; this.tok.kind !== "eof";) this.tok.kind === "newline" ? this.next() : this.kind() === "indent" ? (this.rep.error("unexpected indent", this.tok), this.skipBlock()) : this.kind() === "dedent" ? this.next() : this.statementRecovering(e);
+		return { body: e };
+	}
+	statementRecovering(e) {
+		try {
+			e.push(this.statement());
+		} catch (e) {
+			if (!(e instanceof b)) throw e;
+			this.sync();
+		}
+	}
+	sync() {
+		for (; this.tok.kind !== "newline" && this.tok.kind !== "eof" && this.tok.kind !== "dedent";) this.next();
+		this.tok.kind === "newline" && this.next(), this.kind() === "indent" && this.skipBlock();
+	}
+	skipBlock() {
+		let e = 0;
+		do
+			this.kind() === "indent" ? e++ : this.kind() === "dedent" && e--, this.next();
+		while (e > 0 && this.tok.kind !== "eof");
+	}
+	endStatement() {
+		this.tok.kind === "newline" ? this.next() : this.tok.kind !== "eof" && this.tok.kind !== "dedent" && this.fail(`unexpected ${this.describe()}; expected end of line`);
+	}
+	block() {
+		this.tok.kind !== "newline" && this.fail(`expected end of line before the indented block, found ${this.describe()}`), this.next(), this.kind() !== "indent" && this.fail("expected an indented block"), this.next();
+		let e = [];
+		for (; this.kind() !== "dedent" && this.kind() !== "eof";) this.tok.kind === "newline" ? this.next() : this.kind() === "indent" ? (this.rep.error("unexpected indent", this.tok), this.skipBlock()) : this.statementRecovering(e);
+		return this.kind() === "dedent" && this.next(), e.length === 0 && this.rep.error("a block needs at least one statement", this.t[Math.max(0, this.p - 1)]), e;
+	}
+	statement() {
+		let e = this.tok;
+		if (e.kind === "ident" && e.text === "_reserved") throw new b();
+		if (this.isKw("if")) return this.ifStmt();
+		if (this.isKw("for")) return this.forStmt();
+		if (this.isKw("var")) return this.next(), this.declaration(e.from, !0);
+		if (e.kind === "ident") {
+			let t = this.peek();
+			if (_.has(e.text) && t.kind === "ident" && this.isOp("=", this.peek(2)) || this.isOp("=", t)) return this.declaration(e.from, !1);
+			if (t.kind === "op" && v.has(t.text)) {
+				this.next();
+				let t = this.next().text, n = this.expr(), r = this.tok.from;
+				return this.endStatement(), {
+					k: "assign",
+					name: e.text,
+					nameSpan: e,
+					op: t,
+					value: n,
+					from: e.from,
+					to: Math.max(n.to, r)
+				};
+			}
+		}
+		if (this.isOp("[")) {
+			let t = [];
+			for (this.next();;) {
+				this.tok.kind !== "ident" && this.fail(`expected a name, found ${this.describe()}`);
+				let e = this.next();
+				if (t.push({
+					name: e.text,
+					span: e
+				}), this.isOp(",")) this.next();
+				else break;
+			}
+			this.expectOp("]"), this.expectOp("=", "\"=\" (a tuple of names must be assigned)");
+			let n = this.expr();
+			return this.endStatement(), {
+				k: "tuple",
+				names: t,
+				init: n,
+				from: e.from,
+				to: n.to
+			};
+		}
+		let t = this.expr();
+		return t.k !== "call" && this.fail("this expression has no effect; a statement is a declaration, an assignment, if, for or a call", t), this.endStatement(), {
+			k: "expr",
+			expr: t,
+			from: t.from,
+			to: t.to
+		};
+	}
+	declaration(e, t) {
+		let n = null;
+		this.tok.kind === "ident" && _.has(this.tok.text) && this.peek().kind === "ident" && (n = this.next().text), this.tok.kind !== "ident" && this.fail(`expected a variable name, found ${this.describe()}`);
+		let r = this.next();
+		this.expectOp("=");
+		let i = this.expr();
+		return this.endStatement(), {
+			k: "decl",
+			isVar: t,
+			type: n,
+			name: r.text,
+			nameSpan: r,
+			init: i,
+			from: e,
+			to: i.to
+		};
+	}
+	ifStmt() {
+		let e = this.next(), t = this.expr(), n = this.block(), r = null;
+		return this.isKw("else") && (this.next(), r = this.isKw("if") ? [this.ifStmt()] : this.block()), {
+			k: "if",
+			cond: t,
+			then: n,
+			else: r,
+			from: e.from,
+			to: this.t[this.p - 1].to
+		};
+	}
+	forStmt() {
+		let e = this.next();
+		this.tok.kind !== "ident" && this.fail(`expected a loop variable name, found ${this.describe()}`);
+		let t = this.next();
+		this.expectOp("=");
+		let n = this.expr();
+		this.isKw("to") || this.fail(`expected "to", found ${this.describe()}`), this.next();
+		let r = this.expr(), i = null;
+		this.isKw("by") && (this.next(), i = this.expr());
+		let a = this.block();
+		return {
+			k: "for",
+			name: t.text,
+			nameSpan: t,
+			lo: n,
+			hi: r,
+			by: i,
+			body: a,
+			from: e.from,
+			to: this.t[this.p - 1].to
+		};
+	}
+	expr() {
+		++this.depth > y && this.fail("expression is nested too deeply");
+		try {
+			return this.ternary();
+		} finally {
+			this.depth--;
+		}
+	}
+	ternary() {
+		let e = this.or();
+		if (!this.isOp("?")) return e;
+		this.next();
+		let t = this.expr();
+		this.expectOp(":", "\":\" of the ternary");
+		let n = this.expr();
+		return {
+			k: "tern",
+			c: e,
+			a: t,
+			b: n,
+			from: e.from,
+			to: n.to
+		};
+	}
+	or() {
+		let e = this.and();
+		for (; this.isKw("or");) {
+			this.next();
+			let t = this.and();
+			e = {
+				k: "bin",
+				op: "or",
+				a: e,
+				b: t,
+				from: e.from,
+				to: t.to
+			};
+		}
+		return e;
+	}
+	and() {
+		let e = this.not();
+		for (; this.isKw("and");) {
+			this.next();
+			let t = this.not();
+			e = {
+				k: "bin",
+				op: "and",
+				a: e,
+				b: t,
+				from: e.from,
+				to: t.to
+			};
+		}
+		return e;
+	}
+	not() {
+		if (this.isKw("not")) {
+			let e = this.next();
+			++this.depth > y && this.fail("expression is nested too deeply");
+			try {
+				let t = this.not();
+				return {
+					k: "un",
+					op: "not",
+					x: t,
+					from: e.from,
+					to: t.to
+				};
+			} finally {
+				this.depth--;
+			}
+		}
+		return this.cmp();
+	}
+	cmp() {
+		let e = this.add(), t = this.tok;
+		if (t.kind === "op" && (t.text === "==" || t.text === "!=" || t.text === "<" || t.text === "<=" || t.text === ">" || t.text === ">=")) {
+			this.next();
+			let n = this.add(), r = {
+				k: "bin",
+				op: t.text,
+				a: e,
+				b: n,
+				from: e.from,
+				to: n.to
+			}, i = this.tok;
+			return i.kind === "op" && [
+				"==",
+				"!=",
+				"<",
+				"<=",
+				">",
+				">="
+			].includes(i.text) && this.fail("comparisons do not chain; combine them with 'and'", i), r;
+		}
+		return e;
+	}
+	add() {
+		let e = this.mul();
+		for (; this.isOp("+") || this.isOp("-");) {
+			let t = this.next().text, n = this.mul();
+			e = {
+				k: "bin",
+				op: t,
+				a: e,
+				b: n,
+				from: e.from,
+				to: n.to
+			};
+		}
+		return e;
+	}
+	mul() {
+		let e = this.unary();
+		for (; this.isOp("*") || this.isOp("/") || this.isOp("%");) {
+			let t = this.next().text, n = this.unary();
+			e = {
+				k: "bin",
+				op: t,
+				a: e,
+				b: n,
+				from: e.from,
+				to: n.to
+			};
+		}
+		return e;
+	}
+	unary() {
+		if (this.isOp("-") || this.isOp("+")) {
+			let e = this.next();
+			++this.depth > y && this.fail("expression is nested too deeply");
+			try {
+				let t = this.unary();
+				return {
+					k: "un",
+					op: e.text,
+					x: t,
+					from: e.from,
+					to: t.to
+				};
+			} finally {
+				this.depth--;
+			}
+		}
+		return this.postfix();
+	}
+	postfix() {
+		let e = this.primary();
+		for (;;) if (this.isOp("(")) {
+			this.next();
+			let t = this.args(), n = this.expectOp(")", "\")\" to close the call");
+			e = {
+				k: "call",
+				callee: e,
+				args: t,
+				from: e.from,
+				to: n.to
+			};
+		} else if (this.isOp("[")) {
+			this.next();
+			let t = this.expr(), n = this.expectOp("]", "\"]\" to close the index");
+			e = {
+				k: "idx",
+				x: e,
+				i: t,
+				from: e.from,
+				to: n.to
+			};
+		} else if (this.isOp(".")) {
+			this.next(), this.tok.kind !== "ident" && this.fail(`expected a name after ".", found ${this.describe()}`);
+			let t = this.next();
+			e = {
+				k: "mem",
+				obj: e,
+				name: t.text,
+				nameSpan: t,
+				from: e.from,
+				to: t.to
+			};
+		} else return e;
+	}
+	args() {
+		let e = [];
+		if (this.isOp(")")) return e;
+		for (;;) {
+			if (this.tok.kind === "ident" && this.isOp("=", this.peek())) {
+				let t = this.next();
+				this.next(), e.push({
+					name: t.text,
+					nameSpan: t,
+					value: this.expr()
+				});
+			} else {
+				let t = this.expr();
+				e.push({
+					name: null,
+					value: t
+				});
+			}
+			if (this.isOp(",")) this.next();
+			else return e;
+		}
+	}
+	primary() {
+		let e = this.tok;
+		switch (e.kind) {
+			case "num": return this.next(), {
+				k: "num",
+				value: e.value,
+				float: /[.eE]/.test(e.text),
+				from: e.from,
+				to: e.to
+			};
+			case "str": return this.next(), {
+				k: "str",
+				value: e.text,
+				from: e.from,
+				to: e.to
+			};
+			case "color": return this.next(), {
+				k: "color",
+				value: e.text,
+				from: e.from,
+				to: e.to
+			};
+			case "ident": return this.next(), {
+				k: "id",
+				name: e.text,
+				from: e.from,
+				to: e.to
+			};
+			case "kw":
+				if (e.text === "true" || e.text === "false") return this.next(), {
+					k: "bool",
+					value: e.text === "true",
+					from: e.from,
+					to: e.to
+				};
+				break;
+			case "op":
+				if (e.text === "(") {
+					this.next();
+					let t = this.expr(), n = this.expectOp(")", "\")\"");
+					return {
+						...t,
+						from: e.from,
+						to: n.to
+					};
+				}
+				if (e.text === "[") {
+					this.next();
+					let t = [];
+					if (!this.isOp("]")) for (; t.push(this.expr()), this.isOp(",");) this.next();
+					let n = this.expectOp("]", "\"]\"");
+					return {
+						k: "arr",
+						items: t,
+						from: e.from,
+						to: n.to
+					};
+				}
+		}
+		this.fail(`expected an expression, found ${this.describe()}`);
+	}
+};
+function S(e, n) {
+	return new x(t(e, n), n).program();
+}
+//#endregion
+//#region src/limits.ts
+var C = Object.freeze({
+	maxPeriod: 5e3,
+	maxLoopIterations: 1e4,
+	maxSteps: 2e6,
+	maxColumns: 512,
+	maxBytes: 536870912,
+	maxBars: 1e7,
+	maxFeeds: 8,
+	maxSourceChars: 2e5,
+	batchMs: 8e3,
+	tickMs: 1e3
+}), w = 1e6, T = {
+	m: 6e4,
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+}, E = /^([1-9][0-9]{0,2})([mhdw])$/;
+function D(e) {
+	let t = E.exec(e);
+	return t ? Number(t[1]) * T[t[2]] : null;
+}
+function O(e, t) {
+	return `${e ?? ""}\u0001${t ?? ""}`;
+}
+function k(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = O(n.symbol, n.timeframe), r = t.get(e);
+		r || t.set(e, r = {
+			key: e,
+			symbol: n.symbol,
+			timeframe: n.timeframe,
+			fields: []
+		}), r.fields.includes(n.field) || r.fields.push(n.field);
+	}
+	return [...t.values()];
+}
+function A(e, t) {
+	if (!(Number.isFinite(t) && t > 0)) throw RangeError(`the chart's bar length must be a positive number of milliseconds, got ${String(t)}`);
+	if (e === null) return {
+		align: "same",
+		spanMs: t
+	};
+	let n = D(e);
+	if (n === null) throw RangeError(`timeframe "${e}" is not written like 5m, 1h, 1d or 1w`);
+	if (n < t) throw RangeError(`timeframe "${e}" is shorter than the chart's bars; an outside series must be on the chart's timeframe or a longer one`);
+	return n === t ? {
+		align: "same",
+		spanMs: n
+	} : {
+		align: "closed",
+		spanMs: n
+	};
+}
+//#endregion
+//#region src/check.ts
+var j = {
+	b: "na",
+	q: "const"
+};
+function M(...e) {
+	let t = "~";
+	for (let n of e) if (n !== "~") {
+		if (t === "~") t = n;
+		else if (t !== n) return "@";
+	}
+	return t;
+}
+var N = {
+	value: 0,
+	ohlc: 1,
+	ohlcv: 2
+}, P = {
+	const: 0,
+	input: 1,
+	series: 2
+}, F = (...e) => e.reduce((e, t) => P[t] > P[e] ? t : e, "const"), I = (e) => e.b === "int" || e.b === "float" || e.b === "na", L = (e) => e.q !== "series", R = (e) => e === j ? "na" : e.b === "tuple" ? `a tuple of ${e.elems.length} values (destructure it: [a, b] = ...)` : `${L(e) && e.b !== "na" || e.b === "na" ? "" : "series "}${e.b}`, z = class {
+	parent;
+	names = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.parent = e;
+	}
+	find(e) {
+		for (let t = this; t; t = t.parent) {
+			let n = t.names.get(e);
+			if (n) return n;
+		}
+	}
+};
+function B(e, t) {
+	for (let n of e) n.k === "assign" ? t.add(n.name) : n.k === "if" ? (B(n.then, t), n.else && B(n.else, t)) : n.k === "for" && B(n.body, t);
+}
+var V = (e) => e.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""), H = class {
+	rep;
+	limits;
+	plan = {
+		title: "Script",
+		overlay: !1,
+		scale: "right",
+		dependencies: [],
+		inputs: [],
+		plots: [],
+		body: [],
+		needs: "value",
+		slots: 0,
+		stateVars: []
+	};
+	scope = new z(null);
+	assigned = /* @__PURE__ */ new Set();
+	depth = 0;
+	sawIndicator = !1;
+	keys = /* @__PURE__ */ new Set();
+	loops = 0;
+	constructor(e, t = C) {
+		this.rep = e, this.limits = t;
+	}
+	err(e, t) {
+		this.rep.error(e, t);
+	}
+	need(e) {
+		N[e] > N[this.plan.needs] && (this.plan.needs = e);
+	}
+	run(e) {
+		B(e.body, this.assigned);
+		for (let t of e.body) this.stmt(t, !0);
+		this.plan.body = e.body;
+		let t = this.plan.plots.find((e) => e.kind === "bgcolor");
+		return t && !this.plan.overlay && !this.plan.plots.some((e) => e.kind === "line" || e.kind === "histogram" || e.kind === "area") && this.err("bgcolor shades the pane the script draws in, and with overlay=false the script has a pane only if it plots a line, histogram or area: add a plot(...), or use indicator(..., overlay=true) to shade the price chart", t.span), this.plan;
+	}
+	declare(t, n, r) {
+		this.scope.find(t) ? this.err(`"${t}" is already declared`, r) : Object.prototype.hasOwnProperty.call(c, t) || e.has(t) || t === "na" || t === "nz" || a.has(t) ? this.err(`"${t}" is a built-in name and cannot be redeclared`, r) : (n.decl = r, this.scope.names.set(t, n));
+	}
+	slot() {
+		return this.plan.slots++;
+	}
+	stmt(e, t) {
+		switch (e.k) {
+			case "decl": return this.decl(e, t);
+			case "tuple": return this.tupleDecl(e, t);
+			case "assign": return this.assign(e);
+			case "if": return this.ifStmt(e);
+			case "for": return this.forStmt(e);
+			case "expr": {
+				let n = e.expr;
+				this.call(n, t ? "stmt" : "expr-block");
+				return;
+			}
+		}
+	}
+	decl(e, t) {
+		if (e.isVar && !t && this.err("'var' is only allowed at the top level of the script", e), e.init.k === "call" && this.calleeName(e.init) !== null && this.calleeName(e.init).startsWith("input.")) {
+			if (!t || e.isVar) {
+				this.err("input.* may only declare a top-level variable", e.init), this.skipInputArgs(e.init);
+				return;
+			}
+			this.inputDecl(e);
+			return;
+		}
+		let n = e.init.k === "call" ? this.calleeName(e.init) : null;
+		if (n === "plot" || n === "hline") {
+			if (!t) {
+				this.err(`${n}() is only allowed at the top level of the script`, e.init);
+				return;
+			}
+			(e.isVar || e.type) && this.err("a plot handle cannot be declared var or typed", e), this.call(e.init, "decl");
+			let i = {
+				name: e.name,
+				kind: "plot",
+				ty: r("plot"),
+				key: String(this.plan.plots.length - 1)
+			};
+			this.declare(e.name, i, e.nameSpan), e.sym = i;
+			return;
+		}
+		let i = this.expr(e.init), a = i;
+		if (i.b === "void" && (this.err("this expression has no value", e.init), a = j), i.b === "plot" && (this.err("a plot handle can only come from plot() or hline()", e.init), a = j), i.b === "tuple" && (this.err(`this call returns ${i.elems.length} values; destructure them: [a, b, ...] = ...`, e.init), a = j), e.type) {
+			let t = r(e.type, "const");
+			if (a !== j && !this.assignable(t, a)) {
+				if (t.b === "int" && a.b === "float") {
+					let t = ` (declare it float: float ${e.name} = 0.0, or var float ${e.name} = 0.0; there is no int() conversion)`;
+					this.err(`cannot assign ${R(a)} to ${e.type} "${e.name}"${t}`, e.init);
+				} else this.err(`cannot assign ${R(a)} to ${e.type} "${e.name}"`, e.init);
+			}
+			a = {
+				b: t.b,
+				q: a === j ? "series" : a.q
+			};
+		} else a.b === "na" && a !== j && (this.err(`cannot infer the type of "${e.name}" from na; declare it, e.g. float ${e.name} = na`, e.init), a = j);
+		let o = this.assigned.has(e.name);
+		if (t) {
+			if (e.isVar || o || e.init.st) {
+				let t = {
+					name: e.name,
+					kind: "state",
+					ty: {
+						b: a.b,
+						q: "series"
+					},
+					isVar: e.isVar,
+					slot: this.slot()
+				};
+				this.declare(e.name, t, e.nameSpan), e.sym = t, this.plan.stateVars.push(t);
+			} else {
+				let t = {
+					name: e.name,
+					kind: L(a) ? "simple" : "pure",
+					ty: a
+				};
+				t.kind === "pure" && (t.dom = e.init.dom ?? "@"), this.declare(e.name, t, e.nameSpan), e.sym = t;
+			}
+		} else {
+			let t = {
+				name: e.name,
+				kind: "local",
+				ty: {
+					b: a.b,
+					q: "series"
+				},
+				slot: this.slot()
+			};
+			this.declare(e.name, t, e.nameSpan), e.sym = t;
+		}
+	}
+	tupleDecl(e, t) {
+		if (!t) {
+			this.err("destructuring is only allowed at the top level of the script", e);
+			return;
+		}
+		let n = this.expr(e.init);
+		if (e.syms = [], n === j) for (let t of e.names) this.declare(t.name, {
+			name: t.name,
+			kind: "pure",
+			ty: o
+		}, t.span);
+		else if (n.b !== "tuple") {
+			this.err("only calls that return several values can be destructured", e.init);
+			for (let t of e.names) this.declare(t.name, {
+				name: t.name,
+				kind: "pure",
+				ty: o
+			}, t.span);
+		} else n.elems.length !== e.names.length && this.err(`this call returns ${n.elems.length} values, ${e.names.length} names given`, e), e.names.forEach((t, r) => {
+			this.assigned.has(t.name) && this.err(`"${t.name}" is destructured from a call and cannot be assigned with :=`, t.span);
+			let i = {
+				name: t.name,
+				kind: "pure",
+				ty: n.elems[r] ?? o,
+				dom: e.init.dom ?? "@"
+			};
+			this.declare(t.name, i, t.span), e.syms.push(i);
+		});
+	}
+	assign(e) {
+		let t = this.scope.find(e.name), n = this.expr(e.value);
+		if (!t) {
+			this.err(`"${e.name}" is not declared; declare it first with ${e.name} = ...`, e.nameSpan);
+			return;
+		}
+		if (e.sym = t, t.kind !== "state" && t.kind !== "local") {
+			let n = t.kind === "loop" ? "a loop counter" : t.kind === "input" ? "an input" : t.kind === "builtin" ? "a built-in series" : "not assignable here";
+			this.err(`cannot assign to "${e.name}": it is ${n}`, e.nameSpan);
+			return;
+		}
+		if (n === j) return;
+		let r = n;
+		if (e.op !== ":=") {
+			if (!I(t.ty) || !I(n)) {
+				this.err(`"${e.op}" needs numbers, got ${R(t.ty)} and ${R(n)}`, e);
+				return;
+			}
+			r = {
+				b: t.ty.b === "int" && n.b === "int" && e.op !== "/=" ? "int" : "float",
+				q: "series"
+			};
+		}
+		if (!this.assignable(t.ty, r)) {
+			if (t.ty.b === "int" && r.b === "float") {
+				let n = ` (declare it float: float ${e.name} = 0.0, or var float ${e.name} = 0.0; there is no int() conversion)`;
+				this.err(`cannot assign ${R(r)} to ${t.ty.b} "${e.name}"${n}`, e.value);
+			} else this.err(`cannot assign ${R(r)} to ${t.ty.b} "${e.name}"`, e.value);
+		}
+	}
+	ifStmt(e) {
+		let t = this.expr(e.cond);
+		t !== j && t.b !== "bool" && this.err(`the condition of if must be bool, got ${R(t)}`, e.cond), this.block(e.then), e.else && this.block(e.else);
+	}
+	block(e) {
+		let t = this.scope;
+		this.scope = new z(t), this.depth++;
+		for (let t of e) this.stmt(t, !1);
+		this.depth--, this.scope = t;
+	}
+	forStmt(e) {
+		let t = this.expr(e.lo), n = this.expr(e.hi), r = e.by ? this.expr(e.by) : null;
+		for (let [i, a] of [
+			[t, e.lo],
+			[n, e.hi],
+			[r, e.by]
+		]) i && i !== j && i.b !== "int" && this.err(`a loop bound must be an int, got ${R(i)}`, a);
+		let i = (e) => e === null ? 1 : e.k === "num" ? e.value : e.k === "un" && e.op === "-" && e.x.k === "num" ? -e.x.value : void 0, a = i(e.lo), o = i(e.hi), s = i(e.by);
+		if (s === 0 && this.err("the loop step cannot be 0", e.by), a !== void 0 && o !== void 0 && s !== void 0 && s !== 0) {
+			let t = e.by ? Math.abs(s) : 1, n = Math.floor(Math.abs(o - a) / t) + 1;
+			n > this.limits.maxLoopIterations && this.err(`this loop runs ${n} times; the limit is ${this.limits.maxLoopIterations} iterations per loop`, e);
+		}
+		this.loops++;
+		let c = this.scope;
+		this.scope = new z(c);
+		let l = {
+			name: e.name,
+			kind: "loop",
+			ty: {
+				b: "int",
+				q: "series"
+			},
+			slot: this.slot()
+		};
+		this.declare(e.name, l, e.nameSpan), e.sym = l, this.depth++;
+		for (let t of e.body) this.stmt(t, !1);
+		this.depth--, this.scope = c;
+	}
+	assignable(e, t) {
+		return t === j || e === j || t.b === "na" || e.b === t.b || e.b === "float" && t.b === "int";
+	}
+	expr(e) {
+		let t = this.expr_(e);
+		return e.ty = t, e.dom = this.domOf(e), t;
+	}
+	domOf(e) {
+		if (e.ty === j || e.st) return "@";
+		switch (e.k) {
+			case "num":
+			case "str":
+			case "bool":
+			case "color":
+			case "arr": return "~";
+			case "mem": return e.obj.k === "id" && e.obj.name === "ta" && e.name === "tr" ? "@" : "~";
+			case "id": {
+				let t = e.sym;
+				return !t || t.kind === "simple" ? "~" : t.kind === "input" ? t.ty.b === "float" && t.ty.q === "series" ? "@" : "~" : t.kind === "pure" ? t.dom ?? "@" : "@";
+			}
+			case "un": return e.x.dom ?? "@";
+			case "bin": return M(e.a.dom ?? "@", e.b.dom ?? "@");
+			case "tern": return M(e.c.dom ?? "@", e.a.dom ?? "@", e.b.dom ?? "@");
+			case "idx": return M(e.x.dom ?? "@", e.i.dom ?? "@");
+			case "call": {
+				if (e.fn === "outside") return e.own && e.feed ? e.feed : "@";
+				let t = e.fn ? a.get(e.fn) : void 0;
+				if (!t || !e.bound) return "@";
+				let n = [];
+				t.params.forEach((t, r) => {
+					let i = e.bound[r];
+					i && t.kind === "series" && n.push(i.dom ?? "@");
+				});
+				let r = M(...n);
+				return r === "~" && (t.op === "kernel" || t.op === "study" || t.name === "ta.bb") ? "@" : r;
+			}
+		}
+	}
+	expr_(e) {
+		switch (e.k) {
+			case "num": return r(e.float || !Number.isInteger(e.value) ? "float" : "int");
+			case "str": return r("string");
+			case "bool": return r("bool");
+			case "color": return r("color");
+			case "arr": return this.err("array values are only allowed as options=[...] of input.string", e), j;
+			case "id": return this.ident(e);
+			case "mem": return this.member(e);
+			case "un": return this.unary(e);
+			case "bin": return this.binary(e);
+			case "tern": return this.ternary(e);
+			case "idx": return this.index(e);
+			case "call": return this.call(e, "expr");
+		}
+	}
+	ident(t) {
+		let n = this.scope.find(t.name);
+		if (n) return t.sym = n, (n.kind === "state" || n.kind === "local" || n.kind === "loop") && (t.st = !0), n.ty;
+		let i = c[t.name];
+		return i ? (this.need(i.needs), t.sym = {
+			name: t.name,
+			kind: "builtin",
+			ty: i.ty,
+			key: t.name
+		}, i.ty) : t.name === "na" ? r("na") : e.has(t.name) ? (this.err(`"${t.name}" is a namespace; use ${t.name}.<name>`, t), j) : a.has(t.name) ? (this.err(`"${t.name}" is a function; call it: ${t.name}(...)`, t), j) : (this.err(`unknown name "${t.name}"`, t), j);
+	}
+	member(t) {
+		if (t.obj.k !== "id" || !e.has(t.obj.name) || this.scope.find(t.obj.name)) return this.err("only namespace names can be followed by '.'", t), j;
+		let r = `${t.obj.name}.${t.name}`, i = n[r];
+		return i ? (t.cv = i.value, i.ty) : r === "ta.tr" ? (this.need("ohlc"), s) : a.has(r) ? (this.err(`"${r}" is a function; call it: ${r}(...)`, t), j) : (this.err(`unknown name "${r}"`, t.nameSpan), j);
+	}
+	unary(e) {
+		let t = this.expr(e.x);
+		return e.st = e.x.st ?? !1, t === j ? j : e.op === "not" ? t.b === "bool" ? t : (this.err(`"not" needs a bool, got ${R(t)}`, e), j) : I(t) ? t.b === "na" ? {
+			b: "float",
+			q: t.q
+		} : t : (this.err(`unary "${e.op}" needs a number, got ${R(t)}`, e), j);
+	}
+	binary(e) {
+		let t = this.expr(e.a), n = this.expr(e.b);
+		if (e.st = !!(e.a.st || e.b.st), t === j || n === j) return j;
+		let r = F(t.q, n.q);
+		switch (e.op) {
+			case "and":
+			case "or": return t.b !== "bool" || n.b !== "bool" ? (this.err(`"${e.op}" needs bool operands, got ${R(t)} and ${R(n)}`, e), j) : {
+				b: "bool",
+				q: r
+			};
+			case "==":
+			case "!=": return I(t) && I(n) || t.b === n.b && (t.b === "bool" || t.b === "string" || t.b === "color") ? (t.b === "string" || t.b === "color") && r === "series" ? (this.err("strings and colors can only be compared as constants or inputs", e), j) : {
+				b: "bool",
+				q: r
+			} : (this.err(`cannot compare ${R(t)} with ${R(n)}`, e), j);
+			case "<":
+			case "<=":
+			case ">":
+			case ">=": return !I(t) || !I(n) ? (this.err(`"${e.op}" needs numbers, got ${R(t)} and ${R(n)}`, e), j) : {
+				b: "bool",
+				q: r
+			};
+			default: return !I(t) || !I(n) ? (this.err(`"${e.op}" needs numbers, got ${R(t)} and ${R(n)}${t.b === "bool" || n.b === "bool" ? " (a bool is not a number: use a ternary)" : ""}`, e), j) : {
+				b: t.b === "int" && n.b === "int" && e.op !== "/" ? "int" : "float",
+				q: r
+			};
+		}
+	}
+	ternary(e) {
+		let t = this.expr(e.c), n = this.expr(e.a), r = this.expr(e.b);
+		if (e.st = !!(e.c.st || e.a.st || e.b.st), t !== j && t.b !== "bool" && this.err(`the condition of ?: must be bool, got ${R(t)}`, e.c), n === j || r === j) return j;
+		let i = F(t === j ? "const" : t.q, n.q, r.q);
+		return n.b === "na" ? {
+			b: r.b,
+			q: i
+		} : r.b === "na" ? {
+			b: n.b,
+			q: i
+		} : I(n) && I(r) ? {
+			b: n.b === "int" && r.b === "int" ? "int" : "float",
+			q: i
+		} : n.b === "string" && r.b === "string" && i === "series" ? (this.err("a string cannot depend on a series: the condition of ?: must be a constant or an input (a string is a label, not a value that changes per bar)", e), j) : n.b === r.b ? {
+			b: n.b,
+			q: i
+		} : (this.err(`the branches of ?: have different types: ${R(n)} and ${R(r)}`, e), j);
+	}
+	historyOk(e) {
+		return !e.st || e.k === "id" && e.sym?.kind === "state";
+	}
+	index(e) {
+		let t = this.expr(e.x), n = this.expr(e.i);
+		if (e.st = !!(e.x.st || e.i.st), t === j || n === j) return j;
+		if (t.q !== "series" || !(I(t) || t.b === "bool")) return this.err(`only a series can be indexed with [ ], this is ${R(t)}`, e.x), j;
+		if (n.b !== "int") return this.err(`the history offset must be an int, got ${R(n)}`, e.i), j;
+		if (!this.historyOk(e.x)) return this.err("history [ ] needs a plain series or a top-level variable; a block variable, loop counter or an expression of those has no earlier values. Assign the value to a top-level variable first", e.x), j;
+		let r = e.i.k === "num" ? e.i.value : e.i.k === "un" && e.i.op === "-" && e.i.x.k === "num" ? -e.i.x.value : void 0;
+		return r !== void 0 && (r < 0 || r > 1e6) && this.err(`the history offset must be between 0 and ${w}, got ${r}`, e.i), {
+			b: t.b,
+			q: "series"
+		};
+	}
+	calleeName(e) {
+		return e.callee.k === "id" ? e.callee.name : e.callee.k === "mem" && e.callee.obj.k === "id" ? `${e.callee.obj.name}.${e.callee.name}` : null;
+	}
+	skipInputArgs(e) {
+		for (let t of e.args) this.expr(t.value);
+	}
+	bind(e, t) {
+		let n = e.params.map(() => null), r = 0, i = !1;
+		for (let a of t.args) if (a.name === null) {
+			if (i) {
+				this.err("positional arguments must come before named ones", a.value);
+				continue;
+			}
+			if (r >= e.params.length) return this.err(`${e.name} takes at most ${e.params.length} argument${e.params.length === 1 ? "" : "s"}, got ${t.args.length}`, a.value), n;
+			n[r++] = a.value;
+		} else {
+			i = !0;
+			let t = e.params.findIndex((e) => e.name === a.name);
+			if (t < 0) {
+				this.err(`${e.name} has no parameter "${a.name}" (parameters: ${e.params.map((e) => e.name).join(", ") || "none"})`, a.nameSpan ?? a.value);
+				continue;
+			}
+			if (n[t]) {
+				this.err(`parameter "${a.name}" is given twice`, a.nameSpan ?? a.value);
+				continue;
+			}
+			n[t] = a.value;
+		}
+		return e.params.forEach((r, i) => {
+			!r.opt && !n[i] && !(r.kind === "series" && 0) && this.err(`${e.name} needs the argument "${r.name}"`, t);
+		}), n;
+	}
+	constVal(e) {
+		switch (e.k) {
+			case "num": return e.value;
+			case "str": return e.value;
+			case "bool": return e.value;
+			case "color": return e.value;
+			case "mem": return e.cv;
+			case "un": return e.op === "-" && e.x.k === "num" ? -e.x.value : void 0;
+			default: return;
+		}
+	}
+	checkParam(e, t, n) {
+		let r = n.ty ?? this.expr(n);
+		if (r === j) return;
+		let a = `argument "${t.name}" of ${e.name}`, o = () => {
+			L(r) || this.err(`${a} must be a literal or an input, not a series value`, n);
+		};
+		switch (t.kind) {
+			case "series":
+				I(r) || this.err(`${a} must be a number series, got ${R(r)}`, n);
+				break;
+			case "any":
+				(r.b === "void" || r.b === "plot" || r.b === "tuple") && this.err(`${a} must be a value`, n);
+				break;
+			case "num":
+				if (!I(r) || r.b === "na") {
+					this.err(`${a} must be a number, got ${R(r)}`, n);
+					break;
+				}
+				o();
+				break;
+			case "int":
+				if (r.b !== "int") {
+					this.err(`${a} must be an int, got ${R(r)}`, n);
+					break;
+				}
+				o();
+				break;
+			case "bool":
+			case "string":
+			case "color":
+				if (r.b !== t.kind) {
+					this.err(`${a} must be a ${t.kind}, got ${R(r)}`, n);
+					break;
+				}
+				if (e.name === "plot" && t.name === "color" && n.k === "tern") break;
+				if (o(), t.oneOf) {
+					let e = this.constVal(n);
+					typeof e == "string" && !t.oneOf.includes(e) && this.err(`${a} must be one of ${t.oneOf.map((e) => JSON.stringify(e)).join(", ")}, got ${JSON.stringify(e)}`, n);
+				}
+				break;
+			case "enum": {
+				let e = this.constVal(n);
+				if (typeof e != "string" || !t.oneOf.includes(e) || n.k !== "mem") {
+					let e = t.oneOf === i.plotStyle ? "plot.style_*" : t.oneOf === i.lineStyle ? "hline.style_*" : t.oneOf === i.shape ? "shape.*" : "location.*";
+					this.err(`${a} must be one of ${e}`, n);
+				}
+				break;
+			}
+			case "strlist": break;
+			case "plot": (n.k !== "id" || n.sym?.kind !== "plot") && this.err(`${a} must be a plot handle: p = plot(...)`, n);
+		}
+		let s = this.constVal(n);
+		typeof s == "number" && (t.kind === "int" || t.kind === "num") && (t.min !== void 0 && s < t.min || t.max !== void 0 && s > t.max) && this.err(`${a} must be between ${t.min ?? "-inf"} and ${t.max ?? "inf"}, got ${s}`, n);
+	}
+	call(e, t) {
+		let n = this.calleeName(e);
+		if (n === null) {
+			this.err("only named functions can be called", e.callee);
+			for (let t of e.args) this.expr(t.value);
+			return j;
+		}
+		let r = a.get(n);
+		if (!r) {
+			for (let t of e.args) this.expr(t.value);
+			let t = [...a.keys()].filter((e) => e.endsWith(`.${n.split(".").pop()}`) || e === n.split(".").pop());
+			return (n === "security" || n === "request.security") && t.unshift("outside"), this.err(`unknown function "${n}"${t.length ? `; did you mean ${t.slice(0, 3).join(", ")}?` : ""}`, e.callee), j;
+		}
+		if (e.fn = n, (n === "plot" || n === "hline" || n === "fill" || n === "plotshape" || n === "indicator" || n === "barcolor" || n === "bgcolor") && (this.depth > 0 || t === "expr" || t === "expr-block" ? this.err(`${n}() is only allowed as a statement at the top level of the script`, e) : t === "decl" && n !== "plot" && n !== "hline" && this.err(`${n}() does not return a handle`, e)), n.startsWith("input.") && t !== "decl") {
+			this.err("input.* may only be the whole right-hand side of a top-level declaration: name = input.int(...)", e);
+			for (let t of e.args) this.expr(t.value);
+			return j;
+		}
+		let i = this.bind(r, e);
+		e.bound = i, r.params.forEach((e, t) => {
+			let n = i[t];
+			n && e.kind !== "strlist" && this.expr(n);
+		}), r.params.forEach((e, t) => {
+			let n = i[t];
+			n && e.kind !== "strlist" && this.checkParam(r, e, n);
+		});
+		let o = !1;
+		for (let e of i) e?.st && (o = !0);
+		e.st = o, r.needs && this.need(r.needs);
+		let s = r.ret;
+		switch (r.op) {
+			case "kernel":
+			case "study": return r.params.forEach((e, t) => {
+				let n = i[t];
+				n && n.st && e.kind === "series" && this.err(`argument "${e.name}" of ${r.name} depends on a variable that is declared var, assigned with :=, or is a block variable / loop counter. ${r.name} runs over whole columns, so its inputs must be known before the bar is evaluated`, n);
+			}), e.st = !1, r.op === "study" && this.studySources(r, i), s;
+			case "scalar": return {
+				b: "float",
+				q: F(...i.filter((e) => !!e).map((e) => e.ty.q))
+			};
+			case "special": return this.special(r, e, i, t, s);
+		}
+	}
+	studySources(e, t) {}
+	special(e, t, n, i, a) {
+		let o = (t) => n[e.params.findIndex((e) => e.name === t)] ?? null;
+		switch (e.name) {
+			case "nz": {
+				let e = o("replacement");
+				return {
+					b: "float",
+					q: F(o("x").ty.q, e?.ty?.q ?? "const")
+				};
+			}
+			case "na": return {
+				b: "bool",
+				q: o("x").ty.q
+			};
+			case "math.sum": return a;
+			case "ta.change": {
+				let e = o("source");
+				return this.historyOk(e) || this.err("ta.change needs a plain series or a top-level variable, not an expression of changing variables", e), t.st = !!e.st, {
+					b: "float",
+					q: "series"
+				};
+			}
+			case "ta.crossover":
+			case "ta.crossunder":
+			case "ta.cross":
+				for (let t of [o("a"), o("b")]) this.historyOk(t) || this.err(`${e.name} needs plain series or top-level variables, not expressions of changing variables; assign the value to a variable first`, t);
+				return t.st = !!(o("a").st || o("b").st), {
+					b: "bool",
+					q: "series"
+				};
+			case "ta.bb":
+				for (let e of n) if (e?.st && e.ty.q === "series") {
+					this.err("ta.bb needs inputs known before the bar is evaluated (no var / := / block variables)", e);
+					break;
+				}
+				return t.st = !1, a;
+			case "color.new": return r("color", F(...n.map((e) => e.ty.q)));
+			case "indicator": return this.indicator(t, n);
+			case "plot": return this.plot(t, n);
+			case "hline": return this.hline(t, n);
+			case "fill": return this.fill(t, n);
+			case "plotshape": return this.plotshape(t, n);
+			case "barcolor":
+			case "bgcolor": return this.shade(e.name, t, n);
+			case "outside": return this.outside(t, n, a);
+			default: return e.name.startsWith("input.") ? r("void") : a;
+		}
+	}
+	str(e) {
+		if (!e) return;
+		let t = this.constVal(e);
+		if (typeof t == "string") return t;
+		e.ty && e.ty !== j && e.ty.b === "string" && this.err("this must be a string literal", e);
+	}
+	int(e) {
+		if (!e) return;
+		let t = this.constVal(e);
+		if (typeof t == "number") return t;
+		e.ty && e.ty !== j && I(e.ty) && this.err("this must be a number literal", e);
+	}
+	offsetArg(e) {
+		if (!e) return {};
+		let t = this.constVal(e);
+		return typeof t == "number" ? { offset: t } : e.ty && e.ty !== j && e.ty.b === "int" && L(e.ty) ? { offsetExpr: e } : {};
+	}
+	indicator(e, t) {
+		this.sawIndicator && this.err("indicator() may be called only once", e), this.sawIndicator = !0;
+		let n = this.str(t[0]);
+		n !== void 0 && (this.plan.title = n);
+		let i = this.str(t[1]);
+		if (i !== void 0 && (this.plan.title = i), t[2]) {
+			let e = this.constVal(t[2]);
+			typeof e == "boolean" ? this.plan.overlay = e : t[2].ty && t[2].ty !== j && this.err("overlay must be true or false", t[2]);
+		}
+		let a = this.str(t[3]);
+		return (a === "left" || a === "right") && (this.plan.scale = a), r("void");
+	}
+	colorRef(e, t) {
+		if (!e || e.ty === j) return { value: t };
+		let n = this.constVal(e);
+		if (typeof n == "string" && e.ty?.b === "color") return { value: n };
+		if (e.k === "id" && e.sym?.kind === "input" && e.sym.ty.b === "color") return { input: e.sym.key };
+		if (e.k === "call" && e.fn === "color.new") {
+			let n = this.colorRef(e.bound[0], t), r = e.bound[1] ? this.constVal(e.bound[1]) : void 0;
+			if ("value" in n && typeof r == "number") return { value: U(n.value, r) };
+		}
+		return this.err("a color here must be a constant (color.red, #rrggbb, color.new(...)) or an input.color variable", e), { value: t };
+	}
+	nextKey(e, t) {
+		let n = V(e) || `plot${t}`;
+		/^[0-9]/.test(n) && (n = `p-${n}`);
+		let r = n, i = 2;
+		for (; this.keys.has(r);) r = `${n}-${i++}`;
+		return this.keys.add(r), r;
+	}
+	plot(e, t) {
+		let n = this.plan.plots.length;
+		n >= 64 && this.err("a script may draw at most 64 plots", e);
+		let i = this.str(t[1]) ?? `Plot ${n + 1}`, a = (t[4] ? this.constVal(t[4]) : void 0) ?? "line", o = this.int(t[3]), s = this.offsetArg(t[5]), c = t[6] ? this.colorRef(t[6], "#f23645") : void 0;
+		c && "input" in c && this.err("color_down must be a constant color", t[6]);
+		let l = [
+			"#2962ff",
+			"#ff6d00",
+			"#089981",
+			"#f23645",
+			"#9c27b0",
+			"#fbc02d"
+		][n % 6], u = t[2], d, f;
+		if (u && u.k === "tern" && u.c.ty && u.c.ty !== j && u.c.ty.q === "series" && u.ty && u.ty.b === "color") {
+			let e = this.colorRef(u.a, l), t = this.colorRef(u.b, l);
+			a === "line" ? (!("value" in e) || !("value" in t)) && this.err("both colors of a color that depends on the bar must be constants (color.red, #rrggbb, color.new(...)), not an input.color", u) : this.err("a color that depends on the bar is for line plots; histogram and area take a constant color (a histogram can use color_down for negative values)", u), d = "value" in t ? t : { value: l }, "value" in e && "value" in t && a === "line" && (f = {
+				cond: u.c,
+				color: e.value
+			});
+		} else d = this.colorRef(u, l);
+		return this.plan.plots.push({
+			kind: a,
+			key: this.nextKey(i, n + 1),
+			title: i,
+			color: d,
+			expr: t[0],
+			...o !== void 0 && { width: o },
+			...s,
+			...c && "value" in c && { colorDown: c.value },
+			...f && { colorWhen: f },
+			span: e
+		}), r("plot");
+	}
+	shade(e, t, n) {
+		let i = this.plan.plots.length;
+		i >= 64 && this.err("a script may draw at most 64 plots", t);
+		let a = n[0];
+		a.ty && a.ty !== j && a.ty.b !== "bool" && this.err(`${e} needs a bool condition, got ${R(a.ty)}`, a);
+		let o = `${e === "barcolor" ? "Bar color" : "Background"} ${i + 1}`;
+		return this.plan.plots.push({
+			kind: e,
+			key: this.nextKey(o, i + 1),
+			title: o,
+			color: this.colorRef(n[1], e === "barcolor" ? "#fdd835" : "#2962ff33"),
+			expr: a,
+			span: t
+		}), r("void");
+	}
+	outside(e, t, n) {
+		let r = (e, t) => {
+			if (!e || e.k === "id" && e.name === "na" && !e.sym) return null;
+			if (e.k === "str") return e.value;
+			e.ty && e.ty !== j && this.err(`the ${t} of outside() must be a string literal${t === "timeframe" ? " like \"1d\"" : ""}, or na for this chart's, not a computed value`, e);
+		}, i = r(t[0], "symbol"), a = r(t[2], "timeframe");
+		if (i === void 0 || a === void 0) return n;
+		if (i !== null && (i.length < 1 || i.length > 128 || /[\u0000-\u001f]/.test(i))) return this.err("the symbol of outside() must be 1 to 128 printable characters", t[0]), n;
+		if (a !== null && D(a) === null) return this.err(`the timeframe "${a}" is not written like 5m, 15m, 1h, 4h, 1d or 1w`, t[2]), n;
+		if (i === null && a === null) return this.err("outside() needs a symbol or a timeframe; this chart's own series are close, open, high, low and volume", e), n;
+		let o = (t[1] ? this.constVal(t[1]) : void 0) ?? "close";
+		return e.feed = O(i, a), e.own = a !== null, this.plan.dependencies.some((e) => e.symbol === i && e.timeframe === a && e.field === o) || (this.plan.dependencies.push({
+			symbol: i,
+			field: o,
+			timeframe: a
+		}), k(this.plan.dependencies).length > this.limits.maxFeeds && this.err(`a script may read at most ${this.limits.maxFeeds} outside series (distinct symbol and timeframe pairs)`, e)), n;
+	}
+	hline(e, t) {
+		let n = this.plan.plots.length, i = this.str(t[1]) ?? `Level ${n + 1}`, a = t[3] ? this.constVal(t[3]) : void 0;
+		return this.plan.plots.push({
+			kind: "hline",
+			key: this.nextKey(i, n + 1),
+			title: i,
+			color: this.colorRef(t[2], "#787b86"),
+			expr: t[0],
+			...a && { lineStyle: a },
+			span: e
+		}), r("plot");
+	}
+	fill(e, t) {
+		let n = this.plan.plots.length, i = this.str(t[3]) ?? `Fill ${n + 1}`, a = (e) => e && e.k === "id" && e.sym?.kind === "plot" ? Number(e.sym.key) : void 0, o = a(t[0]), s = a(t[1]);
+		for (let [e, n] of [[o, t[0]], [s, t[1]]]) {
+			if (e === void 0) continue;
+			let t = this.plan.plots[e];
+			t.kind === "hline" ? t.column = !0 : t.kind !== "line" && this.err("fill needs line plots or hline levels (not histogram, area or markers)", n);
+		}
+		return o !== void 0 && o === s && this.err("fill needs two different plots", e), this.plan.plots.push({
+			kind: "fill",
+			key: this.nextKey(i, n + 1),
+			title: i,
+			color: this.colorRef(t[2], "#2962ff33"),
+			...o !== void 0 && { a: o },
+			...s !== void 0 && { b: s },
+			span: e
+		}), r("void");
+	}
+	plotshape(e, t) {
+		let n = this.plan.plots.length, i = t[0], a = this.str(t[1]) ?? `Shape ${n + 1}`, o = (t[2] ? this.constVal(t[2]) : void 0) ?? "circle", s = (t[3] ? this.constVal(t[3]) : void 0) ?? "above", c = i.ty;
+		c && c !== j && (c.b === "bool" && s === "value" ? this.err("location.absolute needs a number (the price to mark), not a bool", i) : c.b !== "bool" && s !== "value" ? this.err("plotshape marks bars where a bool is true; for a number use location=location.absolute", i) : c.b !== "bool" && !I(c) && this.err(`plotshape needs a bool or a number, got ${R(c)}`, i));
+		let l = this.offsetArg(t[5]), u = this.int(t[6]), d = this.int(t[7]);
+		return this.plan.plots.push({
+			kind: "markers",
+			key: this.nextKey(a, n + 1),
+			title: a,
+			color: this.colorRef(t[4], "#2962ff"),
+			expr: i,
+			shape: o,
+			position: s,
+			...l,
+			...u !== void 0 && { last: u },
+			...d !== void 0 && { within: d },
+			span: e
+		}), r("void");
+	}
+	inputDecl(e) {
+		let t = e.init, n = this.calleeName(t), i = a.get(n);
+		if (!i) {
+			this.err(`unknown function "${n}"`, t.callee), this.skipInputArgs(t);
+			return;
+		}
+		t.fn = n;
+		let s = this.bind(i, t);
+		t.bound = s;
+		let c = n.slice(6), u = (e) => i.params.findIndex((t) => t.name === e), d = (e) => s[u(e)] ?? null;
+		i.params.forEach((e, t) => {
+			let r = s[t];
+			r && (e.kind === "strlist" ? (r.k !== "arr" || r.items.length === 0 || r.items.some((e) => e.k !== "str")) && this.err("options must be a non-empty list of string literals: options=[\"a\", \"b\"]", r) : (n !== "input.source" || e.name !== "defval") && (this.expr(r), this.checkParam(i, e, r), r.ty && r.ty !== j && r.ty.q !== "const" && e.kind !== "series" && this.err(`${e.name} of ${n} must be a literal`, r)));
+		});
+		let f = 0, p = d("defval"), m = this.str(d("title")) ?? e.name, h = {
+			key: e.name,
+			kind: c,
+			label: m,
+			default: 0,
+			span: e.nameSpan
+		};
+		if (p) {
+			if (n === "input.source") p.k === "id" && l.includes(p.name) && !this.scope.find(p.name) ? (f = p.name, p.ty = o, this.need(p.name === "close" ? "value" : "ohlc")) : this.err(`the default of input.source must be one of ${l.join(", ")}`, p);
+			else {
+				let e = this.constVal(p);
+				e !== void 0 && (f = e);
+			}
+		}
+		if (h.default = f, c === "int" || c === "float") {
+			let e = d("minval") ? this.int(d("minval")) : void 0, n = d("maxval") ? this.int(d("maxval")) : void 0, r = d("step") ? this.int(d("step")) : void 0;
+			e !== void 0 && (h.min = e), n !== void 0 && (h.max = n), r !== void 0 && (r <= 0 ? this.err("step must be positive", d("step")) : h.step = r), typeof f == "number" && (e !== void 0 && f < e || n !== void 0 && f > n) && this.err(`the default ${f} is outside [${e ?? "-inf"}, ${n ?? "inf"}]`, p), e !== void 0 && n !== void 0 && e > n && this.err("minval is above maxval", t);
+		}
+		if (c === "string") {
+			let e = d("options"), t = e && e.k === "arr" ? e.items.filter((e) => e.k === "str").map((e) => e.value) : [];
+			h.options = t, t.length > 0 && !t.includes(f) && this.err(`the default "${String(f)}" is not one of the options`, p);
+		}
+		c === "color" && typeof f == "string" && !/^#[0-9a-f]{6}([0-9a-f]{2})?$/.test(f) && this.err("the default must be a color", p), this.plan.inputs.push(h);
+		let g = c === "source" ? o : r(c === "string" ? "string" : c, "input"), _ = {
+			name: e.name,
+			kind: "input",
+			ty: g,
+			key: e.name
+		};
+		this.declare(e.name, _, e.nameSpan), e.sym = _, e.init.ty = g;
+	}
+};
+function U(e, t) {
+	let n = e.slice(1);
+	return `rgba(${parseInt(n.slice(0, 2), 16)},${parseInt(n.slice(2, 4), 16)},${parseInt(n.slice(4, 6), 16)},${Math.round((1 - t / 100) * 1e3) / 1e3})`;
+}
+function W(e, t, n = C) {
+	return new H(t, n).run(e);
+}
+//#endregion
+//#region src/codegen.ts
+var G = NaN, K = (e) => e === e && e !== 0;
+function q(e) {
+	let t = 2166136261;
+	for (let n = 0; n < e.length; n++) t = Math.imul(t ^ e.charCodeAt(n), 16777619) >>> 0;
+	return t.toString(16).padStart(8, "0");
+}
+function ee(e, t, n = C) {
+	let r = [], i = [];
+	for (let t of e.inputs) switch (t.kind) {
+		case "int":
+			r.push({
+				key: t.key,
+				label: t.label,
+				type: "int",
+				default: t.default,
+				...t.min !== void 0 && { min: t.min },
+				...t.max !== void 0 && { max: t.max },
+				step: t.step ?? 1
+			});
+			break;
+		case "float":
+			r.push({
+				key: t.key,
+				label: t.label,
+				type: "float",
+				default: t.default,
+				...t.min !== void 0 && { min: t.min },
+				...t.max !== void 0 && { max: t.max },
+				...t.step !== void 0 && { step: t.step }
+			});
+			break;
+		case "bool":
+			r.push({
+				key: t.key,
+				label: t.label,
+				type: "bool",
+				default: t.default
+			});
+			break;
+		case "string":
+			r.push({
+				key: t.key,
+				label: t.label,
+				type: "select",
+				default: t.default,
+				options: t.options
+			});
+			break;
+		case "source":
+			r.push({
+				key: t.key,
+				label: t.label,
+				type: "source",
+				default: t.default,
+				options: l
+			});
+			break;
+		case "color": i.push({
+			key: t.key,
+			label: t.label,
+			default: t.default,
+			plotKeys: []
+		});
+	}
+	let a = (t) => e.inputs.find((e) => e.key === t).default, o = [], s = [], c = /* @__PURE__ */ new Map();
+	return e.plots.forEach((t, r) => {
+		let l = "value" in t.color ? t.color.value : a(t.color.input);
+		"input" in t.color && i.find((e) => e.key === t.color.input).plotKeys.push(t.key);
+		let u = {
+			key: t.key,
+			title: t.title
+		};
+		switch (t.kind) {
+			case "line": {
+				o.push(t.key);
+				let i = t.colorWhen ? `${t.key}~when` : void 0;
+				i && o.push(i), c.set(r, t.key), s.push({
+					kind: "line",
+					...u,
+					col: t.key,
+					color: l,
+					...t.width !== void 0 && { width: t.width },
+					...J(t, e, n),
+					...i && { colorBy: {
+						col: i,
+						color: t.colorWhen.color
+					} }
+				});
+				break;
+			}
+			case "barcolor":
+				o.push(t.key), s.push({
+					kind: "barcolor",
+					...u,
+					col: t.key,
+					color: l
+				});
+				break;
+			case "bgcolor":
+				o.push(t.key), s.push({
+					kind: "bgcolor",
+					...u,
+					col: t.key,
+					color: l
+				});
+				break;
+			case "histogram":
+				o.push(t.key), s.push({
+					kind: "histogram",
+					...u,
+					col: t.key,
+					color: l,
+					...t.colorDown && { colorDown: t.colorDown }
+				});
+				break;
+			case "area":
+				o.push(t.key), s.push({
+					kind: "area",
+					...u,
+					col: t.key,
+					color: l
+				});
+				break;
+			case "markers":
+				o.push(t.key), s.push({
+					kind: "markers",
+					...u,
+					col: t.key,
+					shape: t.shape,
+					position: t.position,
+					color: l,
+					...J(t, e, n),
+					...t.last !== void 0 && { last: t.last },
+					...t.within !== void 0 && { within: t.within }
+				});
+				break;
+			case "hline":
+				if (t.column) {
+					let e = `${t.key}~level`;
+					o.push(e), c.set(r, e);
+				}
+				s.push({
+					kind: "hline",
+					...u,
+					value: (r) => new Y(null, r, e, n).simpleNumber(t.expr),
+					color: l,
+					style: t.lineStyle ?? "dashed"
+				});
+				break;
+			case "fill": s.push({
+				kind: "fill",
+				...u,
+				a: c.get(t.a),
+				b: c.get(t.b),
+				color: l
+			});
+		}
+	}), {
+		def: {
+			id: `script-${q(t)}`,
+			name: e.title,
+			family: "tv",
+			inputs: r,
+			needs: e.needs,
+			pane: e.overlay ? "overlay" : "new",
+			...e.scale === "left" && { scale: "left" },
+			columns: o,
+			plots: s,
+			build: (t, r) => new Y(t, r, e, n).build(),
+			reference: "alphacharts script"
+		},
+		colorInputs: i
+	};
+}
+function J(e, t, n) {
+	if (e.offsetExpr) {
+		let r = e.offsetExpr;
+		return { offset: (i) => {
+			let a = new Y(null, i, t, n).simpleNumber(r);
+			if (!Number.isInteger(a) || a < -5e3 || a > 5e3) throw new h(`offset must be a whole number between -5000 and 5000, got ${a}`, e.span, "runtime");
+			return a;
+		} };
+	}
+	return e.offset === void 0 ? {} : { offset: e.offset };
+}
+var Y = class {
+	g;
+	p;
+	plan;
+	limits;
+	simple = /* @__PURE__ */ new Map();
+	pure = /* @__PURE__ */ new Map();
+	stateCols = /* @__PURE__ */ new Map();
+	hoisted = /* @__PURE__ */ new Map();
+	mats = /* @__PURE__ */ new Map();
+	inits = /* @__PURE__ */ new Map();
+	S;
+	ctx = { steps: 0 };
+	tr = null;
+	bpy = null;
+	fx;
+	joinedCols = /* @__PURE__ */ new Map();
+	sameCols = /* @__PURE__ */ new Map();
+	constructor(e, t, n, r) {
+		this.g = e, this.p = t, this.plan = n, this.limits = r, this.fx = {
+			g: e,
+			key: null
+		}, this.S = new Float64Array(n.slots);
+		for (let e of n.body) e.k === "decl" && e.sym && this.inits.set(e.sym, e.init);
+	}
+	G() {
+		if (!this.fx.g) throw new h("a series is not available here");
+		return this.fx.g;
+	}
+	feedDom(e) {
+		let t = e.dom;
+		return t !== void 0 && t !== "@" && t !== "~" ? t : null;
+	}
+	inFeed(e, t) {
+		let n = this.fx;
+		this.fx = {
+			g: this.g.feed(e).graph,
+			key: e
+		};
+		try {
+			return t();
+		} finally {
+			this.fx = n;
+		}
+	}
+	joinedCol(e, t) {
+		let n = this.inFeed(e, () => this.colOf(t)), r = this.joinedCols.get(n);
+		return r || this.joinedCols.set(n, r = this.G().joined(e, n)), r;
+	}
+	rawCol(e) {
+		let t = e.bound[1], n = t && t.k === "str" ? t.value : "close";
+		if (this.fx.key !== null) return this.G()[n];
+		let r = `${e.feed}\u0002${n}`, i = this.sameCols.get(r);
+		return i || this.sameCols.set(r, i = this.G().external(e.feed, n)), i;
+	}
+	build() {
+		let e = this.G(), t = [];
+		for (let e of this.plan.body) switch (e.k) {
+			case "decl": {
+				let n = e.sym;
+				if (n.kind === "state") t.push(e);
+				else if (n.kind === "pure") {
+					let t = this.feedDom(e.init);
+					this.pure.set(n, t ? this.inFeed(t, () => this.colOf(e.init)) : this.colOf(e.init));
+				}
+				break;
+			}
+			case "tuple": {
+				let t = this.feedDom(e.init), n = t ? this.inFeed(t, () => this.hoist(e.init)) : this.hoist(e.init);
+				e.syms.forEach((e, t) => this.pure.set(e, n[t]));
+				break;
+			}
+			case "assign":
+			case "if":
+			case "for": t.push(e);
+		}
+		(t.length > 0 || this.plan.stateVars.length > 0) && this.buildExec(t);
+		let n = [];
+		for (let t of this.plan.plots) if (t.kind === "hline" && t.column) {
+			let r = this.simpleNumber(t.expr);
+			n.push(e.calc(() => r));
+		} else t.kind !== "hline" && t.kind !== "fill" && (t.kind === "markers" || t.kind === "barcolor" || t.kind === "bgcolor" ? n.push(this.markers(t)) : (n.push(this.colOf(t.expr)), t.colorWhen && n.push(this.colOf(t.colorWhen.cond))));
+		let r = e.cols.length;
+		for (let t of e.feeds.values()) r += t.graph.cols.length;
+		if (r > this.limits.maxColumns) throw new h(`the script needs ${r} columns; the limit is ${this.limits.maxColumns}`);
+		return n;
+	}
+	markers(e) {
+		let t = e.expr, n = this.ev(t, "col"), r = e.position === "value";
+		return this.G().calc(r ? n : (e) => K(n(e)) ? 1 : G);
+	}
+	buildExec(e) {
+		let t = this.G();
+		for (let e of this.plan.stateVars) this.stateCols.set(e, t.col());
+		let n = e.map((e) => this.stmt(e)), r = this.S, i = this.ctx;
+		this.limits.maxSteps;
+		let a = this.plan.stateVars.map((e) => ({
+			slot: e.slot,
+			col: this.stateCols.get(e),
+			restore: !!e.isVar
+		}));
+		t.node((e, t, o) => {
+			for (let e = t; e < o; e++) {
+				i.steps = 0;
+				for (let t of a) t.restore && (r[t.slot] = e > 0 ? t.col.v[e - 1] : G);
+				for (let t of n) t(e);
+				for (let t of a) t.col.v[e] = r[t.slot];
+			}
+		});
+	}
+	step(e) {
+		if (++this.ctx.steps > this.limits.maxSteps) throw new h(`execution budget exceeded: more than ${this.limits.maxSteps} loop steps in one bar`, e, "budget");
+	}
+	stmt(e) {
+		let t = this.S;
+		switch (e.k) {
+			case "decl": {
+				let n = this.ev(e.init, "exec"), r = e.sym.slot;
+				return e.isVar ? (e) => {
+					e === 0 && (t[r] = n(e));
+				} : (e) => {
+					t[r] = n(e);
+				};
+			}
+			case "assign": {
+				let n = this.ev(e.value, "exec"), r = e.sym.slot;
+				switch (e.op) {
+					case ":=": return (e) => {
+						t[r] = n(e);
+					};
+					case "+=": return (e) => {
+						t[r] = t[r] + n(e);
+					};
+					case "-=": return (e) => {
+						t[r] = t[r] - n(e);
+					};
+					case "*=": return (e) => {
+						t[r] = t[r] * n(e);
+					};
+					case "/=": return (e) => {
+						let i = n(e);
+						t[r] = i === 0 ? G : t[r] / i;
+					};
+					default: return (e) => {
+						let i = n(e);
+						t[r] = i === 0 ? G : t[r] % i;
+					};
+				}
+			}
+			case "if": {
+				let t = this.ev(e.cond, "exec"), n = e.then.map((e) => this.stmt(e)), r = (e.else ?? []).map((e) => this.stmt(e));
+				return (e) => {
+					for (let i of K(t(e)) ? n : r) i(e);
+				};
+			}
+			case "for": {
+				let n = this.ev(e.lo, "exec"), r = this.ev(e.hi, "exec"), i = e.by ? this.ev(e.by, "exec") : null, a = e.body.map((e) => this.stmt(e)), o = e.sym.slot, s = this.limits.maxLoopIterations;
+				return (c) => {
+					let l = n(c), u = r(c), d = i ? i(c) : l <= u ? 1 : -1;
+					if (!Number.isFinite(l) || !Number.isFinite(u) || !Number.isFinite(d) || d === 0) throw new h("loop bounds must be finite and the step non-zero", e, "runtime");
+					if (i && (d > 0 && l > u || d < 0 && l < u)) return;
+					!i && l > u && (d = -1);
+					let f = Math.floor(Math.abs(u - l) / Math.abs(d)) + 1;
+					if (f > s) throw new h(`this loop would run ${f} times; the limit is ${s} iterations per loop`, e, "budget");
+					let p = l;
+					for (let n = 0; n < f; n++, p += d) {
+						this.step(e), t[o] = p;
+						for (let e of a) e(c);
+					}
+				};
+			}
+			default: return () => {};
+		}
+	}
+	srcCol(e) {
+		let t = this.G();
+		switch (e) {
+			case "volume": return t.volume;
+			case "time": return t.time;
+			case "bar_index": return t.calc((e) => e);
+			case "bars_per_year": return this.fx.key === null ? this.bpy ??= t.barsPerYear() : t.barsPerYear();
+			default: return t.src(e);
+		}
+	}
+	colOf(e) {
+		let t = this.feedDom(e);
+		if (t && this.fx.key === null) return this.joinedCol(t, e);
+		if (e.k === "call" && e.fn === "outside") return this.rawCol(e);
+		let n = this.G();
+		if (e.k === "id" && e.sym) {
+			let t = e.sym;
+			if (t.kind === "builtin") return this.memo(e, () => this.srcCol(t.key));
+			if (t.kind === "pure") return this.pure.get(t);
+			if (t.kind === "state") return this.stateCols.get(t);
+			if (t.kind === "input" && t.ty.b === "float" && t.ty.q === "series") return this.srcCol(String(this.p[t.key]));
+		}
+		return e.k === "call" && this.isHoisted(e) ? this.hoist(e)[0] : this.memo(e, () => {
+			let t = this.ev(e, "col");
+			return n.calc(t);
+		});
+	}
+	memo(e, t) {
+		let n = this.mats.get(e);
+		return n || this.mats.set(e, n = t()), n;
+	}
+	isHoisted(e) {
+		let t = a.get(e.fn);
+		return !!t && (t.op === "kernel" || t.op === "study" || t.name === "ta.bb");
+	}
+	num(e, t, n, r, i = !0) {
+		let a = this.ev(e, "col")(0);
+		if (!Number.isFinite(a) || i && !Number.isInteger(a) || a < n || a > r) throw new h(`${t} must be ${i ? "an integer" : "a number"} between ${n} and ${r}, got ${a}`, e, "build");
+		return a;
+	}
+	hoist(e) {
+		let t = this.hoisted.get(e);
+		if (t) return t;
+		let n = a.get(e.fn), r = e.bound, i = this.G(), o = this.limits.maxPeriod, s, c = (e) => this.num(r[e], `the length of ${n.name}`, 1, o);
+		switch (n.name) {
+			case "ta.sma":
+				s = [i.sma(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.ema":
+				s = [i.ema(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.wma":
+				s = [i.wma(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.rma":
+				s = [i.rma(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.highest":
+				s = [i.highest(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.lowest":
+				s = [i.lowest(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.highestbars":
+				s = [i.highestBars(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.lowestbars":
+				s = [i.lowestBars(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.stdev":
+			case "ta.variance": {
+				let e = !!r[2] && K(this.ev(r[2], "col")(0)), t = e ? this.num(r[1], `the length of ${n.name} with sample=true`, 2, o) : c(1);
+				s = [n.name === "ta.stdev" ? i.stdev(this.colOf(r[0]), t, e) : i.variance(this.colOf(r[0]), t, e)];
+				break;
+			}
+			case "ta.sum":
+			case "math.sum":
+				s = [i.sum(this.colOf(r[0]), c(1))];
+				break;
+			case "ta.linreg": {
+				let e = this.num(r[1], "the length of ta.linreg", 2, o);
+				s = [i.linreg(this.colOf(r[0]), e).value];
+				break;
+			}
+			case "ta.atr":
+				s = [i.atr(c(0))];
+				break;
+			case "ta.bb": {
+				let e = a.get("ta.bbands").study, t = this.num(r[2], "mult of ta.bb", 0, 100, !1), n = this.runStudy(e, {
+					length: c(1),
+					multUp: t,
+					multDn: t
+				}, this.colOf(r[0]));
+				s = [
+					n[1],
+					n[0],
+					n[2]
+				];
+				break;
+			}
+			default: s = this.hoistStudy(n, e);
+		}
+		return this.hoisted.set(e, s), s;
+	}
+	hoistStudy(e, t) {
+		let n = e.study, r = {}, i = null;
+		e.params.forEach((n, a) => {
+			let o = t.bound[a];
+			if (!o) return;
+			let s = n.input;
+			if (s.type === "source") {
+				i = this.colOf(o);
+				return;
+			}
+			if (s.type === "select") {
+				r[s.key] = this.str(o);
+				return;
+			}
+			if (s.type === "bool") {
+				r[s.key] = K(this.ev(o, "col")(0));
+				return;
+			}
+			let c = this.ev(o, "col")(0);
+			if (!Number.isFinite(c) || s.type === "int" && !Number.isInteger(c) || s.min !== void 0 && c < s.min || s.max !== void 0 && c > s.max) throw new h(`${s.key} of ${e.name} must be ${s.type === "int" ? "an integer" : "a number"}${s.min === void 0 ? "" : ` >= ${s.min}`}${s.max === void 0 ? "" : ` <= ${s.max}`}, got ${c}`, o);
+			r[s.key] = c;
+		});
+		try {
+			return this.runStudy(n, r, i);
+		} catch (n) {
+			throw n instanceof h ? n : new h(`${e.name}: ${n instanceof Error ? n.message : String(n)}`, t);
+		}
+	}
+	runStudy(e, t, n) {
+		let r = f(e, t), i = Object.create(this.G());
+		return n && (i.src = () => n), [...e.build(i, r)];
+	}
+	str(e) {
+		switch (e.k) {
+			case "str": return e.value;
+			case "color": return e.value;
+			case "mem": return String(e.cv);
+			case "id": {
+				let t = e.sym;
+				if (t.kind === "input") return String(this.p[t.key]);
+				if (t.kind === "simple") return String(this.simpleVal(t));
+				break;
+			}
+			case "tern": return K(this.ev(e.c, "col")(0)) ? this.str(e.a) : this.str(e.b);
+			case "call": if (e.fn === "color.new") return String(this.simpleVal2(e));
+		}
+		throw new h("this string cannot be evaluated here", e);
+	}
+	simpleVal2(e) {
+		return String(e.fn);
+	}
+	simpleVal(e) {
+		let t = this.simple.get(e);
+		if (t !== void 0) return t;
+		let n = this.inits.get(e), r = n.ty.b === "string" || n.ty.b === "color" ? this.str(n) : this.ev(n, "col")(0);
+		return this.simple.set(e, r), r;
+	}
+	simpleNumber(e) {
+		return this.ev(e, "col")(0);
+	}
+	hist(e, t, n, r) {
+		let i = this.S, a = (e) => {
+			throw new h(`the history offset must be an integer between 0 and ${w}, got ${e}`, r, "runtime");
+		};
+		if (e.k === "id" && e.sym?.kind === "state" && n === "exec") {
+			let n = e.sym.slot, r = this.stateCols.get(e.sym);
+			return (e) => {
+				let o = t(e);
+				return !Number.isInteger(o) || o < 0 || o > 1e6 ? a(o) : o === 0 ? i[n] : e - o >= 0 ? r.v[e - o] : G;
+			};
+		}
+		let o = this.colOf(e);
+		return (e) => {
+			let n = t(e);
+			return !Number.isInteger(n) || n < 0 || n > 1e6 ? a(n) : e - n >= 0 ? o.v[e - n] : G;
+		};
+	}
+	ev(e, t) {
+		let n = this.S, r = this.feedDom(e);
+		if (r && this.fx.key === null) {
+			let t = this.joinedCol(r, e);
+			return (e) => t.v[e];
+		}
+		switch (e.k) {
+			case "num": {
+				let t = e.value;
+				return () => t;
+			}
+			case "bool": {
+				let t = +!!e.value;
+				return () => t;
+			}
+			case "str":
+			case "color":
+			case "arr": throw new h("a string or color is not a number", e);
+			case "id": {
+				let r = e.sym;
+				if (!r) return () => G;
+				switch (r.kind) {
+					case "builtin": {
+						if (r.key === "bar_index") return (e) => e;
+						let e = this.srcCol(r.key);
+						return (t) => e.v[t];
+					}
+					case "input": {
+						if (r.ty.b === "float" && r.ty.q === "series") {
+							let e = this.srcCol(String(this.p[r.key]));
+							return (t) => e.v[t];
+						}
+						let t = this.p[r.key];
+						if (typeof t == "string") throw new h("a string is not a number", e);
+						let n = typeof t == "boolean" ? +!!t : t;
+						return () => n;
+					}
+					case "simple": {
+						let t = this.simpleVal(r);
+						if (typeof t == "string") throw new h("a string is not a number", e);
+						return () => t;
+					}
+					case "pure": {
+						let e = this.pure.get(r);
+						return (t) => e.v[t];
+					}
+					case "state": {
+						if (t === "exec") {
+							let e = r.slot;
+							return () => n[e];
+						}
+						let e = this.stateCols.get(r);
+						return (t) => e.v[t];
+					}
+					case "local":
+					case "loop": {
+						let e = r.slot;
+						return () => n[e];
+					}
+					default: throw new h("this name has no numeric value", e);
+				}
+			}
+			case "mem":
+				if (typeof e.cv == "number") {
+					let t = e.cv;
+					return () => t;
+				}
+				if (e.obj.k === "id" && e.name === "tr") {
+					let e = this.tr ??= this.G().tr();
+					return (t) => e.v[t];
+				}
+				throw new h("this name has no numeric value", e);
+			case "un": {
+				let n = this.ev(e.x, t);
+				return e.op === "-" ? (e) => -n(e) : e.op === "+" ? n : (e) => +!K(n(e));
+			}
+			case "bin": return this.binary(e, t);
+			case "tern": {
+				let n = this.ev(e.c, t), r = this.ev(e.a, t), i = this.ev(e.b, t);
+				return (e) => K(n(e)) ? r(e) : i(e);
+			}
+			case "idx": {
+				let n = this.ev(e.i, t);
+				return this.hist(e.x, n, t, e);
+			}
+			case "call": return this.callEv(e, t);
+		}
+	}
+	binary(e, t) {
+		let n = e.a.ty, r = e.b.ty;
+		if ((e.op === "==" || e.op === "!=") && (n.b === "string" || n.b === "color") && n.b === r.b) {
+			let t = this.str(e.a) === this.str(e.b), n = +(e.op === "==" === t);
+			return () => n;
+		}
+		let i = this.ev(e.a, t), a = this.ev(e.b, t);
+		switch (e.op) {
+			case "+": return (e) => i(e) + a(e);
+			case "-": return (e) => i(e) - a(e);
+			case "*": return (e) => i(e) * a(e);
+			case "/": return (e) => {
+				let t = a(e);
+				return t === 0 ? G : i(e) / t;
+			};
+			case "%": return (e) => {
+				let t = a(e);
+				return t === 0 ? G : i(e) % t;
+			};
+			case "<": return (e) => +(i(e) < a(e));
+			case "<=": return (e) => +(i(e) <= a(e));
+			case ">": return (e) => +(i(e) > a(e));
+			case ">=": return (e) => +(i(e) >= a(e));
+			case "==": return (e) => +(i(e) === a(e));
+			case "!=": return (e) => {
+				let t = i(e), n = a(e);
+				return +(t === t && n === n && t !== n);
+			};
+			case "and": return (e) => K(i(e)) && K(a(e)) ? 1 : 0;
+			case "or": return (e) => K(i(e)) || K(a(e)) ? 1 : 0;
+			default: throw new h(`unknown operator ${e.op}`, e);
+		}
+	}
+	callEv(e, t) {
+		let n = a.get(e.fn), r = e.bound;
+		if (n.name === "outside") {
+			let t = this.rawCol(e);
+			return (e) => t.v[e];
+		}
+		if (this.isHoisted(e)) {
+			let t = this.hoist(e)[0];
+			return (e) => t.v[e];
+		}
+		switch (n.name) {
+			case "nz": {
+				let e = this.ev(r[0], t), n = r[1] ? this.ev(r[1], t) : () => 0;
+				return (t) => {
+					let r = e(t);
+					return r === r ? r : n(t);
+				};
+			}
+			case "na": {
+				let e = this.ev(r[0], t);
+				return (t) => {
+					let n = e(t);
+					return n === n ? 0 : 1;
+				};
+			}
+			case "ta.change": {
+				let n = this.ev(r[0], t), i = this.hist(r[0], r[1] ? this.ev(r[1], t) : () => 1, t, e);
+				return (e) => n(e) - i(e);
+			}
+			case "ta.crossover":
+			case "ta.crossunder":
+			case "ta.cross": {
+				let i = this.ev(r[0], t), a = this.ev(r[1], t), o = this.hist(r[0], () => 1, t, e), s = this.hist(r[1], () => 1, t, e), c = (e) => i(e) > a(e) && o(e) <= s(e), l = (e) => i(e) < a(e) && o(e) >= s(e);
+				return n.name === "ta.crossover" ? (e) => +!!c(e) : n.name === "ta.crossunder" ? (e) => +!!l(e) : (e) => c(e) || l(e) ? 1 : 0;
+			}
+			case "color.new": throw new h("a color is not a number", e);
+			default:
+				if (n.op === "scalar") {
+					let e = n.fn, i = r.map((e) => this.ev(e, t));
+					if (i.length === 1) {
+						let t = i[0];
+						return (n) => e(t(n));
+					}
+					let a = i[0], o = i[1];
+					return (t) => e(a(t), o(t));
+				}
+				throw new h(`${n.name} cannot be used as a value here`, e);
+		}
+	}
+};
+//#endregion
+//#region src/compile.ts
+function X(e, t = C) {
+	if (typeof e != "string") return {
+		ok: !1,
+		diagnostics: [{
+			severity: "error",
+			message: "the script must be a string",
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 1,
+			from: 0,
+			to: 0
+		}]
+	};
+	if (e.length > t.maxSourceChars) return {
+		ok: !1,
+		diagnostics: [{
+			severity: "error",
+			message: `the script is ${e.length} characters; the limit is ${t.maxSourceChars}`,
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 1,
+			from: 0,
+			to: 0
+		}]
+	};
+	let n = new m(e), r = S(e, n), i = null;
+	if (n.errorCount === 0 && (i = W(r, n, t)), n.errorCount === 0 && i && i.plots.length === 0 && n.error("the script draws nothing: add plot(...)", {
+		from: 0,
+		to: Math.min(e.length, 1)
+	}), n.errorCount > 0 || !i) return {
+		ok: !1,
+		diagnostics: n.list
+	};
+	let { def: a, colorInputs: o } = ee(i, e, t);
+	return {
+		ok: !0,
+		study: a,
+		colorInputs: o,
+		inputs: i.inputs,
+		title: i.title,
+		diagnostics: n.list,
+		source: e,
+		plan: {
+			overlay: i.overlay,
+			scale: i.scale,
+			dependencies: i.dependencies,
+			needs: i.needs,
+			plots: i.plots.map((e) => ({
+				kind: e.kind,
+				title: e.title,
+				expr: e.expr ?? null
+			})),
+			body: i.body
+		}
+	};
+}
+//#endregion
+//#region src/sandbox.ts
+var Z = [
+	"fetch",
+	"XMLHttpRequest",
+	"WebSocket",
+	"WebTransport",
+	"EventSource",
+	"importScripts",
+	"indexedDB",
+	"caches",
+	"BroadcastChannel",
+	"SharedWorker",
+	"Worker",
+	"MessageChannel",
+	"Request",
+	"Response",
+	"localStorage",
+	"sessionStorage",
+	"FileReader",
+	"FileReaderSync",
+	"Notification",
+	"navigator",
+	"location",
+	"document",
+	"window",
+	"XMLHttpRequestUpload",
+	"RTCPeerConnection"
+];
+function te(e = globalThis) {
+	let t = [], n = [];
+	for (let r of Z) try {
+		Object.defineProperty(e, r, {
+			value: void 0,
+			writable: !1,
+			configurable: !1,
+			enumerable: !1
+		}), t.push(r);
+	} catch {
+		n.push(r);
+	}
+	let r = e, i = (e) => () => {
+		throw Error(`${e} is not available to scripts`);
+	};
+	try {
+		Object.defineProperty(e, "eval", {
+			value: i("eval"),
+			writable: !1,
+			configurable: !1
+		});
+	} catch {
+		n.push("eval");
+	}
+	if (r.Math) try {
+		Object.defineProperty(r.Math, "random", {
+			value: i("Math.random"),
+			writable: !1,
+			configurable: !1
+		});
+	} catch {
+		n.push("Math.random");
+	}
+	if (r.Date) try {
+		Object.defineProperty(r.Date, "now", {
+			value: i("Date.now"),
+			writable: !1,
+			configurable: !1
+		});
+	} catch {
+		n.push("Date.now");
+	}
+	let a = e;
+	for (let e of [
+		"Object",
+		"Array",
+		"Function",
+		"String",
+		"Number",
+		"Boolean"
+	]) {
+		let t = a[e]?.prototype;
+		t && Object.freeze(t);
+	}
+	return {
+		blocked: t,
+		missing: n
+	};
+}
+var ne = () => new Promise((e) => setTimeout(e, 0)), re = 65536;
+function Q(e) {
+	return e instanceof h ? {
+		message: e.message,
+		...e.span && {
+			from: e.span.from,
+			to: e.span.to
+		},
+		kind: e.kind
+	} : {
+		message: e instanceof Error ? e.message : String(e),
+		kind: "build"
+	};
+}
+function $(e, t, n = !1) {
+	return {
+		...e,
+		build: (r, i) => {
+			let a = r;
+			n && (a = Object.create(r), a.node = () => r.node(() => {}));
+			let o = e.build(a, i);
+			return r.node((e, n, r) => {
+				t && r - n === 1 && t(n);
+			}), o;
+		}
+	};
+}
+function ie(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+	return (a) => {
+		let o = a;
+		switch (o.type) {
+			case "cancel":
+				r.has(o.id) && n.add(o.id);
+				return;
+			case "dispose":
+				t.delete(o.sid), i.add(o.sid);
+				return;
+			case "bar": {
+				let n = t.get(o.sid);
+				if (!n) {
+					e({
+						type: "tick-error",
+						sid: o.sid,
+						error: {
+							message: "the script has no computed state in this worker (it was restarted); change an input to run it again",
+							kind: "runtime"
+						}
+					});
+					return;
+				}
+				try {
+					let t = n.length, r = t > 0 ? n.graph.time.v[t - 1] : NaN;
+					if (t > 0 && o.bar.time === r ? n.reviseLast(o.bar) : n.push(o.bar), n.length - 1 !== o.index) throw new h(`out of sync with the chart: bar ${o.index} arrived with ${n.length} bars computed`);
+					let i = new Float64Array(n.outputs.length);
+					n.outputs.forEach((e, t) => i[t] = e.v[o.index]), e({
+						type: "values",
+						sid: o.sid,
+						index: o.index,
+						values: i
+					}, [i.buffer]);
+				} catch (t) {
+					e({
+						type: "tick-error",
+						sid: o.sid,
+						error: Q(t)
+					});
+				}
+				return;
+			}
+			case "feed-bar": {
+				let n = t.get(o.sid);
+				if (!n) {
+					e({
+						type: "tick-error",
+						sid: o.sid,
+						error: {
+							message: "the script has no computed state in this worker (it was restarted); change an input to run it again",
+							kind: "runtime"
+						}
+					});
+					return;
+				}
+				try {
+					if (!n.graph.feeds.has(o.key)) throw new h(`this script reads no outside series "${o.key}"`);
+					if (!n.pushFeed(o.key, o.bar)) {
+						e({
+							type: "idle",
+							sid: o.sid
+						});
+						return;
+					}
+					let t = n.length, r = new Float64Array(n.outputs.length);
+					n.outputs.forEach((e, n) => r[n] = e.v[t - 1]), e({
+						type: "values",
+						sid: o.sid,
+						index: t - 1,
+						values: r
+					}, [r.buffer]);
+				} catch (t) {
+					e({
+						type: "tick-error",
+						sid: o.sid,
+						error: Q(t)
+					});
+				}
+				return;
+			}
+			case "run":
+				r.add(o.id), (async () => {
+					try {
+						let r = {
+							...C,
+							...o.limits
+						}, a = X(o.source, r);
+						if (!a.ok) throw new h(a.diagnostics.map((e) => `${e.line}:${e.column}: ${e.message}`).join("; "));
+						let s = o.bars.time.length;
+						if (s > r.maxBars) throw new h(`${s} bars exceed the limit of ${r.maxBars}`, null, "budget");
+						let c = new u($(a.study), o.params), l = Object.entries(o.feeds ?? {});
+						if (l.length > r.maxFeeds) throw new h(`${l.length} outside series exceed the limit of ${r.maxFeeds}`, null, "budget");
+						let d = 0, f = 0, p = 0;
+						for (let [e, t] of l) {
+							let n = t.bars.time.length;
+							if (n > r.maxBars) throw new h(`an outside series has ${n} bars; the limit is ${r.maxBars}`, null, "budget");
+							let i = c.graph.feeds.get(e)?.graph.cols.length ?? 6;
+							f += n, p += i, d += n * i * 8 * 3 + n * 6 * 8;
+						}
+						let m = c.graph.cols.length * s * 8 * 3 + d;
+						if (m > r.maxBytes) {
+							let e = `${(m / 2 ** 20).toFixed(0)} MiB`, t = `${(r.maxBytes / 2 ** 20).toFixed(0)} MiB`;
+							throw l.length === 0 ? new h(`the script needs ${e} (3 x ${c.graph.cols.length} columns x ${s} bars x 8); the limit is ${t}`, null, "budget") : new h(`the script and its ${l.length} outside series need ${e} (3 x ${c.graph.cols.length} columns x ${s} bars x 8, and 3 x ${p} columns of ${f} outside bars in all, x 8, with a copy of their bars); the limit is ${t}`, null, "budget");
+						}
+						for (let [e, t] of l) c.setFeed(e, t.bars, t);
+						if (!await c.loadChunked(o.bars, re, ne, () => n.has(o.id))) {
+							e({
+								type: "cancelled",
+								id: o.id
+							});
+							return;
+						}
+						i.has(o.sid) || t.set(o.sid, c);
+						let g = c.graph.cols.map((e) => e.v.slice());
+						e({
+							type: "result",
+							id: o.id,
+							n: c.length,
+							buffers: g
+						}, g.map((e) => e.buffer));
+					} catch (t) {
+						e({
+							type: "error",
+							id: o.id,
+							error: Q(t)
+						});
+					} finally {
+						n.delete(o.id), r.delete(o.id);
+					}
+				})();
+				return;
+		}
+	};
+}
+//#endregion
+export { X as a, O as c, C as d, p as f, $ as i, k as l, g as m, te as n, A as o, h as p, ie as r, d as s, Z as t, D as u };
+
+//# sourceMappingURL=sandbox-p2HPP8yl.js.map