@keystrokehq/cli 0.1.3 → 0.1.4

package/dist/xan-Y6WF3IRG-DjKO96Pj.mjs

@@ -0,0 +1,2832 @@
+#!/usr/bin/env node
+import { r as s, t as o } from "./chunk-QAYAQNCG-Bl0Kbd53.mjs";
+import { a as q$1, i as p, n, o as r } from "./chunk-BZUGFHVS-CPWRFwK8.mjs";
+import "./chunk-DLL7UR66-BUYgzxnR.mjs";
+import "./chunk-TN7HHBQW-CSB_R-XD.mjs";
+import "./chunk-L64BMZUV-CyR7RKok.mjs";
+import { t as I1 } from "./chunk-4RUAZWKT-D60fyWAB.mjs";
+import { r as x } from "./chunk-NRSASXYY-CuWyREpD.mjs";
+import "./chunk-SAI2SPQQ-CVRoDNs9.mjs";
+import { n as w } from "./chunk-YCLFEX4T-COc1AThz.mjs";
+import "./chunk-STHBFACM-lyj-j2a-.mjs";
+import { t as xe$1 } from "./chunk-4I3HOE5Z-BixWWVkW.mjs";
+import { n as S$1, s as x$1 } from "./chunk-4WKZNNJK-CiwxAWRf.mjs";
+import { n as d } from "./chunk-LEKBROJD-CJMrAyu9.mjs";
+import { a as N, c as g, i as I$1, n as C, o as S$2, r as E$1, s as b, t as A } from "./chunk-VPADYNBD-BKlA28GJ.mjs";
+import { createRequire } from "node:module";
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-Q7H5W7YE.js
+createRequire(import.meta.url);
+var q, Je = n(() => {
+	"use strict";
+	q = class {
+		input;
+		pos = 0;
+		tokens = [];
+		constructor(n) {
+			this.input = n;
+		}
+		tokenize() {
+			for (; this.pos < this.input.length && (this.skipWhitespace(), !(this.pos >= this.input.length));) {
+				let n = this.nextToken();
+				n && this.tokens.push(n);
+			}
+			return this.tokens.push({
+				type: "eof",
+				value: "",
+				pos: this.pos
+			}), this.tokens;
+		}
+		skipWhitespace() {
+			for (; this.pos < this.input.length;) {
+				let n = this.input[this.pos];
+				if (n === " " || n === "	" || n === `
+` || n === "\r") this.pos++;
+				else if (n === "#") for (; this.pos < this.input.length && this.input[this.pos] !== `
+`;) this.pos++;
+				else break;
+			}
+		}
+		nextToken() {
+			let n = this.pos, t = this.input[this.pos];
+			if (t >= "0" && t <= "9") return this.readNumber();
+			if (t === "\"" || t === "'" || t === "`") return this.readString(t);
+			if (t === "b" && this.pos + 1 < this.input.length) {
+				let o = this.input[this.pos + 1];
+				if (o === "\"" || o === "'" || o === "`") return this.pos++, this.readString(o);
+			}
+			if (t === "/") {
+				let o = this.tokens[this.tokens.length - 1];
+				return o && (o.type === "int" || o.type === "float" || o.type === "string" || o.type === "ident" || o.type === ")" || o.type === "]") ? this.input[this.pos + 1] === "/" ? (this.pos += 2, {
+					type: "//",
+					value: "//",
+					pos: n
+				}) : (this.pos++, {
+					type: "/",
+					value: "/",
+					pos: n
+				}) : this.readRegex();
+			}
+			if (this.match("not in")) return {
+				type: "not in",
+				value: "not in",
+				pos: n
+			};
+			if (this.match("=>")) return {
+				type: "=>",
+				value: "=>",
+				pos: n
+			};
+			if (this.match("**")) return {
+				type: "**",
+				value: "**",
+				pos: n
+			};
+			if (this.match("++")) return {
+				type: "++",
+				value: "++",
+				pos: n
+			};
+			if (this.match("//")) return {
+				type: "//",
+				value: "//",
+				pos: n
+			};
+			if (this.match("==")) return {
+				type: "==",
+				value: "==",
+				pos: n
+			};
+			if (this.match("!=")) return {
+				type: "!=",
+				value: "!=",
+				pos: n
+			};
+			if (this.match("<=")) return {
+				type: "<=",
+				value: "<=",
+				pos: n
+			};
+			if (this.match(">=")) return {
+				type: ">=",
+				value: ">=",
+				pos: n
+			};
+			if (this.match("&&")) return {
+				type: "&&",
+				value: "&&",
+				pos: n
+			};
+			if (this.match("||")) return {
+				type: "||",
+				value: "||",
+				pos: n
+			};
+			let r = new Map([
+				["(", "("],
+				[")", ")"],
+				["[", "["],
+				["]", "]"],
+				["{", "{"],
+				["}", "}"],
+				[",", ","],
+				[":", ":"],
+				[";", ";"],
+				["+", "+"],
+				["-", "-"],
+				["*", "*"],
+				["%", "%"],
+				["<", "<"],
+				[">", ">"],
+				["!", "!"],
+				[".", "."],
+				["|", "|"],
+				["=", "="]
+			]).get(t);
+			if (r !== void 0) return this.pos++, {
+				type: r,
+				value: t,
+				pos: n
+			};
+			if (this.isIdentStart(t)) return this.readIdentifier();
+			throw new Error(`Unexpected character '${t}' at position ${this.pos}`);
+		}
+		match(n) {
+			if (this.input.slice(this.pos, this.pos + n.length) === n) {
+				if (/^[a-zA-Z]/.test(n)) {
+					let t = this.input[this.pos + n.length];
+					if (t && this.isIdentChar(t)) return !1;
+				}
+				return this.pos += n.length, !0;
+			}
+			return !1;
+		}
+		isIdentStart(n) {
+			return n >= "a" && n <= "z" || n >= "A" && n <= "Z" || n === "_";
+		}
+		isIdentChar(n) {
+			return this.isIdentStart(n) || n >= "0" && n <= "9";
+		}
+		readNumber() {
+			let n = this.pos, t = !1, s = !1;
+			for (; this.pos < this.input.length;) {
+				let o = this.input[this.pos];
+				if (o >= "0" && o <= "9") this.pos++;
+				else if (o === "_") this.pos++;
+				else if (o === "." && !t && !s) t = !0, this.pos++;
+				else if ((o === "e" || o === "E") && !s) s = !0, t = !0, this.pos++, this.pos < this.input.length && (this.input[this.pos] === "+" || this.input[this.pos] === "-") && this.pos++;
+				else break;
+			}
+			let r = this.input.slice(n, this.pos).replace(/_/g, "");
+			return {
+				type: t ? "float" : "int",
+				value: r,
+				pos: n
+			};
+		}
+		readString(n) {
+			let t = this.pos;
+			this.pos++;
+			let s = "";
+			for (; this.pos < this.input.length;) {
+				let r = this.input[this.pos];
+				if (r === n) return this.pos++, {
+					type: "string",
+					value: s,
+					pos: t
+				};
+				if (r === "\\") {
+					if (this.pos++, this.pos < this.input.length) {
+						let o = this.input[this.pos];
+						switch (o) {
+							case "n":
+								s += `
+`;
+								break;
+							case "r":
+								s += "\r";
+								break;
+							case "t":
+								s += "	";
+								break;
+							case "\\":
+								s += "\\";
+								break;
+							case "\"":
+								s += "\"";
+								break;
+							case "'":
+								s += "'";
+								break;
+							case "`":
+								s += "`";
+								break;
+							case "0":
+								s += "\0";
+								break;
+							default: s += o;
+						}
+						this.pos++;
+					}
+				} else s += r, this.pos++;
+			}
+			throw new Error(`Unterminated string starting at position ${t}`);
+		}
+		readRegex() {
+			let n = this.pos;
+			this.pos++;
+			let t = "", s = "";
+			for (; this.pos < this.input.length;) {
+				let r = this.input[this.pos];
+				if (r === "/") {
+					for (this.pos++; this.pos < this.input.length && this.input[this.pos] === "i";) s += this.input[this.pos], this.pos++;
+					return {
+						type: "regex",
+						value: t + (s ? `/${s}` : ""),
+						pos: n
+					};
+				}
+				r === "\\" ? (t += r, this.pos++, this.pos < this.input.length && (t += this.input[this.pos], this.pos++)) : (t += r, this.pos++);
+			}
+			throw new Error(`Unterminated regex starting at position ${n}`);
+		}
+		readIdentifier() {
+			let n = this.pos;
+			for (; this.pos < this.input.length && this.isIdentChar(this.input[this.pos]);) this.pos++;
+			let t = !1;
+			this.pos < this.input.length && this.input[this.pos] === "?" && (t = !0, this.pos++);
+			let s = this.input.slice(n, t ? this.pos - 1 : this.pos);
+			t && (s += "?");
+			let r = new Map([
+				["true", "true"],
+				["false", "false"],
+				["null", "null"],
+				["and", "and"],
+				["or", "or"],
+				["eq", "eq"],
+				["ne", "ne"],
+				["lt", "lt"],
+				["le", "le"],
+				["gt", "gt"],
+				["ge", "ge"],
+				["in", "in"],
+				["as", "as"],
+				["_", "_"]
+			]), o = s.replace(/\?$/, ""), a = r.get(o);
+			return a !== void 0 && !t ? {
+				type: a,
+				value: o,
+				pos: n
+			} : {
+				type: "ident",
+				value: s,
+				pos: n
+			};
+		}
+	};
+});
+var ze = {};
+p(ze, {
+	parseMoonblade: () => H,
+	parseNamedExpressions: () => U
+});
+function U(e) {
+	let n = [], s = new q(e).tokenize(), r = 0, o = () => s[r] || {
+		type: "eof",
+		value: "",
+		pos: 0
+	}, a = () => s[r++];
+	for (; o().type !== "eof";) {
+		if (o().type === "," && n.length > 0) {
+			a();
+			continue;
+		}
+		let d = [], u = 0, p = r;
+		for (; o().type !== "eof";) {
+			let i = o();
+			if ((i.type === "," || i.type === "as") && u === 0) break;
+			(i.type === "(" || i.type === "[" || i.type === "{") && u++, (i.type === ")" || i.type === "]" || i.type === "}") && u--, d.push(a());
+		}
+		d.push({
+			type: "eof",
+			value: "",
+			pos: 0
+		});
+		let h = new z(d).parse(), l;
+		if (o().type === "as") if (a(), o().type === "(") {
+			a();
+			let i = [];
+			for (; o().type !== ")" && o().type !== "eof";) (o().type === "ident" || o().type === "string") && (i.push(o().value), a()), o().type === "," && a();
+			o().type === ")" && a(), l = i;
+		} else if (o().type === "ident" || o().type === "string") l = o().value, a();
+		else throw new Error(`Expected name after 'as', got ${o().type}`);
+		else l = e.slice(s[p].pos, s[r - 1]?.pos || e.length).trim(), h.type === "identifier" && (l = h.name);
+		n.push({
+			expr: h,
+			name: l
+		});
+	}
+	return n;
+}
+function H(e) {
+	let t = new q(e).tokenize();
+	return new z(t).parse();
+}
+var R, z, V = n(() => {
+	"use strict";
+	Je();
+	R = {
+		PIPE: 1,
+		OR: 2,
+		AND: 3,
+		EQUALITY: 4,
+		COMPARISON: 5,
+		ADDITIVE: 6,
+		MULTIPLICATIVE: 7,
+		POWER: 8,
+		UNARY: 9,
+		POSTFIX: 10
+	}, z = class {
+		pos = 0;
+		tokens;
+		constructor(n) {
+			this.tokens = n;
+		}
+		parse() {
+			let n = this.parseExpr(0);
+			if (this.peek().type !== "eof") throw new Error(`Unexpected token: ${this.peek().value}`);
+			return n;
+		}
+		parseExpr(n) {
+			let t = this.parsePrefix();
+			for (;;) {
+				let s = this.peek(), r = this.getInfixPrec(s.type);
+				if (r < n) break;
+				t = this.parseInfix(t, r);
+			}
+			return t;
+		}
+		parsePrefix() {
+			let n = this.peek();
+			switch (n.type) {
+				case "int": return this.advance(), {
+					type: "int",
+					value: Number.parseInt(n.value, 10)
+				};
+				case "float": return this.advance(), {
+					type: "float",
+					value: Number.parseFloat(n.value)
+				};
+				case "string": return this.advance(), {
+					type: "string",
+					value: n.value
+				};
+				case "regex": {
+					this.advance();
+					let t = n.value.split("/"), s = t.length > 1 ? t[t.length - 1] : "";
+					return {
+						type: "regex",
+						pattern: t.slice(0, -1).join("/") || n.value,
+						caseInsensitive: s.includes("i")
+					};
+				}
+				case "true": return this.advance(), {
+					type: "bool",
+					value: !0
+				};
+				case "false": return this.advance(), {
+					type: "bool",
+					value: !1
+				};
+				case "null": return this.advance(), { type: "null" };
+				case "_": return this.advance(), { type: "underscore" };
+				case "ident": {
+					let t = n.value, s = t.endsWith("?"), r = s ? t.slice(0, -1) : t;
+					if (this.advance(), this.peek().type === "(") return this.parseFunctionCall(r);
+					if (this.peek().type === "=>") {
+						this.advance();
+						let o = this.parseExpr(0);
+						return this.bindLambdaArgs({
+							type: "lambda",
+							params: [r],
+							body: o
+						}, [r]);
+					}
+					return {
+						type: "identifier",
+						name: r,
+						unsure: s
+					};
+				}
+				case "(": {
+					this.advance();
+					let t = this.pos;
+					if (this.peek().type === ")") {
+						if (this.advance(), this.peek().type === "=>") {
+							this.advance();
+							return {
+								type: "lambda",
+								params: [],
+								body: this.parseExpr(0)
+							};
+						}
+						throw new Error("Empty parentheses not allowed");
+					}
+					if (this.peek().type === "ident") {
+						let r = [this.peek().value];
+						this.advance();
+						let o = !0;
+						for (; this.peek().type === ",";) if (this.advance(), this.peek().type === "ident") r.push(this.peek().value), this.advance();
+						else {
+							o = !1;
+							break;
+						}
+						if (o && this.peek().type === ")" && this.peekAt(1).type === "=>") {
+							this.advance(), this.advance();
+							let a = this.parseExpr(0);
+							return this.bindLambdaArgs({
+								type: "lambda",
+								params: r,
+								body: a
+							}, r);
+						}
+						this.pos = t;
+					}
+					let s = this.parseExpr(0);
+					return this.expect(")"), s;
+				}
+				case "[": return this.parseList();
+				case "{": return this.parseMap();
+				case "-": {
+					this.advance();
+					let t = this.parseExpr(R.UNARY);
+					return t.type === "int" ? {
+						type: "int",
+						value: -t.value
+					} : t.type === "float" ? {
+						type: "float",
+						value: -t.value
+					} : {
+						type: "func",
+						name: "neg",
+						args: [{ expr: t }]
+					};
+				}
+				case "!": return this.advance(), {
+					type: "func",
+					name: "not",
+					args: [{ expr: this.parseExpr(R.UNARY) }]
+				};
+				default: throw new Error(`Unexpected token: ${n.type} (${n.value})`);
+			}
+		}
+		parseFunctionCall(n) {
+			this.expect("(");
+			let t = [];
+			if (this.peek().type !== ")") do {
+				t.length > 0 && this.peek().type === "," && this.advance();
+				let s;
+				if (this.peek().type === "ident") {
+					let o = this.peek().value, a = this.pos + 1;
+					a < this.tokens.length && this.tokens[a].type === "=" && (s = o, this.advance(), this.advance());
+				}
+				let r = this.parseExpr(0);
+				t.push({
+					name: s,
+					expr: r
+				});
+			} while (this.peek().type === ",");
+			return this.expect(")"), {
+				type: "func",
+				name: n.toLowerCase(),
+				args: t
+			};
+		}
+		parseList() {
+			this.expect("[");
+			let n = [];
+			if (this.peek().type !== "]") do
+				n.length > 0 && this.peek().type === "," && this.advance(), n.push(this.parseExpr(0));
+			while (this.peek().type === ",");
+			return this.expect("]"), {
+				type: "list",
+				elements: n
+			};
+		}
+		parseMap() {
+			this.expect("{");
+			let n = [];
+			if (this.peek().type !== "}") do {
+				n.length > 0 && this.peek().type === "," && this.advance();
+				let t;
+				if (this.peek().type === "ident") t = this.peek().value, this.advance();
+				else if (this.peek().type === "string") t = this.peek().value, this.advance();
+				else throw new Error(`Expected map key, got ${this.peek().type}`);
+				this.expect(":");
+				let s = this.parseExpr(0);
+				n.push({
+					key: t,
+					value: s
+				});
+			} while (this.peek().type === ",");
+			return this.expect("}"), {
+				type: "map",
+				entries: n
+			};
+		}
+		parseInfix(n, t) {
+			let s = this.peek(), o = new Map([
+				["+", "add"],
+				["-", "sub"],
+				["*", "mul"],
+				["/", "div"],
+				["//", "idiv"],
+				["%", "mod"],
+				["**", "pow"],
+				["++", "concat"],
+				["==", "=="],
+				["!=", "!="],
+				["<", "<"],
+				["<=", "<="],
+				[">", ">"],
+				[">=", ">="],
+				["eq", "eq"],
+				["ne", "ne"],
+				["lt", "lt"],
+				["le", "le"],
+				["gt", "gt"],
+				["ge", "ge"],
+				["&&", "and"],
+				["and", "and"],
+				["||", "or"],
+				["or", "or"]
+			]).get(s.type);
+			if (o !== void 0) {
+				this.advance();
+				let a = this.parseExpr(t + (this.isRightAssoc(s.type) ? 0 : 1));
+				return {
+					type: "func",
+					name: o,
+					args: [{ expr: n }, { expr: a }]
+				};
+			}
+			if (s.type === "|") {
+				this.advance();
+				let a = this.parseExpr(t);
+				return this.handlePipe(n, a);
+			}
+			if (s.type === ".") return this.advance(), this.handleDot(n);
+			if (s.type === "[") return this.advance(), this.handleIndexing(n);
+			if (s.type === "in") return this.advance(), {
+				type: "func",
+				name: "contains",
+				args: [{ expr: this.parseExpr(t + 1) }, { expr: n }]
+			};
+			if (s.type === "not in") return this.advance(), {
+				type: "func",
+				name: "not",
+				args: [{ expr: {
+					type: "func",
+					name: "contains",
+					args: [{ expr: this.parseExpr(t + 1) }, { expr: n }]
+				} }]
+			};
+			throw new Error(`Unexpected infix token: ${s.type}`);
+		}
+		handlePipe(n, t) {
+			if (t.type === "identifier") return {
+				type: "func",
+				name: t.name,
+				args: [{ expr: n }]
+			};
+			if (t.type === "func") {
+				let s = this.countUnderscores(t);
+				return s === 0 ? t : s === 1 ? this.fillUnderscore(t, n) : {
+					type: "pipeline",
+					exprs: [n, t]
+				};
+			}
+			return this.countUnderscores(t) === 1 ? this.fillUnderscore(t, n) : t;
+		}
+		handleDot(n) {
+			let t = this.peek();
+			if (t.type === "ident") {
+				let s = t.value;
+				if (this.advance(), this.peek().type === "(") {
+					let r = this.parseFunctionCall(s);
+					return r.type === "func" && r.args.unshift({ expr: n }), r;
+				}
+				return {
+					type: "func",
+					name: "get",
+					args: [{ expr: n }, { expr: {
+						type: "string",
+						value: s
+					} }]
+				};
+			}
+			if (t.type === "int") {
+				let s = Number.parseInt(t.value, 10);
+				return this.advance(), {
+					type: "func",
+					name: "get",
+					args: [{ expr: n }, { expr: {
+						type: "int",
+						value: s
+					} }]
+				};
+			}
+			if (t.type === "string") {
+				let s = t.value;
+				return this.advance(), {
+					type: "func",
+					name: "get",
+					args: [{ expr: n }, { expr: {
+						type: "string",
+						value: s
+					} }]
+				};
+			}
+			throw new Error(`Expected identifier, number, or string after dot, got ${t.type}`);
+		}
+		handleIndexing(n) {
+			if (this.peek().type === ":") {
+				if (this.advance(), this.peek().type === "]") return this.advance(), {
+					type: "func",
+					name: "slice",
+					args: [{ expr: n }]
+				};
+				let s = this.parseExpr(0);
+				return this.expect("]"), {
+					type: "func",
+					name: "slice",
+					args: [
+						{ expr: n },
+						{ expr: {
+							type: "int",
+							value: 0
+						} },
+						{ expr: s }
+					]
+				};
+			}
+			let t = this.parseExpr(0);
+			if (this.peek().type === ":") {
+				if (this.advance(), this.peek().type === "]") return this.advance(), {
+					type: "func",
+					name: "slice",
+					args: [{ expr: n }, { expr: t }]
+				};
+				let s = this.parseExpr(0);
+				return this.expect("]"), {
+					type: "func",
+					name: "slice",
+					args: [
+						{ expr: n },
+						{ expr: t },
+						{ expr: s }
+					]
+				};
+			}
+			return this.expect("]"), {
+				type: "func",
+				name: "get",
+				args: [{ expr: n }, { expr: t }]
+			};
+		}
+		countUnderscores(n) {
+			return n.type === "underscore" ? 1 : n.type === "func" ? n.args.reduce((t, s) => t + this.countUnderscores(s.expr), 0) : n.type === "list" ? n.elements.reduce((t, s) => t + this.countUnderscores(s), 0) : n.type === "map" ? n.entries.reduce((t, s) => t + this.countUnderscores(s.value), 0) : 0;
+		}
+		fillUnderscore(n, t) {
+			return n.type === "underscore" ? t : n.type === "func" ? {
+				...n,
+				args: n.args.map((s) => ({
+					...s,
+					expr: this.fillUnderscore(s.expr, t)
+				}))
+			} : n.type === "list" ? {
+				...n,
+				elements: n.elements.map((s) => this.fillUnderscore(s, t))
+			} : n.type === "map" ? {
+				...n,
+				entries: n.entries.map((s) => ({
+					...s,
+					value: this.fillUnderscore(s.value, t)
+				}))
+			} : n;
+		}
+		bindLambdaArgs(n, t) {
+			return {
+				...n,
+				body: this.bindLambdaArgsInExpr(n.body, t)
+			};
+		}
+		bindLambdaArgsInExpr(n, t) {
+			return n.type === "identifier" && t.includes(n.name) ? {
+				type: "lambdaBinding",
+				name: n.name
+			} : n.type === "func" ? {
+				...n,
+				args: n.args.map((s) => ({
+					...s,
+					expr: this.bindLambdaArgsInExpr(s.expr, t)
+				}))
+			} : n.type === "list" ? {
+				...n,
+				elements: n.elements.map((s) => this.bindLambdaArgsInExpr(s, t))
+			} : n.type === "map" ? {
+				...n,
+				entries: n.entries.map((s) => ({
+					...s,
+					value: this.bindLambdaArgsInExpr(s.value, t)
+				}))
+			} : n;
+		}
+		getInfixPrec(n) {
+			switch (n) {
+				case "|": return R.PIPE;
+				case "||":
+				case "or": return R.OR;
+				case "&&":
+				case "and": return R.AND;
+				case "==":
+				case "!=":
+				case "eq":
+				case "ne": return R.EQUALITY;
+				case "<":
+				case "<=":
+				case ">":
+				case ">=":
+				case "lt":
+				case "le":
+				case "gt":
+				case "ge":
+				case "in":
+				case "not in": return R.COMPARISON;
+				case "+":
+				case "-":
+				case "++": return R.ADDITIVE;
+				case "*":
+				case "/":
+				case "//":
+				case "%": return R.MULTIPLICATIVE;
+				case "**": return R.POWER;
+				case ".":
+				case "[": return R.POSTFIX;
+				default: return -1;
+			}
+		}
+		isRightAssoc(n) {
+			return n === "**";
+		}
+		peek() {
+			return this.tokens[this.pos] || {
+				type: "eof",
+				value: "",
+				pos: 0
+			};
+		}
+		peekAt(n) {
+			return this.tokens[this.pos + n] || {
+				type: "eof",
+				value: "",
+				pos: 0
+			};
+		}
+		advance() {
+			return this.tokens[this.pos++];
+		}
+		expect(n) {
+			let t = this.peek();
+			if (t.type !== n) throw new Error(`Expected ${n}, got ${t.type}`);
+			return this.advance();
+		}
+	};
+});
+V();
+function E(e, n) {
+	return n.length === 0 ? I(e, []) : n.length === 1 ? {
+		type: "Pipe",
+		left: n[0],
+		right: I(e, [])
+	} : {
+		type: "Pipe",
+		left: n[0],
+		right: I(e, n.slice(1))
+	};
+}
+var K = {
+	add: (e) => S("+", e[0], e[1]),
+	sub: (e) => S("-", e[0], e[1]),
+	mul: (e) => S("*", e[0], e[1]),
+	div: (e) => S("/", e[0], e[1]),
+	mod: (e) => S("%", e[0], e[1]),
+	idiv: (e) => I("floor", [S("/", e[0], e[1])]),
+	pow: (e) => E("pow", e),
+	neg: (e) => ({
+		type: "UnaryOp",
+		op: "-",
+		operand: e[0]
+	}),
+	"==": (e) => S("==", e[0], e[1]),
+	"!=": (e) => S("!=", e[0], e[1]),
+	"<": (e) => S("<", e[0], e[1]),
+	"<=": (e) => S("<=", e[0], e[1]),
+	">": (e) => S(">", e[0], e[1]),
+	">=": (e) => S(">=", e[0], e[1]),
+	eq: (e) => S("==", P(e[0]), P(e[1])),
+	ne: (e) => S("!=", P(e[0]), P(e[1])),
+	lt: (e) => S("<", P(e[0]), P(e[1])),
+	le: (e) => S("<=", P(e[0]), P(e[1])),
+	gt: (e) => S(">", P(e[0]), P(e[1])),
+	ge: (e) => S(">=", P(e[0]), P(e[1])),
+	and: (e) => S("and", e[0], e[1]),
+	or: (e) => S("or", e[0], e[1]),
+	not: (e) => ({
+		type: "UnaryOp",
+		op: "not",
+		operand: e[0]
+	}),
+	len: (e) => E("length", e),
+	length: (e) => E("length", e),
+	upper: (e) => E("ascii_upcase", e),
+	lower: (e) => E("ascii_downcase", e),
+	trim: (e) => E("trim", e),
+	ltrim: (e) => e.length === 0 ? I("ltrimstr", [{
+		type: "Literal",
+		value: " "
+	}]) : {
+		type: "Pipe",
+		left: e[0],
+		right: I("ltrimstr", [{
+			type: "Literal",
+			value: " "
+		}])
+	},
+	rtrim: (e) => e.length === 0 ? I("rtrimstr", [{
+		type: "Literal",
+		value: " "
+	}]) : {
+		type: "Pipe",
+		left: e[0],
+		right: I("rtrimstr", [{
+			type: "Literal",
+			value: " "
+		}])
+	},
+	split: (e) => E("split", e),
+	join: (e) => e.length === 1 ? I("join", [{
+		type: "Literal",
+		value: ""
+	}]) : E("join", e),
+	concat: (e) => S("+", e[0], e[1]),
+	startswith: (e) => E("startswith", e),
+	endswith: (e) => E("endswith", e),
+	contains: (e) => E("contains", e),
+	replace: (e) => E("gsub", e),
+	substr: (e) => e.length === 2 ? {
+		type: "Slice",
+		base: e[0],
+		start: e[1]
+	} : {
+		type: "Slice",
+		base: e[0],
+		start: e[1],
+		end: S("+", e[1], e[2])
+	},
+	abs: (e) => E("fabs", e),
+	floor: (e) => E("floor", e),
+	ceil: (e) => E("ceil", e),
+	round: (e) => E("round", e),
+	sqrt: (e) => E("sqrt", e),
+	log: (e) => E("log", e),
+	log10: (e) => E("log10", e),
+	log2: (e) => E("log2", e),
+	exp: (e) => E("exp", e),
+	sin: (e) => E("sin", e),
+	cos: (e) => E("cos", e),
+	tan: (e) => E("tan", e),
+	asin: (e) => E("asin", e),
+	acos: (e) => E("acos", e),
+	atan: (e) => E("atan", e),
+	min: (e) => E("min", e),
+	max: (e) => E("max", e),
+	first: (e) => e.length === 0 ? {
+		type: "Index",
+		index: {
+			type: "Literal",
+			value: 0
+		}
+	} : {
+		type: "Index",
+		index: {
+			type: "Literal",
+			value: 0
+		},
+		base: e[0]
+	},
+	last: (e) => e.length === 0 ? {
+		type: "Index",
+		index: {
+			type: "Literal",
+			value: -1
+		}
+	} : {
+		type: "Index",
+		index: {
+			type: "Literal",
+			value: -1
+		},
+		base: e[0]
+	},
+	get: (e) => e.length === 1 ? {
+		type: "Index",
+		index: e[0]
+	} : {
+		type: "Index",
+		index: e[1],
+		base: e[0]
+	},
+	slice: (e) => e.length === 1 ? {
+		type: "Slice",
+		base: e[0]
+	} : e.length === 2 ? {
+		type: "Slice",
+		base: e[0],
+		start: e[1]
+	} : {
+		type: "Slice",
+		base: e[0],
+		start: e[1],
+		end: e[2]
+	},
+	keys: "keys",
+	values: "values",
+	entries: (e) => I("to_entries", e),
+	from_entries: "from_entries",
+	reverse: "reverse",
+	sort: "sort",
+	sort_by: "sort_by",
+	group_by: "group_by",
+	unique: "unique",
+	unique_by: "unique_by",
+	flatten: "flatten",
+	map: (e) => ({
+		type: "Pipe",
+		left: e[0],
+		right: {
+			type: "Array",
+			elements: e[1]
+		}
+	}),
+	select: (e) => I("select", e),
+	empty: () => I("empty", []),
+	count: () => I("length", []),
+	sum: (e) => e.length === 0 ? I("add", []) : {
+		type: "Pipe",
+		left: {
+			type: "Array",
+			elements: e[0]
+		},
+		right: I("add", [])
+	},
+	mean: (e) => e.length === 0 ? {
+		type: "Pipe",
+		left: { type: "Identity" },
+		right: S("/", I("add", []), I("length", []))
+	} : {
+		type: "Pipe",
+		left: {
+			type: "Array",
+			elements: e[0]
+		},
+		right: S("/", I("add", []), I("length", []))
+	},
+	avg: (e) => e.length === 0 ? {
+		type: "Pipe",
+		left: { type: "Identity" },
+		right: S("/", I("add", []), I("length", []))
+	} : {
+		type: "Pipe",
+		left: {
+			type: "Array",
+			elements: e[0]
+		},
+		right: S("/", I("add", []), I("length", []))
+	},
+	type: "type",
+	isnull: (e) => e.length === 0 ? S("==", { type: "Identity" }, {
+		type: "Literal",
+		value: null
+	}) : S("==", e[0], {
+		type: "Literal",
+		value: null
+	}),
+	isempty: (e) => e.length === 0 ? S("==", { type: "Identity" }, {
+		type: "Literal",
+		value: ""
+	}) : S("==", e[0], {
+		type: "Literal",
+		value: ""
+	}),
+	tonumber: (e) => e.length === 0 ? I("tonumber", []) : I("tonumber", e),
+	tostring: (e) => e.length === 0 ? I("tostring", []) : I("tostring", e),
+	if: (e) => Ke(e[0], e[1], e[2]),
+	coalesce: (e) => {
+		if (e.length === 0) return {
+			type: "Literal",
+			value: null
+		};
+		if (e.length === 1) return e[0];
+		let [n, ...t] = e;
+		return Ke(S("and", S("!=", n, {
+			type: "Literal",
+			value: null
+		}), S("!=", n, {
+			type: "Literal",
+			value: ""
+		})), n, t.length === 1 ? t[0] : K.coalesce(t));
+	},
+	index: () => ({
+		type: "Field",
+		name: "_row_index"
+	}),
+	now: () => I("now", []),
+	fmt: (e) => I("tostring", e),
+	format: (e) => I("tostring", e)
+};
+Object.setPrototypeOf(K, null);
+function S(e, n, t) {
+	return {
+		type: "BinaryOp",
+		op: e,
+		left: n,
+		right: t
+	};
+}
+function I(e, n) {
+	return {
+		type: "Call",
+		name: e,
+		args: n
+	};
+}
+var rt = "then";
+function Ke(e, n, t) {
+	let s = x$1({
+		type: "Cond",
+		cond: e,
+		elifs: [],
+		else: t || {
+			type: "Literal",
+			value: null
+		}
+	});
+	return s[rt] = n, s;
+}
+function P(e) {
+	return {
+		type: "Pipe",
+		left: e,
+		right: {
+			type: "Call",
+			name: "tostring",
+			args: []
+		}
+	};
+}
+function O(e, n = !0) {
+	switch (e.type) {
+		case "int":
+		case "float": return {
+			type: "Literal",
+			value: e.value
+		};
+		case "string": return {
+			type: "Literal",
+			value: e.value
+		};
+		case "bool": return {
+			type: "Literal",
+			value: e.value
+		};
+		case "null": return {
+			type: "Literal",
+			value: null
+		};
+		case "underscore": return {
+			type: "Index",
+			base: { type: "Identity" },
+			index: {
+				type: "Literal",
+				value: "_"
+			}
+		};
+		case "identifier": return n ? {
+			type: "Field",
+			name: e.name
+		} : {
+			type: "VarRef",
+			name: e.name
+		};
+		case "lambdaBinding": return {
+			type: "VarRef",
+			name: e.name
+		};
+		case "func": {
+			let t = e.args.map((r) => O(r.expr, n)), s = Object.hasOwn(K, e.name) ? K[e.name] : void 0;
+			return typeof s == "function" ? s(t) : I(typeof s == "string" ? s : e.name, t);
+		}
+		case "list": return e.elements.length === 0 ? { type: "Array" } : {
+			type: "Array",
+			elements: e.elements.reduce((t, s, r) => {
+				let o = O(s, n);
+				return r === 0 ? o : {
+					type: "Comma",
+					left: t,
+					right: o
+				};
+			}, null)
+		};
+		case "map": return {
+			type: "Object",
+			entries: e.entries.map((t) => ({
+				key: t.key,
+				value: O(t.value, n)
+			}))
+		};
+		case "regex": return {
+			type: "Literal",
+			value: e.pattern
+		};
+		case "slice": return {
+			type: "Slice",
+			start: e.start ? O(e.start, n) : void 0,
+			end: e.end ? O(e.end, n) : void 0
+		};
+		case "lambda": return O(e.body, n);
+		case "pipeline": return { type: "Identity" };
+		default: throw new Error(`Unknown moonblade expression type: ${e.type}`);
+	}
+}
+function ee(e) {
+	let n = [], t = 0;
+	for (; t < e.length;) {
+		for (; t < e.length && (e[t] === " " || e[t] === ",");) t++;
+		if (t >= e.length) break;
+		let s = t;
+		for (; t < e.length && /\w/.test(e[t]);) t++;
+		let r = e.slice(s, t);
+		for (; t < e.length && e[t] === " ";) t++;
+		if (e[t] !== "(") break;
+		t++;
+		let o = 1, a = t;
+		for (; t < e.length && o > 0;) e[t] === "(" ? o++ : e[t] === ")" && o--, o > 0 && t++;
+		let d = e.slice(a, t).trim();
+		for (t++; t < e.length && e[t] === " ";) t++;
+		let u = "";
+		if (e.slice(t, t + 3).toLowerCase() === "as ") {
+			for (t += 3; t < e.length && e[t] === " ";) t++;
+			let p = t;
+			for (; t < e.length && /\w/.test(e[t]);) t++;
+			u = e.slice(p, t);
+		}
+		u || (u = d ? `${r}(${d})` : `${r}()`), n.push({
+			func: r,
+			expr: d,
+			alias: u
+		});
+	}
+	return n;
+}
+function Be(e) {
+	return /^\w+$/.test(e);
+}
+function Q(e, n, t) {
+	let r = d(e, O(H(n)), t);
+	return r.length > 0 ? r[0] : null;
+}
+function te(e, n, t = {}) {
+	let { func: s, expr: r } = n;
+	if (s === "count" && !r) return e.length;
+	let o;
+	switch (Be(r) ? o = e.map((a) => a[r]).filter((a) => a != null) : o = e.map((a) => Q(a, r, t)).filter((a) => a != null), s) {
+		case "count": return Be(r) ? o.length : o.filter((a) => !!a).length;
+		case "sum": return o.map((d) => typeof d == "number" ? d : Number.parseFloat(String(d))).reduce((d, u) => d + u, 0);
+		case "mean":
+		case "avg": {
+			let a = o.map((d) => typeof d == "number" ? d : Number.parseFloat(String(d)));
+			return a.length > 0 ? a.reduce((d, u) => d + u, 0) / a.length : 0;
+		}
+		case "min": {
+			let a = o.map((d) => typeof d == "number" ? d : Number.parseFloat(String(d)));
+			return a.length > 0 ? Math.min(...a) : null;
+		}
+		case "max": {
+			let a = o.map((d) => typeof d == "number" ? d : Number.parseFloat(String(d)));
+			return a.length > 0 ? Math.max(...a) : null;
+		}
+		case "first": return o.length > 0 ? o[0] : null;
+		case "last": return o.length > 0 ? o[o.length - 1] : null;
+		case "median": {
+			let a = o.map((u) => typeof u == "number" ? u : Number.parseFloat(String(u))).filter((u) => !Number.isNaN(u)).sort((u, p) => u - p);
+			if (a.length === 0) return null;
+			let d = Math.floor(a.length / 2);
+			return a.length % 2 === 0 ? (a[d - 1] + a[d]) / 2 : a[d];
+		}
+		case "mode": {
+			let a = /* @__PURE__ */ new Map();
+			for (let p of o) {
+				let c = String(p);
+				a.set(c, (a.get(c) || 0) + 1);
+			}
+			let d = 0, u = null;
+			for (let [p, c] of a) c > d && (d = c, u = p);
+			return u;
+		}
+		case "cardinality": return new Set(o.map((d) => String(d))).size;
+		case "values": return o.map((a) => String(a)).join("|");
+		case "distinct_values": return [...new Set(o.map((d) => String(d)))].sort().join("|");
+		case "all":
+			if (e.length === 0) return !0;
+			for (let a of e) if (!Q(a, r, t)) return !1;
+			return !0;
+		case "any":
+			for (let a of e) if (Q(a, r, t)) return !0;
+			return !1;
+		default: return null;
+	}
+}
+function Ge(e, n, t = {}) {
+	let s = C();
+	for (let r of n) E$1(s, r.alias, te(e, r, t));
+	return s;
+}
+async function ne(e, n) {
+	let t = "", s = [];
+	for (let c of e) c.startsWith("-") || (t ? s.push(c) : t = c);
+	if (!t) return {
+		stdout: "",
+		stderr: `xan agg: no aggregation expression
+`,
+		exitCode: 1
+	};
+	let { data: r, error: o } = await g(s, n);
+	if (o) return o;
+	let a = { limits: n.limits ? { maxIterations: n.limits.maxJqIterations } : void 0 }, d = ee(t);
+	return {
+		stdout: I$1(d.map((c) => c.alias), [Ge(r, d, a)]),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function se(e, n) {
+	let t = "", s = "", r = [];
+	for (let f = 0; f < e.length; f++) {
+		let m = e[f];
+		m === "--sorted" || m.startsWith("-") || (t ? s ? r.push(m) : s = m : t = m);
+	}
+	if (!t || !s) return {
+		stdout: "",
+		stderr: `xan groupby: usage: xan groupby COLS EXPR [FILE]
+`,
+		exitCode: 1
+	};
+	let { data: o, error: a } = await g(r, n);
+	if (a) return a;
+	let d = { limits: n.limits ? { maxIterations: n.limits.maxJqIterations } : void 0 }, u = t.split(","), p = ee(s), c = [], h = /* @__PURE__ */ new Map();
+	for (let f of o) {
+		let m = u.map((g) => String(f[g])).join("\0");
+		h.has(m) || (h.set(m, []), c.push(m)), h.get(m)?.push(f);
+	}
+	let l = [...u, ...p.map((f) => f.alias)], i = [];
+	for (let f of c) {
+		let m = h.get(f);
+		if (!m) continue;
+		let g = C();
+		for (let y of u) E$1(g, y, m[0][y]);
+		for (let y of p) E$1(g, y.alias, te(m, y, d));
+		i.push(g);
+	}
+	return {
+		stdout: I$1(l, i),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function re(e, n) {
+	let t = [], s = "", r = 10, o = !1, a = [];
+	for (let i = 0; i < e.length; i++) {
+		let f = e[i];
+		(f === "-s" || f === "--select") && i + 1 < e.length ? t = e[++i].split(",") : (f === "-g" || f === "--groupby") && i + 1 < e.length ? s = e[++i] : (f === "-l" || f === "--limit") && i + 1 < e.length ? r = Number.parseInt(e[++i], 10) : f === "--no-extra" ? o = !0 : f === "-A" || f === "--all" ? r = 0 : f.startsWith("-") || a.push(f);
+	}
+	let { headers: d, data: u, error: p } = await g(a, n);
+	if (p) return p;
+	let c = t.length > 0 ? t : d.filter((i) => i !== s);
+	s && t.length === 0 && (c = d.filter((i) => i !== s));
+	let h = [], l = s ? [
+		"field",
+		s,
+		"value",
+		"count"
+	] : [
+		"field",
+		"value",
+		"count"
+	];
+	if (s) {
+		let i = /* @__PURE__ */ new Map();
+		for (let f of u) {
+			let m = String(f[s] ?? "");
+			i.has(m) || i.set(m, []), i.get(m)?.push(f);
+		}
+		for (let f of c) for (let [m, g] of i) {
+			let y = /* @__PURE__ */ new Map();
+			for (let k of g) {
+				let N = k[f], C = N === "" || N === null || N === void 0 ? "" : String(N);
+				y.set(C, (y.get(C) || 0) + 1);
+			}
+			let x = [...y.entries()].sort((k, N) => N[1] !== k[1] ? N[1] - k[1] : k[0].localeCompare(N[0]));
+			o && (x = x.filter(([k]) => k !== "")), r > 0 && (x = x.slice(0, r));
+			for (let [k, N] of x) h.push({
+				field: f,
+				[s]: m,
+				value: k === "" ? "<empty>" : k,
+				count: N
+			});
+		}
+	} else for (let i of c) {
+		let f = /* @__PURE__ */ new Map();
+		for (let g of u) {
+			let y = g[i], x = y === "" || y === null || y === void 0 ? "" : String(y);
+			f.set(x, (f.get(x) || 0) + 1);
+		}
+		let m = [...f.entries()].sort((g, y) => y[1] !== g[1] ? y[1] - g[1] : g[0].localeCompare(y[0]));
+		o && (m = m.filter(([g]) => g !== "")), r > 0 && (m = m.slice(0, r));
+		for (let [g, y] of m) h.push({
+			field: i,
+			value: g === "" ? "<empty>" : g,
+			count: y
+		});
+	}
+	return {
+		stdout: I$1(l, h),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function oe(e, n) {
+	let t = [], s = [];
+	for (let c = 0; c < e.length; c++) {
+		let h = e[c];
+		h === "-s" && c + 1 < e.length ? t = e[++c].split(",") : h.startsWith("-") || s.push(h);
+	}
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	let d = t.length > 0 ? t : r, u = [
+		"field",
+		"type",
+		"count",
+		"min",
+		"max",
+		"mean"
+	], p = [];
+	for (let c of d) {
+		let h = o.map((f) => f[c]).filter((f) => f != null), l = h.map((f) => typeof f == "number" ? f : Number.parseFloat(String(f))).filter((f) => !Number.isNaN(f)), i = l.length === h.length && l.length > 0;
+		p.push({
+			field: c,
+			type: i ? "Number" : "String",
+			count: h.length,
+			min: i ? Math.min(...l) : "",
+			max: i ? Math.max(...l) : "",
+			mean: i ? Math.round(l.reduce((f, m) => f + m, 0) / l.length * 1e10) / 1e10 : ""
+		});
+	}
+	return {
+		stdout: I$1(u, p),
+		stderr: "",
+		exitCode: 0
+	};
+}
+V();
+function Xe(e) {
+	return O(H(e));
+}
+function ot(e) {
+	return I1(`^${e.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+}
+function B(e, n) {
+	let t = [], s = /* @__PURE__ */ new Set();
+	for (let r of e.split(",")) {
+		let o = r.trim();
+		if (o.startsWith("!")) {
+			let c = B(o.slice(1), n);
+			for (let h of c) s.add(h);
+			continue;
+		}
+		if (o === "*") {
+			for (let p of n) t.includes(p) || t.push(p);
+			continue;
+		}
+		if (o.includes("*")) {
+			let p = ot(o);
+			for (let c of n) p.test(c) && !t.includes(c) && t.push(c);
+			continue;
+		}
+		let a = o.match(/^([^:]*):([^:]*)$/);
+		if (a && (a[1] || a[2])) {
+			let p = a[1], c = a[2], h = p ? n.indexOf(p) : 0, l = c ? n.indexOf(c) : n.length - 1;
+			if (h !== -1 && l !== -1) {
+				let i = h <= l ? 1 : -1;
+				for (let f = h; i > 0 ? f <= l : f >= l; f += i) t.includes(n[f]) || t.push(n[f]);
+			}
+			continue;
+		}
+		let d = o.match(/^(\d+)-(\d+)$/);
+		if (d) {
+			let p = Number.parseInt(d[1], 10), c = Number.parseInt(d[2], 10);
+			for (let h = p; h <= c && h < n.length; h++) t.push(n[h]);
+			continue;
+		}
+		let u = Number.parseInt(o, 10);
+		if (!Number.isNaN(u) && u >= 0 && u < n.length) {
+			t.push(n[u]);
+			continue;
+		}
+		n.includes(o) && t.push(o);
+	}
+	return s.size > 0 ? t.filter((r) => !s.has(r)) : t;
+}
+async function ie(e, n) {
+	let t = "", s = [];
+	for (let p of e) p.startsWith("-") || (t ? s.push(p) : t = p);
+	if (!t) return {
+		stdout: "",
+		stderr: `xan select: no columns specified
+`,
+		exitCode: 1
+	};
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	let d = B(t, r);
+	return {
+		stdout: I$1(d, o.map((p) => {
+			let c = C();
+			for (let h of d) E$1(c, h, p[h]);
+			return c;
+		})),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function ae(e, n) {
+	let t = "", s = [];
+	for (let c of e) c.startsWith("-") || (t ? s.push(c) : t = c);
+	if (!t) return {
+		stdout: "",
+		stderr: `xan drop: no columns specified
+`,
+		exitCode: 1
+	};
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	let d = new Set(B(t, r)), u = r.filter((c) => !d.has(c));
+	return {
+		stdout: I$1(u, o.map((c) => {
+			let h = C();
+			for (let l of u) E$1(h, l, c[l]);
+			return h;
+		})),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function le(e, n) {
+	let t = "", s = "", r = [];
+	for (let c = 0; c < e.length; c++) {
+		let h = e[c];
+		h === "-s" && c + 1 < e.length ? s = e[++c] : h.startsWith("-") || (t ? r.push(h) : t = h);
+	}
+	if (!t) return {
+		stdout: "",
+		stderr: `xan rename: no new name(s) specified
+`,
+		exitCode: 1
+	};
+	let { headers: o, data: a, error: d } = await g(r, n);
+	if (d) return d;
+	let u;
+	if (s) {
+		let c = s.split(","), h = t.split(","), l = /* @__PURE__ */ new Map();
+		for (let i = 0; i < c.length && i < h.length; i++) l.set(c[i], h[i]);
+		u = o.map((i) => l.get(i) || i);
+	} else {
+		let c = t.split(",");
+		u = o.map((h, l) => l < c.length ? c[l] : h);
+	}
+	let p = a.map((c) => {
+		let h = C();
+		for (let l = 0; l < o.length; l++) E$1(h, u[l], c[o[l]]);
+		return h;
+	});
+	return {
+		stdout: I$1(u, p),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function ue(e, n) {
+	let t = "index", s = [];
+	for (let p = 0; p < e.length; p++) e[p] === "-c" && p + 1 < e.length ? t = e[++p] : s.push(e[p]);
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	return {
+		stdout: I$1([t, ...r], o.map((p, c) => {
+			let h = C();
+			E$1(h, t, c);
+			for (let l of r) E$1(h, l, p[l]);
+			return h;
+		})),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function ce(e, n) {
+	let t = e.includes("-j") || e.includes("--just-names"), { headers: s, error: r } = await g(e.filter((a) => a !== "-j" && a !== "--just-names"), n);
+	return r || {
+		stdout: t ? `${s.map((a) => a).join(`
+`)}
+` : `${s.map((a, d) => `${d}   ${a}`).join(`
+`)}
+`,
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function pe(e, n) {
+	let { data: t, error: s } = await g(e, n);
+	return s || {
+		stdout: `${t.length}
+`,
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function fe(e, n) {
+	let t = 10, s = [];
+	for (let u = 0; u < e.length; u++) (e[u] === "-l" || e[u] === "-n") && u + 1 < e.length ? t = Number.parseInt(e[++u], 10) : s.push(e[u]);
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	return {
+		stdout: I$1(r, o.slice(0, t)),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function de(e, n) {
+	let t = 10, s = [];
+	for (let u = 0; u < e.length; u++) (e[u] === "-l" || e[u] === "-n") && u + 1 < e.length ? t = Number.parseInt(e[++u], 10) : s.push(e[u]);
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	return {
+		stdout: I$1(r, o.slice(-t)),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function he(e, n) {
+	let t, s, r, o = [];
+	for (let l = 0; l < e.length; l++) {
+		let i = e[l];
+		(i === "-s" || i === "--start") && l + 1 < e.length ? t = Number.parseInt(e[++l], 10) : (i === "-e" || i === "--end") && l + 1 < e.length ? s = Number.parseInt(e[++l], 10) : (i === "-l" || i === "--len") && l + 1 < e.length ? r = Number.parseInt(e[++l], 10) : i.startsWith("-") || o.push(i);
+	}
+	let { headers: a, data: d, error: u } = await g(o, n);
+	if (u) return u;
+	let p = t ?? 0, c;
+	r !== void 0 ? c = p + r : s !== void 0 ? c = s : c = d.length;
+	return {
+		stdout: I$1(a, d.slice(p, c)),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function me(e, n) {
+	let { headers: t, data: s, error: r } = await g(e, n);
+	if (r) return r;
+	return {
+		stdout: I$1(t, [...s].reverse()),
+		stderr: "",
+		exitCode: 0
+	};
+}
+var ge = q$1(xe$1(), 1);
+async function ye(e, n) {
+	let { headers: s, data: r, error: o } = await g(e.filter((p) => !p.startsWith("-")), n);
+	if (o) return o;
+	if (r.length === 0) return {
+		stdout: I$1(["column"], s.map((h) => ({ column: h }))),
+		stderr: "",
+		exitCode: 0
+	};
+	let a = s[0], d = [a, ...r.map((p, c) => String(p[a] ?? `row_${c}`))], u = [];
+	for (let p = 1; p < s.length; p++) {
+		let c = s[p], h = C();
+		E$1(h, a, c);
+		for (let l = 0; l < r.length; l++) E$1(h, d[l + 1], r[l][c]);
+		u.push(h);
+	}
+	return {
+		stdout: I$1(d, u),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function xe(e, n) {
+	let t = null, s = [];
+	for (let c = 0; c < e.length; c++) {
+		let h = e[c];
+		h === "--seed" && c + 1 < e.length ? t = Number.parseInt(e[++c], 10) : h.startsWith("-") || s.push(h);
+	}
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	let d = t !== null ? t : Date.now(), u = () => (d = d * 1103515245 + 12345 & 2147483647, d / 2147483647), p = [...o];
+	for (let c = p.length - 1; c > 0; c--) {
+		let h = Math.floor(u() * (c + 1));
+		[p[c], p[h]] = [p[h], p[c]];
+	}
+	return {
+		stdout: I$1(r, p),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function we(e, n) {
+	let t = null, s = "", r = [];
+	for (let i = 0; i < e.length; i++) {
+		let f = e[i];
+		(f === "-l" || f === "--length") && i + 1 < e.length ? t = Number.parseInt(e[++i], 10) : (f === "-d" || f === "--default") && i + 1 < e.length ? s = e[++i] : f.startsWith("-") || r.push(f);
+	}
+	let o = r[0], a;
+	if (!o || o === "-") a = x(n.stdin);
+	else try {
+		let i = n.fs.resolvePath(n.cwd, o);
+		a = await n.fs.readFile(i);
+	} catch {
+		return {
+			stdout: "",
+			stderr: `xan fixlengths: ${o}: No such file or directory
+`,
+			exitCode: 1
+		};
+	}
+	let u = ge.default.parse(a.trim(), {
+		header: !1,
+		skipEmptyLines: !0
+	}).data;
+	if (u.length === 0) return {
+		stdout: "",
+		stderr: "",
+		exitCode: 0
+	};
+	let p = Math.max(...u.map((i) => i.length)), c = t ?? p, h = u.map((i) => i.length === c ? i : i.length < c ? [...i, ...Array(c - i.length).fill(s)] : i.slice(0, c));
+	return {
+		stdout: `${ge.default.unparse(h).replace(/\r\n/g, `
+`)}
+`,
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function ve(e, n) {
+	let t = null, s = null, r = ".", o = [];
+	for (let l = 0; l < e.length; l++) {
+		let i = e[l];
+		(i === "-c" || i === "--chunks") && l + 1 < e.length ? t = Number.parseInt(e[++l], 10) : (i === "-S" || i === "--size") && l + 1 < e.length ? s = Number.parseInt(e[++l], 10) : (i === "-o" || i === "--output") && l + 1 < e.length ? r = e[++l] : i.startsWith("-") || o.push(i);
+	}
+	if (!t && !s) return {
+		stdout: "",
+		stderr: `xan split: must specify -c or -S
+`,
+		exitCode: 1
+	};
+	let { headers: a, data: d, error: u } = await g(o, n);
+	if (u) return u;
+	let p = [];
+	if (t) {
+		let l = Math.ceil(d.length / t);
+		for (let i = 0; i < t; i++) p.push(d.slice(i * l, (i + 1) * l));
+	} else if (s) for (let l = 0; l < d.length; l += s) p.push(d.slice(l, l + s));
+	let c = p.filter((l) => l.length > 0), h = o[0]?.replace(/\.csv$/, "") || "part";
+	try {
+		let l = n.fs.resolvePath(n.cwd, r);
+		for (let i = 0; i < c.length; i++) {
+			let f = `${h}_${String(i + 1).padStart(3, "0")}.csv`, m = n.fs.resolvePath(l, f);
+			await n.fs.writeFile(m, I$1(a, c[i]));
+		}
+		return {
+			stdout: `Split into ${c.length} parts
+`,
+			stderr: "",
+			exitCode: 0
+		};
+	} catch {
+		return {
+			stdout: `${c.map((i, f) => `Part ${f + 1}: ${i.length} rows`).join(`
+`)}
+`,
+			stderr: "",
+			exitCode: 0
+		};
+	}
+}
+function Ye(e) {
+	return e.replace(/[^a-zA-Z0-9_-]/g, "_") || "empty";
+}
+function it(e) {
+	let n = 2166136261;
+	for (let t = 0; t < e.length; t++) n = (n ^ e.charCodeAt(t)) * 16777619 >>> 0;
+	return n.toString(36).padStart(6, "0").slice(0, 6);
+}
+async function Ce(e, n) {
+	let t = "", s = ".", r = [];
+	for (let l = 0; l < e.length; l++) {
+		let i = e[l];
+		(i === "-o" || i === "--output") && l + 1 < e.length ? s = e[++l] : i.startsWith("-") || (t ? r.push(i) : t = i);
+	}
+	if (!t) return {
+		stdout: "",
+		stderr: `xan partition: usage: xan partition COLUMN [FILE]
+`,
+		exitCode: 1
+	};
+	let { headers: o, data: a, error: d } = await g(r, n);
+	if (d) return d;
+	if (!o.includes(t)) return {
+		stdout: "",
+		stderr: `xan partition: column '${t}' not found
+`,
+		exitCode: 1
+	};
+	let u = /* @__PURE__ */ new Map();
+	for (let l of a) {
+		let i = String(l[t] ?? "");
+		u.has(i) || u.set(i, []), u.get(i)?.push(l);
+	}
+	let p = /* @__PURE__ */ new Map();
+	for (let l of u.keys()) {
+		let i = Ye(l);
+		p.set(i, (p.get(i) ?? 0) + 1);
+	}
+	let c = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map();
+	for (let l of u.keys()) {
+		let i = Ye(l), m = (p.get(i) ?? 0) > 1 ? `${i}_${it(l)}` : i, g = `${m}.csv`, y = 1;
+		for (; c.has(g);) g = `${m}_${y}.csv`, y++;
+		c.add(g), h.set(l, g);
+	}
+	try {
+		let l = n.fs.resolvePath(n.cwd, s);
+		for (let [i, f] of u) {
+			let m = h.get(i);
+			if (!m) continue;
+			let g = n.fs.resolvePath(l, m);
+			await n.fs.writeFile(g, I$1(o, f));
+		}
+		return {
+			stdout: `Partitioned into ${u.size} files by '${t}'
+`,
+			stderr: "",
+			exitCode: 0
+		};
+	} catch {
+		return {
+			stdout: `${Array.from(u.entries()).map(([i, f]) => `${i}: ${f.length} rows`).join(`
+`)}
+`,
+			stderr: "",
+			exitCode: 0
+		};
+	}
+}
+async function be(e, n) {
+	if (e.length === 0) return {
+		stdout: "",
+		stderr: `xan to: usage: xan to <format> [FILE]
+`,
+		exitCode: 1
+	};
+	let t = e[0], s = e.slice(1);
+	return t === "json" ? at(s, n) : {
+		stdout: "",
+		stderr: `xan to: unsupported format '${t}'
+`,
+		exitCode: 1
+	};
+}
+async function at(e, n) {
+	let { data: s, error: r } = await g(e.filter((a) => !a.startsWith("-")), n);
+	return r || {
+		stdout: `${JSON.stringify(s, null, 2)}
+`,
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Se(e, n) {
+	let t = "", s = [];
+	for (let r = 0; r < e.length; r++) {
+		let o = e[r];
+		(o === "-f" || o === "--format") && r + 1 < e.length ? t = e[++r] : o.startsWith("-") || s.push(o);
+	}
+	return t ? t === "json" ? lt(s, n) : {
+		stdout: "",
+		stderr: `xan from: unsupported format '${t}'
+`,
+		exitCode: 1
+	} : {
+		stdout: "",
+		stderr: `xan from: usage: xan from -f <format> [FILE]
+`,
+		exitCode: 1
+	};
+}
+async function lt(e, n) {
+	let t = e[0], s;
+	if (!t || t === "-") s = x(n.stdin);
+	else try {
+		let r = n.fs.resolvePath(n.cwd, t);
+		s = await n.fs.readFile(r);
+	} catch {
+		return {
+			stdout: "",
+			stderr: `xan from: ${t}: No such file or directory
+`,
+			exitCode: 1
+		};
+	}
+	try {
+		let r = JSON.parse(s.trim());
+		if (!Array.isArray(r)) return {
+			stdout: "",
+			stderr: `xan from: JSON input must be an array
+`,
+			exitCode: 1
+		};
+		if (r.length === 0) return {
+			stdout: `
+`,
+			stderr: "",
+			exitCode: 0
+		};
+		if (Array.isArray(r[0])) {
+			let [a, ...d] = r;
+			return {
+				stdout: I$1(a, d.map((p) => {
+					let c = C();
+					for (let h = 0; h < a.length; h++) E$1(c, a[h], p[h]);
+					return c;
+				})),
+				stderr: "",
+				exitCode: 0
+			};
+		}
+		return {
+			stdout: I$1(Object.keys(r[0]).sort(), r),
+			stderr: "",
+			exitCode: 0
+		};
+	} catch {
+		return {
+			stdout: "",
+			stderr: `xan from: invalid JSON input
+`,
+			exitCode: 1
+		};
+	}
+}
+async function ke(e, n) {
+	let t = !1, s$1 = 0, r = "", o = [];
+	for (let l = 0; l < e.length; l++) {
+		let i = e[l];
+		if (i === "-v" || i === "--invert") t = !0;
+		else if ((i === "-l" || i === "--limit") && l + 1 < e.length) s$1 = Number.parseInt(e[++l], 10);
+		else {
+			if (i === "--help") return s({
+				name: "xan filter",
+				summary: "Filter rows by expression",
+				usage: "xan filter [OPTIONS] EXPR [FILE]",
+				description: "Filter CSV rows using moonblade expressions.",
+				options: [
+					"-v, --invert    invert match",
+					"-l, --limit N   limit output to N rows",
+					"    --help      display help"
+				]
+			});
+			i.startsWith("-") || (r ? o.push(i) : r = i);
+		}
+	}
+	if (!r) return {
+		stdout: "",
+		stderr: `xan filter: no expression specified
+`,
+		exitCode: 1
+	};
+	let { headers: a, data: d$1, error: u } = await g(o, n);
+	if (u) return u;
+	let p = { limits: n.limits ? { maxIterations: n.limits.maxJqIterations } : void 0 }, c = Xe(r), h = [];
+	for (let l of d$1) {
+		if (s$1 > 0 && h.length >= s$1) break;
+		let i = d(l, c, p), f = i.length > 0 && i.some((m) => !!m);
+		(t ? !f : f) && h.push(l);
+	}
+	return {
+		stdout: I$1(a, h),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Ie(e, n) {
+	let t = "", s = !1, r = !1, o = [];
+	for (let c = 0; c < e.length; c++) {
+		let h = e[c];
+		h === "-N" || h === "--numeric" ? s = !0 : h === "-R" || h === "-r" || h === "--reverse" ? r = !0 : h === "-s" && c + 1 < e.length ? t = e[++c] : h.startsWith("-") || o.push(h);
+	}
+	let { headers: a, data: d, error: u } = await g(o, n);
+	if (u) return u;
+	!t && a.length > 0 && (t = a[0]);
+	return {
+		stdout: I$1(a, [...d].sort((c, h) => {
+			let l = c[t], i = h[t], f;
+			if (s) f = (typeof l == "number" ? l : Number.parseFloat(String(l))) - (typeof i == "number" ? i : Number.parseFloat(String(i)));
+			else f = String(l).localeCompare(String(i));
+			return r ? -f : f;
+		})),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Ne(e, n) {
+	let t = "", s = [];
+	for (let p = 0; p < e.length; p++) {
+		let c = e[p];
+		c === "-s" && p + 1 < e.length ? t = e[++p] : c.startsWith("-") || s.push(c);
+	}
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	let d = /* @__PURE__ */ new Set();
+	return {
+		stdout: I$1(r, o.filter((p) => {
+			let c = t ? String(p[t]) : JSON.stringify(p);
+			return d.has(c) ? !1 : (d.add(c), !0);
+		})),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Ee(e, n) {
+	let t = 10, s = "", r = !1, o = [];
+	for (let h = 0; h < e.length; h++) {
+		let l = e[h];
+		(l === "-l" || l === "-n") && h + 1 < e.length ? t = Number.parseInt(e[++h], 10) : l === "-R" || l === "-r" || l === "--reverse" ? r = !0 : l.startsWith("-") || (s ? o.push(l) : s = l);
+	}
+	let { headers: a, data: d, error: u } = await g(o, n);
+	if (u) return u;
+	!s && a.length > 0 && (s = a[0]);
+	return {
+		stdout: I$1(a, [...d].sort((h, l) => {
+			let i = h[s], f = l[s], m = typeof i == "number" ? i : Number.parseFloat(String(i)), g = typeof f == "number" ? f : Number.parseFloat(String(f));
+			return r ? m - g : g - m;
+		}).slice(0, t)),
+		stderr: "",
+		exitCode: 0
+	};
+}
+V();
+async function Ae(e, n) {
+	let t = "", s = !1, r = !1, o = [];
+	for (let f = 0; f < e.length; f++) {
+		let m = e[f];
+		m === "-O" || m === "--overwrite" ? s = !0 : m === "--filter" ? r = !0 : m.startsWith("-") || (t ? o.push(m) : t = m);
+	}
+	if (!t) return {
+		stdout: "",
+		stderr: `xan map: no expression specified
+`,
+		exitCode: 1
+	};
+	let { headers: a, data: d$2, error: u } = await g(o, n);
+	if (u) return u;
+	let c = U(t).map(({ expr: f, name: m }) => ({
+		alias: typeof m == "string" ? m : m[0],
+		ast: O(f)
+	})), h = { limits: n.limits ? { maxIterations: n.limits.maxJqIterations } : void 0 }, l;
+	if (s) {
+		l = [...a];
+		for (let f of c) a.includes(f.alias) || l.push(f.alias);
+	} else l = [...a, ...c.map((f) => f.alias)];
+	let i = [];
+	for (let f = 0; f < d$2.length; f++) {
+		let m = d$2[f], g = b(m), y = !1, x = Object.assign(S$1(m), { _row_index: f });
+		for (let k of c) {
+			let N = d(x, k.ast, h), C = N.length > 0 ? N[0] : null;
+			if (r && C == null) {
+				y = !0;
+				break;
+			}
+			E$1(g, k.alias, C);
+		}
+		y || i.push(g);
+	}
+	return {
+		stdout: I$1(l, i),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Fe(e, n) {
+	let t = "", s = "", r$1 = "", o = [];
+	for (let m = 0; m < e.length; m++) {
+		let g = e[m];
+		(g === "-r" || g === "--rename") && m + 1 < e.length ? r$1 = e[++m] : g.startsWith("-") || (t ? s ? o.push(g) : s = g : t = g);
+	}
+	if (!t || !s) return {
+		stdout: "",
+		stderr: `xan transform: usage: xan transform COLUMN EXPR [FILE]
+`,
+		exitCode: 1
+	};
+	let { headers: a, data: d$3, error: u } = await g(o, n);
+	if (u) return u;
+	let p = t.split(",").map((m) => m.trim()), c = r$1 ? r$1.split(",").map((m) => m.trim()) : [];
+	for (let m of p) if (!a.includes(m)) return {
+		stdout: "",
+		stderr: `xan transform: column '${m}' not found
+`,
+		exitCode: 1
+	};
+	let h = O(U(s)[0]?.expr || (V(), r(ze)).parseMoonblade(s)), l = { limits: n.limits ? { maxIterations: n.limits.maxJqIterations } : void 0 }, i = a.map((m) => {
+		let g = p.indexOf(m);
+		return g !== -1 && c[g] ? c[g] : m;
+	}), f = [];
+	for (let m of d$3) {
+		let g = b(m);
+		for (let y = 0; y < p.length; y++) {
+			let x = p[y], N = d(Object.assign(S$1(m), { _: m[x] }), h, l), C = N.length > 0 ? N[0] : null, A = c[y] || x;
+			A !== x && delete g[x], E$1(g, A, C);
+		}
+		f.push(g);
+	}
+	return {
+		stdout: I$1(i, f),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Oe(e, n) {
+	let t = "", s = "|", r = !1, o = "", a = [];
+	for (let i = 0; i < e.length; i++) {
+		let f = e[i];
+		(f === "-s" || f === "--separator") && i + 1 < e.length ? s = e[++i] : f === "--drop-empty" ? r = !0 : (f === "-r" || f === "--rename") && i + 1 < e.length ? o = e[++i] : f.startsWith("-") || (t ? a.push(f) : t = f);
+	}
+	if (!t) return {
+		stdout: "",
+		stderr: `xan explode: usage: xan explode COLUMN [FILE]
+`,
+		exitCode: 1
+	};
+	let { headers: d, data: u, error: p } = await g(a, n);
+	if (p) return p;
+	if (!d.includes(t)) return {
+		stdout: "",
+		stderr: `xan explode: column '${t}' not found
+`,
+		exitCode: 1
+	};
+	let c = o ? d.map((i) => i === t ? o : i) : d, h = o || t, l = [];
+	for (let i of u) {
+		let f = i[t], m = f == null ? "" : String(f);
+		if (m === "") {
+			if (!r) {
+				let g = b(i);
+				o && (delete g[t], E$1(g, h, "")), l.push(g);
+			}
+		} else {
+			let g = m.split(s);
+			for (let y of g) {
+				let x = b(i);
+				o && delete x[t], E$1(x, h, y), l.push(x);
+			}
+		}
+	}
+	return {
+		stdout: I$1(c, l),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Le(e, n) {
+	let t = "", s = "|", r = "", o = [];
+	for (let g = 0; g < e.length; g++) {
+		let y = e[g];
+		(y === "-s" || y === "--sep") && g + 1 < e.length ? s = e[++g] : (y === "-r" || y === "--rename") && g + 1 < e.length ? r = e[++g] : y.startsWith("-") || (t ? o.push(y) : t = y);
+	}
+	if (!t) return {
+		stdout: "",
+		stderr: `xan implode: usage: xan implode COLUMN [FILE]
+`,
+		exitCode: 1
+	};
+	let { headers: a, data: d, error: u } = await g(o, n);
+	if (u) return u;
+	if (!a.includes(t)) return {
+		stdout: "",
+		stderr: `xan implode: column '${t}' not found
+`,
+		exitCode: 1
+	};
+	let p = a.filter((g) => g !== t), c = r ? a.map((g) => g === t ? r : g) : a, h = r || t, l = [], i = null, f = [], m = null;
+	for (let g of d) {
+		let y = p.map((N) => String(g[N] ?? "")).join("\0"), x = g[t], k = x == null ? "" : String(x);
+		if (y !== i) {
+			if (m !== null) {
+				let N = b(m);
+				r && delete N[t], E$1(N, h, f.join(s)), l.push(N);
+			}
+			i = y, f = [k], m = g;
+		} else f.push(k);
+	}
+	if (m !== null) {
+		let g = b(m);
+		r && delete g[t], E$1(g, h, f.join(s)), l.push(g);
+	}
+	return {
+		stdout: I$1(c, l),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Pe(e, n) {
+	let t = "", s = "", r = "", o = "", a = "inner", d = "", u = 0;
+	for (let C = 0; C < e.length; C++) {
+		let A = e[C];
+		A === "--left" ? a = "left" : A === "--right" ? a = "right" : A === "--full" ? a = "full" : (A === "-D" || A === "--default") && C + 1 < e.length ? d = e[++C] : A.startsWith("-") || (u++, u === 1 ? t = A : u === 2 ? s = A : u === 3 ? r = A : u === 4 && (o = A));
+	}
+	if (!t || !s || !r || !o) return {
+		stdout: "",
+		stderr: `xan join: usage: xan join KEY1 FILE1 KEY2 FILE2 [OPTIONS]
+`,
+		exitCode: 1
+	};
+	let p = await g([s], n);
+	if (p.error) return p.error;
+	let c = await g([o], n);
+	if (c.error) return c.error;
+	let { headers: h, data: l } = p, { headers: i, data: f } = c;
+	if (!h.includes(t)) return {
+		stdout: "",
+		stderr: `xan join: column '${t}' not found in first file
+`,
+		exitCode: 1
+	};
+	if (!i.includes(r)) return {
+		stdout: "",
+		stderr: `xan join: column '${r}' not found in second file
+`,
+		exitCode: 1
+	};
+	let m = /* @__PURE__ */ new Map();
+	for (let C of f) {
+		let A = String(C[r] ?? "");
+		m.has(A) || m.set(A, []), m.get(A)?.push(C);
+	}
+	let g$1 = new Set(h), y = i.filter((C) => !g$1.has(C)), x = [...h, ...y], k = [], N = /* @__PURE__ */ new Set();
+	for (let C$1 of l) {
+		let A = String(C$1[t] ?? ""), j = m.get(A);
+		if (j && j.length > 0) {
+			N.add(A);
+			for (let L of j) {
+				let T = C();
+				for (let W of h) E$1(T, W, C$1[W]);
+				for (let W of y) E$1(T, W, L[W]);
+				k.push(T);
+			}
+		} else if (a === "left" || a === "full") {
+			let L = C();
+			for (let T of h) E$1(L, T, C$1[T]);
+			for (let T of y) E$1(L, T, d);
+			k.push(L);
+		}
+	}
+	if (a === "right" || a === "full") for (let C$2 of f) {
+		let A = String(C$2[r] ?? "");
+		if (!N.has(A)) {
+			let j = C();
+			for (let L of h) E$1(j, L, i.includes(L) ? C$2[L] : d);
+			for (let L of y) E$1(j, L, C$2[L]);
+			k.push(j);
+		}
+	}
+	return {
+		stdout: I$1(x, k),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Re(e, n) {
+	let t = "", s = "", r = [], o = [];
+	for (let y = 0; y < e.length; y++) {
+		let x = e[y];
+		(x === "-g" || x === "--groupby") && y + 1 < e.length ? r = e[++y].split(",").map((k) => k.trim()) : x.startsWith("-") || (t ? s ? o.push(x) : s = x : t = x);
+	}
+	if (!t || !s) return {
+		stdout: "",
+		stderr: `xan pivot: usage: xan pivot COLUMN AGG_EXPR [OPTIONS] [FILE]
+`,
+		exitCode: 1
+	};
+	let { headers: a, data: d, error: u } = await g(o, n);
+	if (u) return u;
+	if (!a.includes(t)) return {
+		stdout: "",
+		stderr: `xan pivot: column '${t}' not found
+`,
+		exitCode: 1
+	};
+	let p = s.match(/^(\w+)\((\w+)\)$/);
+	if (!p) return {
+		stdout: "",
+		stderr: `xan pivot: invalid aggregation expression '${s}'
+`,
+		exitCode: 1
+	};
+	let [, c, h] = p;
+	r.length === 0 && (r = a.filter((y) => y !== t && y !== h));
+	let l = [];
+	for (let y of d) {
+		let x = String(y[t] ?? "");
+		l.includes(x) || l.push(x);
+	}
+	let i = /* @__PURE__ */ new Map(), f = [];
+	for (let y of d) {
+		let x = r.map((A) => String(y[A] ?? "")).join("\0"), k = String(y[t] ?? ""), N = y[h];
+		i.has(x) || (i.set(x, /* @__PURE__ */ new Map()), f.push(x));
+		let C = i.get(x);
+		C && (C.has(k) || C.set(k, []), C.get(k)?.push(N));
+	}
+	let m = [...r, ...l], g$2 = [];
+	for (let y of f) {
+		let x = y.split("\0"), k = i.get(y);
+		if (!k) continue;
+		let N = C();
+		for (let C = 0; C < r.length; C++) E$1(N, r[C], x[C]);
+		for (let C of l) E$1(N, C, ut(c, k.get(C) || []));
+		g$2.push(N);
+	}
+	return {
+		stdout: I$1(m, g$2),
+		stderr: "",
+		exitCode: 0
+	};
+}
+function ut(e, n) {
+	let t = n.filter((s) => s != null).map((s) => typeof s == "number" ? s : Number.parseFloat(String(s))).filter((s) => !Number.isNaN(s));
+	switch (e) {
+		case "count": return n.length;
+		case "sum": return t.reduce((s, r) => s + r, 0);
+		case "mean":
+		case "avg": return t.length > 0 ? t.reduce((s, r) => s + r, 0) / t.length : null;
+		case "min": return t.length > 0 ? Math.min(...t) : null;
+		case "max": return t.length > 0 ? Math.max(...t) : null;
+		case "first": return n.length > 0 ? String(n[0] ?? "") : null;
+		case "last": return n.length > 0 ? String(n[n.length - 1] ?? "") : null;
+		default: return null;
+	}
+}
+async function Me(e, n) {
+	let t = "", s = [];
+	for (let d = 0; d < e.length; d++) {
+		let u = e[d];
+		(u === "-s" || u === "--sort") && d + 1 < e.length ? t = e[++d] : u.startsWith("-") || s.push(u);
+	}
+	if (s.length < 2) return {
+		stdout: "",
+		stderr: `xan merge: usage: xan merge [OPTIONS] FILE1 FILE2 ...
+`,
+		exitCode: 1
+	};
+	let r = [], o = null;
+	for (let d of s) {
+		let u = await g([d], n);
+		if (u.error) return u.error;
+		if (o === null) o = u.headers;
+		else if (JSON.stringify(o) !== JSON.stringify(u.headers)) return {
+			stdout: "",
+			stderr: `xan merge: all files must have the same headers
+`,
+			exitCode: 1
+		};
+		r.push({
+			headers: u.headers,
+			data: u.data
+		});
+	}
+	if (!o) return {
+		stdout: "",
+		stderr: "",
+		exitCode: 0
+	};
+	let a = [];
+	for (let { data: d } of r) a = a.concat(d);
+	if (t) {
+		if (!o.includes(t)) return {
+			stdout: "",
+			stderr: `xan merge: column '${t}' not found
+`,
+			exitCode: 1
+		};
+		a.sort((d, u) => {
+			let p = d[t], c = u[t], h = typeof p == "number" ? p : Number.parseFloat(String(p)), l = typeof c == "number" ? c : Number.parseFloat(String(c));
+			return !Number.isNaN(h) && !Number.isNaN(l) ? h - l : String(p ?? "").localeCompare(String(c ?? ""));
+		});
+	}
+	return {
+		stdout: I$1(o, a),
+		stderr: "",
+		exitCode: 0
+	};
+}
+V();
+async function $e(e, n) {
+	let { headers: s, data: r, error: o } = await g(e.filter((u) => !u.startsWith("-")), n);
+	return o || (r.length === 0 ? {
+		stdout: "",
+		stderr: "",
+		exitCode: 0
+	} : {
+		stdout: r.map((u) => s.map((p) => u[p])).map((u) => u.map((p) => ct(p)).join(",")).join(`
+`) + `
+`,
+		stderr: "",
+		exitCode: 0
+	});
+}
+function ct(e) {
+	if (e == null) return "";
+	let n = String(e);
+	return n.includes(",") || n.includes("\"") || n.includes(`
+`) ? `"${n.replace(/"/g, "\"\"")}"` : n;
+}
+async function Te(e, n) {
+	let t = null, s = null, r = [];
+	for (let l = 0; l < e.length; l++) {
+		let i = e[l];
+		if (i === "--seed" && l + 1 < e.length) s = Number.parseInt(e[++l], 10);
+		else if (!i.startsWith("-")) {
+			let f = Number.parseInt(i, 10);
+			t === null && !Number.isNaN(f) && f > 0 ? t = f : r.push(i);
+		}
+	}
+	if (t === null) return {
+		stdout: "",
+		stderr: `xan sample: usage: xan sample <sample-size> [FILE]
+`,
+		exitCode: 1
+	};
+	let { headers: o, data: a, error: d } = await g(r, n);
+	if (d) return d;
+	if (a.length <= t) return {
+		stdout: I$1(o, a),
+		stderr: "",
+		exitCode: 0
+	};
+	let u = s !== null ? s : Date.now(), p = () => (u = u * 1103515245 + 12345 & 2147483647, u / 2147483647), c = a.map((l, i) => i);
+	for (let l = c.length - 1; l > 0; l--) {
+		let i = Math.floor(p() * (l + 1));
+		[c[l], c[i]] = [c[i], c[l]];
+	}
+	return {
+		stdout: I$1(o, c.slice(0, t).sort((l, i) => l - i).map((l) => a[l])),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function je(e, n) {
+	let t = !1, s = [];
+	for (let u = 0; u < e.length; u++) {
+		let p = e[u];
+		p === "-p" || p === "--pad" ? t = !0 : p.startsWith("-") || s.push(p);
+	}
+	if (s.length === 0) return {
+		stdout: "",
+		stderr: `xan cat: no files specified
+`,
+		exitCode: 1
+	};
+	let r = await w(n, s, {
+		cmdName: "xan cat",
+		stopOnError: !0
+	});
+	if (r.exitCode !== 0) return {
+		stdout: "",
+		stderr: r.stderr,
+		exitCode: r.exitCode
+	};
+	let o = [], a = [];
+	for (let { content: u } of r.files) {
+		let { headers: p, data: c } = S$2(x(u));
+		o.push({
+			headers: p,
+			data: c
+		});
+		for (let h of p) a.includes(h) || a.push(h);
+	}
+	if (!t) {
+		let u = JSON.stringify(o[0].headers);
+		for (let p = 1; p < o.length; p++) if (JSON.stringify(o[p].headers) !== u) return {
+			stdout: "",
+			stderr: `xan cat: headers do not match (use -p to pad)
+`,
+			exitCode: 1
+		};
+		a = o[0].headers;
+	}
+	let d = [];
+	for (let { headers: u, data: p } of o) for (let c of p) {
+		let h = C();
+		for (let l of a) E$1(h, l, u.includes(l) ? c[l] : "");
+		d.push(h);
+	}
+	return {
+		stdout: I$1(a, d),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function De(e, n) {
+	let t = "", s = [], r = !1, o = !1, a = [];
+	for (let i = 0; i < e.length; i++) {
+		let f = e[i];
+		(f === "-s" || f === "--select") && i + 1 < e.length ? s = e[++i].split(",") : f === "-v" || f === "--invert" ? r = !0 : f === "-i" || f === "--ignore-case" ? o = !0 : f === "-r" || f === "--regex" || f.startsWith("-") || (t ? a.push(f) : t = f);
+	}
+	if (!t) return {
+		stdout: "",
+		stderr: `xan search: no pattern specified
+`,
+		exitCode: 1
+	};
+	let { headers: d, data: u, error: p } = await g(a, n);
+	if (p) return p;
+	let c = s.length > 0 ? s : d, h;
+	try {
+		h = I1(t, o ? "i" : "");
+	} catch {
+		return {
+			stdout: "",
+			stderr: `xan search: invalid regex pattern '${t}'
+`,
+			exitCode: 1
+		};
+	}
+	return {
+		stdout: I$1(d, u.filter((i) => {
+			let f = c.some((m) => {
+				let g = i[m];
+				return g != null && h.test(String(g));
+			});
+			return r ? !f : f;
+		})),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Ue(e, n) {
+	let t = "", s = [];
+	for (let l of e) l.startsWith("-") || (t ? s.push(l) : t = l);
+	if (!t) return {
+		stdout: "",
+		stderr: `xan flatmap: no expression specified
+`,
+		exitCode: 1
+	};
+	let { headers: r, data: o, error: a } = await g(s, n);
+	if (a) return a;
+	let u = U(t).map(({ expr: l, name: i }) => ({
+		alias: typeof i == "string" ? i : i[0],
+		ast: O(l)
+	})), p = { limits: n.limits ? { maxIterations: n.limits.maxJqIterations } : void 0 }, c = [...r, ...u.map((l) => l.alias)], h = [];
+	for (let l of o) {
+		let i = [], f = 1;
+		for (let m of u) {
+			let g = d(l, m.ast, p), y = g.length > 0 && Array.isArray(g[0]) ? g[0] : g;
+			i.push(y), f = Math.max(f, y.length);
+		}
+		for (let m = 0; m < f; m++) {
+			let g = b(l);
+			for (let y = 0; y < u.length; y++) {
+				let x = i[y][m] ?? null;
+				E$1(g, u[y].alias, x);
+			}
+			h.push(g);
+		}
+	}
+	return {
+		stdout: I$1(c, h),
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function Ve(e, n) {
+	let { cmdView: t } = await import("./xan-view-HDVKHFC2-DhDNVE_V.mjs");
+	return t(e, n);
+}
+var Qe = new Set([
+	"fuzzy-join",
+	"glob",
+	"hist",
+	"input",
+	"parallel",
+	"plot",
+	"progress",
+	"range",
+	"scrape",
+	"tokenize",
+	"union-find"
+]), pt = new Set([
+	"agg",
+	"behead",
+	"cat",
+	"count",
+	"dedup",
+	"drop",
+	"enum",
+	"explode",
+	"f",
+	"filter",
+	"fixlengths",
+	"flatmap",
+	"flatten",
+	"fmt",
+	"frequency",
+	"freq",
+	"from",
+	"groupby",
+	"head",
+	"headers",
+	"implode",
+	"join",
+	"map",
+	"merge",
+	"partition",
+	"pivot",
+	"rename",
+	"reverse",
+	"sample",
+	"search",
+	"select",
+	"shuffle",
+	"slice",
+	"sort",
+	"split",
+	"stats",
+	"tail",
+	"to",
+	"top",
+	"transform",
+	"transpose",
+	"view",
+	...Qe
+]), Ze = {
+	name: "xan",
+	summary: "CSV toolkit for data manipulation",
+	usage: "xan <COMMAND> [OPTIONS] [FILE]",
+	description: `xan is a collection of commands for working with CSV data.
+It provides a simple, ergonomic interface for common data operations.
+
+COMMANDS:
+  Core:
+    headers    Show column names
+    count      Count rows
+    head       Show first N rows
+    tail       Show last N rows
+    slice      Extract row range
+    reverse    Reverse row order
+    behead     Remove header row
+    sample     Random sample of rows
+
+  Column operations:
+    select     Select columns (supports glob, ranges, negation)
+    drop       Drop columns
+    rename     Rename columns
+    enum       Add row index column
+
+  Row operations:
+    filter     Filter rows by expression
+    search     Filter rows by regex match
+    sort       Sort rows
+    dedup      Remove duplicates
+    top        Get top N by column
+
+  Transformations:
+    map        Add computed columns
+    transform  Modify existing columns
+    explode    Split column into multiple rows
+    implode    Combine rows, join column values
+    flatmap    Map returning multiple rows
+    pivot      Reshape rows into columns
+    transpose  Swap rows and columns
+
+  Aggregation:
+    agg        Aggregate values
+    groupby    Group and aggregate
+    frequency  Count value occurrences
+    stats      Show column statistics
+
+  Multi-file:
+    cat        Concatenate CSV files
+    join       Join two CSV files on key
+    merge      Merge sorted CSV files
+    split      Split into multiple files
+    partition  Split by column value
+
+  Data conversion:
+    to         Convert CSV to other formats (json)
+    from       Convert other formats to CSV (json)
+    shuffle    Randomly reorder rows
+    fixlengths Fix ragged CSV files
+
+  Output:
+    view       Pretty print as table
+    flatten    Display records vertically (alias: f)
+    fmt        Format output
+
+EXAMPLES:
+  xan headers data.csv
+  xan count data.csv
+  xan head -n 5 data.csv
+  xan select name,email data.csv
+  xan select 'vec_*' data.csv          # glob pattern
+  xan select 'a:c' data.csv            # column range
+  xan filter 'age > 30' data.csv
+  xan search -r '^foo' data.csv
+  xan sort -N price data.csv
+  xan agg 'sum(amount) as total' data.csv
+  xan groupby region 'count() as n' data.csv
+  xan explode tags data.csv
+  xan join id file1.csv id file2.csv
+  xan pivot year 'sum(sales)' data.csv`,
+	options: ["    --help    display this help and exit"]
+}, ft = {
+	headers: {
+		name: "xan headers",
+		summary: "Show column names",
+		usage: "xan headers [OPTIONS] [FILE]",
+		description: "Display column names from a CSV file.",
+		options: ["-j, --just-names    show names only (no index)"]
+	},
+	count: {
+		name: "xan count",
+		summary: "Count rows",
+		usage: "xan count [FILE]",
+		description: "Count the number of data rows (excluding header).",
+		options: []
+	},
+	filter: {
+		name: "xan filter",
+		summary: "Filter rows by expression",
+		usage: "xan filter [OPTIONS] EXPR [FILE]",
+		description: "Filter CSV rows using moonblade expressions.",
+		options: ["-v, --invert    invert match", "-l, --limit N   limit output rows"]
+	},
+	search: {
+		name: "xan search",
+		summary: "Filter rows by regex",
+		usage: "xan search [OPTIONS] PATTERN [FILE]",
+		description: "Filter CSV rows by regex match on columns.",
+		options: [
+			"-s, --select COLS   search only these columns",
+			"-v, --invert        invert match",
+			"-i, --ignore-case   case insensitive"
+		]
+	},
+	select: {
+		name: "xan select",
+		summary: "Select columns",
+		usage: "xan select COLS [FILE]",
+		description: "Select columns by name, index, glob, or range.",
+		options: ["Supports: col names, indices (0,1), ranges (a:c), globs (vec_*), negation (!col)"]
+	},
+	explode: {
+		name: "xan explode",
+		summary: "Split column into rows",
+		usage: "xan explode COLUMN [OPTIONS] [FILE]",
+		description: "Split delimited column values into multiple rows.",
+		options: [
+			"-s, --separator SEP  separator (default: |)",
+			"--drop-empty         drop empty values",
+			"-r, --rename NAME    rename column"
+		]
+	},
+	implode: {
+		name: "xan implode",
+		summary: "Combine rows",
+		usage: "xan implode COLUMN [OPTIONS] [FILE]",
+		description: "Combine consecutive rows, joining column values.",
+		options: ["-s, --sep SEP        separator (default: |)", "-r, --rename NAME    rename column"]
+	},
+	join: {
+		name: "xan join",
+		summary: "Join CSV files",
+		usage: "xan join KEY1 FILE1 KEY2 FILE2 [OPTIONS]",
+		description: "Join two CSV files on key columns.",
+		options: [
+			"--left               left outer join",
+			"--right              right outer join",
+			"--full               full outer join",
+			"-D, --default VAL    default for missing"
+		]
+	},
+	pivot: {
+		name: "xan pivot",
+		summary: "Reshape to columns",
+		usage: "xan pivot COLUMN AGG_EXPR [OPTIONS] [FILE]",
+		description: "Turn row values into columns.",
+		options: ["-g, --groupby COLS   group by columns"]
+	}
+}, yn = {
+	name: "xan",
+	async execute(e, n) {
+		if (e.length === 0 || o(e)) return s(Ze);
+		let t = e[0], s$2 = e.slice(1);
+		if (o(s$2)) {
+			let r = ft[t];
+			return r ? s(r) : s(Ze);
+		}
+		if (Qe.has(t)) return {
+			stdout: "",
+			stderr: `xan ${t}: not yet implemented
+`,
+			exitCode: 1
+		};
+		switch (t) {
+			case "headers": return ce(s$2, n);
+			case "count": return pe(s$2, n);
+			case "head": return fe(s$2, n);
+			case "tail": return de(s$2, n);
+			case "slice": return he(s$2, n);
+			case "reverse": return me(s$2, n);
+			case "behead": return $e(s$2, n);
+			case "sample": return Te(s$2, n);
+			case "select": return ie(s$2, n);
+			case "drop": return ae(s$2, n);
+			case "rename": return le(s$2, n);
+			case "enum": return ue(s$2, n);
+			case "filter": return ke(s$2, n);
+			case "search": return De(s$2, n);
+			case "sort": return Ie(s$2, n);
+			case "dedup": return Ne(s$2, n);
+			case "top": return Ee(s$2, n);
+			case "map": return Ae(s$2, n);
+			case "transform": return Fe(s$2, n);
+			case "explode": return Oe(s$2, n);
+			case "implode": return Le(s$2, n);
+			case "flatmap": return Ue(s$2, n);
+			case "pivot": return Re(s$2, n);
+			case "agg": return ne(s$2, n);
+			case "groupby": return se(s$2, n);
+			case "frequency":
+			case "freq": return re(s$2, n);
+			case "stats": return oe(s$2, n);
+			case "cat": return je(s$2, n);
+			case "join": return Pe(s$2, n);
+			case "merge": return Me(s$2, n);
+			case "split": return ve(s$2, n);
+			case "partition": return Ce(s$2, n);
+			case "to": return be(s$2, n);
+			case "from": return Se(s$2, n);
+			case "transpose": return ye(s$2, n);
+			case "shuffle": return xe(s$2, n);
+			case "fixlengths": return we(s$2, n);
+			case "view": return A(s$2, n);
+			case "flatten":
+			case "f": return N(s$2, n);
+			case "fmt": return Ve(s$2, n);
+			default: return pt.has(t) ? {
+				stdout: "",
+				stderr: `xan ${t}: not yet implemented
+`,
+				exitCode: 1
+			} : {
+				stdout: "",
+				stderr: `xan: unknown command '${t}'
+Run 'xan --help' for usage.
+`,
+				exitCode: 1
+			};
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/xan-Y6WF3IRG.js
+createRequire(import.meta.url);
+//#endregion
+export { yn as xanCommand };
+
+//# sourceMappingURL=xan-Y6WF3IRG-DjKO96Pj.mjs.map