@gabrielbryk/jq-ts 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -61,11 +61,22 @@ const keywordKinds = {
 	reduce: "Reduce",
 	foreach: "Foreach",
 	try: "Try",
-	catch: "Catch"
+	catch: "Catch",
+	def: "Def",
+	label: "Label",
+	break: "Break"
 };
 
 //#endregion
 //#region src/lexer.ts
+/**
+* Tokenizes the input jq string into a list of AST tokens.
+* Handles string interpolation, comments, and operator grouping.
+*
+* @param text - The source code to tokenize.
+* @returns An array of {@link Token}, including an EOF token at the end.
+* @throws {@link LexError} if an invalid character or sequence is encountered.
+*/
 const lex = (text) => {
 	const tokens = [];
 	const length = text.length;
@@ -87,6 +98,7 @@ const lex = (text) => {
 	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);
+	const modeStack = [0];
 	while (pos < length) {
 		const ch = peek();
 		if (isWhitespace(ch)) {
@@ -98,10 +110,27 @@ const lex = (text) => {
 			continue;
 		}
 		const start = pos;
+		if (ch === ")") {
+			if (modeStack.length > 1) {
+				advance();
+				const endPos = readString(start, false);
+				const value = readStringValue(start, start + 1, endPos - (peek(-1) === "\"" ? 1 : 2));
+				if (text[endPos - 1] === "\"") {
+					modeStack.pop();
+					pushToken("StringEnd", start, endPos, value);
+				} else pushToken("StringMiddle", start, endPos, value);
+				continue;
+			}
+		}
 		switch (ch) {
 			case "\"": {
-				const endPos = readString(start);
-				pushToken("String", start, endPos, readStringValue(start, start + 1, endPos - 1));
+				const endPos = readString(start, true);
+				const isInterp = text.substring(endPos - 2, endPos) === "\\(";
+				const value = readStringValue(start, start + 1, endPos - (isInterp ? 2 : 1));
+				if (isInterp) {
+					modeStack.push(1);
+					pushToken("StringStart", start, endPos, value);
+				} else pushToken("String", start, endPos, value);
 				continue;
 			}
 			case ".":
@@ -119,15 +148,28 @@ const lex = (text) => {
 				advance();
 				pushToken("Comma", start, pos);
 				continue;
+			case "?":
+				advance();
+				pushToken("Question", start, pos);
+				continue;
 			case "|":
 				advance();
-				pushToken("Pipe", start, pos);
+				if (peek() === "=") {
+					advance();
+					pushToken("BarEq", start, pos);
+				} else pushToken("Pipe", start, pos);
 				continue;
 			case "/":
 				advance();
 				if (peek() === "/") {
 					advance();
-					pushToken("Alt", start, pos);
+					if (peek() === "=") {
+						advance();
+						pushToken("AltEq", start, pos);
+					} else pushToken("Alt", start, pos);
+				} else if (peek() === "=") {
+					advance();
+					pushToken("SlashEq", start, pos);
 				} else pushToken("Slash", start, pos);
 				continue;
 			case "(":
@@ -160,26 +202,38 @@ const lex = (text) => {
 				continue;
 			case "+":
 				advance();
-				pushToken("Plus", start, pos);
+				if (peek() === "=") {
+					advance();
+					pushToken("PlusEq", start, pos);
+				} else pushToken("Plus", start, pos);
 				continue;
 			case "-":
 				advance();
-				pushToken("Minus", start, pos);
+				if (peek() === "=") {
+					advance();
+					pushToken("MinusEq", start, pos);
+				} else pushToken("Minus", start, pos);
 				continue;
 			case "*":
 				advance();
-				pushToken("Star", start, pos);
+				if (peek() === "=") {
+					advance();
+					pushToken("StarEq", start, pos);
+				} else pushToken("Star", start, pos);
 				continue;
 			case "%":
 				advance();
-				pushToken("Percent", start, pos);
+				if (peek() === "=") {
+					advance();
+					pushToken("PercentEq", start, pos);
+				} else pushToken("Percent", start, pos);
 				continue;
 			case "=":
 				advance();
 				if (peek() === "=") {
 					advance();
 					pushToken("EqualEqual", start, pos);
-				} else throw new LexError("Unexpected \"=\" (only \"==\" supported)", makeSpan(start, pos));
+				} else pushToken("Eq", start, pos);
 				continue;
 			case "!":
 				advance();
@@ -247,19 +301,23 @@ const lex = (text) => {
 		}
 		return pos;
 	}
-	function readString(tokenStart) {
-		advance();
+	function readString(tokenStart, openQuote) {
+		if (openQuote) advance();
 		while (pos < length) {
 			const current = advance();
 			if (current === "\"") return pos;
 			if (current === "\\") {
+				if (peek() === "(") {
+					advance();
+					return pos;
+				}
 				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));
+					for (let i = 0; i < 4; i++) {
+						const h = advance();
+						if (!h || !isHexDigit(h)) throw new LexError("Invalid Unicode escape", makeSpan(tokenStart, pos));
 					}
 					continue;
 				}
@@ -275,41 +333,44 @@ const lex = (text) => {
 			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;
+				if (!next) throw new LexError("Unexpected end of input", makeSpan(tokenStart, pos));
+				if ("\"\\/bfnrt".includes(next)) {
+					switch (next) {
+						case "\"":
+							result += "\"";
+							break;
+						case "\\":
+							result += "\\";
+							break;
+						case "/":
+							result += "/";
+							break;
+						case "b":
+							result += "\b";
+							break;
+						case "f":
+							result += "\f";
+							break;
+						case "n":
+							result += "\n";
+							break;
+						case "r":
+							result += "\r";
+							break;
+						case "t":
+							result += "	";
+							break;
 					}
-					default: throw new LexError(`Invalid escape sequence "\\${next}"`, makeSpan(tokenStart, tokenStart + (i - innerStart) + 2));
+					i += 2;
+					continue;
+				}
+				if (next === "u") {
+					const hex = text.slice(i + 2, i + 6);
+					result += String.fromCharCode(parseInt(hex, 16));
+					i += 6;
+					continue;
 				}
+				throw new LexError(`Invalid escape sequence "\\${next}"`, makeSpan(tokenStart, pos));
 			} else {
 				result += ch;
 				i += 1;
@@ -339,16 +400,56 @@ var Parser = class {
 		this.tokens = tokens;
 	}
 	parseFilter() {
-		const expr = this.parseBinding();
+		const expr = this.parseDef();
 		this.consume("EOF", "Expected end of expression");
 		return expr;
 	}
-	parseBinding() {
-		let expr = this.parseComma();
+	parseDef(allowComma = true) {
+		if (this.match("Def")) {
+			const startSpan = this.previous().span;
+			const nameToken = this.consume("Identifier", "Expected function name");
+			const name = String(nameToken.value);
+			const args = [];
+			if (this.match("LParen")) {
+				if (!this.check("RParen")) do {
+					const argToken = this.consume("Identifier", "Expected argument name");
+					args.push(String(argToken.value));
+				} while (this.match("Semicolon"));
+				this.consume("RParen", "Expected \")\" after arguments");
+			}
+			this.consume("Colon", "Expected \":\" after function signature");
+			const body = this.parseDef(true);
+			this.consume("Semicolon", "Expected \";\" after function body");
+			const next = this.parseDef(allowComma);
+			return {
+				kind: "Def",
+				name,
+				args,
+				body,
+				next,
+				span: spanBetween(startSpan, next.span)
+			};
+		}
+		return this.parseBinding(allowComma);
+	}
+	parseBinding(allowComma = true) {
+		if (this.match("Label")) {
+			const start = this.previous();
+			const varToken = this.consume("Variable", "Expected variable name after \"label\"");
+			this.consume("Pipe", "Expected \"|\" after label");
+			const body = this.parseBinding(allowComma);
+			return {
+				kind: "Label",
+				label: String(varToken.value),
+				body,
+				span: spanBetween(start.span, body.span)
+			};
+		}
+		let expr = allowComma ? this.parseComma() : this.parseAssignment();
 		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();
+			const body = this.parseBinding(allowComma);
 			expr = {
 				kind: "As",
 				bind: expr,
@@ -360,9 +461,9 @@ var Parser = class {
 		return expr;
 	}
 	parseComma() {
-		let expr = this.parsePipe();
+		let expr = this.parseAssignment();
 		while (this.match("Comma")) {
-			const right = this.parsePipe();
+			const right = this.parseAssignment();
 			expr = {
 				kind: "Comma",
 				left: expr,
@@ -372,6 +473,49 @@ var Parser = class {
 		}
 		return expr;
 	}
+	parseAssignment() {
+		const expr = this.parsePipe();
+		if (this.match("Eq") || this.match("BarEq") || this.match("PlusEq") || this.match("MinusEq") || this.match("StarEq") || this.match("SlashEq") || this.match("PercentEq") || this.match("AltEq")) {
+			const opToken = this.previous();
+			const right = this.parseAssignment();
+			let op;
+			switch (opToken.kind) {
+				case "Eq":
+					op = "=";
+					break;
+				case "BarEq":
+					op = "|=";
+					break;
+				case "PlusEq":
+					op = "+=";
+					break;
+				case "MinusEq":
+					op = "-=";
+					break;
+				case "StarEq":
+					op = "*=";
+					break;
+				case "SlashEq":
+					op = "/=";
+					break;
+				case "PercentEq":
+					op = "%=";
+					break;
+				case "AltEq":
+					op = "//=";
+					break;
+				default: throw new Error(`Unknown assignment op: ${opToken.kind}`);
+			}
+			return {
+				kind: "Assignment",
+				op,
+				left: expr,
+				right,
+				span: spanBetween(expr.span, right.span)
+			};
+		}
+		return expr;
+	}
 	parsePipe() {
 		let expr = this.parsePipeOperand();
 		while (this.match("Pipe")) {
@@ -508,6 +652,19 @@ var Parser = class {
 				continue;
 			}
 			if (this.match("LBracket")) {
+				if (this.match("Colon")) {
+					let end = null;
+					if (!this.check("RBracket")) end = this.parsePipe();
+					const close = this.consume("RBracket", "Expected \"]\" after slice");
+					expr = {
+						kind: "Slice",
+						target: expr,
+						start: null,
+						end,
+						span: spanBetween(expr.span, close.span)
+					};
+					continue;
+				}
 				if (this.match("RBracket")) {
 					const close = this.previous();
 					expr = {
@@ -518,6 +675,19 @@ var Parser = class {
 					continue;
 				}
 				const index = this.parsePipe();
+				if (this.match("Colon")) {
+					let end = null;
+					if (!this.check("RBracket")) end = this.parsePipe();
+					const close = this.consume("RBracket", "Expected \"]\" after slice");
+					expr = {
+						kind: "Slice",
+						target: expr,
+						start: index,
+						end,
+						span: spanBetween(expr.span, close.span)
+					};
+					continue;
+				}
 				const closing = this.consume("RBracket", "Expected \"]\" after index expression");
 				expr = {
 					kind: "IndexAccess",
@@ -527,6 +697,19 @@ var Parser = class {
 				};
 				continue;
 			}
+			if (this.match("Question")) {
+				const op = this.previous();
+				expr = {
+					kind: "Try",
+					body: expr,
+					handler: {
+						kind: "Identity",
+						span: op.span
+					},
+					span: spanBetween(expr.span, op.span)
+				};
+				continue;
+			}
 			break;
 		}
 		return expr;
@@ -538,6 +721,7 @@ var Parser = class {
 		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("StringStart")) return this.parseStringInterpolation(this.previous());
 		if (this.match("Variable")) {
 			const token = this.previous();
 			return {
@@ -550,7 +734,7 @@ var Parser = class {
 		if (this.match("If")) return this.parseIf(this.previous());
 		if (this.match("LParen")) {
 			const start = this.previous();
-			const expr = this.parseComma();
+			const expr = this.parseDef();
 			const close = this.consume("RParen", "Expected \")\" after expression");
 			expr.span = spanBetween(start.span, close.span);
 			return expr;
@@ -564,8 +748,21 @@ var Parser = class {
 			kind: "Recurse",
 			span: this.previous().span
 		};
+		if (this.match("DotDot")) return {
+			kind: "Recurse",
+			span: this.previous().span
+		};
+		if (this.match("Break")) return this.parseBreak(this.previous());
 		throw this.error(this.peek(), "Unexpected token");
 	}
+	parseBreak(start) {
+		const varToken = this.consume("Variable", "Expected variable after \"break\"");
+		return {
+			kind: "Break",
+			label: String(varToken.value),
+			span: spanBetween(start.span, varToken.span)
+		};
+	}
 	parseReduce(start) {
 		const source = this.parsePipe();
 		this.consume("As", "Expected \"as\" after reduce source");
@@ -606,11 +803,11 @@ var Parser = class {
 		};
 	}
 	parseTry(start) {
-		const body = this.parseComma();
+		const body = this.parseDef(true);
 		let handler;
 		let endSpan = body.span;
 		if (this.match("Catch")) {
-			handler = this.parseComma();
+			handler = this.parseDef(true);
 			endSpan = handler.span;
 		}
 		return {
@@ -622,24 +819,24 @@ var Parser = class {
 	}
 	parseIf(start) {
 		const branches = [];
-		const firstCond = this.parsePipe();
+		const firstCond = this.parseDef(true);
 		this.consume("Then", "Expected \"then\" after condition");
-		const firstThen = this.parsePipe();
+		const firstThen = this.parseDef(true);
 		branches.push({
 			cond: firstCond,
 			then: firstThen
 		});
 		while (this.match("Elif")) {
-			const cond = this.parsePipe();
+			const cond = this.parseDef(true);
 			this.consume("Then", "Expected \"then\" after elif condition");
-			const thenBranch = this.parsePipe();
+			const thenBranch = this.parseDef(true);
 			branches.push({
 				cond,
 				then: thenBranch
 			});
 		}
 		this.consume("Else", "Expected \"else\" in if expression");
-		const elseBranch = this.parsePipe();
+		const elseBranch = this.parseDef(true);
 		const endToken = this.consume("End", "Expected \"end\" to close if expression");
 		return {
 			kind: "If",
@@ -650,26 +847,36 @@ var Parser = class {
 	}
 	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");
+		if (!this.match("RBracket")) {
+			do
+				items.push(this.parseDef(false));
+			while (this.match("Comma"));
+			this.consume("RBracket", "Expected \"]\" after array elements");
+		}
 		return {
 			kind: "Array",
 			items,
-			span: spanBetween(start.span, end.span)
+			span: spanBetween(start.span, this.previous().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");
+		if (!this.match("RBrace")) {
+			do {
+				const key = this.parseObjectKey();
+				this.consume("Colon", "Expected \":\" after object key");
+				const value = this.parseDef(false);
+				entries.push({
+					key,
+					value
+				});
+			} while (this.match("Comma"));
+			this.consume("RBrace", "Expected \"}\" after object entries");
+		}
 		return {
 			kind: "Object",
 			entries,
-			span: spanBetween(start.span, end.span)
+			span: spanBetween(start.span, this.previous().span)
 		};
 	}
 	parseObjectEntry() {
@@ -677,7 +884,7 @@ var Parser = class {
 		this.consume("Colon", "Expected \":\" after object key");
 		return {
 			key,
-			value: this.parsePipe()
+			value: this.parseDef(false)
 		};
 	}
 	parseObjectKey() {
@@ -741,6 +948,19 @@ var Parser = class {
 				continue;
 			}
 			if (this.match("LBracket")) {
+				if (this.match("Colon")) {
+					let end = null;
+					if (!this.check("RBracket")) end = this.parsePipe();
+					const close = this.consume("RBracket", "Expected \"]\" after slice");
+					expr = {
+						kind: "Slice",
+						target: expr,
+						start: null,
+						end,
+						span: spanBetween(expr.span, close.span)
+					};
+					continue;
+				}
 				if (this.match("RBracket")) {
 					const close = this.previous();
 					expr = {
@@ -751,6 +971,19 @@ var Parser = class {
 					continue;
 				}
 				const index = this.parsePipe();
+				if (this.match("Colon")) {
+					let end = null;
+					if (!this.check("RBracket")) end = this.parsePipe();
+					const close = this.consume("RBracket", "Expected \"]\" after slice");
+					expr = {
+						kind: "Slice",
+						target: expr,
+						start: index,
+						end,
+						span: spanBetween(expr.span, close.span)
+					};
+					continue;
+				}
 				const closing = this.consume("RBracket", "Expected \"]\" after index expression");
 				expr = {
 					kind: "IndexAccess",
@@ -760,6 +993,19 @@ var Parser = class {
 				};
 				continue;
 			}
+			if (this.match("Question")) {
+				const op = this.previous();
+				expr = {
+					kind: "Try",
+					body: expr,
+					handler: {
+						kind: "Identity",
+						span: op.span
+					},
+					span: spanBetween(expr.span, op.span)
+				};
+				continue;
+			}
 			break;
 		}
 		return expr;
@@ -786,7 +1032,7 @@ var Parser = class {
 		const args = [];
 		if (this.check("RParen")) return args;
 		do
-			args.push(this.parsePipe());
+			args.push(this.parseDef(true));
 		while (this.match("Semicolon"));
 		return args;
 	}
@@ -806,6 +1052,53 @@ var Parser = class {
 			span: spanBetween(left.span, right.span)
 		};
 	}
+	parseStringInterpolation(start) {
+		const parts = [{
+			kind: "Literal",
+			value: String(start.value),
+			span: start.span
+		}];
+		while (true) {
+			const expr = this.parseDef();
+			parts.push({
+				kind: "Pipe",
+				left: expr,
+				right: {
+					kind: "Call",
+					name: "tostring",
+					args: [],
+					span: expr.span
+				},
+				span: expr.span
+			});
+			if (this.match("StringMiddle")) {
+				const token = this.previous();
+				parts.push({
+					kind: "Literal",
+					value: String(token.value),
+					span: token.span
+				});
+				continue;
+			}
+			if (this.match("StringEnd")) {
+				const token = this.previous();
+				parts.push({
+					kind: "Literal",
+					value: String(token.value),
+					span: token.span
+				});
+				break;
+			}
+			throw this.error(this.peek(), "Expected closing paren of interpolation or continuation");
+		}
+		return parts.reduce((acc, curr) => ({
+			kind: "Binary",
+			op: "+",
+			left: acc,
+			right: curr,
+			span: spanBetween(acc.span, curr.span)
+		}));
+	}
 	match(kind) {
 		if (this.check(kind)) {
 			this.advance();
@@ -855,6 +1148,17 @@ const spanBetween = (a, b) => ({
 	end: Math.max(a.end, b.end)
 });
 
+//#endregion
+//#region src/builtins/registry.ts
+const builtins = {};
+const registerBuiltin = (spec) => {
+	if (!builtins[spec.name]) builtins[spec.name] = [];
+	builtins[spec.name].push(spec);
+};
+const registerBuiltins = (specs) => {
+	for (const spec of specs) registerBuiltin(spec);
+};
+
 //#endregion
 //#region src/value.ts
 /**
@@ -881,7 +1185,7 @@ const valueEquals = (a, b) => {
 		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)) {
+	if (isPlainObject(a) && isPlainObject(b)) {
 		const aKeys = Object.keys(a).sort();
 		const bKeys = Object.keys(b).sort();
 		if (aKeys.length !== bKeys.length) return false;
@@ -918,7 +1222,7 @@ const compareValues = (a, b) => {
 		}
 		return a.length < b.length ? -1 : 1;
 	}
-	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+	if (isPlainObject(a) && isPlainObject(b)) {
 		const aKeys = Object.keys(a).sort();
 		const bKeys = Object.keys(b).sort();
 		const len = Math.min(aKeys.length, bKeys.length);
@@ -952,7 +1256,14 @@ const typeRank = (value) => {
 * @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);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Checks if a value is a JSON array.
+*
+* @param value - The value to check.
+* @returns `true` if `value` is an array.
+*/
+const isValueArray = (value) => 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.
@@ -960,7 +1271,7 @@ const isPlainObject$1 = (value) => typeof value === "object" && value !== null &
 * @param value - The value to inspect.
 * @returns The lower-case type name.
 */
-const describeType$1 = (value) => {
+const describeType = (value) => {
 	if (value === null) return "null";
 	if (typeof value === "boolean") return "boolean";
 	if (typeof value === "number") return "number";
@@ -970,7 +1281,7 @@ const describeType$1 = (value) => {
 };
 
 //#endregion
-//#region src/builtins.ts
+//#region src/builtins/utils.ts
 const emit$1 = (value, span, tracker) => {
 	tracker.emit(span);
 	return value;
@@ -987,22 +1298,25 @@ const stableStringify = (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: {
+
+//#endregion
+//#region src/builtins/std.ts
+const stdBuiltins = [
+	{
 		name: "type",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			yield emit$1(describeType$1(input), span, tracker);
+			yield emit$1(describeType(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) {
@@ -1016,128 +1330,421 @@ const builtins = {
 				yield emit$1(num, span, tracker);
 				return;
 			}
-			throw new RuntimeError(`Cannot convert ${describeType$1(input)} to number`, span);
+			throw new RuntimeError(`Cannot convert ${describeType(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);
+			else throw new RuntimeError(`Cannot take length of ${describeType(input)}`, span);
 		}
 	},
-	keys: {
-		name: "keys",
+	{
+		name: "empty",
+		arity: 0,
+		apply: function* () {}
+	},
+	{
+		name: "toboolean",
 		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);
+			yield emit$1(isTruthy(input), span, tracker);
 		}
 	},
-	has: {
-		name: "has",
+	{
+		name: "walk",
 		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);
+			const f = args[0];
+			const walkRec = function* (curr) {
+				tracker.step(span);
+				let newStruct = curr;
+				if (Array.isArray(curr)) {
+					const newArr = [];
+					for (const item of curr) for (const walkedItem of walkRec(item)) newArr.push(walkedItem);
+					newStruct = newArr;
+				} else if (isPlainObject(curr)) {
+					const newObj = {};
+					const keys = Object.keys(curr).sort();
+					let objValid = true;
+					for (const key of keys) {
+						const val = curr[key];
+						let lastVal;
+						let found = false;
+						for (const walkedVal of walkRec(val)) {
+							lastVal = walkedVal;
+							found = true;
+						}
+						if (found) newObj[key] = lastVal;
+						else {
+							objValid = false;
+							break;
+						}
+					}
+					if (!objValid) return;
+					newStruct = newObj;
+				}
+				yield* evaluate$1(f, newStruct, env, tracker);
+			};
+			yield* walkRec(input);
 		}
-	},
-	error: {
-		name: "error",
+	}
+];
+
+//#endregion
+//#region src/builtins/errors.ts
+const errorBuiltins = [{
+	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);
+	}
+}];
+
+//#endregion
+//#region src/builtins/strings.ts
+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(a) && isPlainObject(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);
+};
+const stringBuiltins = [
+	{
+		name: "split",
 		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);
+			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);
+			}
 		}
 	},
-	map: {
-		name: "map",
+	{
+		name: "join",
 		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);
+			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(item)}`, span);
+					parts.push(item);
+				}
+				yield emit$1(parts.join(sep), span, tracker);
 			}
-			yield emit$1(result, span, tracker);
 		}
 	},
-	select: {
-		name: "select",
+	{
+		name: "startswith",
 		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;
+			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);
 			}
 		}
 	},
-	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",
+	{
+		name: "endswith",
 		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]
-				});
+			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);
 			}
-			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);
+	{
+		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);
 		}
 	},
-	unique_by: {
-		name: "unique_by",
+	{
+		name: "index",
 		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 searchGen = evaluate$1(args[0], input, env, tracker);
+			for (const search of searchGen) if (Array.isArray(input)) {
+				let foundIndex = null;
+				for (let i = 0; i < input.length; i++) {
+					const val = input[i];
+					if (val !== void 0 && valueEquals(val, search)) {
+						foundIndex = i;
+						break;
+					}
+				}
+				yield emit$1(foundIndex, span, tracker);
+			} else if (typeof input === "string") {
+				if (typeof search !== "string") throw new RuntimeError("index expects string search when input is string", span);
+				const idx = input.indexOf(search);
+				yield emit$1(idx === -1 ? null : idx, span, tracker);
+			} else if (input === null) yield emit$1(null, span, tracker);
+			else throw new RuntimeError("index expects string or array", span);
+		}
+	},
+	{
+		name: "rindex",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const searchGen = evaluate$1(args[0], input, env, tracker);
+			for (const search of searchGen) if (Array.isArray(input)) {
+				let foundIndex = null;
+				for (let i = input.length - 1; i >= 0; i--) {
+					const val = input[i];
+					if (val !== void 0 && valueEquals(val, search)) {
+						foundIndex = i;
+						break;
+					}
+				}
+				yield emit$1(foundIndex, span, tracker);
+			} else if (typeof input === "string") {
+				if (typeof search !== "string") throw new RuntimeError("rindex expects string search when input is string", span);
+				const idx = input.lastIndexOf(search);
+				yield emit$1(idx === -1 ? null : idx, span, tracker);
+			} else if (input === null) yield emit$1(null, span, tracker);
+			else throw new RuntimeError("rindex expects string or array", span);
+		}
+	},
+	{
+		name: "indices",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const searchGen = evaluate$1(args[0], input, env, tracker);
+			for (const search of searchGen) {
+				const indices = [];
+				if (Array.isArray(input)) for (let i = 0; i < input.length; i++) {
+					const val = input[i];
+					if (val !== void 0 && valueEquals(val, search)) indices.push(i);
+				}
+				else if (typeof input === "string") {
+					if (typeof search !== "string") throw new RuntimeError("indices expects string", span);
+					if (search.length === 0) {} else {
+						let pos = 0;
+						while (pos < input.length) {
+							const idx = input.indexOf(search, pos);
+							if (idx === -1) break;
+							indices.push(idx);
+							pos = idx + 1;
+							pos = idx + search.length;
+						}
+					}
+				} else {
+					if (input === null) {
+						yield emit$1(null, span, tracker);
+						continue;
+					}
+					throw new RuntimeError("indices expects string or array", span);
+				}
+				yield emit$1(indices, span, tracker);
+			}
+		}
+	},
+	{
+		name: "explode",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "string") throw new RuntimeError("explode expects string", span);
+			yield emit$1(Array.from(input).map((c) => c.codePointAt(0)), span, tracker);
+		}
+	},
+	{
+		name: "implode",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("implode expects array", span);
+			const chars = [];
+			for (const item of input) {
+				if (typeof item !== "number") throw new RuntimeError("implode item must be number", span);
+				chars.push(String.fromCodePoint(item));
+			}
+			yield emit$1(chars.join(""), span, tracker);
+		}
+	},
+	{
+		name: "ltrimstr",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (typeof input !== "string") throw new RuntimeError("ltrimstr expects string", span);
+			const prefixGen = evaluate$1(args[0], input, env, tracker);
+			for (const prefix of prefixGen) {
+				if (typeof prefix !== "string") throw new RuntimeError("ltrimstr prefix must be a string", span);
+				if (input.startsWith(prefix)) yield emit$1(input.slice(prefix.length), span, tracker);
+				else yield emit$1(input, span, tracker);
+			}
+		}
+	},
+	{
+		name: "rtrimstr",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (typeof input !== "string") throw new RuntimeError("rtrimstr expects string", span);
+			const suffixGen = evaluate$1(args[0], input, env, tracker);
+			for (const suffix of suffixGen) {
+				if (typeof suffix !== "string") throw new RuntimeError("rtrimstr suffix must be a string", span);
+				if (input.endsWith(suffix)) yield emit$1(input.slice(0, input.length - suffix.length), span, tracker);
+				else yield emit$1(input, span, tracker);
+			}
+		}
+	},
+	{
+		name: "ascii_downcase",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "string") throw new RuntimeError("ascii_downcase expects string", span);
+			yield emit$1(input.toLowerCase(), span, tracker);
+		}
+	},
+	{
+		name: "ascii_upcase",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "string") throw new RuntimeError("ascii_upcase expects string", span);
+			yield emit$1(input.toUpperCase(), span, tracker);
+		}
+	}
+];
+
+//#endregion
+//#region src/builtins/collections.ts
+function sortStable(arr, compare$1) {
+	return arr.map((item, index) => ({
+		item,
+		index
+	})).sort((a, b) => {
+		const cmp = compare$1(a.item, b.item);
+		return cmp !== 0 ? cmp : a.index - b.index;
+	}).map((p) => p.item);
+}
+const collectionBuiltins = [
+	{
+		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);
+		}
+	},
+	{
+		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);
+		}
+	},
+	{
+		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);
+		}
+	},
+	{
+		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;
+			}
+		}
+	},
+	{
+		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);
+		}
+	},
+	{
+		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);
+		}
+	},
+	{
+		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);
+		}
+	},
+	{
+		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 = [];
@@ -1154,7 +1761,7 @@ const builtins = {
 			yield emit$1(result, span, tracker);
 		}
 	},
