bonsai-js 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2226 @@
+import { a as attachLocation, c as offsetToPosition, i as ExpressionError, l as suggest, n as BonsaiSecurityError, o as formatBonsaiError, r as BonsaiTypeError, s as formatError, t as BonsaiReferenceError } from "./errors-t5i9AEaf.mjs";
+//#region src/lexer.ts
+const KEYWORDS = new Map([
+	["true", {
+		type: "Boolean",
+		value: "true"
+	}],
+	["false", {
+		type: "Boolean",
+		value: "false"
+	}],
+	["null", {
+		type: "Null",
+		value: "null"
+	}],
+	["undefined", {
+		type: "Undefined",
+		value: "undefined"
+	}],
+	["in", {
+		type: "Operator",
+		value: "in"
+	}],
+	["not", {
+		type: "Operator",
+		value: "not"
+	}]
+]);
+function isDigit(ch) {
+	return ch >= "0" && ch <= "9";
+}
+function isAlpha(ch) {
+	return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_" || ch === "$";
+}
+function isAlphaNumeric(ch) {
+	return isAlpha(ch) || isDigit(ch);
+}
+function isHexDigit(ch) {
+	return isDigit(ch) || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+}
+function tokenize(source) {
+	const tokens = [];
+	let i = 0;
+	while (i < source.length) {
+		const ch = source[i];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+			i++;
+			continue;
+		}
+		if (isDigit(ch)) {
+			const start = i;
+			if (ch === "0" && i + 1 < source.length && (source[i + 1] === "x" || source[i + 1] === "X")) {
+				i += 2;
+				while (i < source.length && (isHexDigit(source[i]) || source[i] === "_")) i++;
+				tokens.push({
+					type: "Number",
+					value: source.slice(start, i),
+					start,
+					end: i
+				});
+				continue;
+			}
+			if (ch === "0" && i + 1 < source.length && (source[i + 1] === "b" || source[i + 1] === "B")) {
+				i += 2;
+				while (i < source.length && (source[i] === "0" || source[i] === "1" || source[i] === "_")) i++;
+				tokens.push({
+					type: "Number",
+					value: source.slice(start, i),
+					start,
+					end: i
+				});
+				continue;
+			}
+			if (ch === "0" && i + 1 < source.length && (source[i + 1] === "o" || source[i + 1] === "O")) {
+				i += 2;
+				while (i < source.length && (source[i] >= "0" && source[i] <= "7" || source[i] === "_")) i++;
+				tokens.push({
+					type: "Number",
+					value: source.slice(start, i),
+					start,
+					end: i
+				});
+				continue;
+			}
+			while (i < source.length && (isDigit(source[i]) || source[i] === "_")) i++;
+			if (i < source.length && source[i] === "." && i + 1 < source.length && isDigit(source[i + 1])) {
+				i++;
+				while (i < source.length && (isDigit(source[i]) || source[i] === "_")) i++;
+			}
+			if (i < source.length && (source[i] === "e" || source[i] === "E")) {
+				i++;
+				if (i < source.length && (source[i] === "+" || source[i] === "-")) i++;
+				while (i < source.length && (isDigit(source[i]) || source[i] === "_")) i++;
+			}
+			tokens.push({
+				type: "Number",
+				value: source.slice(start, i),
+				start,
+				end: i
+			});
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const quote = ch;
+			const start = i;
+			i++;
+			let value = "";
+			while (i < source.length && source[i] !== quote) {
+				if (source[i] === "\\") {
+					i++;
+					const escaped = source[i];
+					switch (escaped) {
+						case "n":
+							value += "\n";
+							break;
+						case "t":
+							value += "	";
+							break;
+						case "r":
+							value += "\r";
+							break;
+						case "\\":
+							value += "\\";
+							break;
+						case "0":
+							value += "\0";
+							break;
+						case "x": {
+							const hex = source.slice(i + 1, i + 3);
+							if (hex.length < 2 || !isHexDigit(hex[0]) || !isHexDigit(hex[1])) throw new ExpressionError("Invalid \\x escape: expected 2 hex digits", {
+								source,
+								start,
+								end: i + 3
+							});
+							value += String.fromCharCode(parseInt(hex, 16));
+							i += 2;
+							break;
+						}
+						case "u":
+							if (i + 1 < source.length && source[i + 1] === "{") {
+								const closeBrace = source.indexOf("}", i + 2);
+								if (closeBrace === -1) throw new ExpressionError("Invalid \\u{} escape: missing closing brace", {
+									source,
+									start,
+									end: source.length
+								});
+								const hex = source.slice(i + 2, closeBrace);
+								if (hex.length === 0) throw new ExpressionError("Invalid \\u{} escape: empty code point", {
+									source,
+									start,
+									end: closeBrace + 1
+								});
+								for (const c of hex) if (!isHexDigit(c)) throw new ExpressionError(`Invalid \\u{} escape: non-hex digit "${c}"`, {
+									source,
+									start,
+									end: closeBrace + 1
+								});
+								const MAX_UNICODE_CODE_POINT = 1114111;
+								const codePoint = parseInt(hex, 16);
+								if (codePoint > MAX_UNICODE_CODE_POINT) throw new ExpressionError("Invalid \\u{} escape: code point out of range", {
+									source,
+									start,
+									end: closeBrace + 1
+								});
+								value += String.fromCodePoint(codePoint);
+								i = closeBrace;
+							} else {
+								const UNICODE_ESCAPE_LEN = 4;
+								const hex = source.slice(i + 1, i + 1 + UNICODE_ESCAPE_LEN);
+								if (hex.length < UNICODE_ESCAPE_LEN) throw new ExpressionError("Invalid \\u escape: expected 4 hex digits", {
+									source,
+									start,
+									end: i + 1 + UNICODE_ESCAPE_LEN
+								});
+								for (const c of hex) if (!isHexDigit(c)) throw new ExpressionError("Invalid \\u escape: expected 4 hex digits", {
+									source,
+									start,
+									end: i + 1 + UNICODE_ESCAPE_LEN
+								});
+								value += String.fromCharCode(parseInt(hex, 16));
+								i += UNICODE_ESCAPE_LEN;
+							}
+							break;
+						default:
+							value += escaped;
+							break;
+					}
+				} else value += source[i];
+				i++;
+			}
+			if (i >= source.length) throw new ExpressionError("Unterminated string", {
+				source,
+				start,
+				end: i
+			});
+			i++;
+			tokens.push({
+				type: "String",
+				value,
+				start,
+				end: i
+			});
+			continue;
+		}
+		if (ch === "`") {
+			const start = i;
+			i++;
+			let raw = "`";
+			while (i < source.length && source[i] !== "`") if (source[i] === "$" && i + 1 < source.length && source[i + 1] === "{") {
+				raw += "${";
+				i += 2;
+				let depth = 1;
+				while (i < source.length && depth > 0) {
+					const ic = source[i];
+					if (ic === "\"" || ic === "'") {
+						raw += ic;
+						i++;
+						while (i < source.length && source[i] !== ic) {
+							if (source[i] === "\\" && i + 1 < source.length) {
+								raw += source[i] + source[i + 1];
+								i += 2;
+								continue;
+							}
+							raw += source[i];
+							i++;
+						}
+						if (i < source.length) {
+							raw += source[i];
+							i++;
+						}
+						continue;
+					}
+					if (ic === "{") depth++;
+					else if (ic === "}") depth--;
+					if (depth > 0) raw += ic;
+					i++;
+				}
+				raw += "}";
+			} else {
+				raw += source[i];
+				i++;
+			}
+			if (i >= source.length) throw new ExpressionError("Unterminated template literal", {
+				source,
+				start,
+				end: i
+			});
+			raw += "`";
+			i++;
+			tokens.push({
+				type: "TemplateLiteral",
+				value: raw,
+				start,
+				end: i
+			});
+			continue;
+		}
+		if (isAlpha(ch)) {
+			const start = i;
+			while (i < source.length && isAlphaNumeric(source[i])) i++;
+			const value = source.slice(start, i);
+			const kw = KEYWORDS.get(value);
+			if (kw) tokens.push({
+				type: kw.type,
+				value: kw.value,
+				start,
+				end: i
+			});
+			else tokens.push({
+				type: "Identifier",
+				value,
+				start,
+				end: i
+			});
+			continue;
+		}
+		const start = i;
+		if (ch === "." && i + 2 < source.length && source[i + 1] === "." && source[i + 2] === ".") {
+			tokens.push({
+				type: "Spread",
+				value: "...",
+				start,
+				end: i + 3
+			});
+			i += 3;
+			continue;
+		}
+		if (ch === ".") {
+			tokens.push({
+				type: "Punctuation",
+				value: ".",
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		if (ch === "|") {
+			if (i + 1 < source.length && source[i + 1] === ">") {
+				tokens.push({
+					type: "Pipe",
+					value: "|>",
+					start,
+					end: i + 2
+				});
+				i += 2;
+				continue;
+			}
+			if (i + 1 < source.length && source[i + 1] === "|") {
+				tokens.push({
+					type: "Operator",
+					value: "||",
+					start,
+					end: i + 2
+				});
+				i += 2;
+				continue;
+			}
+		}
+		if (ch === "&" && i + 1 < source.length && source[i + 1] === "&") {
+			tokens.push({
+				type: "Operator",
+				value: "&&",
+				start,
+				end: i + 2
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "=" && i + 1 < source.length && source[i + 1] === "=") {
+			tokens.push({
+				type: "Operator",
+				value: "==",
+				start,
+				end: i + 2
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "!" && i + 1 < source.length && source[i + 1] === "=") {
+			tokens.push({
+				type: "Operator",
+				value: "!=",
+				start,
+				end: i + 2
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "!") {
+			tokens.push({
+				type: "Operator",
+				value: "!",
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		if (ch === "<") {
+			if (i + 1 < source.length && source[i + 1] === "=") {
+				tokens.push({
+					type: "Operator",
+					value: "<=",
+					start,
+					end: i + 2
+				});
+				i += 2;
+				continue;
+			}
+			tokens.push({
+				type: "Operator",
+				value: "<",
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		if (ch === ">") {
+			if (i + 1 < source.length && source[i + 1] === "=") {
+				tokens.push({
+					type: "Operator",
+					value: ">=",
+					start,
+					end: i + 2
+				});
+				i += 2;
+				continue;
+			}
+			tokens.push({
+				type: "Operator",
+				value: ">",
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		if (ch === "*" && i + 1 < source.length && source[i + 1] === "*") {
+			tokens.push({
+				type: "Operator",
+				value: "**",
+				start,
+				end: i + 2
+			});
+			i += 2;
+			continue;
+		}
+		if (ch === "?") {
+			if (i + 1 < source.length && source[i + 1] === ".") {
+				tokens.push({
+					type: "OptionalChain",
+					value: "?.",
+					start,
+					end: i + 2
+				});
+				i += 2;
+				continue;
+			}
+			if (i + 1 < source.length && source[i + 1] === "?") {
+				tokens.push({
+					type: "NullishCoalescing",
+					value: "??",
+					start,
+					end: i + 2
+				});
+				i += 2;
+				continue;
+			}
+			tokens.push({
+				type: "Punctuation",
+				value: "?",
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+			tokens.push({
+				type: "Operator",
+				value: ch,
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		if ("()[]{},:".includes(ch)) {
+			tokens.push({
+				type: "Punctuation",
+				value: ch,
+				start,
+				end: i + 1
+			});
+			i++;
+			continue;
+		}
+		throw new ExpressionError(`Unexpected character "${ch}"`, {
+			source,
+			start,
+			end: i + 1
+		});
+	}
+	tokens.push({
+		type: "EOF",
+		value: "",
+		start: i,
+		end: i
+	});
+	return tokens;
+}
+//#endregion
+//#region src/parser.ts
+const PIPE_PRECEDENCE = 5;
+const PRECEDENCE = {
+	"||": 10,
+	"&&": 20,
+	"??": 25,
+	"==": 30,
+	"!=": 30,
+	"<": 40,
+	">": 40,
+	"<=": 40,
+	">=": 40,
+	"in": 40,
+	"+": 50,
+	"-": 50,
+	"*": 60,
+	"/": 60,
+	"%": 60,
+	"**": 70,
+	"!": void 0,
+	"not": void 0
+};
+const MAX_PARSE_DEPTH = 32;
+function parse(source, _depth = 0) {
+	if (_depth > MAX_PARSE_DEPTH) throw new ExpressionError("Maximum template nesting depth exceeded", {
+		source,
+		start: 0,
+		end: source.length
+	});
+	const tokens = tokenize(source);
+	let pos = 0;
+	function current() {
+		return tokens[pos];
+	}
+	function advance() {
+		return tokens[pos++];
+	}
+	function expect(type, value) {
+		const tok = current();
+		if (tok.type !== type || value !== void 0 && tok.value !== value) throw new ExpressionError(`Expected ${value ? `"${value}"` : type} but got ${tok.value ? `"${tok.value}"` : tok.type}`, {
+			source,
+			start: tok.start,
+			end: tok.end
+		});
+		return advance();
+	}
+	function parseExpression(minPrec = 0) {
+		let left = parseUnary();
+		if (current().type === "Punctuation" && current().value === "?" && minPrec === 0) {
+			advance();
+			const consequent = parseExpression(0);
+			expect("Punctuation", ":");
+			const alternate = parseExpression(0);
+			left = {
+				type: "ConditionalExpression",
+				test: left,
+				consequent,
+				alternate,
+				start: left.start,
+				end: alternate.end
+			};
+			return left;
+		}
+		while (current().type === "Pipe" && minPrec <= PIPE_PRECEDENCE) {
+			advance();
+			const transform = parsePipeTransform();
+			left = {
+				type: "PipeExpression",
+				input: left,
+				transform,
+				start: left.start,
+				end: transform.end
+			};
+		}
+		while (true) {
+			const tok = current();
+			let prec;
+			if (tok.type === "Operator") {
+				prec = PRECEDENCE[tok.value];
+				if (tok.value === "not") {
+					const nextTok = tokens[pos + 1];
+					if (nextTok && nextTok.type === "Operator" && nextTok.value === "in") prec = PRECEDENCE["in"];
+				}
+			} else if (tok.type === "NullishCoalescing") prec = PRECEDENCE["??"];
+			if (prec === void 0 || prec < minPrec) break;
+			const op = advance();
+			let opValue;
+			if (op.type === "NullishCoalescing") opValue = "??";
+			else if (op.value === "not") {
+				advance();
+				opValue = "not in";
+			} else opValue = op.value;
+			const right = parseExpression(opValue === "**" ? prec : prec + 1);
+			left = {
+				type: "BinaryExpression",
+				operator: opValue,
+				left,
+				right,
+				start: left.start,
+				end: right.end
+			};
+		}
+		if (current().type === "Punctuation" && current().value === "?" && minPrec === 0) {
+			advance();
+			const consequent = parseExpression(0);
+			expect("Punctuation", ":");
+			const alternate = parseExpression(0);
+			left = {
+				type: "ConditionalExpression",
+				test: left,
+				consequent,
+				alternate,
+				start: left.start,
+				end: alternate.end
+			};
+		}
+		while (current().type === "Pipe" && minPrec <= PIPE_PRECEDENCE) {
+			advance();
+			const transform = parsePipeTransform();
+			left = {
+				type: "PipeExpression",
+				input: left,
+				transform,
+				start: left.start,
+				end: transform.end
+			};
+		}
+		return left;
+	}
+	function parsePipeTransform() {
+		let node = parsePrimary();
+		if (current().type === "Punctuation" && current().value === "(") {
+			advance();
+			const args = [];
+			while (!(current().type === "Punctuation" && current().value === ")")) {
+				if (args.length > 0) expect("Punctuation", ",");
+				if (current().type === "Punctuation" && current().value === ")") break;
+				args.push(parseExpression(0));
+			}
+			const end = expect("Punctuation", ")").end;
+			node = {
+				type: "CallExpression",
+				callee: node,
+				args,
+				start: node.start,
+				end
+			};
+		}
+		return node;
+	}
+	function parseUnary() {
+		const tok = current();
+		if (tok.type === "Operator" && (tok.value === "!" || tok.value === "-" || tok.value === "+")) {
+			advance();
+			const operand = parseUnary();
+			return {
+				type: "UnaryExpression",
+				operator: tok.value,
+				operand,
+				start: tok.start,
+				end: operand.end
+			};
+		}
+		return parsePostfix();
+	}
+	function parsePostfix() {
+		let node = parsePrimary();
+		while (true) {
+			const tok = current();
+			if (tok.type === "Punctuation" && tok.value === ".") {
+				advance();
+				const prop = expect("Identifier");
+				node = {
+					type: "MemberExpression",
+					object: node,
+					property: {
+						type: "Identifier",
+						name: prop.value,
+						start: prop.start,
+						end: prop.end
+					},
+					computed: false,
+					start: node.start,
+					end: prop.end
+				};
+				continue;
+			}
+			if (tok.type === "Punctuation" && tok.value === "[") {
+				advance();
+				const property = parseExpression(0);
+				const end = expect("Punctuation", "]").end;
+				node = {
+					type: "MemberExpression",
+					object: node,
+					property,
+					computed: true,
+					start: node.start,
+					end
+				};
+				continue;
+			}
+			if (tok.type === "OptionalChain") {
+				advance();
+				if (current().type === "Punctuation" && current().value === "[") {
+					advance();
+					const property = parseExpression(0);
+					const end = expect("Punctuation", "]").end;
+					node = {
+						type: "OptionalMemberExpression",
+						object: node,
+						property,
+						computed: true,
+						start: node.start,
+						end
+					};
+					continue;
+				}
+				const prop = expect("Identifier");
+				node = {
+					type: "OptionalMemberExpression",
+					object: node,
+					property: {
+						type: "Identifier",
+						name: prop.value,
+						start: prop.start,
+						end: prop.end
+					},
+					computed: false,
+					start: node.start,
+					end: prop.end
+				};
+				continue;
+			}
+			if (tok.type === "Punctuation" && tok.value === "(") {
+				advance();
+				const args = [];
+				while (!(current().type === "Punctuation" && current().value === ")")) {
+					if (args.length > 0) expect("Punctuation", ",");
+					if (current().type === "Punctuation" && current().value === ")") break;
+					args.push(parseExpression(0));
+				}
+				const end = expect("Punctuation", ")").end;
+				node = {
+					type: "CallExpression",
+					callee: node,
+					args,
+					start: node.start,
+					end
+				};
+				continue;
+			}
+			break;
+		}
+		return node;
+	}
+	function parsePrimary() {
+		const tok = current();
+		if (tok.type === "Number") {
+			advance();
+			const raw = tok.value.replace(/_/g, "");
+			return {
+				type: "NumberLiteral",
+				value: Number(raw),
+				start: tok.start,
+				end: tok.end
+			};
+		}
+		if (tok.type === "String") {
+			advance();
+			return {
+				type: "StringLiteral",
+				value: tok.value,
+				start: tok.start,
+				end: tok.end
+			};
+		}
+		if (tok.type === "Boolean") {
+			advance();
+			return {
+				type: "BooleanLiteral",
+				value: tok.value === "true",
+				start: tok.start,
+				end: tok.end
+			};
+		}
+		if (tok.type === "Null") {
+			advance();
+			return {
+				type: "NullLiteral",
+				value: null,
+				start: tok.start,
+				end: tok.end
+			};
+		}
+		if (tok.type === "Undefined") {
+			advance();
+			return {
+				type: "UndefinedLiteral",
+				value: void 0,
+				start: tok.start,
+				end: tok.end
+			};
+		}
+		if (tok.type === "TemplateLiteral") return parseTemplateLiteral();
+		if (tok.type === "Identifier") {
+			advance();
+			return {
+				type: "Identifier",
+				name: tok.value,
+				start: tok.start,
+				end: tok.end
+			};
+		}
+		if (tok.type === "Punctuation" && tok.value === "(") {
+			advance();
+			const expr = parseExpression(0);
+			expect("Punctuation", ")");
+			return expr;
+		}
+		if (tok.type === "Punctuation" && tok.value === "[") return parseArrayLiteral();
+		if (tok.type === "Punctuation" && tok.value === "{") return parseObjectLiteral();
+		if (tok.type === "Punctuation" && tok.value === ".") return parseLambdaExpression();
+		if (tok.type === "Spread") {
+			advance();
+			const argument = parseExpression(0);
+			return {
+				type: "SpreadElement",
+				argument,
+				start: tok.start,
+				end: argument.end
+			};
+		}
+		throw new ExpressionError(`Unexpected ${tok.type === "EOF" ? "end of expression" : `token "${tok.value}"`}`, {
+			source,
+			start: tok.start,
+			end: tok.end
+		});
+	}
+	function parseLambdaExpression() {
+		const start = current().start;
+		advance();
+		const prop = expect("Identifier");
+		let node = {
+			type: "LambdaAccessor",
+			property: prop.value,
+			start,
+			end: prop.end
+		};
+		while (true) {
+			const tok = current();
+			if (tok.type === "Punctuation" && tok.value === ".") {
+				advance();
+				const nextProp = expect("Identifier");
+				node = {
+					type: "MemberExpression",
+					object: node,
+					property: {
+						type: "Identifier",
+						name: nextProp.value,
+						start: nextProp.start,
+						end: nextProp.end
+					},
+					computed: false,
+					start: node.start,
+					end: nextProp.end
+				};
+				continue;
+			}
+			if (tok.type === "OptionalChain") {
+				advance();
+				const nextProp = expect("Identifier");
+				node = {
+					type: "OptionalMemberExpression",
+					object: node,
+					property: {
+						type: "Identifier",
+						name: nextProp.value,
+						start: nextProp.start,
+						end: nextProp.end
+					},
+					computed: false,
+					start: node.start,
+					end: nextProp.end
+				};
+				continue;
+			}
+			if (tok.type === "Punctuation" && tok.value === "[") {
+				advance();
+				const property = parseExpression(0);
+				const end = expect("Punctuation", "]").end;
+				node = {
+					type: "MemberExpression",
+					object: node,
+					property,
+					computed: true,
+					start: node.start,
+					end
+				};
+				continue;
+			}
+			if (tok.type === "Punctuation" && tok.value === "(") {
+				advance();
+				const args = [];
+				while (!(current().type === "Punctuation" && current().value === ")")) {
+					if (args.length > 0) expect("Punctuation", ",");
+					if (current().type === "Punctuation" && current().value === ")") break;
+					args.push(parseExpression(0));
+				}
+				const end = expect("Punctuation", ")").end;
+				node = {
+					type: "CallExpression",
+					callee: node,
+					args,
+					start: node.start,
+					end
+				};
+				continue;
+			}
+			break;
+		}
+		const tok = current();
+		let prec;
+		if (tok.type === "Operator") {
+			prec = PRECEDENCE[tok.value];
+			if (tok.value === "not") {
+				const nextTok = tokens[pos + 1];
+				if (nextTok && nextTok.type === "Operator" && nextTok.value === "in") prec = PRECEDENCE["in"];
+			}
+		} else if (tok.type === "NullishCoalescing") prec = PRECEDENCE["??"];
+		if (prec !== void 0) {
+			let left = node;
+			while (true) {
+				const opTok = current();
+				let opPrec;
+				if (opTok.type === "Operator") {
+					opPrec = PRECEDENCE[opTok.value];
+					if (opTok.value === "not") {
+						const nextTok = tokens[pos + 1];
+						if (nextTok && nextTok.type === "Operator" && nextTok.value === "in") opPrec = PRECEDENCE["in"];
+					}
+				} else if (opTok.type === "NullishCoalescing") opPrec = PRECEDENCE["??"];
+				if (opPrec === void 0) break;
+				const op = advance();
+				let opValue;
+				if (op.type === "NullishCoalescing") opValue = "??";
+				else if (op.value === "not") {
+					advance();
+					opValue = "not in";
+				} else opValue = op.value;
+				const right = parseExpression(opValue === "**" ? opPrec : opPrec + 1);
+				left = {
+					type: "BinaryExpression",
+					operator: opValue,
+					left,
+					right,
+					start: left.start,
+					end: right.end
+				};
+			}
+			node = left;
+		}
+		if (current().type === "Punctuation" && current().value === "?") {
+			advance();
+			const consequent = parseExpression(0);
+			expect("Punctuation", ":");
+			const alternate = parseExpression(0);
+			return {
+				type: "LambdaExpression",
+				body: {
+					type: "ConditionalExpression",
+					test: node,
+					consequent,
+					alternate,
+					start,
+					end: alternate.end
+				},
+				start,
+				end: alternate.end
+			};
+		}
+		if (node.type === "LambdaAccessor") return node;
+		return {
+			type: "LambdaExpression",
+			body: node,
+			start,
+			end: node.end
+		};
+	}
+	function parseArrayLiteral() {
+		const start = expect("Punctuation", "[").start;
+		const elements = [];
+		while (!(current().type === "Punctuation" && current().value === "]")) {
+			if (elements.length > 0) expect("Punctuation", ",");
+			if (current().type === "Punctuation" && current().value === "]") break;
+			elements.push(parseExpression(0));
+		}
+		return {
+			type: "ArrayLiteral",
+			elements,
+			start,
+			end: expect("Punctuation", "]").end
+		};
+	}
+	function parseObjectLiteral() {
+		const start = expect("Punctuation", "{").start;
+		const properties = [];
+		while (!(current().type === "Punctuation" && current().value === "}")) {
+			if (properties.length > 0) expect("Punctuation", ",");
+			if (current().type === "Punctuation" && current().value === "}") break;
+			let key;
+			let computed = false;
+			if (current().type === "Punctuation" && current().value === "[") {
+				advance();
+				key = parseExpression(0);
+				expect("Punctuation", "]");
+				computed = true;
+			} else {
+				const tok = current();
+				if (tok.type === "Identifier") {
+					advance();
+					key = {
+						type: "Identifier",
+						name: tok.value,
+						start: tok.start,
+						end: tok.end
+					};
+					const next = current();
+					if (next.type === "Punctuation" && (next.value === "," || next.value === "}")) {
+						const value = {
+							type: "Identifier",
+							name: tok.value,
+							start: tok.start,
+							end: tok.end
+						};
+						properties.push({
+							type: "ObjectProperty",
+							key,
+							value,
+							computed: false,
+							start: key.start,
+							end: value.end
+						});
+						continue;
+					}
+				} else if (tok.type === "String") {
+					advance();
+					key = {
+						type: "StringLiteral",
+						value: tok.value,
+						start: tok.start,
+						end: tok.end
+					};
+				} else throw new ExpressionError(`Expected property name but got "${tok.value}"`, {
+					source,
+					start: tok.start,
+					end: tok.end
+				});
+			}
+			expect("Punctuation", ":");
+			const value = parseExpression(0);
+			properties.push({
+				type: "ObjectProperty",
+				key,
+				value,
+				computed,
+				start: key.start,
+				end: value.end
+			});
+		}
+		return {
+			type: "ObjectLiteral",
+			properties,
+			start,
+			end: expect("Punctuation", "}").end
+		};
+	}
+	function parseTemplateLiteral() {
+		const tok = advance();
+		const raw = tok.value.slice(1, -1);
+		const parts = [];
+		let i = 0;
+		let textStart = 0;
+		while (i < raw.length) if (raw[i] === "$" && i + 1 < raw.length && raw[i + 1] === "{") {
+			if (i > textStart) {
+				const text = raw.slice(textStart, i);
+				parts.push({
+					type: "StringLiteral",
+					value: text,
+					start: tok.start,
+					end: tok.end
+				});
+			}
+			i += 2;
+			let depth = 1;
+			const exprStart = i;
+			while (i < raw.length && depth > 0) {
+				if (raw[i] === "{") depth++;
+				else if (raw[i] === "}") depth--;
+				if (depth > 0) i++;
+			}
+			const exprSource = raw.slice(exprStart, i);
+			i++;
+			textStart = i;
+			const exprAst = parse(exprSource, _depth + 1);
+			parts.push(exprAst);
+		} else i++;
+		if (textStart < raw.length) {
+			const text = raw.slice(textStart);
+			parts.push({
+				type: "StringLiteral",
+				value: text,
+				start: tok.start,
+				end: tok.end
+			});
+		}
+		return {
+			type: "TemplateLiteral",
+			parts,
+			start: tok.start,
+			end: tok.end
+		};
+	}
+	const result = parseExpression(0);
+	if (current().type !== "EOF") {
+		const tok = current();
+		throw new ExpressionError(`Unexpected token "${tok.value}"`, {
+			source,
+			start: tok.start,
+			end: tok.end
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/compiler.ts
+function compile(ast) {
+	return optimize(ast);
+}
+function optimize(node) {
+	switch (node.type) {
+		case "BinaryExpression": {
+			const left = optimize(node.left);
+			const right = optimize(node.right);
+			if (isConstant(left) && isConstant(right)) {
+				const result = evalConstant(node.operator, valueOf(left), valueOf(right));
+				if (result !== void 0) return makeConstant(result, node.start, node.end);
+			}
+			return {
+				...node,
+				left,
+				right
+			};
+		}
+		case "ConditionalExpression": {
+			const test = optimize(node.test);
+			if (isConstant(test)) return valueOf(test) ? optimize(node.consequent) : optimize(node.alternate);
+			return {
+				...node,
+				test,
+				consequent: optimize(node.consequent),
+				alternate: optimize(node.alternate)
+			};
+		}
+		case "UnaryExpression": {
+			const operand = optimize(node.operand);
+			if (isConstant(operand)) {
+				const val = valueOf(operand);
+				if (node.operator === "!" && typeof val === "boolean") return {
+					type: "BooleanLiteral",
+					value: !val,
+					start: node.start,
+					end: node.end
+				};
+				if (node.operator === "-" && typeof val === "number") return {
+					type: "NumberLiteral",
+					value: -val,
+					start: node.start,
+					end: node.end
+				};
+			}
+			return {
+				...node,
+				operand
+			};
+		}
+		case "PipeExpression": return {
+			...node,
+			input: optimize(node.input),
+			transform: optimize(node.transform)
+		};
+		case "ArrayLiteral": return {
+			...node,
+			elements: node.elements.map((e) => optimize(e))
+		};
+		case "CallExpression": return {
+			...node,
+			args: node.args.map((a) => optimize(a))
+		};
+		case "MemberExpression":
+		case "OptionalMemberExpression": return {
+			...node,
+			object: optimize(node.object),
+			property: node.computed ? optimize(node.property) : node.property
+		};
+		case "LambdaExpression": return {
+			...node,
+			body: optimize(node.body)
+		};
+		default: return node;
+	}
+}
+function isConstant(node) {
+	return node.type === "NumberLiteral" || node.type === "StringLiteral" || node.type === "BooleanLiteral" || node.type === "NullLiteral";
+}
+function valueOf(node) {
+	if (node.type === "NumberLiteral") return node.value;
+	if (node.type === "StringLiteral") return node.value;
+	if (node.type === "BooleanLiteral") return node.value;
+	if (node.type === "NullLiteral") return null;
+}
+function evalConstant(op, left, right) {
+	if (typeof left === "number" && typeof right === "number") switch (op) {
+		case "+": return left + right;
+		case "-": return left - right;
+		case "*": return left * right;
+		case "/": return left / right;
+		case "%": return left % right;
+		case "**": return left ** right;
+		case "<": return left < right;
+		case ">": return left > right;
+		case "<=": return left <= right;
+		case ">=": return left >= right;
+		case "==": return left === right;
+		case "!=": return left !== right;
+	}
+	if (typeof left === "string" && typeof right === "string" && op === "+") return left + right;
+	if (typeof left === "boolean" && typeof right === "boolean") {
+		if (op === "&&") return left && right;
+		if (op === "||") return left || right;
+	}
+	if (op === "==") return left === right;
+	if (op === "!=") return left !== right;
+}
+function makeConstant(value, start, end) {
+	if (typeof value === "number") return {
+		type: "NumberLiteral",
+		value,
+		start,
+		end
+	};
+	if (typeof value === "string") return {
+		type: "StringLiteral",
+		value,
+		start,
+		end
+	};
+	if (typeof value === "boolean") return {
+		type: "BooleanLiteral",
+		value,
+		start,
+		end
+	};
+	if (value === null) return {
+		type: "NullLiteral",
+		value: null,
+		start,
+		end
+	};
+	return {
+		type: "UndefinedLiteral",
+		value: void 0,
+		start,
+		end
+	};
+}
+//#endregion
+//#region src/eval-ops.ts
+/** Receiver type check for safe methods. */
+function isAllowedReceiver(obj, methodName) {
+	const t = typeof obj;
+	switch (methodName) {
+		case "startsWith":
+		case "endsWith":
+		case "substring":
+		case "charAt":
+		case "charCodeAt":
+		case "repeat":
+		case "trimStart":
+		case "trimEnd":
+		case "replace":
+		case "replaceAll": return t === "string";
+		case "includes":
+		case "indexOf":
+		case "slice":
+		case "at": return t === "string" || Array.isArray(obj);
+		case "toFixed": return t === "number";
+		case "toString": return t === "string" || t === "number";
+		default: return false;
+	}
+}
+function toPropertyKey(value) {
+	return String(value);
+}
+function applyBinaryOp(operator, left, right) {
+	switch (operator) {
+		case "+": return left + right;
+		case "-": return left - right;
+		case "*": return left * right;
+		case "/": return left / right;
+		case "%": return left % right;
+		case "**": return left ** right;
+		case "==": return left === right;
+		case "!=": return left !== right;
+		case "<": return left < right;
+		case ">": return left > right;
+		case "<=": return left <= right;
+		case ">=": return left >= right;
+		case "in":
+			if (typeof right === "string") return right.includes(left);
+			if (Array.isArray(right)) return right.includes(left);
+			throw new BonsaiTypeError("in", "a string or array", right);
+		case "not in":
+			if (typeof right === "string") return !right.includes(left);
+			if (Array.isArray(right)) return !right.includes(left);
+			throw new BonsaiTypeError("not in", "a string or array", right);
+		default: throw new Error(`Unknown binary operator: ${operator}`);
+	}
+}
+function applyUnaryOp(operator, operand) {
+	switch (operator) {
+		case "!": return !operand;
+		case "-": return -operand;
+		case "+": return Number(operand);
+		default: throw new Error(`Unknown unary operator: ${operator}`);
+	}
+}
+function validateMethodCall(obj, methodName, guard) {
+	guard.checkNameAccess(methodName, "method");
+	if (obj == null) throw new BonsaiTypeError(methodName, "a non-null value", obj);
+	if (!isAllowedReceiver(obj, methodName)) throw new BonsaiSecurityError("METHOD_NOT_ALLOWED", `Method "${methodName}" is not allowed on ${typeof obj}`);
+	const method = obj[methodName];
+	if (typeof method !== "function") throw new BonsaiTypeError(methodName, "a method", method);
+	return method;
+}
+function resolveTransform(name, transforms) {
+	if (!Object.hasOwn(transforms, name)) throw new BonsaiReferenceError("transform", name, suggest(name, Object.keys(transforms)));
+	return transforms[name];
+}
+function resolveFunction(name, functions) {
+	if (!Object.hasOwn(functions, name)) throw new BonsaiReferenceError("function", name, suggest(name, Object.keys(functions)));
+	return functions[name];
+}
+function getIdentifierName(node, message = "Expected identifier") {
+	if (node.type !== "Identifier") throw new Error(message);
+	return node.name;
+}
+function getObjectLiteralKeyName(node, message = "Expected identifier or string literal") {
+	if (node.type === "Identifier" || node.type === "StringLiteral") return node.type === "Identifier" ? node.name : node.value;
+	throw new Error(message);
+}
+function expandSpreadValue(value, maxLength) {
+	if (Array.isArray(value)) {
+		if (maxLength !== void 0 && value.length > maxLength) throw new BonsaiSecurityError("MAX_ARRAY_LENGTH", `Spread source length (${value.length}) exceeds maximum (${maxLength})`);
+		return value;
+	}
+	if (value != null) {
+		if (typeof value[Symbol.iterator] === "function") {
+			const result = [];
+			for (const item of value) {
+				result.push(item);
+				if (maxLength !== void 0 && result.length > maxLength) throw new BonsaiSecurityError("MAX_ARRAY_LENGTH", `Spread exceeds maximum array length (${maxLength})`);
+			}
+			return result;
+		}
+	}
+	throw new BonsaiTypeError("spread", "an iterable value", value);
+}
+const REPLACE_METHODS = new Set(["replace", "replaceAll"]);
+const MAX_REPEAT_COUNT = 1e5;
+function validateMethodArgs(methodName, args) {
+	if (REPLACE_METHODS.has(methodName)) for (const arg of args) {
+		if (typeof arg === "function") throw new BonsaiTypeError(methodName, "string arguments (callbacks are not allowed)", arg);
+		if (arg instanceof RegExp) throw new BonsaiTypeError(methodName, "string arguments (RegExp is not allowed)", arg);
+		if (arg != null && typeof arg === "object") throw new BonsaiTypeError(methodName, "string arguments (objects are not allowed)", arg);
+	}
+	if (methodName === "repeat") {
+		const count = Number(args[0]);
+		if (!Number.isFinite(count) || count < 0 || count > MAX_REPEAT_COUNT) throw new BonsaiTypeError("repeat", `a count between 0 and ${MAX_REPEAT_COUNT}`, args[0]);
+	}
+}
+function accessMember(object, propertyNode, computed, computedValue, guard) {
+	const key = computed ? toPropertyKey(computedValue) : getIdentifierName(propertyNode, "Expected identifier property");
+	guard.checkNameAccess(key, "member");
+	return object?.[key];
+}
+//#endregion
+//#region src/evaluator.ts
+function rejectPromise(value, kind, name) {
+	if (value instanceof Promise) throw new BonsaiTypeError(name, `a synchronous ${kind} result — use evaluate() instead of evaluateSync() for async`, value);
+	return value;
+}
+function evaluate(node, context, transforms, functions, guard, source) {
+	return evalNode(node, {
+		ctx: context,
+		tr: transforms,
+		fn: functions,
+		g: guard,
+		s: source
+	});
+}
+function evalNode(node, env) {
+	const { ctx, g, s } = env;
+	g.enterDepth();
+	g.step();
+	try {
+		switch (node.type) {
+			case "NumberLiteral":
+			case "StringLiteral":
+			case "BooleanLiteral": return node.value;
+			case "NullLiteral": return null;
+			case "UndefinedLiteral": return;
+			case "Identifier":
+				g.checkNameAccess(node.name, "identifier");
+				return Object.hasOwn(ctx, node.name) ? ctx[node.name] : void 0;
+			case "UnaryExpression": return applyUnaryOp(node.operator, evalNode(node.operand, env));
+			case "BinaryExpression": {
+				const op = node.operator;
+				if (op === "&&") {
+					const left = evalNode(node.left, env);
+					return left ? evalNode(node.right, env) : left;
+				}
+				if (op === "||") {
+					const left = evalNode(node.left, env);
+					return left ? left : evalNode(node.right, env);
+				}
+				if (op === "??") {
+					const left = evalNode(node.left, env);
+					return left != null ? left : evalNode(node.right, env);
+				}
+				return applyBinaryOp(op, evalNode(node.left, env), evalNode(node.right, env));
+			}
+			case "ConditionalExpression": return evalNode(node.test, env) ? evalNode(node.consequent, env) : evalNode(node.alternate, env);
+			case "MemberExpression": {
+				const object = evalNode(node.object, env);
+				const computedValue = node.computed ? evalNode(node.property, env) : void 0;
+				try {
+					return accessMember(object, node.property, node.computed, computedValue, g);
+				} catch (e) {
+					if (s) attachLocation(e, s, node.start, node.end);
+					throw e;
+				}
+			}
+			case "OptionalMemberExpression": {
+				const object = evalNode(node.object, env);
+				if (object == null) return void 0;
+				const computedValue = node.computed ? evalNode(node.property, env) : void 0;
+				try {
+					return accessMember(object, node.property, node.computed, computedValue, g);
+				} catch (e) {
+					if (s) attachLocation(e, s, node.start, node.end);
+					throw e;
+				}
+			}
+			case "ArrayLiteral": {
+				const elements = [];
+				for (const el of node.elements) if (el.type === "SpreadElement") elements.push(...expandSpreadValue(evalNode(el.argument, env), g.policy.maxArrayLength));
+				else elements.push(evalNode(el, env));
+				g.checkArrayLength(elements.length);
+				return elements;
+			}
+			case "ObjectLiteral": {
+				const obj = Object.create(null);
+				for (const prop of node.properties) {
+					const key = getObjectPropertyKey$1(prop, env);
+					obj[key] = evalNode(prop.value, env);
+				}
+				return obj;
+			}
+			case "CallExpression": return evalCallExpression(node, env);
+			case "PipeExpression": {
+				const input = evalNode(node.input, env);
+				try {
+					return evalPipe(input, node.transform, env);
+				} catch (e) {
+					if (s) attachLocation(e, s, node.transform.start, node.transform.end);
+					throw e;
+				}
+			}
+			case "TemplateLiteral": {
+				let result = "";
+				for (const part of node.parts) result += part.type === "StringLiteral" ? part.value : String(evalNode(part, env));
+				return result;
+			}
+			case "SpreadElement": return evalNode(node.argument, env);
+			case "LambdaAccessor": return makeLambdaAccessor$1(node.property, g);
+			case "LambdaExpression": return (item) => evalLambdaBody(node.body, item, env);
+			default: throw new Error(`Unknown node type: ${node.type}`);
+		}
+	} finally {
+		g.exitDepth();
+	}
+}
+function evalCallExpression(node, env) {
+	const { fn, g, s } = env;
+	if (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") {
+		const obj = evalNode(node.callee.object, env);
+		if (node.callee.type === "OptionalMemberExpression" && obj == null) return void 0;
+		const computedValue = node.callee.computed ? evalNode(node.callee.property, env) : void 0;
+		const methodName = node.callee.computed ? String(computedValue) : getIdentifierName(node.callee.property, "Expected method name");
+		try {
+			const method = validateMethodCall(obj, methodName, g);
+			const args = [];
+			for (const arg of node.args) pushCallArgument(args, arg, env);
+			validateMethodArgs(methodName, args);
+			return rejectPromise(method.call(obj, ...args), "method", methodName);
+		} catch (e) {
+			if (s) attachLocation(e, s, node.start, node.end);
+			throw e;
+		}
+	}
+	if (node.callee.type === "Identifier") try {
+		const func = resolveFunction(node.callee.name, fn);
+		const args = [];
+		for (const arg of node.args) pushCallArgument(args, arg, env);
+		return rejectPromise(func(...args), "function", node.callee.name);
+	} catch (e) {
+		if (s) attachLocation(e, s, node.start, node.end);
+		throw e;
+	}
+	throw new Error("Cannot call non-identifier");
+}
+function pushCallArgument(args, node, env) {
+	if (node.type === "SpreadElement") {
+		args.push(...expandSpreadValue(evalNode(node.argument, env), env.g.policy.maxArrayLength));
+		return;
+	}
+	args.push(evalArg(node, env));
+}
+function evalArg(node, env) {
+	if (node.type === "LambdaAccessor") return makeLambdaAccessor$1(node.property, env.g);
+	return evalNode(node, env);
+}
+function evalPipe(input, transformNode, env) {
+	const { tr } = env;
+	if (transformNode.type === "CallExpression") {
+		const calleeName = getIdentifierName(transformNode.callee, "Transform must be an identifier");
+		const func = resolveTransform(calleeName, tr);
+		const args = [];
+		for (const arg of transformNode.args) pushCallArgument(args, arg, env);
+		return rejectPromise(func(input, ...args), "transform", calleeName);
+	}
+	if (transformNode.type === "Identifier") return rejectPromise(resolveTransform(transformNode.name, tr)(input), "transform", transformNode.name);
+	throw new Error("Invalid transform expression");
+}
+function evalLambdaBody(node, item, env) {
+	const { g } = env;
+	g.enterDepth();
+	g.step();
+	let ownDepth = true;
+	try {
+		switch (node.type) {
+			case "LambdaAccessor":
+				g.checkNameAccess(node.property, "member");
+				return item?.[node.property];
+			case "MemberExpression": {
+				const object = evalLambdaBody(node.object, item, env);
+				const computedValue = node.computed ? evalNode(node.property, env) : void 0;
+				return accessMember(object, node.property, node.computed, computedValue, g);
+			}
+			case "OptionalMemberExpression": {
+				const object = evalLambdaBody(node.object, item, env);
+				if (object == null) return void 0;
+				const computedValue = node.computed ? evalNode(node.property, env) : void 0;
+				return accessMember(object, node.property, node.computed, computedValue, g);
+			}
+			case "CallExpression":
+				if (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") {
+					const obj = evalLambdaBody(node.callee.object, item, env);
+					if (node.callee.type === "OptionalMemberExpression" && obj == null) return void 0;
+					const computedValue = node.callee.computed ? evalNode(node.callee.property, env) : void 0;
+					const methodName = node.callee.computed ? String(computedValue) : getIdentifierName(node.callee.property, "Expected method name");
+					const method = validateMethodCall(obj, methodName, g);
+					const args = [];
+					for (const arg of node.args) if (arg.type === "SpreadElement") args.push(...expandSpreadValue(evalNode(arg.argument, env), g.policy.maxArrayLength));
+					else args.push(evalNode(arg, env));
+					validateMethodArgs(methodName, args);
+					return rejectPromise(method.call(obj, ...args), "method", methodName);
+				}
+				ownDepth = false;
+				g.exitDepth();
+				return evalNode(node, env);
+			case "BinaryExpression": {
+				const op = node.operator;
+				if (op === "&&") {
+					const left = evalLambdaBody(node.left, item, env);
+					return left ? evalLambdaBody(node.right, item, env) : left;
+				}
+				if (op === "||") {
+					const left = evalLambdaBody(node.left, item, env);
+					return left ? left : evalLambdaBody(node.right, item, env);
+				}
+				if (op === "??") {
+					const left = evalLambdaBody(node.left, item, env);
+					return left != null ? left : evalLambdaBody(node.right, item, env);
+				}
+				return applyBinaryOp(op, evalLambdaBody(node.left, item, env), evalLambdaBody(node.right, item, env));
+			}
+			case "UnaryExpression": return applyUnaryOp(node.operator, evalLambdaBody(node.operand, item, env));
+			case "ConditionalExpression": return evalLambdaBody(node.test, item, env) ? evalLambdaBody(node.consequent, item, env) : evalLambdaBody(node.alternate, item, env);
+			case "LambdaExpression": return evalLambdaBody(node.body, item, env);
+			default:
+				ownDepth = false;
+				g.exitDepth();
+				return evalNode(node, env);
+		}
+	} finally {
+		if (ownDepth) g.exitDepth();
+	}
+}
+function getObjectPropertyKey$1(prop, env) {
+	const key = prop.computed ? String(evalNode(prop.key, env)) : getObjectLiteralKeyName(prop.key);
+	env.g.checkNameAccess(key, "object-key");
+	return key;
+}
+function makeLambdaAccessor$1(property, guard) {
+	return (item) => {
+		guard.checkNameAccess(property, "member");
+		return item?.[property];
+	};
+}
+//#endregion
+//#region src/evaluator-async.ts
+async function evaluateAsync(node, context, transforms, functions, guard, source) {
+	const result = await evalNodeAsync(node, {
+		ctx: context,
+		tr: transforms,
+		fn: functions,
+		g: guard,
+		s: source
+	});
+	guard.checkTimeout();
+	return result;
+}
+async function evalNodeAsync(node, env) {
+	const { ctx, g, s } = env;
+	g.enterDepth();
+	g.step();
+	try {
+		switch (node.type) {
+			case "NumberLiteral":
+			case "StringLiteral":
+			case "BooleanLiteral": return node.value;
+			case "NullLiteral": return null;
+			case "UndefinedLiteral": return;
+			case "Identifier":
+				g.checkNameAccess(node.name, "identifier");
+				return Object.hasOwn(ctx, node.name) ? ctx[node.name] : void 0;
+			case "UnaryExpression": return applyUnaryOp(node.operator, await evalNodeAsync(node.operand, env));
+			case "BinaryExpression": {
+				const op = node.operator;
+				if (op === "&&") {
+					const left = await evalNodeAsync(node.left, env);
+					return left ? await evalNodeAsync(node.right, env) : left;
+				}
+				if (op === "||") {
+					const left = await evalNodeAsync(node.left, env);
+					return left ? left : await evalNodeAsync(node.right, env);
+				}
+				if (op === "??") {
+					const left = await evalNodeAsync(node.left, env);
+					return left != null ? left : await evalNodeAsync(node.right, env);
+				}
+				return applyBinaryOp(op, await evalNodeAsync(node.left, env), await evalNodeAsync(node.right, env));
+			}
+			case "ConditionalExpression": return await evalNodeAsync(node.test, env) ? await evalNodeAsync(node.consequent, env) : await evalNodeAsync(node.alternate, env);
+			case "MemberExpression": {
+				const object = await evalNodeAsync(node.object, env);
+				const computedValue = node.computed ? await evalNodeAsync(node.property, env) : void 0;
+				try {
+					return accessMember(object, node.property, node.computed, computedValue, g);
+				} catch (e) {
+					if (s) attachLocation(e, s, node.start, node.end);
+					throw e;
+				}
+			}
+			case "OptionalMemberExpression": {
+				const object = await evalNodeAsync(node.object, env);
+				if (object == null) return void 0;
+				const computedValue = node.computed ? await evalNodeAsync(node.property, env) : void 0;
+				try {
+					return accessMember(object, node.property, node.computed, computedValue, g);
+				} catch (e) {
+					if (s) attachLocation(e, s, node.start, node.end);
+					throw e;
+				}
+			}
+			case "ArrayLiteral": {
+				const elements = [];
+				for (const el of node.elements) if (el.type === "SpreadElement") elements.push(...expandSpreadValue(await evalNodeAsync(el.argument, env), g.policy.maxArrayLength));
+				else elements.push(await evalNodeAsync(el, env));
+				g.checkArrayLength(elements.length);
+				return elements;
+			}
+			case "ObjectLiteral": {
+				const obj = Object.create(null);
+				for (const prop of node.properties) {
+					const key = await getObjectPropertyKey(prop, env);
+					obj[key] = await evalNodeAsync(prop.value, env);
+				}
+				return obj;
+			}
+			case "CallExpression": return await evalCallExpressionAsync(node, env);
+			case "PipeExpression": {
+				const input = await evalNodeAsync(node.input, env);
+				try {
+					return await evalPipeAsync(input, node.transform, env);
+				} catch (e) {
+					if (s) attachLocation(e, s, node.transform.start, node.transform.end);
+					throw e;
+				}
+			}
+			case "TemplateLiteral": {
+				let result = "";
+				for (const part of node.parts) result += part.type === "StringLiteral" ? part.value : String(await evalNodeAsync(part, env));
+				return result;
+			}
+			case "SpreadElement": return await evalNodeAsync(node.argument, env);
+			case "LambdaAccessor": return makeLambdaAccessor(node.property, g);
+			case "LambdaExpression": return (item) => evalLambdaBodyAsync(node.body, item, env);
+			default: throw new Error(`Unknown node type: ${node.type}`);
+		}
+	} finally {
+		g.exitDepth();
+	}
+}
+async function evalCallExpressionAsync(node, env) {
+	const { fn, g, s } = env;
+	if (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") {
+		const obj = await evalNodeAsync(node.callee.object, env);
+		if (node.callee.type === "OptionalMemberExpression" && obj == null) return void 0;
+		const computedValue = node.callee.computed ? await evalNodeAsync(node.callee.property, env) : void 0;
+		const methodName = node.callee.computed ? String(computedValue) : getIdentifierName(node.callee.property, "Expected method name");
+		try {
+			const method = validateMethodCall(obj, methodName, g);
+			const args = [];
+			for (const arg of node.args) await pushCallArgumentAsync(args, arg, env);
+			validateMethodArgs(methodName, args);
+			const result = await method.call(obj, ...args);
+			g.checkTimeout();
+			return result;
+		} catch (e) {
+			if (s) attachLocation(e, s, node.start, node.end);
+			throw e;
+		}
+	}
+	if (node.callee.type === "Identifier") try {
+		const func = resolveFunction(node.callee.name, fn);
+		const args = [];
+		for (const arg of node.args) await pushCallArgumentAsync(args, arg, env);
+		const result = await func(...args);
+		g.checkTimeout();
+		return result;
+	} catch (e) {
+		if (s) attachLocation(e, s, node.start, node.end);
+		throw e;
+	}
+	throw new Error("Cannot call non-identifier");
+}
+async function pushCallArgumentAsync(args, node, env) {
+	if (node.type === "SpreadElement") {
+		args.push(...expandSpreadValue(await evalNodeAsync(node.argument, env), env.g.policy.maxArrayLength));
+		return;
+	}
+	args.push(await evalArgAsync(node, env));
+}
+async function evalArgAsync(node, env) {
+	if (node.type === "LambdaAccessor") return makeLambdaAccessor(node.property, env.g);
+	return await evalNodeAsync(node, env);
+}
+async function evalPipeAsync(input, transformNode, env) {
+	const { tr, g } = env;
+	if (transformNode.type === "CallExpression") {
+		const func = resolveTransform(getIdentifierName(transformNode.callee, "Transform must be an identifier"), tr);
+		const args = [];
+		for (const arg of transformNode.args) await pushCallArgumentAsync(args, arg, env);
+		const result = await func(input, ...args);
+		g.checkTimeout();
+		return result;
+	}
+	if (transformNode.type === "Identifier") {
+		const result = await resolveTransform(transformNode.name, tr)(input);
+		g.checkTimeout();
+		return result;
+	}
+	throw new Error("Invalid transform expression");
+}
+async function evalLambdaBodyAsync(node, item, env) {
+	const { g } = env;
+	g.enterDepth();
+	g.step();
+	let ownDepth = true;
+	try {
+		switch (node.type) {
+			case "LambdaAccessor":
+				g.checkNameAccess(node.property, "member");
+				return item?.[node.property];
+			case "MemberExpression": {
+				const object = await evalLambdaBodyAsync(node.object, item, env);
+				const computedValue = node.computed ? await evalNodeAsync(node.property, env) : void 0;
+				return accessMember(object, node.property, node.computed, computedValue, g);
+			}
+			case "OptionalMemberExpression": {
+				const object = await evalLambdaBodyAsync(node.object, item, env);
+				if (object == null) return void 0;
+				const computedValue = node.computed ? await evalNodeAsync(node.property, env) : void 0;
+				return accessMember(object, node.property, node.computed, computedValue, g);
+			}
+			case "CallExpression":
+				if (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") {
+					const obj = await evalLambdaBodyAsync(node.callee.object, item, env);
+					if (node.callee.type === "OptionalMemberExpression" && obj == null) return void 0;
+					const computedValue = node.callee.computed ? await evalNodeAsync(node.callee.property, env) : void 0;
+					const methodName = node.callee.computed ? String(computedValue) : getIdentifierName(node.callee.property, "Expected method name");
+					const method = validateMethodCall(obj, methodName, g);
+					const args = [];
+					for (const arg of node.args) if (arg.type === "SpreadElement") args.push(...expandSpreadValue(await evalNodeAsync(arg.argument, env), g.policy.maxArrayLength));
+					else args.push(await evalNodeAsync(arg, env));
+					validateMethodArgs(methodName, args);
+					return await method.call(obj, ...args);
+				}
+				ownDepth = false;
+				g.exitDepth();
+				return await evalNodeAsync(node, env);
+			case "BinaryExpression": {
+				const op = node.operator;
+				if (op === "&&") {
+					const left = await evalLambdaBodyAsync(node.left, item, env);
+					return left ? await evalLambdaBodyAsync(node.right, item, env) : left;
+				}
+				if (op === "||") {
+					const left = await evalLambdaBodyAsync(node.left, item, env);
+					return left ? left : await evalLambdaBodyAsync(node.right, item, env);
+				}
+				if (op === "??") {
+					const left = await evalLambdaBodyAsync(node.left, item, env);
+					return left != null ? left : await evalLambdaBodyAsync(node.right, item, env);
+				}
+				return applyBinaryOp(op, await evalLambdaBodyAsync(node.left, item, env), await evalLambdaBodyAsync(node.right, item, env));
+			}
+			case "UnaryExpression": return applyUnaryOp(node.operator, await evalLambdaBodyAsync(node.operand, item, env));
+			case "ConditionalExpression": return await evalLambdaBodyAsync(node.test, item, env) ? await evalLambdaBodyAsync(node.consequent, item, env) : await evalLambdaBodyAsync(node.alternate, item, env);
+			case "LambdaExpression": return await evalLambdaBodyAsync(node.body, item, env);
+			default:
+				ownDepth = false;
+				g.exitDepth();
+				return await evalNodeAsync(node, env);
+		}
+	} finally {
+		if (ownDepth) g.exitDepth();
+	}
+}
+async function getObjectPropertyKey(prop, env) {
+	const key = prop.computed ? String(await evalNodeAsync(prop.key, env)) : getObjectLiteralKeyName(prop.key);
+	env.g.checkNameAccess(key, "object-key");
+	return key;
+}
+function makeLambdaAccessor(property, guard) {
+	return (item) => {
+		guard.checkNameAccess(property, "member");
+		return item?.[property];
+	};
+}
+//#endregion
+//#region src/execution-context.ts
+const BLOCKED_PROPERTIES = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const MAX_INDEX_DIGITS = 10;
+function isCanonicalIndex(key) {
+	if (key.length === 0 || key.length > MAX_INDEX_DIGITS) return false;
+	const n = Number(key);
+	return Number.isInteger(n) && n >= 0 && String(n) === key;
+}
+const TIMEOUT_CHECK_INTERVAL = 1e3;
+const DEFAULT_MAX_DEPTH = 100;
+const DEFAULT_MAX_ARRAY_LENGTH = 1e5;
+/** Immutable per-instance security configuration derived from BonsaiOptions. */
+var SecurityPolicy = class {
+	maxDepth;
+	maxArrayLength;
+	timeout;
+	allowedProperties;
+	deniedProperties;
+	constructor(options = {}) {
+		this.maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+		this.maxArrayLength = options.maxArrayLength ?? DEFAULT_MAX_ARRAY_LENGTH;
+		this.timeout = options.timeout ?? 0;
+		this.allowedProperties = options.allowedProperties ? new Set(options.allowedProperties) : void 0;
+		this.deniedProperties = options.deniedProperties ? new Set(options.deniedProperties) : void 0;
+	}
+};
+/** Mutable per-evaluation state: tracks depth, step count, and deadline for a single evaluation. */
+var ExecutionContext = class {
+	stepCount = 0;
+	depth = 0;
+	deadline;
+	policy;
+	now;
+	constructor(policy, now = Date.now) {
+		this.policy = policy;
+		this.now = now;
+		this.deadline = policy.timeout ? now() + policy.timeout : 0;
+	}
+	step() {
+		if (this.deadline) {
+			this.stepCount++;
+			if (this.stepCount % TIMEOUT_CHECK_INTERVAL === 0) this.checkTimeout();
+		}
+	}
+	checkTimeout() {
+		if (this.deadline && this.now() >= this.deadline) throw new BonsaiSecurityError("TIMEOUT", `Expression timeout: exceeded ${this.policy.timeout}ms`);
+	}
+	enterDepth() {
+		if (++this.depth > this.policy.maxDepth) throw new BonsaiSecurityError("MAX_DEPTH", `Maximum expression depth (${this.policy.maxDepth}) exceeded`);
+	}
+	exitDepth() {
+		this.depth--;
+	}
+	withDepth(fn) {
+		this.enterDepth();
+		try {
+			return fn();
+		} finally {
+			this.exitDepth();
+		}
+	}
+	checkNameAccess(key, kind) {
+		if (BLOCKED_PROPERTIES.has(key)) throw new BonsaiSecurityError("BLOCKED_PROPERTY", `Blocked: access to "${key}" is not allowed`);
+		if (kind === "identifier" || kind === "object-key") return;
+		if (isCanonicalIndex(key)) return;
+		if (this.policy.allowedProperties) {
+			if (!this.policy.allowedProperties.has(key)) throw new BonsaiSecurityError("PROPERTY_NOT_ALLOWED", `Blocked: "${key}" is not in allowed properties`);
+		}
+		if (this.policy.deniedProperties) {
+			if (this.policy.deniedProperties.has(key)) throw new BonsaiSecurityError("PROPERTY_DENIED", `Blocked: "${key}" is in denied properties`);
+		}
+	}
+	checkArrayLength(length) {
+		if (length > this.policy.maxArrayLength) throw new BonsaiSecurityError("MAX_ARRAY_LENGTH", `Array length (${length}) exceeds maximum (${this.policy.maxArrayLength})`);
+	}
+};
+//#endregion
+//#region src/cache.ts
+var LRUCache = class {
+	max;
+	map = /* @__PURE__ */ new Map();
+	constructor(max) {
+		this.max = max > 0 ? max : 0;
+	}
+	get(key) {
+		if (!this.map.has(key)) return void 0;
+		const value = this.map.get(key);
+		this.map.delete(key);
+		this.map.set(key, value);
+		return value;
+	}
+	set(key, value) {
+		if (this.max === 0) return;
+		if (this.map.has(key)) this.map.delete(key);
+		else if (this.map.size >= this.max) {
+			const oldest = this.map.keys().next().value;
+			this.map.delete(oldest);
+		}
+		this.map.set(key, value);
+	}
+	get size() {
+		return this.map.size;
+	}
+	clear() {
+		this.map.clear();
+	}
+};
+//#endregion
+//#region src/plugins.ts
+function createPluginRegistry() {
+	const transformMap = /* @__PURE__ */ new Map();
+	const functionMap = /* @__PURE__ */ new Map();
+	let transformsCache = {};
+	let functionsCache = {};
+	let transformsDirty = false;
+	let functionsDirty = false;
+	const registry = {
+		addTransform(name, fn) {
+			transformMap.set(name, fn);
+			transformsDirty = true;
+		},
+		addFunction(name, fn) {
+			functionMap.set(name, fn);
+			functionsDirty = true;
+		},
+		removeTransform(name) {
+			const r = transformMap.delete(name);
+			if (r) transformsDirty = true;
+			return r;
+		},
+		removeFunction(name) {
+			const r = functionMap.delete(name);
+			if (r) functionsDirty = true;
+			return r;
+		},
+		getTransform(name) {
+			return transformMap.get(name);
+		},
+		getFunction(name) {
+			return functionMap.get(name);
+		},
+		getTransformNames() {
+			return [...transformMap.keys()];
+		},
+		getFunctionNames() {
+			return [...functionMap.keys()];
+		},
+		use(plugin) {
+			plugin(registry);
+		},
+		get transforms() {
+			if (transformsDirty) {
+				transformsCache = Object.fromEntries(transformMap);
+				transformsDirty = false;
+			}
+			return transformsCache;
+		},
+		get functions() {
+			if (functionsDirty) {
+				functionsCache = Object.fromEntries(functionMap);
+				functionsDirty = false;
+			}
+			return functionsCache;
+		}
+	};
+	return registry;
+}
+//#endregion
+//#region src/index.ts
+const DEFAULT_CACHE_SIZE = 256;
+let _shared;
+/**
+* Evaluate a single expression with default options. Uses a shared instance internally.
+* For repeated evaluation or custom configuration, use `bonsai()` to create a dedicated instance.
+*/
+function evaluateExpression(expression, context) {
+	if (!_shared) _shared = bonsai();
+	return _shared.evaluateSync(expression, context);
+}
+/**
+* Create a new Bonsai instance with optional safety and caching configuration.
+* Register transforms and functions via `.use()`, `.addTransform()`, and `.addFunction()`.
+*
+* @example
+* ```ts
+* const expr = bonsai({ timeout: 50 })
+* expr.use(strings)
+* expr.evaluateSync('name |> trim |> upper', { name: '  hello  ' }) // "HELLO"
+* ```
+*/
+function bonsai(options = {}) {
+	const registry = createPluginRegistry();
+	const cache = new LRUCache(options.cacheSize ?? DEFAULT_CACHE_SIZE);
+	const astCache = new LRUCache(options.cacheSize ?? DEFAULT_CACHE_SIZE);
+	const policy = new SecurityPolicy(options);
+	function createExecutionContext() {
+		return new ExecutionContext(policy);
+	}
+	function getAst(source) {
+		let ast = astCache.get(source);
+		if (ast) return ast;
+		ast = compile(parse(source));
+		astCache.set(source, ast);
+		return ast;
+	}
+	function compileExpr(source) {
+		const cached = cache.get(source);
+		if (cached) return cached;
+		const optimized = getAst(source);
+		const compiled = {
+			ast: optimized,
+			source,
+			async evaluate(context = {}) {
+				return evaluateAsync(optimized, context, registry.transforms, registry.functions, createExecutionContext(), source);
+			},
+			evaluateSync(context = {}) {
+				return evaluate(optimized, context, registry.transforms, registry.functions, createExecutionContext(), source);
+			}
+		};
+		cache.set(source, compiled);
+		return compiled;
+	}
+	const instance = {
+		use(plugin) {
+			plugin(instance);
+			return instance;
+		},
+		addTransform(name, fn) {
+			registry.addTransform(name, fn);
+			return instance;
+		},
+		addFunction(name, fn) {
+			registry.addFunction(name, fn);
+			return instance;
+		},
+		removeTransform(name) {
+			return registry.removeTransform(name);
+		},
+		removeFunction(name) {
+			return registry.removeFunction(name);
+		},
+		hasTransform(name) {
+			return registry.getTransform(name) !== void 0;
+		},
+		hasFunction(name) {
+			return registry.getFunction(name) !== void 0;
+		},
+		listTransforms() {
+			return registry.getTransformNames();
+		},
+		listFunctions() {
+			return registry.getFunctionNames();
+		},
+		clearCache() {
+			cache.clear();
+			astCache.clear();
+		},
+		compile(expression) {
+			return compileExpr(expression);
+		},
+		async evaluate(expression, context = {}) {
+			return evaluateAsync(getAst(expression), context, registry.transforms, registry.functions, createExecutionContext(), expression);
+		},
+		evaluateSync(expression, context = {}) {
+			return evaluate(getAst(expression), context, registry.transforms, registry.functions, createExecutionContext(), expression);
+		},
+		validate(expression) {
+			try {
+				const ast = parse(expression);
+				return {
+					valid: true,
+					errors: [],
+					ast,
+					references: extractReferences(ast)
+				};
+			} catch (error) {
+				let message;
+				if (error instanceof ExpressionError) message = error.rawMessage;
+				else if (error instanceof Error) message = error.message;
+				else message = String(error);
+				const { start, end } = error instanceof ExpressionError ? error : {
+					start: 0,
+					end: 1
+				};
+				const position = offsetToPosition(expression, start);
+				return {
+					valid: false,
+					errors: [{
+						message,
+						position: {
+							line: position.line,
+							column: position.column
+						},
+						formatted: error instanceof ExpressionError ? error.message : formatError(message, {
+							source: expression,
+							start,
+							end
+						})
+					}]
+				};
+			}
+		}
+	};
+	return instance;
+}
+function extractReferences(node) {
+	const identifiers = /* @__PURE__ */ new Set();
+	const transforms = /* @__PURE__ */ new Set();
+	const functions = /* @__PURE__ */ new Set();
+	function walk(n) {
+		switch (n.type) {
+			case "Identifier":
+				identifiers.add(n.name);
+				break;
+			case "PipeExpression":
+				walk(n.input);
+				if (n.transform.type === "Identifier") transforms.add(n.transform.name);
+				else if (n.transform.type === "CallExpression") {
+					if (n.transform.callee.type === "Identifier") transforms.add(getIdentifierName(n.transform.callee));
+					n.transform.args.forEach(walk);
+				}
+				break;
+			case "CallExpression":
+				if (n.callee.type === "Identifier") functions.add(n.callee.name);
+				else walk(n.callee);
+				n.args.forEach(walk);
+				break;
+			case "BinaryExpression":
+				walk(n.left);
+				walk(n.right);
+				break;
+			case "UnaryExpression":
+				walk(n.operand);
+				break;
+			case "ConditionalExpression":
+				walk(n.test);
+				walk(n.consequent);
+				walk(n.alternate);
+				break;
+			case "MemberExpression":
+			case "OptionalMemberExpression":
+				walk(n.object);
+				if (n.computed) walk(n.property);
+				break;
+			case "ArrayLiteral":
+				n.elements.forEach(walk);
+				break;
+			case "ObjectLiteral":
+				n.properties.forEach((p) => {
+					walk(p.key);
+					walk(p.value);
+				});
+				break;
+			case "TemplateLiteral":
+				n.parts.forEach(walk);
+				break;
+			case "SpreadElement":
+				walk(n.argument);
+				break;
+			case "LambdaExpression":
+				walk(n.body);
+				break;
+		}
+	}
+	walk(node);
+	return {
+		identifiers: [...identifiers],
+		transforms: [...transforms],
+		functions: [...functions]
+	};
+}
+//#endregion
+export { BonsaiReferenceError, BonsaiSecurityError, BonsaiTypeError, ExpressionError, bonsai, compile, evaluateExpression, formatBonsaiError, formatError, parse, tokenize };
+
+//# sourceMappingURL=index.mjs.map