@gabrielbryk/jq-ts 1.1.0

package/dist/index.cjs

@@ -0,0 +1,2040 @@
+
+//#region src/errors.ts
+var BaseError = class extends Error {
+	kind;
+	span;
+	constructor(kind, message, span) {
+		super(message);
+		this.kind = kind;
+		this.span = span;
+		this.name = `${kind.charAt(0).toUpperCase() + kind.slice(1)}Error`;
+	}
+};
+/**
+* Thrown when the lexer encounters invalid input characters.
+*/
+var LexError = class extends BaseError {
+	constructor(message, span) {
+		super("lex", message, span);
+	}
+};
+/**
+* Thrown when the parser encounters invalid syntax.
+*/
+var ParseError = class extends BaseError {
+	constructor(message, span) {
+		super("parse", message, span);
+	}
+};
+/**
+* Thrown when the AST contains unsupported or invalid features (e.g., restricted operators).
+*/
+var ValidationError = class extends BaseError {
+	constructor(message, span) {
+		super("validate", message, span);
+	}
+};
+/**
+* Thrown during execution for runtime issues (type errors, limits exceeded, user-raised errors).
+*/
+var RuntimeError = class extends BaseError {
+	constructor(message, span) {
+		super("runtime", message, span);
+	}
+};
+
+//#endregion
+//#region src/tokens.ts
+const keywordKinds = {
+	if: "If",
+	then: "Then",
+	elif: "Elif",
+	else: "Else",
+	end: "End",
+	as: "As",
+	and: "And",
+	or: "Or",
+	not: "Not",
+	null: "Null",
+	true: "True",
+	false: "False",
+	reduce: "Reduce",
+	foreach: "Foreach",
+	try: "Try",
+	catch: "Catch"
+};
+
+//#endregion
+//#region src/lexer.ts
+const lex = (text) => {
+	const tokens = [];
+	const length = text.length;
+	let pos = 0;
+	const peek = (offset = 0) => text[pos + offset];
+	const advance = () => text[pos++];
+	const makeSpan = (start, end) => ({
+		start,
+		end
+	});
+	const pushToken = (kind, start, end, value) => {
+		tokens.push({
+			kind,
+			span: makeSpan(start, end),
+			value
+		});
+	};
+	const isWhitespace = (ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+	const isDigit = (ch) => !!ch && ch >= "0" && ch <= "9";
+	const isIdentifierStart = (ch) => !!ch && (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_");
+	const isIdentifierPart = (ch) => isIdentifierStart(ch) || isDigit(ch);
+	while (pos < length) {
+		const ch = peek();
+		if (isWhitespace(ch)) {
+			advance();
+			continue;
+		}
+		if (ch === "#") {
+			while (pos < length && peek() !== "\n") advance();
+			continue;
+		}
+		const start = pos;
+		switch (ch) {
+			case "\"": {
+				const endPos = readString(start);
+				pushToken("String", start, endPos, readStringValue(start, start + 1, endPos - 1));
+				continue;
+			}
+			case ".":
+				advance();
+				if (peek() === ".") {
+					advance();
+					pushToken("DotDot", start, pos);
+				} else pushToken("Dot", start, pos);
+				continue;
+			case ";":
+				advance();
+				pushToken("Semicolon", start, pos);
+				continue;
+			case ",":
+				advance();
+				pushToken("Comma", start, pos);
+				continue;
+			case "|":
+				advance();
+				pushToken("Pipe", start, pos);
+				continue;
+			case "/":
+				advance();
+				if (peek() === "/") {
+					advance();
+					pushToken("Alt", start, pos);
+				} else pushToken("Slash", start, pos);
+				continue;
+			case "(":
+				advance();
+				pushToken("LParen", start, pos);
+				continue;
+			case ")":
+				advance();
+				pushToken("RParen", start, pos);
+				continue;
+			case "[":
+				advance();
+				pushToken("LBracket", start, pos);
+				continue;
+			case "]":
+				advance();
+				pushToken("RBracket", start, pos);
+				continue;
+			case "{":
+				advance();
+				pushToken("LBrace", start, pos);
+				continue;
+			case "}":
+				advance();
+				pushToken("RBrace", start, pos);
+				continue;
+			case ":":
+				advance();
+				pushToken("Colon", start, pos);
+				continue;
+			case "+":
+				advance();
+				pushToken("Plus", start, pos);
+				continue;
+			case "-":
+				advance();
+				pushToken("Minus", start, pos);
+				continue;
+			case "*":
+				advance();
+				pushToken("Star", start, pos);
+				continue;
+			case "%":
+				advance();
+				pushToken("Percent", start, pos);
+				continue;
+			case "=":
+				advance();
+				if (peek() === "=") {
+					advance();
+					pushToken("EqualEqual", start, pos);
+				} else throw new LexError("Unexpected \"=\" (only \"==\" supported)", makeSpan(start, pos));
+				continue;
+			case "!":
+				advance();
+				if (peek() === "=") {
+					advance();
+					pushToken("BangEqual", start, pos);
+				} else throw new LexError("Unexpected \"!\" (only \"!=\" supported)", makeSpan(start, pos));
+				continue;
+			case "<":
+				advance();
+				if (peek() === "=") {
+					advance();
+					pushToken("LessEqual", start, pos);
+				} else pushToken("Less", start, pos);
+				continue;
+			case ">":
+				advance();
+				if (peek() === "=") {
+					advance();
+					pushToken("GreaterEqual", start, pos);
+				} else pushToken("Greater", start, pos);
+				continue;
+			case "$": {
+				advance();
+				if (!isIdentifierStart(peek())) throw new LexError("Expected identifier after \"$\"", makeSpan(start, pos));
+				const nameStart = pos;
+				while (isIdentifierPart(peek())) advance();
+				pushToken("Variable", start, pos, text.slice(nameStart, pos));
+				continue;
+			}
+			default: break;
+		}
+		if (isDigit(ch)) {
+			const end = readNumber(start);
+			const raw = text.slice(start, end);
+			const value = Number(raw);
+			if (!Number.isFinite(value)) throw new LexError(`Invalid number literal: ${raw}`, makeSpan(start, end));
+			pushToken("Number", start, end, value);
+			continue;
+		}
+		if (isIdentifierStart(ch)) {
+			while (isIdentifierPart(peek())) advance();
+			const raw = text.slice(start, pos);
+			const keyword = keywordKinds[raw];
+			if (keyword === "Null" || keyword === "True" || keyword === "False") pushToken(keyword, start, pos);
+			else if (keyword) pushToken(keyword, start, pos);
+			else pushToken("Identifier", start, pos, raw);
+			continue;
+		}
+		throw new LexError(`Unexpected character "${ch}"`, makeSpan(start, start + 1));
+	}
+	pushToken("EOF", pos, pos);
+	return tokens;
+	function readNumber(tokenStart) {
+		while (isDigit(peek())) advance();
+		if (peek() === "." && isDigit(peek(1))) {
+			advance();
+			while (isDigit(peek())) advance();
+		}
+		if (peek() === "e" || peek() === "E") {
+			advance();
+			if (peek() === "+" || peek() === "-") advance();
+			if (!isDigit(peek())) throw new LexError(`Invalid exponent in number literal`, makeSpan(tokenStart, pos));
+			while (isDigit(peek())) advance();
+		}
+		return pos;
+	}
+	function readString(tokenStart) {
+		advance();
+		while (pos < length) {
+			const current = advance();
+			if (current === "\"") return pos;
+			if (current === "\\") {
+				const esc = advance();
+				if (!esc) break;
+				if ("\"\\/bfnrt".includes(esc)) continue;
+				if (esc === "u") {
+					for (let i = 0; i < 4; i += 1) {
+						const hex = advance();
+						if (!hex || !isHexDigit(hex)) throw new LexError("Invalid Unicode escape in string literal", makeSpan(tokenStart, pos));
+					}
+					continue;
+				}
+				throw new LexError(`Invalid escape sequence "\\${esc}"`, makeSpan(tokenStart, pos));
+			}
+		}
+		throw new LexError("Unterminated string literal", makeSpan(tokenStart, pos));
+	}
+	function readStringValue(tokenStart, innerStart, innerEnd) {
+		let result = "";
+		let i = innerStart;
+		while (i < innerEnd) {
+			const ch = text[i];
+			if (ch === "\\") {
+				const next = text[i + 1];
+				switch (next) {
+					case "\"":
+					case "\\":
+					case "/":
+						result += next;
+						i += 2;
+						break;
+					case "b":
+						result += "\b";
+						i += 2;
+						break;
+					case "f":
+						result += "\f";
+						i += 2;
+						break;
+					case "n":
+						result += "\n";
+						i += 2;
+						break;
+					case "r":
+						result += "\r";
+						i += 2;
+						break;
+					case "t":
+						result += "	";
+						i += 2;
+						break;
+					case "u": {
+						const hex = text.slice(i + 2, i + 6);
+						result += String.fromCharCode(Number.parseInt(hex, 16));
+						i += 6;
+						break;
+					}
+					default: throw new LexError(`Invalid escape sequence "\\${next}"`, makeSpan(tokenStart, tokenStart + (i - innerStart) + 2));
+				}
+			} else {
+				result += ch;
+				i += 1;
+			}
+		}
+		return result;
+	}
+};
+const isHexDigit = (ch) => !!ch && (ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F");
+
+//#endregion
+//#region src/parser.ts
+/**
+* Parses a jq source string into an Abstract Syntax Tree (AST).
+*
+* @param source - The input jq query string.
+* @returns The root {@link FilterNode} of the AST.
+* @throws {LexError} If the source contains invalid characters.
+* @throws {ParseError} If the syntax is invalid.
+*/
+const parse = (source) => {
+	return new Parser(lex(source)).parseFilter();
+};
+var Parser = class {
+	current = 0;
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	parseFilter() {
+		const expr = this.parseBinding();
+		this.consume("EOF", "Expected end of expression");
+		return expr;
+	}
+	parseBinding() {
+		let expr = this.parseComma();
+		while (this.match("As")) {
+			const varToken = this.consume("Variable", "Expected variable name after \"as\"");
+			this.consume("Pipe", "Expected \"|\" after variable binding");
+			const body = this.parseBinding();
+			expr = {
+				kind: "As",
+				bind: expr,
+				name: String(varToken.value),
+				body,
+				span: spanBetween(expr.span, body.span)
+			};
+		}
+		return expr;
+	}
+	parseComma() {
+		let expr = this.parsePipe();
+		while (this.match("Comma")) {
+			const right = this.parsePipe();
+			expr = {
+				kind: "Comma",
+				left: expr,
+				right,
+				span: spanBetween(expr.span, right.span)
+			};
+		}
+		return expr;
+	}
+	parsePipe() {
+		let expr = this.parsePipeOperand();
+		while (this.match("Pipe")) {
+			const right = this.parsePipeOperand();
+			expr = {
+				kind: "Pipe",
+				left: expr,
+				right,
+				span: spanBetween(expr.span, right.span)
+			};
+		}
+		return expr;
+	}
+	parsePipeOperand() {
+		return this.parseAlt();
+	}
+	parseAlt() {
+		let expr = this.parseOr();
+		while (this.match("Alt")) {
+			const right = this.parseOr();
+			expr = {
+				kind: "Alt",
+				left: expr,
+				right,
+				span: spanBetween(expr.span, right.span)
+			};
+		}
+		return expr;
+	}
+	parseOr() {
+		let expr = this.parseAnd();
+		while (this.match("Or")) {
+			const right = this.parseAnd();
+			expr = {
+				kind: "Bool",
+				op: "Or",
+				left: expr,
+				right,
+				span: spanBetween(expr.span, right.span)
+			};
+		}
+		return expr;
+	}
+	parseAnd() {
+		let expr = this.parseComparison();
+		while (this.match("And")) {
+			const right = this.parseComparison();
+			expr = {
+				kind: "Bool",
+				op: "And",
+				left: expr,
+				right,
+				span: spanBetween(expr.span, right.span)
+			};
+		}
+		return expr;
+	}
+	parseComparison() {
+		let expr = this.parseAdd();
+		while (true) if (this.match("EqualEqual")) {
+			const right = this.parseAdd();
+			expr = this.makeBinary(expr, right, "Eq");
+		} else if (this.match("BangEqual")) {
+			const right = this.parseAdd();
+			expr = this.makeBinary(expr, right, "Neq");
+		} else if (this.match("Less")) {
+			const right = this.parseAdd();
+			expr = this.makeBinary(expr, right, "Lt");
+		} else if (this.match("LessEqual")) {
+			const right = this.parseAdd();
+			expr = this.makeBinary(expr, right, "Lte");
+		} else if (this.match("Greater")) {
+			const right = this.parseAdd();
+			expr = this.makeBinary(expr, right, "Gt");
+		} else if (this.match("GreaterEqual")) {
+			const right = this.parseAdd();
+			expr = this.makeBinary(expr, right, "Gte");
+		} else break;
+		return expr;
+	}
+	parseAdd() {
+		let expr = this.parseMul();
+		while (true) if (this.match("Plus")) {
+			const right = this.parseMul();
+			expr = this.makeBinary(expr, right, "+");
+		} else if (this.match("Minus")) {
+			const right = this.parseMul();
+			expr = this.makeBinary(expr, right, "-");
+		} else break;
+		return expr;
+	}
+	parseMul() {
+		let expr = this.parseUnary();
+		while (true) if (this.match("Star")) {
+			const right = this.parseUnary();
+			expr = this.makeBinary(expr, right, "*");
+		} else if (this.match("Slash")) {
+			const right = this.parseUnary();
+			expr = this.makeBinary(expr, right, "/");
+		} else if (this.match("Percent")) {
+			const right = this.parseUnary();
+			expr = this.makeBinary(expr, right, "%");
+		} else break;
+		return expr;
+	}
+	parseUnary() {
+		if (this.match("Not")) {
+			const op = this.previous();
+			const expr = this.parseUnary();
+			return {
+				kind: "Unary",
+				op: "Not",
+				expr,
+				span: spanBetween(op.span, expr.span)
+			};
+		}
+		if (this.match("Minus")) {
+			const op = this.previous();
+			const expr = this.parseUnary();
+			return {
+				kind: "Unary",
+				op: "Neg",
+				expr,
+				span: spanBetween(op.span, expr.span)
+			};
+		}
+		return this.parsePostfix();
+	}
+	parsePostfix() {
+		let expr = this.parsePrimary();
+		while (true) {
+			if (this.match("Dot")) {
+				expr = this.finishFieldAccess(expr);
+				continue;
+			}
+			if (this.match("LBracket")) {
+				if (this.match("RBracket")) {
+					const close = this.previous();
+					expr = {
+						kind: "Iterate",
+						target: expr,
+						span: spanBetween(expr.span, close.span)
+					};
+					continue;
+				}
+				const index = this.parsePipe();
+				const closing = this.consume("RBracket", "Expected \"]\" after index expression");
+				expr = {
+					kind: "IndexAccess",
+					target: expr,
+					index,
+					span: spanBetween(expr.span, closing.span)
+				};
+				continue;
+			}
+			break;
+		}
+		return expr;
+	}
+	parsePrimary() {
+		if (this.match("Dot")) return this.parseLeadingDot(this.previous());
+		if (this.match("Null")) return this.literalNode(null, this.previous().span);
+		if (this.match("True")) return this.literalNode(true, this.previous().span);
+		if (this.match("False")) return this.literalNode(false, this.previous().span);
+		if (this.match("Number")) return this.literalNode(Number(this.previous().value), this.previous().span);
+		if (this.match("String")) return this.literalNode(String(this.previous().value), this.previous().span);
+		if (this.match("Variable")) {
+			const token = this.previous();
+			return {
+				kind: "Var",
+				name: String(token.value),
+				span: token.span
+			};
+		}
+		if (this.match("Identifier")) return this.finishIdentifier(this.previous());
+		if (this.match("If")) return this.parseIf(this.previous());
+		if (this.match("LParen")) {
+			const start = this.previous();
+			const expr = this.parseComma();
+			const close = this.consume("RParen", "Expected \")\" after expression");
+			expr.span = spanBetween(start.span, close.span);
+			return expr;
+		}
+		if (this.match("LBracket")) return this.parseArray(this.previous());
+		if (this.match("LBrace")) return this.parseObject(this.previous());
+		if (this.match("Reduce")) return this.parseReduce(this.previous());
+		if (this.match("Foreach")) return this.parseForeach(this.previous());
+		if (this.match("Try")) return this.parseTry(this.previous());
+		if (this.match("DotDot")) return {
+			kind: "Recurse",
+			span: this.previous().span
+		};
+		throw this.error(this.peek(), "Unexpected token");
+	}
+	parseReduce(start) {
+		const source = this.parsePipe();
+		this.consume("As", "Expected \"as\" after reduce source");
+		const varToken = this.consume("Variable", "Expected variable after \"as\"");
+		this.consume("LParen", "Expected \"(\" after variable");
+		const init = this.parseComma();
+		this.consume("Semicolon", "Expected \";\" after init");
+		const update = this.parseComma();
+		const end = this.consume("RParen", "Expected \")\" after update");
+		return {
+			kind: "Reduce",
+			source,
+			var: String(varToken.value),
+			init,
+			update,
+			span: spanBetween(start.span, end.span)
+		};
+	}
+	parseForeach(start) {
+		const source = this.parsePipe();
+		this.consume("As", "Expected \"as\" after foreach source");
+		const varToken = this.consume("Variable", "Expected variable after \"as\"");
+		this.consume("LParen", "Expected \"(\" after variable");
+		const init = this.parseComma();
+		this.consume("Semicolon", "Expected \";\" after init");
+		const update = this.parseComma();
+		let extract;
+		if (this.match("Semicolon")) extract = this.parseComma();
+		const end = this.consume("RParen", "Expected \")\" after foreach body");
+		return {
+			kind: "Foreach",
+			source,
+			var: String(varToken.value),
+			init,
+			update,
+			extract,
+			span: spanBetween(start.span, end.span)
+		};
+	}
+	parseTry(start) {
+		const body = this.parseComma();
+		let handler;
+		let endSpan = body.span;
+		if (this.match("Catch")) {
+			handler = this.parseComma();
+			endSpan = handler.span;
+		}
+		return {
+			kind: "Try",
+			body,
+			handler,
+			span: spanBetween(start.span, endSpan)
+		};
+	}
+	parseIf(start) {
+		const branches = [];
+		const firstCond = this.parsePipe();
+		this.consume("Then", "Expected \"then\" after condition");
+		const firstThen = this.parsePipe();
+		branches.push({
+			cond: firstCond,
+			then: firstThen
+		});
+		while (this.match("Elif")) {
+			const cond = this.parsePipe();
+			this.consume("Then", "Expected \"then\" after elif condition");
+			const thenBranch = this.parsePipe();
+			branches.push({
+				cond,
+				then: thenBranch
+			});
+		}
+		this.consume("Else", "Expected \"else\" in if expression");
+		const elseBranch = this.parsePipe();
+		const endToken = this.consume("End", "Expected \"end\" to close if expression");
+		return {
+			kind: "If",
+			branches,
+			else: elseBranch,
+			span: spanBetween(start.span, endToken.span)
+		};
+	}
+	parseArray(start) {
+		const items = [];
+		if (!this.check("RBracket")) do
+			items.push(this.parsePipe());
+		while (this.match("Comma"));
+		const end = this.consume("RBracket", "Expected \"]\" after array literal");
+		return {
+			kind: "Array",
+			items,
+			span: spanBetween(start.span, end.span)
+		};
+	}
+	parseObject(start) {
+		const entries = [];
+		if (!this.check("RBrace")) do
+			entries.push(this.parseObjectEntry());
+		while (this.match("Comma"));
+		const end = this.consume("RBrace", "Expected \"}\" after object literal");
+		return {
+			kind: "Object",
+			entries,
+			span: spanBetween(start.span, end.span)
+		};
+	}
+	parseObjectEntry() {
+		const key = this.parseObjectKey();
+		this.consume("Colon", "Expected \":\" after object key");
+		return {
+			key,
+			value: this.parsePipe()
+		};
+	}
+	parseObjectKey() {
+		if (this.match("Identifier")) {
+			const token = this.previous();
+			return {
+				kind: "KeyIdentifier",
+				name: String(token.value),
+				span: token.span
+			};
+		}
+		if (this.match("String")) {
+			const token = this.previous();
+			return {
+				kind: "KeyString",
+				value: String(token.value),
+				span: token.span
+			};
+		}
+		if (this.match("LParen")) {
+			const start = this.previous();
+			const expr = this.parseComma();
+			const closing = this.consume("RParen", "Expected \")\" after computed key expression");
+			return {
+				kind: "KeyExpr",
+				expr,
+				span: spanBetween(start.span, closing.span)
+			};
+		}
+		throw this.error(this.peek(), "Expected identifier, string, or \"(expr)\" as object key");
+	}
+	finishFieldAccess(target) {
+		if (this.match("Identifier")) {
+			const token = this.previous();
+			return {
+				kind: "FieldAccess",
+				target,
+				field: String(token.value),
+				span: spanBetween(target.span, token.span)
+			};
+		}
+		if (this.match("String")) {
+			const token = this.previous();
+			return {
+				kind: "FieldAccess",
+				target,
+				field: String(token.value),
+				span: spanBetween(target.span, token.span)
+			};
+		}
+		throw this.error(this.peek(), "Expected field name after \".\"");
+	}
+	parseLeadingDot(dot) {
+		let expr = {
+			kind: "Identity",
+			span: dot.span
+		};
+		while (true) {
+			if (this.check("Identifier") || this.check("String")) {
+				expr = this.finishFieldAccess(expr);
+				continue;
+			}
+			if (this.match("LBracket")) {
+				if (this.match("RBracket")) {
+					const close = this.previous();
+					expr = {
+						kind: "Iterate",
+						target: expr,
+						span: spanBetween(expr.span, close.span)
+					};
+					continue;
+				}
+				const index = this.parsePipe();
+				const closing = this.consume("RBracket", "Expected \"]\" after index expression");
+				expr = {
+					kind: "IndexAccess",
+					target: expr,
+					index,
+					span: spanBetween(expr.span, closing.span)
+				};
+				continue;
+			}
+			break;
+		}
+		return expr;
+	}
+	finishIdentifier(token) {
+		if (this.match("LParen")) {
+			const args = this.parseCallArguments();
+			const closing = this.consume("RParen", "Expected \")\" after arguments");
+			return {
+				kind: "Call",
+				name: String(token.value),
+				args,
+				span: spanBetween(token.span, closing.span)
+			};
+		}
+		return {
+			kind: "Call",
+			name: String(token.value),
+			args: [],
+			span: token.span
+		};
+	}
+	parseCallArguments() {
+		const args = [];
+		if (this.check("RParen")) return args;
+		do
+			args.push(this.parsePipe());
+		while (this.match("Semicolon"));
+		return args;
+	}
+	literalNode(value, span) {
+		return {
+			kind: "Literal",
+			value,
+			span
+		};
+	}
+	makeBinary(left, right, op) {
+		return {
+			kind: "Binary",
+			op,
+			left,
+			right,
+			span: spanBetween(left.span, right.span)
+		};
+	}
+	match(kind) {
+		if (this.check(kind)) {
+			this.advance();
+			return true;
+		}
+		return false;
+	}
+	consume(kind, message) {
+		if (this.check(kind)) return this.advance();
+		throw this.error(this.peek(), message);
+	}
+	check(kind) {
+		if (this.isAtEnd()) return kind === "EOF";
+		return this.peek().kind === kind;
+	}
+	advance() {
+		if (!this.isAtEnd()) this.current += 1;
+		return this.previous();
+	}
+	isAtEnd() {
+		return this.peek().kind === "EOF";
+	}
+	peek() {
+		return this.tokens[this.current] ?? {
+			kind: "EOF",
+			span: {
+				start: 0,
+				end: 0
+			}
+		};
+	}
+	previous() {
+		return this.tokens[this.current - 1] ?? {
+			kind: "EOF",
+			span: {
+				start: 0,
+				end: 0
+			}
+		};
+	}
+	error(token, message) {
+		return new ParseError(message, token.span);
+	}
+};
+const spanBetween = (a, b) => ({
+	start: Math.min(a.start, b.start),
+	end: Math.max(a.end, b.end)
+});
+
+//#endregion
+//#region src/value.ts
+/**
+* Checks if a value is considered "truthy" in jq logic.
+* In jq, only `false` and `null` are falsey; everything else (including 0 and empty strings) is truthy.
+*
+* @param value - The value to check.
+* @returns `true` if truthy, `false` otherwise.
+*/
+const isTruthy = (value) => !(value === false || value === null);
+/**
+* deeply compares two JSON values for equality.
+*
+* @param a - The first value.
+* @param b - The second value.
+* @returns `true` if the values are structurally equal, `false` otherwise.
+*/
+const valueEquals = (a, b) => {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "number" && typeof b === "number") return Object.is(a, b);
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i += 1) if (!valueEquals(a[i], b[i])) return false;
+		return true;
+	}
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+		const aKeys = Object.keys(a).sort();
+		const bKeys = Object.keys(b).sort();
+		if (aKeys.length !== bKeys.length) return false;
+		for (let i = 0; i < aKeys.length; i += 1) {
+			const key = aKeys[i];
+			if (key !== bKeys[i]) return false;
+			if (!valueEquals(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return false;
+};
+/**
+* Compares two JSON values according to standard jq ordering rules.
+*
+* The sort order is: null < false < true < numbers < strings < arrays < objects.
+* Arrays and objects are compared recursively.
+*
+* @param a - The first value.
+* @param b - The second value.
+* @returns `-1` if `a < b`, `0` if `a == b`, and `1` if `a > b`.
+*/
+const compareValues = (a, b) => {
+	if (valueEquals(a, b)) return 0;
+	const rankDiff = typeRank(a) - typeRank(b);
+	if (rankDiff !== 0) return rankDiff < 0 ? -1 : 1;
+	if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+	if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		const len = Math.min(a.length, b.length);
+		for (let i = 0; i < len; i += 1) {
+			const cmp = compareValues(a[i], b[i]);
+			if (cmp !== 0) return cmp;
+		}
+		return a.length < b.length ? -1 : 1;
+	}
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+		const aKeys = Object.keys(a).sort();
+		const bKeys = Object.keys(b).sort();
+		const len = Math.min(aKeys.length, bKeys.length);
+		for (let i = 0; i < len; i += 1) {
+			const key = aKeys[i];
+			const keyCmp = compareStrings(key, bKeys[i]);
+			if (keyCmp !== 0) return keyCmp;
+			const valueCmp = compareValues(a[key], b[key]);
+			if (valueCmp !== 0) return valueCmp;
+		}
+		return aKeys.length < bKeys.length ? -1 : 1;
+	}
+	return 0;
+};
+const compareStrings = (a, b) => {
+	if (a === b) return 0;
+	return a < b ? -1 : 1;
+};
+const typeRank = (value) => {
+	if (value === null) return 0;
+	if (value === false) return 1;
+	if (value === true) return 2;
+	if (typeof value === "number") return 3;
+	if (typeof value === "string") return 4;
+	if (Array.isArray(value)) return 5;
+	return 6;
+};
+/**
+* Checks if a value is a plain JSON object (and not null or an array).
+*
+* @param value - The value to check.
+* @returns `true` if `value` is a non-null object (and not an array).
+*/
+const isPlainObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Returns the type name of a value as a string (e.g., "null", "boolean", "number", "string", "array", "object").
+* This corresponds to the output of the `type` builtin.
+*
+* @param value - The value to inspect.
+* @returns The lower-case type name.
+*/
+const describeType$1 = (value) => {
+	if (value === null) return "null";
+	if (typeof value === "boolean") return "boolean";
+	if (typeof value === "number") return "number";
+	if (typeof value === "string") return "string";
+	if (Array.isArray(value)) return "array";
+	return "object";
+};
+
+//#endregion
+//#region src/builtins.ts
+const emit$1 = (value, span, tracker) => {
+	tracker.emit(span);
+	return value;
+};
+const ensureIndex = (val) => {
+	if (typeof val === "number" && Number.isInteger(val)) return val;
+	if (typeof val === "string" && /^-?\d+$/.test(val)) return parseInt(val, 10);
+};
+const stableStringify = (value) => {
+	if (value === null) return "null";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") return value.toString();
+	if (typeof value === "string") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+};
+const builtins = {
+	type: {
+		name: "type",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield emit$1(describeType$1(input), span, tracker);
+		}
+	},
+	tostring: {
+		name: "tostring",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield emit$1(stableStringify(input), span, tracker);
+		}
+	},
+	tonumber: {
+		name: "tonumber",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "number") {
+				yield emit$1(input, span, tracker);
+				return;
+			}
+			if (typeof input === "string") {
+				const num = Number(input);
+				if (!Number.isFinite(num)) throw new RuntimeError(`Cannot convert string "${input}" to number`, span);
+				yield emit$1(num, span, tracker);
+				return;
+			}
+			throw new RuntimeError(`Cannot convert ${describeType$1(input)} to number`, span);
+		}
+	},
+	length: {
+		name: "length",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input === "string") yield emit$1(Array.from(input).length, span, tracker);
+			else if (Array.isArray(input)) yield emit$1(input.length, span, tracker);
+			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).length, span, tracker);
+			else throw new RuntimeError(`Cannot take length of ${describeType$1(input)}`, span);
+		}
+	},
+	keys: {
+		name: "keys",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input)) yield emit$1(Array.from({ length: input.length }, (_, i) => i), span, tracker);
+			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).sort(), span, tracker);
+			else throw new RuntimeError(`keys expects an array or object`, span);
+		}
+	},
+	has: {
+		name: "has",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const keyFilter = args[0];
+			for (const key of evaluate$1(keyFilter, input, env, tracker)) if (Array.isArray(input)) {
+				const idx = ensureIndex(key);
+				yield emit$1(idx !== void 0 && idx >= 0 && idx < input.length, span, tracker);
+			} else if (input !== null && typeof input === "object") {
+				let keyStr;
+				if (typeof key === "string") keyStr = key;
+				else if (typeof key === "number") keyStr = key.toString();
+				else throw new RuntimeError(`has() key must be string or number for object input`, span);
+				yield emit$1(Object.prototype.hasOwnProperty.call(input, keyStr), span, tracker);
+			} else throw new RuntimeError(`has() expects an array or object input`, span);
+		}
+	},
+	error: {
+		name: "error",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			for (const msg of evaluate$1(args[0], input, env, tracker)) throw new RuntimeError(typeof msg === "string" ? msg : stableStringify(msg), span);
+		}
+	},
+	map: {
+		name: "map",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("map expects an array", span);
+			const result = [];
+			const filter = args[0];
+			for (const item of input) {
+				tracker.step(span);
+				for (const output of evaluate$1(filter, item, env, tracker)) result.push(output);
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	select: {
+		name: "select",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const filter = args[0];
+			for (const res of evaluate$1(filter, input, env, tracker)) if (isTruthy(res)) {
+				yield emit$1(input, span, tracker);
+				return;
+			}
+		}
+	},
+	sort: {
+		name: "sort",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("sort expects an array", span);
+			const sorted = sortStable(input, (a, b) => compareValues(a, b));
+			tracker.step(span);
+			yield emit$1(sorted, span, tracker);
+		}
+	},
+	sort_by: {
+		name: "sort_by",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("sort_by expects an array", span);
+			const filter = args[0];
+			const pairs = [];
+			for (const item of input) {
+				tracker.step(span);
+				const keys = Array.from(evaluate$1(filter, item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("sort_by key expression must return exactly one value", span);
+				pairs.push({
+					val: item,
+					key: keys[0]
+				});
+			}
+			yield emit$1(sortStable(pairs, (a, b) => compareValues(a.key, b.key)).map((p) => p.val), span, tracker);
+		}
+	},
+	unique: {
+		name: "unique",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("unique expects an array", span);
+			const seen = [];
+			const result = [];
+			for (const item of input) {
+				tracker.step(span);
+				if (!seen.some((s) => valueEquals(s, item))) {
+					seen.push(item);
+					result.push(item);
+				}
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	unique_by: {
+		name: "unique_by",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("unique_by expects an array", span);
+			const filter = args[0];
+			const seenKeys = [];
+			const result = [];
+			for (const item of input) {
+				tracker.step(span);
+				const keys = Array.from(evaluate$1(filter, item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("unique_by key expression must return exactly one value", span);
+				const key = keys[0];
+				if (!seenKeys.some((s) => valueEquals(s, key))) {
+					seenKeys.push(key);
+					result.push(item);
+				}
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	to_entries: {
+		name: "to_entries",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (Array.isArray(input)) yield emit$1(input.map((v, i) => ({
+				key: i,
+				value: v
+			})), span, tracker);
+			else if (input !== null && typeof input === "object") yield emit$1(Object.keys(input).sort().map((k) => ({
+				key: k,
+				value: input[k]
+			})), span, tracker);
+			else throw new RuntimeError("to_entries expects array or object", span);
+		}
+	},
+	from_entries: {
+		name: "from_entries",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("from_entries expects an array", span);
+			const result = {};
+			for (const item of input) {
+				tracker.step(span);
+				if (item === null || typeof item !== "object" || Array.isArray(item)) throw new RuntimeError("from_entries expects array of objects", span);
+				const obj = item;
+				if (!("key" in obj) || !("value" in obj)) throw new RuntimeError("from_entries items must have \"key\" and \"value\"", span);
+				const key = obj["key"];
+				if (typeof key !== "string") throw new RuntimeError("from_entries object keys must be strings", span);
+				result[key] = obj["value"];
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	with_entries: {
+		name: "with_entries",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			let entries;
+			if (Array.isArray(input)) entries = input.map((v, i) => ({
+				key: i,
+				value: v
+			}));
+			else if (input !== null && typeof input === "object") entries = Object.keys(input).sort().map((k) => ({
+				key: k,
+				value: input[k]
+			}));
+			else throw new RuntimeError("with_entries expects array or object", span);
+			const transformed = [];
+			const filter = args[0];
+			for (const entry of entries) {
+				tracker.step(span);
+				for (const outVar of evaluate$1(filter, entry, env, tracker)) transformed.push(outVar);
+			}
+			const result = {};
+			for (const item of transformed) {
+				if (item === null || typeof item !== "object" || Array.isArray(item)) throw new RuntimeError("with_entries filter must produce objects", span);
+				const obj = item;
+				if (!("key" in obj) || !("value" in obj)) throw new RuntimeError("with_entries items must have \"key\" and \"value\"", span);
+				const key = obj["key"];
+				if (typeof key !== "string") throw new RuntimeError("with_entries keys must be strings", span);
+				result[key] = obj["value"];
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	split: {
+		name: "split",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (typeof input !== "string") throw new RuntimeError("split input must be a string", span);
+			const sepGen = evaluate$1(args[0], input, env, tracker);
+			for (const sep of sepGen) {
+				if (typeof sep !== "string") throw new RuntimeError("split separator must be a string", span);
+				yield emit$1(input.split(sep), span, tracker);
+			}
+		}
+	},
+	join: {
+		name: "join",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("join input must be an array", span);
+			const sepGen = evaluate$1(args[0], input, env, tracker);
+			for (const sep of sepGen) {
+				if (typeof sep !== "string") throw new RuntimeError("join separator must be a string", span);
+				const parts = [];
+				for (const item of input) {
+					if (typeof item !== "string") throw new RuntimeError(`join expects strings, but got ${describeType$1(item)}`, span);
+					parts.push(item);
+				}
+				yield emit$1(parts.join(sep), span, tracker);
+			}
+		}
+	},
+	startswith: {
+		name: "startswith",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (typeof input !== "string") throw new RuntimeError("startswith input must be a string", span);
+			const prefixGen = evaluate$1(args[0], input, env, tracker);
+			for (const prefix of prefixGen) {
+				if (typeof prefix !== "string") throw new RuntimeError("startswith prefix must be a string", span);
+				yield emit$1(input.startsWith(prefix), span, tracker);
+			}
+		}
+	},
+	endswith: {
+		name: "endswith",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (typeof input !== "string") throw new RuntimeError("endswith input must be a string", span);
+			const suffixGen = evaluate$1(args[0], input, env, tracker);
+			for (const suffix of suffixGen) {
+				if (typeof suffix !== "string") throw new RuntimeError("endswith suffix must be a string", span);
+				yield emit$1(input.endsWith(suffix), span, tracker);
+			}
+		}
+	},
+	contains: {
+		name: "contains",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const bGen = evaluate$1(args[0], input, env, tracker);
+			for (const b of bGen) yield emit$1(checkContains(input, b), span, tracker);
+		}
+	},
+	paths: {
+		name: "paths",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield* traversePaths(input, [], span, tracker);
+		}
+	},
+	getpath: {
+		name: "getpath",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			for (const pathVal of evaluate$1(args[0], input, env, tracker)) yield emit$1(getPath(input, ensurePath(pathVal, span)) ?? null, span, tracker);
+		}
+	},
+	setpath: {
+		name: "setpath",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const paths = Array.from(evaluate$1(args[0], input, env, tracker));
+			const values = Array.from(evaluate$1(args[1], input, env, tracker));
+			for (const pathVal of paths) {
+				const path = ensurePath(pathVal, span);
+				for (const val of values) yield emit$1(updatePath(input, path, () => val, span) ?? null, span, tracker);
+			}
+		}
+	},
+	delpaths: {
+		name: "delpaths",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			for (const pathsVal of evaluate$1(args[0], input, env, tracker)) {
+				if (!Array.isArray(pathsVal)) throw new RuntimeError("delpaths expects an array of paths", span);
+				yield emit$1(deletePaths(input, pathsVal.map((p) => ensurePath(p, span)), span), span, tracker);
+			}
+		}
+	}
+};
+const checkContains = (a, b) => {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "string" && typeof b === "string") return a.includes(b);
+	if (Array.isArray(a) && Array.isArray(b)) return b.every((bItem) => a.some((aItem) => checkContains(aItem, bItem)));
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+		const keys = Object.keys(b);
+		for (const key of keys) {
+			if (!Object.prototype.hasOwnProperty.call(a, key)) return false;
+			const valA = a[key];
+			const valB = b[key];
+			if (!checkContains(valA, valB)) return false;
+		}
+		return true;
+	}
+	return valueEquals(a, b);
+};
+/**
+* Recursively traverses a JSON value to find all paths to leaf nodes.
+* Yields paths as arrays of strings/numbers.
+*/
+function* traversePaths(root, currentPath, span, tracker) {
+	tracker.step(span);
+	if (root === null || typeof root !== "object" || Array.isArray(root) && root.length === 0 || isPlainObject$1(root) && Object.keys(root).length === 0) {
+		yield emit$1([...currentPath], span, tracker);
+		return;
+	}
+	if (Array.isArray(root)) for (let i = 0; i < root.length; i++) yield* traversePaths(root[i], [...currentPath, i], span, tracker);
+	else if (isPlainObject$1(root)) {
+		const keys = Object.keys(root).sort();
+		for (const key of keys) yield* traversePaths(root[key], [...currentPath, key], span, tracker);
+	}
+}
+const isPath = (val) => {
+	if (!Array.isArray(val)) return false;
+	return val.every((p) => typeof p === "string" || typeof p === "number" && Number.isInteger(p));
+};
+const ensurePath = (val, span) => {
+	if (isPath(val)) return val;
+	throw new RuntimeError("Path must be an array of strings or integers", span);
+};
+const getPath = (root, path) => {
+	let curr = root;
+	for (const part of path) {
+		if (curr === null) return void 0;
+		if (typeof part === "string" && isPlainObject$1(curr)) {
+			if (!Object.prototype.hasOwnProperty.call(curr, part)) return void 0;
+			curr = curr[part];
+		} else if (typeof part === "number" && Array.isArray(curr)) {
+			if (part < 0 || part >= curr.length) return void 0;
+			curr = curr[part];
+		} else return;
+	}
+	return curr;
+};
+/**
+* Immutably updates a value at a given path.
+* Creates intermediate objects/arrays as needed.
+*/
+const updatePath = (root, path, updateFn, span, depth = 0) => {
+	if (path.length === 0) return updateFn(root);
+	const [head, ...tail] = path;
+	if (typeof head === "string") {
+		let obj = {};
+		if (isPlainObject$1(root)) obj = { ...root };
+		else if (root === null) obj = {};
+		else throw new RuntimeError(`Cannot index ${describeType$1(root)} with string "${head}"`, span);
+		const newVal = updatePath((Object.prototype.hasOwnProperty.call(obj, head) ? obj[head] : void 0) ?? null, tail, updateFn, span, depth + 1);
+		if (newVal === void 0) delete obj[head];
+		else obj[head] = newVal;
+		return obj;
+	}
+	if (typeof head === "number") {
+		let arr = [];
+		if (Array.isArray(root)) arr = [...root];
+		else if (root === null) arr = [];
+		else throw new RuntimeError(`Cannot index ${describeType$1(root)} with number ${head}`, span);
+		const idx = head < 0 ? arr.length + head : head;
+		if (idx < 0) throw new RuntimeError("Invalid negative index", span);
+		const newVal = updatePath((idx < arr.length ? arr[idx] : null) ?? null, tail, updateFn, span, depth + 1);
+		if (newVal === void 0) if (idx >= arr.length) {
+			while (arr.length < idx) arr.push(null);
+			arr.push(newVal);
+		} else arr[idx] = newVal;
+		else if (idx >= arr.length) {
+			while (arr.length < idx) arr.push(null);
+			arr.push(newVal);
+		} else arr[idx] = newVal;
+		return arr;
+	}
+	throw new RuntimeError(`Path segment must be string or integer`, span);
+};
+const deletePaths = (root, paths, span) => {
+	if (paths.some((p) => p.length === 0)) return null;
+	if (isPlainObject$1(root)) {
+		const result = { ...root };
+		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "string");
+		const byKey = {};
+		for (const p of relevantPaths) {
+			const key = p[0];
+			if (!byKey[key]) byKey[key] = [];
+			byKey[key].push(p.slice(1));
+		}
+		for (const key of Object.keys(byKey)) {
+			const tails = byKey[key];
+			if (tails.some((t) => t.length === 0)) delete result[key];
+			else result[key] = deletePaths(root[key], tails, span);
+		}
+		return result;
+	}
+	if (Array.isArray(root)) {
+		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "number");
+		const actions = {};
+		for (const p of relevantPaths) {
+			let idx = p[0];
+			if (idx < 0) idx = root.length + idx;
+			if (idx < 0 || idx >= root.length) continue;
+			if (!actions[idx]) actions[idx] = [];
+			actions[idx].push(p.slice(1));
+		}
+		const finalArr = [];
+		for (let i = 0; i < root.length; i++) {
+			const tails = actions[i];
+			if (tails) if (tails.some((t) => t.length === 0)) continue;
+			else finalArr.push(deletePaths(root[i], tails, span));
+			else finalArr.push(root[i]);
+		}
+		return finalArr;
+	}
+	return root;
+};
+function sortStable(arr, compare) {
+	return arr.map((item, index) => ({
+		item,
+		index
+	})).sort((a, b) => {
+		const cmp = compare(a.item, b.item);
+		return cmp !== 0 ? cmp : a.index - b.index;
+	}).map((p) => p.item);
+}
+
+//#endregion
+//#region src/validate.ts
+/**
+* Validates the AST for correctness and supported features.
+* Checks for unknown function calls and arity mismatches.
+*
+* @param node - The root AST node to validate.
+* @throws {ValidationError} If validation fails.
+*/
+const validate = (node) => {
+	visit(node);
+};
+const visit = (node) => {
+	switch (node.kind) {
+		case "Identity":
+		case "Literal":
+		case "Var": return;
+		case "FieldAccess":
+			visit(node.target);
+			return;
+		case "IndexAccess":
+			visit(node.target);
+			visit(node.index);
+			return;
+		case "Array":
+			node.items.forEach(visit);
+			return;
+		case "Object":
+			node.entries.forEach((entry) => {
+				if (entry.key.kind === "KeyExpr") visit(entry.key.expr);
+				visit(entry.value);
+			});
+			return;
+		case "Pipe":
+		case "Comma":
+		case "Alt":
+			visit(node.left);
+			visit(node.right);
+			return;
+		case "Binary":
+		case "Bool":
+			visit(node.left);
+			visit(node.right);
+			return;
+		case "Unary":
+			visit(node.expr);
+			return;
+		case "If":
+			node.branches.forEach((branch) => {
+				visit(branch.cond);
+				visit(branch.then);
+			});
+			visit(node.else);
+			return;
+		case "As":
+			visit(node.bind);
+			visit(node.body);
+			return;
+		case "Call": {
+			const builtin = builtins[node.name];
+			if (!builtin) throw new ValidationError(`Unknown function: ${node.name}`, node.span);
+			if (builtin.arity !== node.args.length) throw new ValidationError(`Function ${node.name} expects ${builtin.arity} arguments, but got ${node.args.length}`, node.span);
+			node.args.forEach(visit);
+			return;
+		}
+		case "Reduce":
+			visit(node.source);
+			visit(node.init);
+			visit(node.update);
+			return;
+		case "Foreach":
+			visit(node.source);
+			visit(node.init);
+			visit(node.update);
+			if (node.extract) visit(node.extract);
+			return;
+		case "Try":
+			visit(node.body);
+			if (node.handler) visit(node.handler);
+			return;
+		case "Recurse":
+		case "Iterate": return;
+		default: return node;
+	}
+};
+
+//#endregion
+//#region src/limits.ts
+const DEFAULT_LIMITS = {
+	maxSteps: 1e5,
+	maxDepth: 200,
+	maxOutputs: 1e4
+};
+/**
+* Resolves a partial limits configuration into a complete one with defaults.
+*
+* @param config - The user-provided configuration.
+* @returns The resolved limits.
+*/
+const resolveLimits = (config = {}) => ({
+	maxSteps: config.maxSteps ?? DEFAULT_LIMITS.maxSteps,
+	maxDepth: config.maxDepth ?? DEFAULT_LIMITS.maxDepth,
+	maxOutputs: config.maxOutputs ?? DEFAULT_LIMITS.maxOutputs
+});
+/**
+* Tracks execution usage against defined limits.
+* Throws {@link RuntimeError} if any limit is exceeded.
+*/
+var LimitTracker = class {
+	steps = 0;
+	depth = 0;
+	outputs = 0;
+	constructor(limits) {
+		this.limits = limits;
+	}
+	/**
+	* Records a single execution step (AST node visit).
+	* @param span - The source span for error reporting.
+	*/
+	step(span) {
+		this.steps += 1;
+		if (this.steps > this.limits.maxSteps) throw new RuntimeError("Step limit exceeded", span);
+	}
+	/**
+	* Enters a new scope/stack frame, incrementing the depth counter.
+	* @param span - The source span for error reporting.
+	*/
+	enter(span) {
+		this.depth += 1;
+		if (this.depth > this.limits.maxDepth) throw new RuntimeError("Max depth exceeded", span);
+	}
+	/**
+	* Exits the current scope, decrementing the depth counter.
+	*/
+	exit() {
+		this.depth = Math.max(0, this.depth - 1);
+	}
+	/**
+	* Records an output value being emitted.
+	* @param span - The source span for error reporting.
+	*/
+	emit(span) {
+		this.outputs += 1;
+		if (this.outputs > this.limits.maxOutputs) throw new RuntimeError("Output limit exceeded", span);
+	}
+};
+
+//#endregion
+//#region src/eval.ts
+const runAst = (ast, input, options = {}) => {
+	const tracker = new LimitTracker(resolveLimits(options.limits));
+	const env = [/* @__PURE__ */ new Map()];
+	return Array.from(evaluate(ast, input, env, tracker));
+};
+/**
+* Evaluates an AST node against an input value.
+* This is a generator function that yields results lazily.
+*
+* @param node - The AST node to evaluate.
+* @param input - The current input value (context).
+* @param env - The variable environment stack.
+* @param tracker - Limits tracker for cycle/output limits.
+*/
+function* evaluate(node, input, env, tracker) {
+	tracker.step(node.span);
+	tracker.enter(node.span);
+	try {
+		switch (node.kind) {
+			case "Identity":
+				yield emit(input, node.span, tracker);
+				return;
+			case "Literal":
+				yield emit(node.value, node.span, tracker);
+				return;
+			case "Var":
+				yield emit(getVar(env, node.name, node.span), node.span, tracker);
+				return;
+			case "FieldAccess":
+				yield* evalField(node, input, env, tracker);
+				return;
+			case "IndexAccess":
+				yield* evalIndex(node, input, env, tracker);
+				return;
+			case "Array":
+				yield emit(buildArray(node, input, env, tracker), node.span, tracker);
+				return;
+			case "Object":
+				yield* buildObjects(node, input, env, tracker);
+				return;
+			case "Pipe":
+				for (const left of evaluate(node.left, input, env, tracker)) yield* evaluate(node.right, left, env, tracker);
+				return;
+			case "Comma":
+				yield* evaluate(node.left, input, env, tracker);
+				yield* evaluate(node.right, input, env, tracker);
+				return;
+			case "Alt": {
+				const valid = Array.from(evaluate(node.left, input, env, tracker)).filter((v) => v !== null && v !== false);
+				if (valid.length > 0) for (const v of valid) yield v;
+				else yield* evaluate(node.right, input, env, tracker);
+				return;
+			}
+			case "Unary":
+				if (node.op === "Not") for (const value of evaluate(node.expr, input, env, tracker)) yield emit(!isTruthy(value), node.span, tracker);
+				else for (const value of evaluate(node.expr, input, env, tracker)) yield emit(applyUnaryNeg(value, node.span), node.span, tracker);
+				return;
+			case "Binary":
+				yield* evalBinary(node, input, env, tracker);
+				return;
+			case "Bool":
+				if (node.op === "Or") for (const left of evaluate(node.left, input, env, tracker)) if (isTruthy(left)) yield emit(true, node.span, tracker);
+				else for (const right of evaluate(node.right, input, env, tracker)) yield emit(isTruthy(right), node.span, tracker);
+				else for (const left of evaluate(node.left, input, env, tracker)) if (!isTruthy(left)) yield emit(false, node.span, tracker);
+				else for (const right of evaluate(node.right, input, env, tracker)) yield emit(isTruthy(right), node.span, tracker);
+				return;
+			case "If":
+				for (const branch of node.branches) {
+					const condValues = Array.from(evaluate(branch.cond, input, env, tracker));
+					if (condValues.length > 1) throw new RuntimeError("Condition produced multiple values", branch.cond.span);
+					if (condValues.length === 1 && isTruthy(condValues[0])) {
+						yield* evaluate(branch.then, input, env, tracker);
+						return;
+					}
+				}
+				yield* evaluate(node.else, input, env, tracker);
+				return;
+			case "As": {
+				const boundValues = Array.from(evaluate(node.bind, input, env, tracker));
+				for (const value of boundValues) {
+					pushBinding(env, node.name, value);
+					try {
+						yield* evaluate(node.body, input, env, tracker);
+					} finally {
+						popBinding(env);
+					}
+				}
+				return;
+			}
+			case "Call": {
+				const builtin = builtins[node.name];
+				if (!builtin) throw new RuntimeError(`Unknown function: ${node.name}/${node.args.length}`, node.span);
+				yield* builtin.apply(input, node.args, env, tracker, evaluate, node.span);
+				return;
+			}
+			case "Reduce":
+				yield* evalReduce(node, input, env, tracker);
+				return;
+			case "Foreach":
+				yield* evalForeach(node, input, env, tracker);
+				return;
+			case "Try":
+				yield* evalTry(node, input, env, tracker);
+				return;
+			case "Recurse":
+				yield* evalRecurse(node, input, env, tracker);
+				return;
+			case "Iterate":
+				yield* evalIterate(node, input, env, tracker);
+				return;
+		}
+	} finally {
+		tracker.exit();
+	}
+}
+const emit = (value, span, tracker) => {
+	tracker.emit(span);
+	return value;
+};
+const evalField = function* (node, input, env, tracker) {
+	for (const container of evaluate(node.target, input, env, tracker)) {
+		if (container === null) {
+			yield emit(null, node.span, tracker);
+			continue;
+		}
+		if (isPlainObject(container)) {
+			yield emit(Object.prototype.hasOwnProperty.call(container, node.field) ? container[node.field] : null, node.span, tracker);
+			continue;
+		}
+		throw new RuntimeError(`Cannot index ${describeType(container)} with string`, node.span);
+	}
+};
+const evalIndex = function* (node, input, env, tracker) {
+	const indexValues = Array.from(evaluate(node.index, input, env, tracker));
+	for (const container of evaluate(node.target, input, env, tracker)) {
+		if (container === null) {
+			yield emit(null, node.span, tracker);
+			continue;
+		}
+		if (isValueArray(container)) {
+			for (const idxValue of indexValues) {
+				const index = ensureInteger(idxValue, node.span);
+				const resolved = index < 0 ? container.length + index : index;
+				if (resolved < 0 || resolved >= container.length) yield emit(null, node.span, tracker);
+				else yield emit(container[resolved], node.span, tracker);
+			}
+			continue;
+		}
+		if (isPlainObject(container)) {
+			for (const keyValue of indexValues) {
+				if (typeof keyValue !== "string") throw new RuntimeError(`Cannot index object with ${describeType(keyValue)}`, node.span);
+				yield emit(Object.prototype.hasOwnProperty.call(container, keyValue) ? container[keyValue] : null, node.span, tracker);
+			}
+			continue;
+		}
+		throw new RuntimeError(`Cannot index ${describeType(container)}`, node.span);
+	}
+};
+const evalIterate = function* (node, input, env, tracker) {
+	for (const container of evaluate(node.target, input, env, tracker)) {
+		if (container === null) continue;
+		if (isValueArray(container)) {
+			for (const item of container) yield emit(item, node.span, tracker);
+			continue;
+		}
+		if (isPlainObject(container)) {
+			const keys = Object.keys(container).sort();
+			for (const key of keys) yield emit(container[key], node.span, tracker);
+			continue;
+		}
+		throw new RuntimeError(`Cannot iterate over ${describeType(container)}`, node.span);
+	}
+};
+const evalReduce = function* (node, input, env, tracker) {
+	const initValues = Array.from(evaluate(node.init, input, env, tracker));
+	if (initValues.length !== 1) throw new RuntimeError("Reduce init must single value", node.init.span);
+	let acc = initValues[0];
+	for (const item of evaluate(node.source, input, env, tracker)) {
+		tracker.step(node.span);
+		pushBinding(env, node.var, item);
+		try {
+			const updates = Array.from(evaluate(node.update, acc, env, tracker));
+			if (updates.length !== 1) throw new RuntimeError("Reduce update must produce single value", node.update.span);
+			acc = updates[0];
+		} finally {
+			popBinding(env);
+		}
+	}
+	yield emit(acc, node.span, tracker);
+};
+const evalForeach = function* (node, input, env, tracker) {
+	const initValues = Array.from(evaluate(node.init, input, env, tracker));
+	if (initValues.length !== 1) throw new RuntimeError("Foreach init must single value", node.init.span);
+	let acc = initValues[0];
+	for (const item of evaluate(node.source, input, env, tracker)) {
+		tracker.step(node.span);
+		pushBinding(env, node.var, item);
+		try {
+			const updates = Array.from(evaluate(node.update, acc, env, tracker));
+			if (updates.length !== 1) throw new RuntimeError("Foreach update must produce single value", node.update.span);
+			acc = updates[0];
+			if (node.extract) for (const extracted of evaluate(node.extract, acc, env, tracker)) yield emit(extracted, node.span, tracker);
+			else yield emit(acc, node.span, tracker);
+		} finally {
+			popBinding(env);
+		}
+	}
+};
+const evalTry = function* (node, input, env, tracker) {
+	try {
+		yield* evaluate(node.body, input, env, tracker);
+	} catch (err) {
+		if (err instanceof RuntimeError) {
+			if (node.handler) yield* evaluate(node.handler, err.message, env, tracker);
+		} else throw err;
+	}
+};
+const evalRecurse = function* (node, input, env, tracker) {
+	yield emit(input, node.span, tracker);
+	tracker.step(node.span);
+	if (isValueArray(input)) for (const item of input) yield* evaluate(node, item, env, tracker);
+	else if (isPlainObject(input)) {
+		const keys = Object.keys(input).sort();
+		for (const key of keys) yield* evaluate(node, input[key], env, tracker);
+	}
+};
+const buildArray = (node, input, env, tracker) => {
+	const result = [];
+	node.items.forEach((item) => {
+		for (const value of evaluate(item, input, env, tracker)) result.push(value);
+	});
+	return result;
+};
+const buildObjects = function* (node, input, env, tracker) {
+	if (node.entries.length === 0) {
+		yield emit({}, node.span, tracker);
+		return;
+	}
+	let partials = [{}];
+	for (const entry of node.entries) {
+		const keys = resolveObjectKeys(entry.key, input, env, tracker);
+		const values = Array.from(evaluate(entry.value, input, env, tracker));
+		const next = [];
+		partials.forEach((partial) => {
+			keys.forEach((key) => {
+				values.forEach((value) => {
+					next.push(extendRecord(partial, key, value));
+				});
+			});
+		});
+		partials = next;
+		if (partials.length === 0) return;
+	}
+	for (const obj of partials) yield emit(obj, node.span, tracker);
+};
+const resolveObjectKeys = (key, input, env, tracker) => {
+	if (key.kind === "KeyIdentifier") return [key.name];
+	if (key.kind === "KeyString") return [key.value];
+	return Array.from(evaluate(key.expr, input, env, tracker)).map((value) => {
+		if (typeof value !== "string") throw new RuntimeError("Object key expression must produce strings", key.span);
+		return value;
+	});
+};
+const evalBinary = function* (node, input, env, tracker) {
+	const leftValues = Array.from(evaluate(node.left, input, env, tracker));
+	const rightValues = Array.from(evaluate(node.right, input, env, tracker));
+	for (const left of leftValues) for (const right of rightValues) yield emit(applyBinaryOp(node.op, left, right, node.span), node.span, tracker);
+};
+const applyBinaryOp = (op, left, right, span) => {
+	switch (op) {
+		case "+": return applyPlus(left, right, span);
+		case "-": return applyMinus(left, right, span);
+		case "*": return applyMultiply(left, right, span);
+		case "/": return applyDivide(left, right, span);
+		case "%": return applyModulo(left, right, span);
+		case "Eq": return valueEquals(left, right);
+		case "Neq": return !valueEquals(left, right);
+		case "Lt": return compareValues(left, right) < 0;
+		case "Lte": return compareValues(left, right) <= 0;
+		case "Gt": return compareValues(left, right) > 0;
+		case "Gte": return compareValues(left, right) >= 0;
+		default: throw new RuntimeError(`Unsupported operator ${op}`, span);
+	}
+};
+const applyUnaryNeg = (value, span) => {
+	if (typeof value === "number") return -value;
+	throw new RuntimeError("Unary \"-\" expects a number", span);
+};
+const applyPlus = (left, right, span) => {
+	if (left === null) return cloneValue(right);
+	if (right === null) return cloneValue(left);
+	if (typeof left === "number" && typeof right === "number") return left + right;
+	if (typeof left === "string" && typeof right === "string") return left + right;
+	if (isValueArray(left) && isValueArray(right)) return [...left, ...right];
+	if (isPlainObject(left) && isPlainObject(right)) return mergeShallowObjects(left, right);
+	throw new RuntimeError(`Cannot add ${describeType(left)} and ${describeType(right)}`, span);
+};
+const applyMinus = (left, right, span) => {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	if (isValueArray(left) && isValueArray(right)) return left.filter((item) => !right.some((candidate) => valueEquals(item, candidate)));
+	throw new RuntimeError(`Cannot subtract ${describeType(right)} from ${describeType(left)}`, span);
+};
+const applyMultiply = (left, right, span) => {
+	if (typeof left === "number" && typeof right === "number") return left * right;
+	if (typeof left === "string" && typeof right === "number") return repeatString(left, right, span);
+	if (typeof right === "string" && typeof left === "number") return repeatString(right, left, span);
+	if (isPlainObject(left) && isPlainObject(right)) return deepMergeObjects(left, right);
+	throw new RuntimeError(`Cannot multiply ${describeType(left)} and ${describeType(right)}`, span);
+};
+const applyDivide = (left, right, span) => {
+	if (typeof left !== "number" || typeof right !== "number") throw new RuntimeError("Division expects two numbers", span);
+	if (right === 0) throw new RuntimeError("Division by zero", span);
+	return left / right;
+};
+const applyModulo = (left, right, span) => {
+	if (typeof left !== "number" || typeof right !== "number") throw new RuntimeError("Modulo expects two numbers", span);
+	if (right === 0) throw new RuntimeError("Modulo by zero", span);
+	return left % right;
+};
+const repeatString = (text, countValue, span) => {
+	const count = ensureInteger(countValue, span);
+	if (count < 0) throw new RuntimeError("String repeat expects non-negative count", span);
+	return text.repeat(count);
+};
+const deepMergeObjects = (left, right) => {
+	const result = {};
+	Object.keys(left).forEach((key) => {
+		const leftValue = left[key];
+		if (leftValue !== void 0) result[key] = cloneValue(leftValue);
+	});
+	Object.keys(right).forEach((key) => {
+		const existing = result[key];
+		const rightValue = right[key];
+		if (rightValue === void 0) return;
+		if (existing !== void 0 && isPlainObject(existing) && isPlainObject(rightValue)) result[key] = deepMergeObjects(existing, rightValue);
+		else result[key] = cloneValue(rightValue);
+	});
+	return result;
+};
+const cloneValue = (value) => {
+	if (isValueArray(value)) return value.map((item) => cloneValue(item));
+	if (isPlainObject(value)) {
+		const result = {};
+		Object.keys(value).forEach((key) => {
+			const child = value[key];
+			if (child !== void 0) result[key] = cloneValue(child);
+		});
+		return result;
+	}
+	return value;
+};
+const getVar = (env, name, span) => {
+	for (let i = env.length - 1; i >= 0; i -= 1) {
+		const frame = env[i];
+		if (frame && frame.has(name)) return frame.get(name);
+	}
+	throw new RuntimeError(`Unbound variable: $${name}`, span);
+};
+const pushBinding = (env, name, value) => {
+	env.push(new Map([[name, value]]));
+};
+const popBinding = (env) => {
+	env.pop();
+};
+const ensureInteger = (value, span) => {
+	if (typeof value !== "number" || !Number.isInteger(value)) throw new RuntimeError("Index must be an integer number", span);
+	return value;
+};
+const extendRecord = (base, key, value) => {
+	const next = {};
+	Object.keys(base).forEach((existingKey) => {
+		const existingValue = base[existingKey];
+		if (existingValue !== void 0) next[existingKey] = existingValue;
+	});
+	next[key] = value;
+	return next;
+};
+const mergeShallowObjects = (left, right) => {
+	const result = {};
+	Object.keys(left).forEach((key) => {
+		const leftValue = left[key];
+		if (leftValue !== void 0) result[key] = leftValue;
+	});
+	Object.keys(right).forEach((key) => {
+		const rightValue = right[key];
+		if (rightValue !== void 0) result[key] = rightValue;
+	});
+	return result;
+};
+const isValueArray = (value) => Array.isArray(value);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const describeType = (value) => {
+	if (value === null) return "null";
+	if (typeof value === "boolean") return "boolean";
+	if (typeof value === "number") return "number";
+	if (typeof value === "string") return "string";
+	if (Array.isArray(value)) return "array";
+	return "object";
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Runs a jq query against a JSON input.
+*
+* @param source - The jq query string (e.g., `.foo | .bar`).
+* @param input - The JSON input value (object, array, string, number, boolean, or null).
+* @param options - Execution options including limits.
+* @returns An array of results. jq queries always produce zero or more values.
+* @throws {LexError} If the query contains invalid characters.
+* @throws {ParseError} If the query syntax is invalid.
+* @throws {ValidationError} If the query uses unsupported features.
+* @throws {RuntimeError} If execution fails (e.g., type error) or exceeds limits.
+*/
+const run = (source, input, options = {}) => {
+	const ast = parse(source);
+	validate(ast);
+	return runAst(ast, input, options);
+};
+
+//#endregion
+exports.LexError = LexError;
+exports.LimitTracker = LimitTracker;
+exports.ParseError = ParseError;
+exports.RuntimeError = RuntimeError;
+exports.ValidationError = ValidationError;
+exports.parse = parse;
+exports.resolveLimits = resolveLimits;
+exports.run = run;
+exports.runAst = runAst;
+exports.validate = validate;