-	to_entries: {
+	{
 		name: "to_entries",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
@@ -1169,7 +1776,7 @@ const builtins = {
 			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) {
@@ -1187,7 +1794,7 @@ const builtins = {
 			yield emit$1(result, span, tracker);
 		}
 	},
-	with_entries: {
+	{
 		name: "with_entries",
 		arity: 1,
 		apply: function* (input, args, env, tracker, evaluate$1, span) {
@@ -1219,133 +1826,290 @@ const builtins = {
 			yield emit$1(result, span, tracker);
 		}
 	},
-	split: {
-		name: "split",
+	{
+		name: "group_by",
 		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);
+			if (!Array.isArray(input)) throw new RuntimeError("group_by expects an array", span);
+			const pairs = [];
+			const filter = args[0];
+			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("group_by key expression must return exactly one value", span);
+				pairs.push({
+					val: item,
+					key: keys[0]
+				});
 			}
-		}
-	},
-	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);
+			const sorted = sortStable(pairs, (a, b) => compareValues(a.key, b.key));
+			const groups = [];
+			if (sorted.length > 0) {
+				let currentGroup = [sorted[0].val];
+				let currentKey = sorted[0].key;
+				for (let i = 1; i < sorted.length; i++) {
+					const pair = sorted[i];
+					if (compareValues(pair.key, currentKey) === 0) currentGroup.push(pair.val);
+					else {
+						groups.push(currentGroup);
+						currentGroup = [pair.val];
+						currentKey = pair.key;
+					}
 				}
-				yield emit$1(parts.join(sep), span, tracker);
+				groups.push(currentGroup);
 			}
+			yield emit$1(groups, 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);
-			}
+	{
+		name: "reverse",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("reverse expects an array", span);
+			yield emit$1([...input].reverse(), span, tracker);
 		}
 	},
