@gabrielbryk/jq-ts 1.2.0 → 1.3.1

package/dist/index.cjs

@@ -864,8 +864,27 @@ var Parser = class {
 		if (!this.match("RBrace")) {
 			do {
 				const key = this.parseObjectKey();
-				this.consume("Colon", "Expected \":\" after object key");
-				const value = this.parseDef(false);
+				let value;
+				if (this.match("Colon")) value = this.parseDef(false);
+				else if (key.kind === "KeyIdentifier") value = {
+					kind: "FieldAccess",
+					target: {
+						kind: "Identity",
+						span: key.span
+					},
+					field: key.name,
+					span: key.span
+				};
+				else if (key.kind === "KeyString") value = {
+					kind: "FieldAccess",
+					target: {
+						kind: "Identity",
+						span: key.span
+					},
+					field: key.value,
+					span: key.span
+				};
+				else throw this.error(this.peek(), "Expected \":\" after object key");
 				entries.push({
 					key,
 					value
@@ -1347,6 +1366,51 @@ const stdBuiltins = [
 		name: "empty",
 		arity: 0,
 		apply: function* () {}
+	},
+	{
+		name: "toboolean",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			yield emit$1(isTruthy(input), span, tracker);
+		}
+	},
+	{
+		name: "walk",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, 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);
+		}
 	}
 ];
 
@@ -1360,6 +1424,232 @@ const errorBuiltins = [{
 	}
 }];
 
+//#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) {
+			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);
+			}
+		}
+	},
+	{
+		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(item)}`, span);
+					parts.push(item);
+				}
+				yield emit$1(parts.join(sep), span, tracker);
+			}
+		}
+	},
+	{
+		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: "endswith",
+		arity: 1,
+		apply: function* (input, args, env, tracker, evaluate$1, span) {
+			if (typeof input !== "string") throw new RuntimeError("endswith input must be a string", span);
+			const suffixGen = evaluate$1(args[0], input, env, tracker);
+			for (const suffix of suffixGen) {
+				if (typeof suffix !== "string") throw new RuntimeError("endswith suffix must be a string", span);
+				yield emit$1(input.endsWith(suffix), span, tracker);
+			}
+		}
+	},
+	{
+		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: "index",
+		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 = 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) {
@@ -1554,189 +1844,207 @@ const collectionBuiltins = [
 			}
 			yield emit$1(result, span, tracker);
 		}
-	}
-];
-
-//#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",
+		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]
+				});
+			}
+			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;
+					}
+				}
+				groups.push(currentGroup);
 			}
+			yield emit$1(groups, span, tracker);
 		}
 	},
 	{
-		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(item)}`, span);
-					parts.push(item);
-				}
-				yield emit$1(parts.join(sep), 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);
 		}
 	},
 	{
-		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: "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: "endswith",
+		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);
 			}
 		}
 	},
 	{
-		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);
 		}
 	},
 	{
-		name: "index",
-		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 = 0; i < input.length; i++) {
-					const val = input[i];
-					if (val !== void 0 && valueEquals(val, search)) {
-						foundIndex = i;
-						break;
-					}
+		name: "transpose",
+		arity: 0,
+		apply: function* (input, _args, _env, tracker, _eval, span) {
+			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);
 				}
-				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);
+				result.push(newRow);
+			}
+			yield emit$1(result, span, tracker);
 		}
 	},
 	{
-		name: "rindex",
+		name: "bsearch",
 		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;
+			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;
 				}
-				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);
+				if (idx !== -1) yield emit$1(idx, span, tracker);
+				else yield emit$1(-low - 1, span, tracker);
+			}
 		}
 	},
 	{
-		name: "indices",
+		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);
+		}
+	},
+	{
+		name: "combinations",
 		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);
+			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;
 				}
-				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;
-						}
+				const arrays = [];
+				for (let i = 0; i < nVal; i++) arrays.push(input);
+				const helper = function* (idx, current) {
+					if (idx === arrays.length) {
+						yield [...current];
+						return;
 					}
-				} else {
-					if (input === null) {
-						yield emit$1(null, span, tracker);
-						continue;
+					const arr = arrays[idx];
+					for (const item of arr) {
+						current.push(item);
+						yield* helper(idx + 1, current);
+						current.pop();
 					}
-					throw new RuntimeError("indices expects string or array", span);
-				}
-				yield emit$1(indices, span, tracker);
+				};
+				if (input.length === 0 && nVal > 0) {} else for (const combo of helper(0, [])) yield emit$1(combo, 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: "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);
 		}
 	}
 ];
@@ -2110,8 +2418,216 @@ const iteratorBuiltins = [
 			};
 			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);
+			}
+		}
+	}
+];
+
+//#endregion
+//#region src/eval/ops.ts
+/**
+* Applies a unary negation (`-`).
+*
+* @param value - The value to negate.
+* @param span - Source span for errors.
+* @returns The negated value.
+*/
+const applyUnaryNeg = (value, span) => {
+	if (typeof value === "number") return -value;
+	throw new RuntimeError(`Invalid operand for unary -: ${describeType(value)}`, span);
+};
+/**
+* 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.
+*/
+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);
+	}
+};
+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
@@ -2296,6 +2812,23 @@ const mathBuiltins = [
 			}
 			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);
+		}
 	}
 ];
 
@@ -2504,164 +3037,6 @@ var LimitTracker = class {
 	}
 };
 
-//#endregion
-//#region src/eval/ops.ts
-/**
-* Applies a unary negation (`-`).
-*
-* @param value - The value to negate.
-* @param span - Source span for errors.
-* @returns The negated value.
-*/
-const applyUnaryNeg = (value, span) => {
-	if (typeof value === "number") return -value;
-	throw new RuntimeError(`Invalid operand for unary -: ${describeType(value)}`, span);
-};
-/**
-* 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.
-*/
-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);
-	}
-};
-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/eval/env.ts
 /**
@@ -2727,6 +3102,7 @@ const ensureInteger = (value, span) => {
 */
 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;
@@ -2780,7 +3156,10 @@ function* applyUpdates(current, paths, index, op, rhsNode, contextInput, env, tr
 			newValues.push(res);
 		}
 	}
-	if (newValues.length === 0) return;
+	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);
 }