-	endswith: {
-		name: "endswith",
+	{
+		name: "flatten",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("flatten expects an array", span);
+			const flattenRec = (arr) => {
+				let res = [];
+				for (const item of arr) if (Array.isArray(item)) res = res.concat(flattenRec(item));
+				else res.push(item);
+				return res;
+			};
+			yield emit$1(flattenRec(input), span, tracker);
+		}
+	},
+	{
+		name: "flatten",
 		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);
+			if (!Array.isArray(input)) throw new RuntimeError("flatten expects an array", span);
+			const depths = evaluate$1(args[0], input, env, tracker);
+			for (const depthVal of depths) {
+				if (typeof depthVal !== "number") throw new RuntimeError("flatten depth must be a number", span);
+				const flattenDepth = (arr, d) => {
+					if (d <= 0) return arr;
+					let res = [];
+					for (const item of arr) if (Array.isArray(item)) res = res.concat(flattenDepth(item, d - 1));
+					else res.push(item);
+					return res;
+				};
+				yield emit$1(flattenDepth(input, depthVal), 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);
+	{
+		name: "keys_unsorted",
+		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), span, tracker);
+			else throw new RuntimeError(`keys_unsorted expects an array or object`, span);
 		}
 	},
-	paths: {
-		name: "paths",
+	{
+		name: "transpose",
 		arity: 0,
 		apply: function* (input, _args, _env, tracker, _eval, span) {
-			yield* traversePaths(input, [], span, tracker);
+			if (!Array.isArray(input)) throw new RuntimeError("transpose expects an array", span);
+			const arr = input;
+			if (arr.length === 0) {
+				yield emit$1([], span, tracker);
+				return;
+			}
+			let maxLen = 0;
+			for (const row of arr) {
+				if (!Array.isArray(row)) throw new RuntimeError("transpose input must be array of arrays", span);
+				if (row.length > maxLen) maxLen = row.length;
+			}
+			const result = [];
+			for (let j = 0; j < maxLen; j++) {
+				const newRow = [];
+				for (let i = 0; i < arr.length; i++) {
+					const row = arr[i];
+					const val = j < row.length ? row[j] : null;
+					newRow.push(val);
+				}
+				result.push(newRow);
+			}
+			yield emit$1(result, span, tracker);
 		}
 	},
-	getpath: {
-		name: "getpath",
+	{
+		name: "bsearch",
 		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);
+			if (!Array.isArray(input)) throw new RuntimeError("bsearch expects an array", span);
+			const targetGen = evaluate$1(args[0], input, env, tracker);
+			for (const target of targetGen) {
+				let low = 0;
+				let high = input.length - 1;
+				let idx = -1;
+				while (low <= high) {
+					const mid = Math.floor((low + high) / 2);
+					const cmp = compareValues(input[mid], target);
+					if (cmp === 0) {
+						idx = mid;
+						break;
+					} else if (cmp < 0) low = mid + 1;
+					else high = mid - 1;
+				}
+				if (idx !== -1) yield emit$1(idx, span, tracker);
+				else yield emit$1(-low - 1, 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);
+	{
+		name: "combinations",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("combinations expects an array", span);
+			if (input.some((x) => !Array.isArray(x))) throw new RuntimeError("combinations input must be array of arrays", span);
+			const arrays = input;
+			if (arrays.length === 0) {
+				yield emit$1([], span, tracker);
+				return;
 			}
+			const helper = function* (idx, current) {
+				if (idx === arrays.length) {
+					yield [...current];
+					return;
+				}
+				const arr = arrays[idx];
+				if (arr.length === 0) return;
+				for (const item of arr) {
+					current.push(item);
+					yield* helper(idx + 1, current);
+					current.pop();
+				}
+			};
+			for (const combo of helper(0, [])) yield emit$1(combo, span, tracker);
 		}
 	},
-	delpaths: {
-		name: "delpaths",
+	{
+		name: "combinations",
 		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);
+			if (!Array.isArray(input)) throw new RuntimeError("combinations expects an array", span);
+			const nGen = evaluate$1(args[0], input, env, tracker);
+			for (const nVal of nGen) {
+				if (typeof nVal !== "number") throw new RuntimeError("combinations(n) expects n to be number", span);
+				if (nVal === 0) {
+					yield emit$1([], span, tracker);
+					continue;
+				}
+				const arrays = [];
+				for (let i = 0; i < nVal; i++) arrays.push(input);
+				const helper = function* (idx, current) {
+					if (idx === arrays.length) {
+						yield [...current];
+						return;
+					}
+					const arr = arrays[idx];
+					for (const item of arr) {
+						current.push(item);
+						yield* helper(idx + 1, current);
+						current.pop();
+					}
+				};
+				if (input.length === 0 && nVal > 0) {} else for (const combo of helper(0, [])) yield emit$1(combo, 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;
+	},
+	{
+		name: "inside",
+		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(b, input), span, tracker);
 		}
-		return true;
 	}
-	return valueEquals(a, b);
-};
+];
+
+//#endregion
+//#region src/eval/path_eval.ts
 /**
-* Recursively traverses a JSON value to find all paths to leaf nodes.
-* Yields paths as arrays of strings/numbers.
+* Resolves properties paths for assignment or `path()` built-in.
+* Returns an array of paths (arrays of strings/numbers) for valid locations.
+*
+* @param node - The AST node describing trailing field access/indexing.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
 */
+const evaluatePath = function* (node, input, env, tracker, evaluate$1) {
+	switch (node.kind) {
+		case "Identity":
+			yield [];
+			return;
+		case "FieldAccess":
+			for (const parent of evaluatePath(node.target, input, env, tracker, evaluate$1)) yield [...parent, node.field];
+			return;
+		case "IndexAccess": {
+			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
+			const output = evaluate$1(node.index, input, env, tracker);
+			for (const keyVal of output) {
+				let key;
+				if (typeof keyVal === "string") key = keyVal;
+				else if (typeof keyVal === "number" && Number.isInteger(keyVal)) key = keyVal;
+				else throw new RuntimeError("Path index must be string or integer", node.span);
+				for (const parent of parentPaths) yield [...parent, key];
+			}
+			return;
+		}
+		case "Pipe": {
+			const leftPaths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate$1));
+			for (const p of leftPaths) {
+				const val = getPath(input, p) ?? null;
+				for (const q of evaluatePath(node.right, val, env, tracker, evaluate$1)) yield [...p, ...q];
+			}
+			return;
+		}
+		case "Comma":
+			yield* evaluatePath(node.left, input, env, tracker, evaluate$1);
+			yield* evaluatePath(node.right, input, env, tracker, evaluate$1);
+			return;
+		case "Iterate": {
+			const parentPaths = Array.from(evaluatePath(node.target, input, env, tracker, evaluate$1));
+			for (const p of parentPaths) {
+				const val = getPath(input, p);
+				if (Array.isArray(val)) for (let i = 0; i < val.length; i++) yield [...p, i];
+				else if (val !== null && typeof val === "object") for (const key of Object.keys(val)) yield [...p, key];
+				else {
+					if (val === null) continue;
+					throw new RuntimeError(`Cannot iterate over ${typeof val}`, node.span);
+				}
+			}
+			return;
+		}
+		case "Call":
+			if (node.name === "select") {
+				const conds = evaluate$1(node.args[0], input, env, tracker);
+				let matched = false;
+				for (const c of conds) if (c !== null && c !== false) matched = true;
+				if (matched) yield [];
+				return;
+			}
+			throw new RuntimeError(`Function ${node.name} not supported in path expression`, node.span);
+		default: throw new RuntimeError("Invalid path expression", node.span);
+	}
+};
+
+//#endregion
+//#region src/builtins/paths.ts
 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) {
+	if (root === null || typeof root !== "object" || Array.isArray(root) && root.length === 0 || isPlainObject(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)) {
+	else if (isPlainObject(root)) {
 		const keys = Object.keys(root).sort();
 		for (const key of keys) yield* traversePaths(root[key], [...currentPath, key], span, tracker);
 	}
@@ -1362,7 +2126,7 @@ 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 (typeof part === "string" && isPlainObject(curr)) {
 			if (!Object.prototype.hasOwnProperty.call(curr, part)) return void 0;
 			curr = curr[part];
 		} else if (typeof part === "number" && Array.isArray(curr)) {
@@ -1372,18 +2136,14 @@ const getPath = (root, path) => {
 	}
 	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 };
+		if (isPlainObject(root)) obj = { ...root };
 		else if (root === null) obj = {};
-		else throw new RuntimeError(`Cannot index ${describeType$1(root)} with string "${head}"`, span);
+		else throw new RuntimeError(`Cannot index ${describeType(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;
@@ -1393,7 +2153,7 @@ const updatePath = (root, path, updateFn, span, depth = 0) => {
 		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);
+		else throw new RuntimeError(`Cannot index ${describeType(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);
@@ -1411,7 +2171,7 @@ const updatePath = (root, path, updateFn, span, depth = 0) => {
 };
 const deletePaths = (root, paths, span) => {
 	if (paths.some((p) => p.length === 0)) return null;
-	if (isPlainObject$1(root)) {
+	if (isPlainObject(root)) {
 		const result = { ...root };
 		const relevantPaths = paths.filter((p) => p.length > 0 && typeof p[0] === "string");
 		const byKey = {};
@@ -1448,180 +2208,1362 @@ const deletePaths = (root, paths, span) => {
 	}
 	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);
-}
+const pathBuiltins = [
+	{
+		name: "paths",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield* traversePaths(input, [], span, tracker);
+		}
+	},
+	{
+		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);
+		}
+	},
+	{
+		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);
+			}
+		}
+	},
+	{
+		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);
+			}
+		}
+	},
+	{
+		name: "path",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			for (const p of evaluatePath(args[0], input, env, tracker, evaluate$1)) yield emit$1(p, span, tracker);
+		}
+	}
+];
 
 //#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;
+//#region src/builtins/iterators.ts
+const iteratorBuiltins = [
+	{
+		name: "range",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const ends = evaluate$1(args[0], input, env, tracker);
+			for (const end of ends) {
+				if (typeof end !== "number") throw new RuntimeError("range expects numbers", span);
+				for (let i = 0; i < end; i++) yield emit$1(i, span, tracker);
+			}
+		}
+	},
+	{
+		name: "range",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const starts = Array.from(evaluate$1(args[0], input, env, tracker));
+			const ends = Array.from(evaluate$1(args[1], input, env, tracker));
+			for (const start of starts) for (const end of ends) {
+				if (typeof start !== "number" || typeof end !== "number") throw new RuntimeError("range expects numbers", span);
+				if (start < end) for (let i = start; i < end; i++) yield emit$1(i, span, tracker);
+			}
+		}
+	},
+	{
+		name: "range",
+		arity: 3,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const starts = Array.from(evaluate$1(args[0], input, env, tracker));
+			const ends = Array.from(evaluate$1(args[1], input, env, tracker));
+			const steps = Array.from(evaluate$1(args[2], input, env, tracker));
+			for (const start of starts) for (const end of ends) for (const step of steps) {
+				if (typeof start !== "number" || typeof end !== "number" || typeof step !== "number") throw new RuntimeError("range expects numbers", span);
+				if (step === 0) throw new RuntimeError("range step cannot be zero", span);
+				if (step > 0) for (let i = start; i < end; i += step) yield emit$1(i, span, tracker);
+				else for (let i = start; i > end; i += step) yield emit$1(i, span, tracker);
+			}
+		}
+	},
+	{
+		name: "limit",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const limits = evaluate$1(args[0], input, env, tracker);
+			for (const n of limits) {
+				if (typeof n !== "number") throw new RuntimeError("limit expects number", span);
+				let count = 0;
+				if (n > 0) for (const val of evaluate$1(args[1], input, env, tracker)) {
+					yield val;
+					count++;
+					if (count >= n) break;
+				}
+			}
+		}
+	},
+	{
+		name: "first",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1) {
+			for (const val of evaluate$1(args[0], input, env, tracker)) {
+				yield val;
+				break;
+			}
+		}
+	},
+	{
+		name: "last",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1) {
+			let lastVal;
+			let found = false;
+			for (const val of evaluate$1(args[0], input, env, tracker)) {
+				lastVal = val;
+				found = true;
+			}
+			if (found) yield lastVal;
+		}
+	},
+	{
+		name: "nth",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const indices = evaluate$1(args[0], input, env, tracker);
+			for (const n of indices) {
+				if (typeof n !== "number") throw new RuntimeError("nth expects number", span);
+				let count = 0;
+				for (const val of evaluate$1(args[1], input, env, tracker)) {
+					if (count === n) {
+						yield val;
+						break;
+					}
+					count++;
+				}
+			}
+		}
+	},
+	{
+		name: "isempty",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			let empty = true;
+			for (const _ of evaluate$1(args[0], input, env, tracker)) {
+				empty = false;
+				break;
+			}
+			yield emit$1(empty, span, tracker);
+		}
+	},
+	{
+		name: "all",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			let result = true;
+			for (const val of evaluate$1(args[0], input, env, tracker)) if (!isTruthy(val)) {
+				result = false;
+				break;
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "any",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			let result = false;
+			for (const val of evaluate$1(args[0], input, env, tracker)) if (isTruthy(val)) {
+				result = true;
+				break;
+			}
+			yield emit$1(result, span, tracker);
+		}
+	},
+	{
+		name: "recurse",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const rec = function* (curr) {
+				yield emit$1(curr, span, tracker);
+				const nexts = evaluate$1(args[0], curr, env, tracker);
+				for (const next of nexts) yield* rec(next);
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "while",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const condExpr = args[0];
+			const updateExpr = args[1];
+			const rec = function* (curr) {
+				tracker.step(span);
+				let condMatches = false;
+				for (const c of evaluate$1(condExpr, curr, env, tracker)) if (isTruthy(c)) {
+					condMatches = true;
+					break;
+				}
+				if (condMatches) {
+					yield emit$1(curr, span, tracker);
+					for (const next of evaluate$1(updateExpr, curr, env, tracker)) yield* rec(next);
+				}
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "until",
+		arity: 2,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			const condExpr = args[0];
+			const updateExpr = args[1];
+			const rec = function* (curr) {
+				tracker.step(span);
+				let condMatches = false;
+				for (const c of evaluate$1(condExpr, curr, env, tracker)) if (isTruthy(c)) {
+					condMatches = true;
+					break;
+				}
+				if (condMatches) yield emit$1(curr, span, tracker);
+				else for (const next of evaluate$1(updateExpr, curr, env, tracker)) yield* rec(next);
+			};
+			yield* rec(input);
+		}
+	},
+	{
+		name: "repeat",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			while (true) {
+				tracker.step(span);
+				yield* evaluate$1(args[0], input, env, tracker);
+			}
 		}
-		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
-};
+//#region src/eval/ops.ts
 /**
-* Resolves a partial limits configuration into a complete one with defaults.
+* Applies a unary negation (`-`).
 *
-* @param config - The user-provided configuration.
-* @returns The resolved limits.
+* @param value - The value to negate.
+* @param span - Source span for errors.
+* @returns The negated value.
 */
-const resolveLimits = (config = {}) => ({
-	maxSteps: config.maxSteps ?? DEFAULT_LIMITS.maxSteps,
-	maxDepth: config.maxDepth ?? DEFAULT_LIMITS.maxDepth,
-	maxOutputs: config.maxOutputs ?? DEFAULT_LIMITS.maxOutputs
-});
+const applyUnaryNeg = (value, span) => {
+	if (typeof value === "number") return -value;
+	throw new RuntimeError(`Invalid operand for unary -: ${describeType(value)}`, span);
+};
 /**
-* Tracks execution usage against defined limits.
-* Throws {@link RuntimeError} if any limit is exceeded.
+* Applies a binary operator.
+*
+* Supports arithmetic (`+`, `-`, `*`, `/`, `%`) and comparators.
+*
+* @param op - The operator string.
+* @param left - The left operand.
+* @param right - The right operand.
+* @param span - Source span for errors.
+* @returns The result of the operation.
 */
-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);
+const applyBinaryOp = (op, left, right, span) => {
+	switch (op) {
+		case "+": return add(left, right, span);
+		case "-": return sub(left, right, span);
+		case "*": return mul(left, right, span);
+		case "/": return div(left, right, span);
+		case "%": return mod(left, right, span);
+		case "Eq": return isEqual(left, right);
+		case "Neq": return !isEqual(left, right);
+		case "Lt": return compare(left, right) < 0;
+		case "Lte": return compare(left, right) <= 0;
+		case "Gt": return compare(left, right) > 0;
+		case "Gte": return compare(left, right) >= 0;
+		default: throw new RuntimeError(`Unknown binary operator: ${op}`, span);
 	}
-	/**
-	* Enters a new scope/stack frame, incrementing the depth counter.
+};
+function isEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((v, i) => isEqual(v, b[i]));
+	}
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+		const ka = Object.keys(a).sort();
+		const kb = Object.keys(b).sort();
+		if (ka.length !== kb.length) return false;
+		if (!ka.every((k, i) => k === kb[i])) return false;
+		return ka.every((k) => isEqual(a[k], b[k]));
+	}
+	return false;
+}
+function compare(a, b) {
+	if (a === b) return 0;
+	const typeOrder = (v) => {
+		if (v === null) return 0;
+		if (typeof v === "boolean") return 1;
+		if (typeof v === "number") return 2;
+		if (typeof v === "string") return 3;
+		if (Array.isArray(v)) return 4;
+		if (isPlainObject$1(v)) return 5;
+		return 6;
+	};
+	const ta = typeOrder(a);
+	const tb = typeOrder(b);
+	if (ta !== tb) return ta - tb;
+	if (typeof a === "boolean" && typeof b === "boolean") return (a ? 1 : 0) - (b ? 1 : 0);
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		for (let i = 0; i < Math.min(a.length, b.length); i++) {
+			const c = compare(a[i], b[i]);
+			if (c !== 0) return c;
+		}
+		return a.length - b.length;
+	}
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
+		const keysA = Object.keys(a).sort();
+		const keysB = Object.keys(b).sort();
+		for (let i = 0; i < Math.min(keysA.length, keysB.length); i++) {
+			const kA = keysA[i];
+			const kB = keysB[i];
+			if (kA !== kB) return kA < kB ? -1 : 1;
+			const c = compare(a[kA], b[kB]);
+			if (c !== 0) return c;
+		}
+		return keysA.length - keysB.length;
+	}
+	return 0;
+}
+function add(left, right, span) {
+	if (left === null && right === null) return null;
+	if (left === null && typeof right === "number") return right;
+	if (typeof left === "number" && right === null) return left;
+	if (typeof left === "number" && typeof right === "number") return left + right;
+	if (typeof left === "string" && typeof right === "string") return left + right;
+	if (Array.isArray(left) && Array.isArray(right)) return [...left, ...right];
+	if (isPlainObject$1(left) && isPlainObject$1(right)) return {
+		...left,
+		...right
+	};
+	throw new RuntimeError(`Cannot add ${describeType(left)} and ${describeType(right)}`, span);
+}
+function sub(left, right, span) {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		const toRemove = new Set(right.map(stableStringify));
+		return left.filter((x) => !toRemove.has(stableStringify(x)));
+	}
+	throw new RuntimeError(`Cannot subtract ${describeType(right)} from ${describeType(left)}`, span);
+}
+function mul(left, right, span) {
+	if (typeof left === "number" && typeof right === "number") return left * right;
+	if (typeof left === "string" && typeof right === "number") return repeatString(left, right);
+	if (typeof left === "number" && typeof right === "string") return repeatString(right, left);
+	if (isPlainObject$1(left) && isPlainObject$1(right)) return mergeDeep(left, right);
+	throw new RuntimeError(`Cannot multiply ${describeType(left)} by ${describeType(right)}`, span);
+}
+function div(left, right, span) {
+	if (typeof left === "number" && typeof right === "number") {
+		if (right === 0) throw new RuntimeError("Division by zero", span);
+		return left / right;
+	}
+	if (typeof left === "string" && typeof right === "string") return left.split(right);
+	throw new RuntimeError(`Cannot divide ${describeType(left)} by ${describeType(right)}`, span);
+}
+function mod(left, right, span) {
+	if (typeof left === "number" && typeof right === "number") {
+		if (right === 0) throw new RuntimeError("Modulo by zero", span);
+		return left % right;
+	}
+	throw new RuntimeError(`Cannot modulo ${describeType(left)} by ${describeType(right)}`, span);
+}
+function repeatString(str, count) {
+	if (count <= 0) return null;
+	const n = Math.floor(count);
+	if (n <= 0) return null;
+	return str.repeat(n);
+}
+function mergeDeep(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sVal = source[key];
+		const tVal = result[key];
+		if (isPlainObject$1(sVal) && tVal !== void 0 && isPlainObject$1(tVal)) result[key] = mergeDeep(tVal, sVal);
+		else result[key] = sVal;
+	}
+	return result;
+}
+function isPlainObject$1(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+//#endregion
+//#region src/builtins/math.ts
+const mathBuiltins = [
+	{
+		name: "floor",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("floor expects number", span);
+			yield emit$1(Math.floor(input), span, tracker);
+		}
+	},
+	{
+		name: "ceil",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("ceil expects number", span);
+			yield emit$1(Math.ceil(input), span, tracker);
+		}
+	},
+	{
+		name: "round",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("round expects number", span);
+			yield emit$1(Math.round(input), span, tracker);
+		}
+	},
+	{
+		name: "abs",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("abs expects number", span);
+			yield emit$1(Math.abs(input), span, tracker);
+		}
+	},
+	{
+		name: "sqrt",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") throw new RuntimeError("sqrt expects number", span);
+			yield emit$1(Math.sqrt(input), span, tracker);
+		}
+	},
+	{
+		name: "isnan",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			yield emit$1(Number.isNaN(input), span, tracker);
+		}
+	},
+	{
+		name: "infinite",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			yield emit$1(!Number.isFinite(input) && !Number.isNaN(input), span, tracker);
+		}
+	},
+	{
+		name: "isfinite",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") {
+				yield emit$1(true, span, tracker);
+				return;
+			}
+			yield emit$1(Number.isFinite(input), span, tracker);
+		}
+	},
+	{
+		name: "normal",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			if (!Number.isFinite(input) || Number.isNaN(input) || input === 0) {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			yield emit$1(true, span, tracker);
+		}
+	},
+	{
+		name: "subnormal",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (typeof input !== "number") {
+				yield emit$1(false, span, tracker);
+				return;
+			}
+			yield emit$1(false, span, tracker);
+		}
+	},
+	{
+		name: "min",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("min expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let minVal = input[0];
+			for (let i = 1; i < input.length; i++) if (compareValues(input[i], minVal) < 0) minVal = input[i];
+			yield emit$1(minVal, span, tracker);
+		}
+	},
+	{
+		name: "max",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("max expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let maxVal = input[0];
+			for (let i = 1; i < input.length; i++) if (compareValues(input[i], maxVal) > 0) maxVal = input[i];
+			yield emit$1(maxVal, span, tracker);
+		}
+	},
+	{
+		name: "min_by",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("min_by expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let minItem = input[0];
+			let minKey;
+			const keys0 = Array.from(evaluate$1(args[0], minItem, env, tracker));
+			if (keys0.length !== 1) throw new RuntimeError("min_by key must return one value", span);
+			minKey = keys0[0];
+			for (let i = 1; i < input.length; i++) {
+				const item = input[i];
+				const keys = Array.from(evaluate$1(args[0], item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("min_by key must return one value", span);
+				const key = keys[0];
+				if (compareValues(key, minKey) < 0) {
+					minKey = key;
+					minItem = item;
+				}
+			}
+			yield emit$1(minItem, span, tracker);
+		}
+	},
+	{
+		name: "max_by",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("max_by expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let maxItem = input[0];
+			let maxKey;
+			const keys0 = Array.from(evaluate$1(args[0], maxItem, env, tracker));
+			if (keys0.length !== 1) throw new RuntimeError("max_by key must return one value", span);
+			maxKey = keys0[0];
+			for (let i = 1; i < input.length; i++) {
+				const item = input[i];
+				const keys = Array.from(evaluate$1(args[0], item, env, tracker));
+				if (keys.length !== 1) throw new RuntimeError("max_by key must return one value", span);
+				const key = keys[0];
+				if (compareValues(key, maxKey) > 0) {
+					maxKey = key;
+					maxItem = item;
+				}
+			}
+			yield emit$1(maxItem, span, tracker);
+		}
+	},
+	{
+		name: "add",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			if (!Array.isArray(input)) throw new RuntimeError("add expects an array", span);
+			if (input.length === 0) {
+				yield emit$1(null, span, tracker);
+				return;
+			}
+			let acc = input[0];
+			for (let i = 1; i < input.length; i++) {
+				tracker.step(span);
+				acc = add(acc, input[i], span);
+			}
+			yield emit$1(acc, span, tracker);
+		}
+	}
+];
+
+//#endregion
+//#region src/builtins/index.ts
+const registerAllBuiltins = () => {
+	registerBuiltins(stdBuiltins);
+	registerBuiltins(errorBuiltins);
+	registerBuiltins(collectionBuiltins);
+	registerBuiltins(stringBuiltins);
+	registerBuiltins(pathBuiltins);
+	registerBuiltins(iteratorBuiltins);
+	registerBuiltins(mathBuiltins);
+};
+
+//#endregion
+//#region src/builtins.ts
+registerAllBuiltins();
+
+//#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, scope) => {
+	switch (node.kind) {
+		case "Identity":
+		case "Literal":
+		case "Var": return;
+		case "FieldAccess":
+			visit(node.target, scope);
+			return;
+		case "IndexAccess":
+			visit(node.target, scope);
+			visit(node.index, scope);
+			return;
+		case "Array":
+			node.items.forEach((n) => visit(n, scope));
+			return;
+		case "Object":
+			node.entries.forEach((entry) => {
+				if (entry.key.kind === "KeyExpr") visit(entry.key.expr, scope);
+				visit(entry.value, scope);
+			});
+			return;
+		case "Pipe":
+		case "Comma":
+		case "Alt":
+			visit(node.left, scope);
+			visit(node.right, scope);
+			return;
+		case "Binary":
+		case "Bool":
+			visit(node.left, scope);
+			visit(node.right, scope);
+			return;
+		case "Unary":
+			visit(node.expr, scope);
+			return;
+		case "If":
+			node.branches.forEach((branch) => {
+				visit(branch.cond, scope);
+				visit(branch.then, scope);
+			});
+			visit(node.else, scope);
+			return;
+		case "As":
+			visit(node.bind, scope);
+			visit(node.body, scope);
+			return;
+		case "Call": {
+			for (let i = scope.length - 1; i >= 0; i--) if (scope[i].has(node.name)) {
+				for (const arg of node.args) visit(arg, scope);
+				return;
+			}
+			const specs = builtins[node.name];
+			if (!specs || specs.length === 0) throw new ValidationError(`Unknown function: ${node.name}`, node.span);
+			if (!specs.find((s) => s.arity === node.args.length)) {
+				const arities = specs.map((s) => s.arity).join(" or ");
+				throw new ValidationError(`Function ${node.name} expects ${arities} arguments, but got ${node.args.length}`, node.span);
+			}
+			for (const arg of node.args) visit(arg, scope);
+			return;
+		}
+		case "Assignment":
+			visit(node.left, scope);
+			visit(node.right, scope);
+			return;
+		case "Def": {
+			const bodyScope = new Set(node.args);
+			bodyScope.add(node.name);
+			visit(node.body, [...scope, bodyScope]);
+			const nextScope = new Set([node.name]);
+			visit(node.next, [...scope, nextScope]);
+			return;
+		}
+		case "Reduce":
+			visit(node.source, scope);
+			visit(node.init, scope);
+			visit(node.update, scope);
+			return;
+		case "Foreach":
+			visit(node.source, scope);
+			visit(node.init, scope);
+			visit(node.update, scope);
+			if (node.extract) visit(node.extract, scope);
+			return;
+		case "Try":
+			visit(node.body, scope);
+			if (node.handler) visit(node.handler, scope);
+			return;
+		case "Recurse":
+		case "Iterate":
+		case "Break": return;
+		case "Label":
+			visit(node.body, scope);
+			return;
+		case "Slice":
+			visit(node.target, scope);
+			if (node.start) visit(node.start, scope);
+			if (node.end) visit(node.end, scope);
+			return;
+		default: return node;
+	}
+};
+
+//#endregion
+//#region src/eval/break.ts
+/**
+* Internal error class used to implement control flow breaks (`break $label`).
+* Caught by `evalLabel` or `evalForeach`/`evalReduce` if labels match.
+*/
+var BreakSignal = class BreakSignal extends Error {
+	constructor(label) {
+		super(`Break: ${label}`);
+		this.label = label;
+		Object.setPrototypeOf(this, BreakSignal.prototype);
+	}
+};
+
+//#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);
+	/**
+	* 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/env.ts
+/**
+* Retrieves a variable value from the environment stack.
+* Searches from the current (top) frame down to the global frame.
+*/
+const getVar = (env, name) => {
+	for (let i = env.length - 1; i >= 0; i--) if (env[i].vars.has(name)) return env[i].vars.get(name);
+};
+/**
+* Bounds a value to a variable name in the current scope frame.
+*/
+const pushBinding = (env, name, value) => {
+	env[env.length - 1].vars.set(name, value);
+};
+/**
+* Removes a variable binding from the current scope frame.
+*/
+const popBinding = (env, name) => {
+	env[env.length - 1].vars.delete(name);
+};
+
+//#endregion
+//#region src/eval/common.ts
+/**
+* Emits a value, recording it in the limits tracker.
+*
+* @param value - The value to yield.
+* @param span - The source span responsible for this value.
+* @param tracker - The limits tracker.
+* @returns The value itself.
+*/
+const emit = (value, span, tracker) => {
+	tracker.emit(span);
+	return value;
+};
+/**
+* Ensures a value is an integer. Throws a RuntimeError otherwise.
+*
+* @param value - The value to check.
+* @param span - To report error.
+* @returns The integer value.
+*/
+const ensureInteger = (value, span) => {
+	if (typeof value === "number" && Number.isInteger(value)) return value;
+	throw new RuntimeError("Expected integer", span);
+};
+
+//#endregion
+//#region src/eval/assignment.ts
+/**
+* Evaluates assignment and update operators (`=`, `|=`, `+=`, etc.).
+*
+* Implements the complex path update logic of jq.
+* It first resolves the path(s) on the left-hand side, then computes new values,
+* and finally reconstructs the object with the updated values.
+*
+* @param node - The assignment AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalAssignment = function* (node, input, env, tracker, evaluate$1) {
+	const paths = Array.from(evaluatePath(node.left, input, env, tracker, evaluate$1));
+	paths.sort((a, b) => compareValues(a, b) * -1);
+	if (paths.length === 0) {
+		yield emit(input, node.span, tracker);
+		return;
+	}
+	if (node.op === "=") {
+		const rhsValues = Array.from(evaluate$1(node.right, input, env, tracker));
+		if (rhsValues.length === 0) return;
+		for (const rhsVal of rhsValues) {
+			let current = input;
+			for (const path of paths) current = updatePath(current, path, () => rhsVal, node.span) ?? current;
+			yield emit(current, node.span, tracker);
+		}
+		return;
+	}
+	yield* applyUpdates(input, paths, 0, node.op, node.right, input, env, tracker, evaluate$1);
+};
+function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tracker, evaluate$1) {
+	if (index >= paths.length) {
+		yield current;
+		return;
+	}
+	const path = paths[index];
+	const oldValue = getPath(current, path) ?? null;
+	let newValues = [];
+	if (op === "|=") newValues = Array.from(evaluate$1(rhsNode, oldValue, env, tracker));
+	else {
+		const rhsResults = Array.from(evaluate$1(rhsNode, contextInput, env, tracker));
+		for (const rhs of rhsResults) {
+			let res;
+			switch (op) {
+				case "+=":
+					res = applyBinaryOp("+", oldValue, rhs, rhsNode.span);
+					break;
+				case "-=":
+					res = applyBinaryOp("-", oldValue, rhs, rhsNode.span);
+					break;
+				case "*=":
+					res = applyBinaryOp("*", oldValue, rhs, rhsNode.span);
+					break;
+				case "/=":
+					res = applyBinaryOp("/", oldValue, rhs, rhsNode.span);
+					break;
+				case "%=":
+					res = applyBinaryOp("%", oldValue, rhs, rhsNode.span);
+					break;
+				case "//=":
+					res = oldValue !== null && oldValue !== false ? oldValue : rhs;
+					break;
+				default: throw new RuntimeError(`Unknown assignment op: ${op}`, rhsNode.span);
+			}
+			newValues.push(res);
+		}
+	}
+	if (newValues.length === 0) {
+		yield* applyUpdates(deletePaths(current, [path], rhsNode.span), paths, index + 1, op, rhsNode, contextInput, env, tracker, evaluate$1);
+		return;
+	}
+	for (const val of newValues) yield* applyUpdates(updatePath(current, path, () => val, rhsNode.span) ?? current, paths, index + 1, op, rhsNode, contextInput, env, tracker, evaluate$1);
+}
+
+//#endregion
+//#region src/eval/iterators.ts
+/**
+* Iterates over the values of an array or object (`.[]`).
+*
+* @param node - The iterate AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalIterate = function* (node, input, env, tracker, evaluate$1) {
+	for (const container of evaluate$1(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);
+	}
+};
+/**
+* Executes a `reduce` operation.
+*
+* `reduce inputs as $var (init; update)`
+*
+* @param node - The reduce AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalReduce = function* (node, input, env, tracker, evaluate$1) {
+	const initValues = Array.from(evaluate$1(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$1(node.source, input, env, tracker)) {
+		tracker.step(node.span);
+		pushBinding(env, node.var, item);
+		try {
+			const updates = Array.from(evaluate$1(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, node.var);
+		}
+	}
+	yield emit(acc, node.span, tracker);
+};
+/**
+* Executes a `foreach` operation.
+*
+* `foreach inputs as $var (init; update; extract)`
+*
+* @param node - The foreach AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalForeach = function* (node, input, env, tracker, evaluate$1) {
+	const initValues = Array.from(evaluate$1(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$1(node.source, input, env, tracker)) {
+		tracker.step(node.span);
+		pushBinding(env, node.var, item);
+		try {
+			const updates = Array.from(evaluate$1(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$1(node.extract, acc, env, tracker)) yield emit(extracted, node.span, tracker);
+			else yield emit(acc, node.span, tracker);
+		} finally {
+			popBinding(env, node.var);
+		}
+	}
+};
+/**
+* Evaluates the recursive operator `..`.
+* Deprecated node type kept for compatibility; currently implements `..` logic.
+*
+* @param node - The recurse AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalRecurse = function* (node, input, env, tracker, evaluate$1) {
+	yield emit(input, node.span, tracker);
+	const children = [];
+	if (isValueArray(input)) children.push(...input);
+	else if (isPlainObject(input)) {
+		const keys = Object.keys(input).sort();
+		for (const key of keys) children.push(input[key]);
+	}
+	for (const child of children) yield* evalRecurse(node, child, env, tracker, evaluate$1);
+};
+
+//#endregion
+//#region src/eval/access.ts
+/**
+* Evaluates field access (`.foo`).
+*
+* @param node - The field access AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalField = function* (node, input, env, tracker, evaluate$1) {
+	for (const container of evaluate$1(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);
+	}
+};
+/**
+* Evaluates index access (`.[0]`, `.["foo"]`).
+* Supports negative indices for arrays.
+*
+* @param node - The index access AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalIndex = function* (node, input, env, tracker, evaluate$1) {
+	const indexValues = Array.from(evaluate$1(node.index, input, env, tracker));
+	for (const container of evaluate$1(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);
+	}
+};
+/**
+* Evaluates array slicing (`.[start:end]`).
+* Supports optional start/end (defaults to 0/length) and negative indices (via JS slice).
+*
+* @param node - The slice AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalSlice = function* (node, input, env, tracker, evaluate$1) {
+	for (const target of evaluate$1(node.target, input, env, tracker)) {
+		if (typeof target !== "string" && !Array.isArray(target)) throw new RuntimeError("Slice expected string or array", node.span);
+		const starts = [];
+		if (node.start) for (const s of evaluate$1(node.start, input, env, tracker)) {
+			if (typeof s !== "number") throw new RuntimeError("Slice start must be number", node.span);
+			starts.push(s);
+		}
+		else starts.push(0);
+		const ends = [];
+		if (node.end) for (const e of evaluate$1(node.end, input, env, tracker)) {
+			if (typeof e !== "number") throw new RuntimeError("Slice end must be number", node.span);
+			ends.push(e);
+		}
+		else ends.push(target.length);
+		for (const s of starts) for (const e of ends) yield emit(target.slice(s, e), node.span, tracker);
+	}
+};
+
+//#endregion
+//#region src/eval/constructors.ts
+/**
+* constructs arrays from the input.
+*
+* `[.foo, .bar]` -> `[foo_val, bar_val]`
+* It computes the Cartesian product of all items in the array definition.
+*
+* @param node - The array definition AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const buildArray = function* (node, input, env, tracker, evaluate$1) {
+	const result = [];
+	for (const itemNode of node.items) for (const itemVal of evaluate$1(itemNode, input, env, tracker)) result.push(itemVal);
+	yield result;
+};
+/**
+* constructs objects from the input.
+*
+* `{a: .foo, b: .bar}`
+* Computes the Cartesian product of all key-value pairs.
+*
+* @param node - The object definition AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const buildObjects = function* (node, input, env, tracker, evaluate$1) {
+	yield* fillObject(node.entries, 0, {}, input, env, tracker, evaluate$1);
+};
+function* fillObject(entries, index, current, input, env, tracker, evaluate$1) {
+	if (index >= entries.length) {
+		yield { ...current };
+		return;
+	}
+	const entry = entries[index];
+	let keys = [];
+	if (entry.key.kind === "KeyIdentifier") keys = [entry.key.name];
+	else if (entry.key.kind === "KeyString") keys = [entry.key.value];
+	else for (const k of evaluate$1(entry.key.expr, input, env, tracker)) {
+		if (typeof k !== "string") throw new RuntimeError("Object key must be a string", entry.key.span);
+		keys.push(k);
 	}
-	/**
-	* 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);
+	for (const key of keys) for (const val of evaluate$1(entry.value, input, env, tracker)) {
+		current[key] = val;
+		yield* fillObject(entries, index + 1, current, input, env, tracker, evaluate$1);
+		delete current[key];
+	}
+}
+
+//#endregion
+//#region src/eval/functions.ts
+/**
+* Evaluates a function call.
+*
+* Checks for:
+* 1. User-defined functions in the current environment stack (local scope).
+* 2. Standard library built-ins.
+*
+* Handles closure creation for arguments and recursion.
+*
+* @param node - The call AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalCall = function* (node, input, env, tracker, evaluate$1) {
+	for (let i = env.length - 1; i >= 0; i--) {
+		const funcs = env[i].funcs.get(node.name);
+		if (funcs) {
+			const def = funcs.find((f) => f.args.length === node.args.length);
+			if (def) {
+				const newFrame = {
+					vars: /* @__PURE__ */ new Map(),
+					funcs: /* @__PURE__ */ new Map()
+				};
+				for (let j = 0; j < node.args.length; j++) {
+					const argName = def.args[j];
+					const argBody = node.args[j];
+					const argDefs = newFrame.funcs.get(argName) || [];
+					argDefs.push({
+						args: [],
+						body: argBody,
+						closure: env
+					});
+					newFrame.funcs.set(argName, argDefs);
+				}
+				const newStack = [...def.closure, newFrame];
+				yield* evaluate$1(def.body, input, newStack, tracker);
+				return;
+			}
+		}
+	}
+	const specs = builtins[node.name];
+	if (!specs) throw new RuntimeError(`Unknown function: ${node.name}`, node.span);
+	const builtin = specs.find((s) => s.arity === node.args.length);
+	if (!builtin) throw new RuntimeError(`Function ${node.name} does not accept ${node.args.length} arguments`, node.span);
+	yield* builtin.apply(input, node.args, env, tracker, evaluate$1, node.span);
+};
+/**
+* Defines a new function in the environment.
+*
+* Adds the function definition to the current scope and executes the `next` expression
+* with the updated environment.
+*
+* @param node - The function definition AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalDef = function* (node, input, env, tracker, evaluate$1) {
+	const newFrame = {
+		vars: /* @__PURE__ */ new Map(),
+		funcs: /* @__PURE__ */ new Map()
+	};
+	const currentDefs = newFrame.funcs.get(node.name) || [];
+	const funDef = {
+		args: node.args,
+		body: node.body,
+		closure: []
+	};
+	currentDefs.push(funDef);
+	newFrame.funcs.set(node.name, currentDefs);
+	const newStack = [...env, newFrame];
+	funDef.closure = newStack;
+	yield* evaluate$1(node.next, input, newStack, tracker);
+};
+
+//#endregion
+//#region src/eval/control_flow.ts
+/**
+* Evaluates an `if-then-else` expression.
+*
+* @param node - The If AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalIf = function* (node, input, env, tracker, evaluate$1) {
+	yield* evalIfBranch(node, 0, input, env, tracker, evaluate$1);
+};
+function* evalIfBranch(node, branchIndex, input, env, tracker, evaluate$1) {
+	if (branchIndex >= node.branches.length) {
+		yield* evaluate$1(node.else, input, env, tracker);
+		return;
+	}
+	const branch = node.branches[branchIndex];
+	for (const cond of evaluate$1(branch.cond, input, env, tracker)) if (isTruthy(cond)) yield* evaluate$1(branch.then, input, env, tracker);
+	else yield* evalIfBranch(node, branchIndex + 1, input, env, tracker, evaluate$1);
+}
+/**
+* Evaluates a `try-catch` expression.
+*
+* @param node - The Try AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalTry = function* (node, input, env, tracker, evaluate$1) {
+	try {
+		yield* evaluate$1(node.body, input, env, tracker);
+	} catch (err) {
+		if (err instanceof RuntimeError) {
+			if (node.handler) yield* evaluate$1(node.handler, err.message, env, tracker);
+		} else throw err;
+	}
+};
+/**
+* Evaluates a `label` expression, establishing a target for `break`.
+*
+* @param node - The Label AST node.
+* @param input - The current input value.
+* @param env - The environment.
+* @param tracker - Limits tracker.
+* @param evaluate - Recursive evaluator.
+*/
+const evalLabel = function* (node, input, env, tracker, evaluate$1) {
+	try {
+		yield* evaluate$1(node.body, input, env, tracker);
+	} catch (e) {
+		if (e instanceof BreakSignal) {
+			if (e.label === node.label) return;
+		}
+		throw e;
 	}
 };
 
 //#endregion
-//#region src/eval.ts
+//#region src/eval/dispatch.ts
+/**
+* Runs a jq AST against an input value.
+*
+* @param ast - The parsed AST.
+* @param input - The initial input value (JSON).
+* @param options - Execution options.
+* @returns An array of all values yielded by the filter.
+*/
 const runAst = (ast, input, options = {}) => {
 	const tracker = new LimitTracker(resolveLimits(options.limits));
-	const env = [/* @__PURE__ */ new Map()];
+	const env = [{
+		vars: /* @__PURE__ */ new Map(),
+		funcs: /* @__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.
+* The core evaluation generator.
 *
-* @param node - The AST node to evaluate.
+* This function dispatches execution to specific handlers based on the AST node kind.
+* It uses a generator to support jq's streaming nature (backtracking and multiple outputs).
+*
+* @param node - The current 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.
+* @param env - The current environment (variables and functions).
+* @param tracker - The limit tracker for safety.
+* @yields The output values produced by the filter.
 */
 function* evaluate(node, input, env, tracker) {
+	if (!node) throw new Error("evaluate called with undefined node");
 	tracker.step(node.span);
 	tracker.enter(node.span);
 	try {
@@ -1632,23 +3574,33 @@ function* evaluate(node, input, env, tracker) {
 			case "Literal":
 				yield emit(node.value, node.span, tracker);
 				return;
-			case "Var":
-				yield emit(getVar(env, node.name, node.span), node.span, tracker);
+			case "Var": {
+				const val = getVar(env, node.name);
+				if (val === void 0) throw new RuntimeError(`Undefined variable: ${node.name}`, node.span);
+				yield emit(val, node.span, tracker);
 				return;
+			}
 			case "FieldAccess":
-				yield* evalField(node, input, env, tracker);
+				yield* evalField(node, input, env, tracker, evaluate);
 				return;
 			case "IndexAccess":
-				yield* evalIndex(node, input, env, tracker);
+				yield* evalIndex(node, input, env, tracker, evaluate);
+				return;
+			case "Slice":
+				yield* evalSlice(node, input, env, tracker, evaluate);
 				return;
 			case "Array":
-				yield emit(buildArray(node, input, env, tracker), node.span, tracker);
+				yield* buildArray(node, input, env, tracker, evaluate);
 				return;
 			case "Object":
-				yield* buildObjects(node, input, env, tracker);
+				yield* buildObjects(node, input, env, tracker, evaluate);
+				return;
+			case "Label":
+				yield* evalLabel(node, input, env, tracker, evaluate);
 				return;
+			case "Break": throw new BreakSignal(node.label);
 			case "Pipe":
-				for (const left of evaluate(node.left, input, env, tracker)) yield* evaluate(node.right, left, env, tracker);
+				for (const leftVal of evaluate(node.left, input, env, tracker)) yield* evaluate(node.right, leftVal, env, tracker);
 				return;
 			case "Comma":
 				yield* evaluate(node.left, input, env, tracker);
@@ -1664,348 +3616,62 @@ function* evaluate(node, input, env, tracker) {
 				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);
+				for (const l of evaluate(node.left, input, env, tracker)) if (node.op === "And") if (!isTruthy(l)) yield emit(false, node.span, tracker);
+				else for (const r of evaluate(node.right, input, env, tracker)) yield emit(isTruthy(l) && isTruthy(r), node.span, tracker);
+				else if (isTruthy(l)) yield emit(true, node.span, tracker);
+				else for (const r of evaluate(node.right, input, env, tracker)) yield emit(isTruthy(l) || isTruthy(r), node.span, tracker);
+				return;
+			case "Binary": {
+				const leftRes = Array.from(evaluate(node.left, input, env, tracker));
+				const rightRes = Array.from(evaluate(node.right, input, env, tracker));
+				for (const l of leftRes) for (const r of rightRes) yield emit(applyBinaryOp(node.op, l, r, node.span), 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);
+				yield* evalIf(node, input, env, tracker, evaluate);
 				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);
-					}
-				}
+			case "Try":
+				yield* evalTry(node, input, env, tracker, evaluate);
 				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);
+			case "Recurse":
+				yield* evalRecurse(node, input, env, tracker, evaluate);
+				return;
+			case "Iterate":
+				yield* evalIterate(node, input, env, tracker, evaluate);
+				return;
+			case "Assignment":
+				yield* evalAssignment(node, input, env, tracker, evaluate);
 				return;
-			}
 			case "Reduce":
-				yield* evalReduce(node, input, env, tracker);
+				yield* evalReduce(node, input, env, tracker, evaluate);
 				return;
 			case "Foreach":
-				yield* evalForeach(node, input, env, tracker);
+				yield* evalForeach(node, input, env, tracker, evaluate);
 				return;
-			case "Try":
-				yield* evalTry(node, input, env, tracker);
+			case "As": {
+				const values = Array.from(evaluate(node.bind, input, env, tracker));
+				for (const val of values) {
+					const newFrame = {
+						vars: new Map([[node.name, val]]),
+						funcs: /* @__PURE__ */ new Map()
+					};
+					const newEnv = [...env, newFrame];
+					yield* evaluate(node.body, input, newEnv, tracker);
+				}
 				return;
-			case "Recurse":
-				yield* evalRecurse(node, input, env, tracker);
+			}
+			case "Call":
+				yield* evalCall(node, input, env, tracker, evaluate);
 				return;
-			case "Iterate":
-				yield* evalIterate(node, input, env, tracker);
+			case "Def":
+				yield* evalDef(node, input, env, tracker, evaluate);
 				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