@keystrokehq/keystroke 0.1.32 → 0.1.34

package/dist/chunk-ZZKH2ELC-Dm1TMkxv.mjs

@@ -0,0 +1,1370 @@
+import { O as r } from "./dist-9SXOJb9L.mjs";
+import { t as I1 } from "./chunk-4RUAZWKT-CISqwIli.mjs";
+import { r as s, t as o } from "./chunk-QAYAQNCG-B1r1SmqS.mjs";
+import { t as x } from "./chunk-TDD4NFYE-Djy1ztDY.mjs";
+import { t as u } from "./chunk-AQ6FYS2X-BQ5Y2cHL.mjs";
+import { n as i, r as r$1, t as h } from "./chunk-27JIFWUR-C_jDOm1q.mjs";
+import { createRequire } from "node:module";
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-ZZKH2ELC.js
+createRequire(import.meta.url);
+function k(e, t) {
+	switch (e.type) {
+		case "name": {
+			let n = e.pattern, a = n.match(/^\*(\.[a-zA-Z0-9]+)$/);
+			if (a) {
+				let s = a[1], o = t.name;
+				if (e.ignoreCase) {
+					if (!o.toLowerCase().endsWith(s.toLowerCase())) return {
+						matches: !1,
+						pruned: !1,
+						printed: !1
+					};
+				} else if (!o.endsWith(s)) return {
+					matches: !1,
+					pruned: !1,
+					printed: !1
+				};
+				return {
+					matches: !0,
+					pruned: !1,
+					printed: !1
+				};
+			}
+			return {
+				matches: u(t.name, n, e.ignoreCase),
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "path": {
+			let n = e.pattern, a = t.relativePath, s = n.split("/");
+			for (let i = 0; i < s.length - 1; i++) {
+				let r = s[i];
+				if (r && r !== "." && r !== ".." && !r.includes("*") && !r.includes("?") && !r.includes("[")) {
+					let p = `/${r}/`;
+					if (e.ignoreCase) {
+						if (!a.toLowerCase().includes(p.toLowerCase())) return {
+							matches: !1,
+							pruned: !1,
+							printed: !1
+						};
+					} else if (!a.includes(p)) return {
+						matches: !1,
+						pruned: !1,
+						printed: !1
+					};
+				}
+			}
+			let o = n.match(/\*(\.[a-zA-Z0-9]+)$/);
+			if (o) {
+				let i = o[1];
+				if (e.ignoreCase) {
+					if (!a.toLowerCase().endsWith(i.toLowerCase())) return {
+						matches: !1,
+						pruned: !1,
+						printed: !1
+					};
+				} else if (!a.endsWith(i)) return {
+					matches: !1,
+					pruned: !1,
+					printed: !1
+				};
+			}
+			return {
+				matches: u(a, n, e.ignoreCase),
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "regex": try {
+			let n = e.ignoreCase ? "i" : "";
+			return {
+				matches: I1(e.pattern, n).test(t.relativePath),
+				pruned: !1,
+				printed: !1
+			};
+		} catch {
+			return {
+				matches: !1,
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "type": return e.fileType === "f" ? {
+			matches: t.isFile,
+			pruned: !1,
+			printed: !1
+		} : e.fileType === "d" ? {
+			matches: t.isDirectory,
+			pruned: !1,
+			printed: !1
+		} : {
+			matches: !1,
+			pruned: !1,
+			printed: !1
+		};
+		case "empty": return {
+			matches: t.isEmpty,
+			pruned: !1,
+			printed: !1
+		};
+		case "mtime": {
+			let a = (Date.now() - t.mtime) / (1e3 * 60 * 60 * 24), s;
+			return e.comparison === "more" ? s = a > e.days : e.comparison === "less" ? s = a < e.days : s = Math.floor(a) === e.days, {
+				matches: s,
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "newer": {
+			let n = t.newerRefTimes.get(e.refPath);
+			return n === void 0 ? {
+				matches: !1,
+				pruned: !1,
+				printed: !1
+			} : {
+				matches: t.mtime > n,
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "size": {
+			let n = e.value;
+			switch (e.unit) {
+				case "c":
+					n = e.value;
+					break;
+				case "k":
+					n = e.value * 1024;
+					break;
+				case "M":
+					n = e.value * 1024 * 1024;
+					break;
+				case "G":
+					n = e.value * 1024 * 1024 * 1024;
+					break;
+				case "b":
+					n = e.value * 512;
+					break;
+			}
+			let a;
+			return e.comparison === "more" ? a = t.size > n : e.comparison === "less" ? a = t.size < n : e.unit === "b" ? a = Math.ceil(t.size / 512) === e.value : a = t.size === n, {
+				matches: a,
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "perm": {
+			let n = t.mode & 511, a = e.mode & 511, s;
+			return e.matchType === "exact" ? s = n === a : e.matchType === "all" ? s = (n & a) === a : s = (n & a) !== 0, {
+				matches: s,
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "prune": return {
+			matches: !0,
+			pruned: !0,
+			printed: !1
+		};
+		case "print": return {
+			matches: !0,
+			pruned: !1,
+			printed: !0
+		};
+		case "not": {
+			let n = k(e.expr, t);
+			return {
+				matches: !n.matches,
+				pruned: n.pruned,
+				printed: !1
+			};
+		}
+		case "and": {
+			let n = k(e.left, t);
+			if (!n.matches) return {
+				matches: !1,
+				pruned: n.pruned,
+				printed: !1
+			};
+			let a = k(e.right, t);
+			return {
+				matches: a.matches,
+				pruned: n.pruned || a.pruned,
+				printed: n.printed || a.printed
+			};
+		}
+		case "or": {
+			let n = k(e.left, t);
+			if (n.matches) return n;
+			let a = k(e.right, t);
+			return {
+				matches: a.matches,
+				pruned: n.pruned || a.pruned,
+				printed: a.printed
+			};
+		}
+	}
+}
+function _(e) {
+	if (!e) return !1;
+	switch (e.type) {
+		case "name":
+		case "path":
+		case "regex":
+		case "type":
+		case "prune":
+		case "print": return !1;
+		case "empty":
+		case "mtime":
+		case "newer":
+		case "size":
+		case "perm": return !0;
+		case "not": return _(e.expr);
+		case "and":
+		case "or": return _(e.left) || _(e.right);
+	}
+}
+function j(e) {
+	if (!e) return !1;
+	switch (e.type) {
+		case "empty": return !0;
+		case "not": return j(e.expr);
+		case "and":
+		case "or": return j(e.left) || j(e.right);
+		default: return !1;
+	}
+}
+function ue(e) {
+	let t = {
+		terminalDirName: null,
+		requiredExtension: null
+	};
+	if (!e) return t;
+	let n = Ee(e);
+	if (Me(e) && n.length === 1) {
+		let o = n[0].split("/").filter((i) => i.length > 0);
+		if (o.length >= 2) for (let i = o.length - 2; i >= 0; i--) {
+			let r = o[i];
+			if (!r.includes("*") && !r.includes("?") && !r.includes("[") && r !== "." && r !== "..") {
+				let p = o[i + 1];
+				if (p && (p.includes("*") || p.includes("?"))) {
+					t.terminalDirName = r;
+					let l = p.match(/^\*(\.[a-zA-Z0-9]+)$/);
+					l && (t.requiredExtension = l[1]);
+				}
+				break;
+			}
+		}
+	}
+	return t;
+}
+function Ee(e) {
+	let t = [], n = (a) => {
+		a.type === "path" ? t.push(a.pattern) : a.type === "not" ? n(a.expr) : (a.type === "and" || a.type === "or") && (n(a.left), n(a.right));
+	};
+	return n(e), t;
+}
+function Me(e) {
+	let t = (n) => n.type === "type" && n.fileType === "f" ? !0 : n.type === "not" ? t(n.expr) : n.type === "and" || n.type === "or" ? t(n.left) || t(n.right) : !1;
+	return t(e);
+}
+function he(e) {
+	let t = [], n = (a) => {
+		a && (a.type === "newer" ? t.push(a.refPath) : a.type === "not" ? n(a.expr) : (a.type === "and" || a.type === "or") && (n(a.left), n(a.right)));
+	};
+	return n(e), t;
+}
+function J(e) {
+	if (!e) return !0;
+	switch (e.type) {
+		case "name":
+		case "path":
+		case "regex":
+		case "type":
+		case "prune":
+		case "print": return !0;
+		case "empty":
+		case "mtime":
+		case "newer":
+		case "size":
+		case "perm": return !1;
+		case "not": return J(e.expr);
+		case "and":
+		case "or": return J(e.left) && J(e.right);
+	}
+}
+function L(e, t, n, a, s) {
+	switch (e.type) {
+		case "name": {
+			let o = e.pattern, i = o.match(/^\*(\.[a-zA-Z0-9]+)$/);
+			if (i) {
+				let r = i[1];
+				if (e.ignoreCase) {
+					if (!t.toLowerCase().endsWith(r.toLowerCase())) return {
+						matches: !1,
+						pruned: !1,
+						printed: !1
+					};
+				} else if (!t.endsWith(r)) return {
+					matches: !1,
+					pruned: !1,
+					printed: !1
+				};
+				return {
+					matches: !0,
+					pruned: !1,
+					printed: !1
+				};
+			}
+			return {
+				matches: u(t, o, e.ignoreCase),
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "path": {
+			let o = e.pattern, i = o.split("/");
+			for (let p = 0; p < i.length - 1; p++) {
+				let l = i[p];
+				if (l && l !== "." && l !== ".." && !l.includes("*") && !l.includes("?") && !l.includes("[")) {
+					let d = `/${l}/`;
+					if (e.ignoreCase) {
+						if (!n.toLowerCase().includes(d.toLowerCase())) return {
+							matches: !1,
+							pruned: !1,
+							printed: !1
+						};
+					} else if (!n.includes(d)) return {
+						matches: !1,
+						pruned: !1,
+						printed: !1
+					};
+				}
+			}
+			let r = o.match(/\*(\.[a-zA-Z0-9]+)$/);
+			if (r) {
+				let p = r[1];
+				if (e.ignoreCase) {
+					if (!n.toLowerCase().endsWith(p.toLowerCase())) return {
+						matches: !1,
+						pruned: !1,
+						printed: !1
+					};
+				} else if (!n.endsWith(p)) return {
+					matches: !1,
+					pruned: !1,
+					printed: !1
+				};
+			}
+			return {
+				matches: u(n, o, e.ignoreCase),
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "regex": try {
+			let o = e.ignoreCase ? "i" : "";
+			return {
+				matches: I1(e.pattern, o).test(n),
+				pruned: !1,
+				printed: !1
+			};
+		} catch {
+			return {
+				matches: !1,
+				pruned: !1,
+				printed: !1
+			};
+		}
+		case "type": return e.fileType === "f" ? {
+			matches: a,
+			pruned: !1,
+			printed: !1
+		} : e.fileType === "d" ? {
+			matches: s,
+			pruned: !1,
+			printed: !1
+		} : {
+			matches: !1,
+			pruned: !1,
+			printed: !1
+		};
+		case "prune": return {
+			matches: !0,
+			pruned: !0,
+			printed: !1
+		};
+		case "print": return {
+			matches: !0,
+			pruned: !1,
+			printed: !0
+		};
+		case "not": {
+			let o = L(e.expr, t, n, a, s);
+			return {
+				matches: !o.matches,
+				pruned: o.pruned,
+				printed: !1
+			};
+		}
+		case "and": {
+			let o = L(e.left, t, n, a, s);
+			if (!o.matches) return {
+				matches: !1,
+				pruned: o.pruned,
+				printed: !1
+			};
+			let i = L(e.right, t, n, a, s);
+			return {
+				matches: i.matches,
+				pruned: o.pruned || i.pruned,
+				printed: o.printed || i.printed
+			};
+		}
+		case "or": {
+			let o = L(e.left, t, n, a, s);
+			if (o.matches) return o;
+			let i = L(e.right, t, n, a, s);
+			return {
+				matches: i.matches,
+				pruned: o.pruned || i.pruned,
+				printed: i.printed
+			};
+		}
+		default: return {
+			matches: !1,
+			pruned: !1,
+			printed: !1
+		};
+	}
+}
+function V(e) {
+	if (!e) return !1;
+	switch (e.type) {
+		case "prune": return !0;
+		case "not": return V(e.expr);
+		case "and":
+		case "or": return V(e.left) || V(e.right);
+		default: return !1;
+	}
+}
+function z(e) {
+	switch (e.type) {
+		case "name":
+		case "path":
+		case "regex":
+		case "type":
+		case "prune":
+		case "print": return !0;
+		case "empty":
+		case "mtime":
+		case "newer":
+		case "size":
+		case "perm": return !1;
+		case "not": return z(e.expr);
+		case "and":
+		case "or": return z(e.left) && z(e.right);
+	}
+}
+function de(e, t) {
+	if (!e || !t.isDirectory) return { shouldPrune: !1 };
+	if (!z(e)) return se(e, t);
+	return { shouldPrune: k(e, {
+		name: t.name,
+		relativePath: t.relativePath,
+		isFile: t.isFile,
+		isDirectory: t.isDirectory,
+		isEmpty: !1,
+		mtime: 0,
+		size: 0,
+		mode: 0,
+		newerRefTimes: /* @__PURE__ */ new Map()
+	}).pruned };
+}
+function se(e, t) {
+	switch (e.type) {
+		case "or":
+			if (z(e.left)) {
+				let n = {
+					name: t.name,
+					relativePath: t.relativePath,
+					isFile: t.isFile,
+					isDirectory: t.isDirectory,
+					isEmpty: !1,
+					mtime: 0,
+					size: 0,
+					mode: 0,
+					newerRefTimes: /* @__PURE__ */ new Map()
+				};
+				if (k(e.left, n).pruned) return { shouldPrune: !0 };
+			}
+			return se(e.right, t);
+		case "and":
+			if (z(e.left) && z(e.right)) return { shouldPrune: k(e, {
+				name: t.name,
+				relativePath: t.relativePath,
+				isFile: t.isFile,
+				isDirectory: t.isDirectory,
+				isEmpty: !1,
+				mtime: 0,
+				size: 0,
+				mode: 0,
+				newerRefTimes: /* @__PURE__ */ new Map()
+			}).pruned };
+			if (z(e.left)) {
+				let n = {
+					name: t.name,
+					relativePath: t.relativePath,
+					isFile: t.isFile,
+					isDirectory: t.isDirectory,
+					isEmpty: !1,
+					mtime: 0,
+					size: 0,
+					mode: 0,
+					newerRefTimes: /* @__PURE__ */ new Map()
+				};
+				return k(e.left, n).matches ? se(e.right, t) : { shouldPrune: !1 };
+			}
+			return { shouldPrune: !1 };
+		case "not": return { shouldPrune: !1 };
+		default: return { shouldPrune: !1 };
+	}
+}
+function me(e, t) {
+	let n = [], a = [], s = t;
+	for (; s < e.length;) {
+		let i = e[s];
+		if (i === "(" || i === "\\(") {
+			n.push({ type: "lparen" }), s++;
+			continue;
+		}
+		if (i === ")" || i === "\\)") {
+			n.push({ type: "rparen" }), s++;
+			continue;
+		}
+		if (i === "-name" && s + 1 < e.length) n.push({
+			type: "expr",
+			expr: {
+				type: "name",
+				pattern: e[++s]
+			}
+		});
+		else if (i === "-iname" && s + 1 < e.length) n.push({
+			type: "expr",
+			expr: {
+				type: "name",
+				pattern: e[++s],
+				ignoreCase: !0
+			}
+		});
+		else if (i === "-path" && s + 1 < e.length) n.push({
+			type: "expr",
+			expr: {
+				type: "path",
+				pattern: e[++s]
+			}
+		});
+		else if (i === "-ipath" && s + 1 < e.length) n.push({
+			type: "expr",
+			expr: {
+				type: "path",
+				pattern: e[++s],
+				ignoreCase: !0
+			}
+		});
+		else if (i === "-regex" && s + 1 < e.length) n.push({
+			type: "expr",
+			expr: {
+				type: "regex",
+				pattern: e[++s]
+			}
+		});
+		else if (i === "-iregex" && s + 1 < e.length) n.push({
+			type: "expr",
+			expr: {
+				type: "regex",
+				pattern: e[++s],
+				ignoreCase: !0
+			}
+		});
+		else if (i === "-type" && s + 1 < e.length) {
+			let r = e[++s];
+			if (r === "f" || r === "d") n.push({
+				type: "expr",
+				expr: {
+					type: "type",
+					fileType: r
+				}
+			});
+			else return {
+				expr: null,
+				pathIndex: s,
+				error: `find: Unknown argument to -type: ${r}
+`,
+				actions: []
+			};
+		} else if (i === "-empty") n.push({
+			type: "expr",
+			expr: { type: "empty" }
+		});
+		else if (i === "-mtime" && s + 1 < e.length) {
+			let r = e[++s], p = "exact", l = r;
+			r.startsWith("+") ? (p = "more", l = r.slice(1)) : r.startsWith("-") && (p = "less", l = r.slice(1));
+			let d = parseInt(l, 10);
+			Number.isNaN(d) || n.push({
+				type: "expr",
+				expr: {
+					type: "mtime",
+					days: d,
+					comparison: p
+				}
+			});
+		} else if (i === "-newer" && s + 1 < e.length) {
+			let r = e[++s];
+			n.push({
+				type: "expr",
+				expr: {
+					type: "newer",
+					refPath: r
+				}
+			});
+		} else if (i === "-size" && s + 1 < e.length) {
+			let r = e[++s], p = "exact", l = r;
+			r.startsWith("+") ? (p = "more", l = r.slice(1)) : r.startsWith("-") && (p = "less", l = r.slice(1));
+			let d = l.match(/^(\d+)([ckMGb])?$/);
+			if (d) {
+				let O = parseInt(d[1], 10), x = d[2] || "b";
+				n.push({
+					type: "expr",
+					expr: {
+						type: "size",
+						value: O,
+						unit: x,
+						comparison: p
+					}
+				});
+			}
+		} else if (i === "-perm" && s + 1 < e.length) {
+			let r = e[++s], p = "exact", l = r;
+			r.startsWith("-") ? (p = "all", l = r.slice(1)) : r.startsWith("/") && (p = "any", l = r.slice(1));
+			let d = parseInt(l, 8);
+			Number.isNaN(d) || n.push({
+				type: "expr",
+				expr: {
+					type: "perm",
+					mode: d,
+					matchType: p
+				}
+			});
+		} else if (i === "-prune") n.push({
+			type: "expr",
+			expr: { type: "prune" }
+		});
+		else if (i === "-not" || i === "!") n.push({ type: "not" });
+		else if (i === "-o" || i === "-or") n.push({
+			type: "op",
+			op: "or"
+		});
+		else if (i === "-a" || i === "-and") n.push({
+			type: "op",
+			op: "and"
+		});
+		else if (i === "-maxdepth" || i === "-mindepth") s++;
+		else if (i !== "-depth") if (i === "-exec") {
+			let r = [];
+			for (s++; s < e.length && e[s] !== ";" && e[s] !== "+";) r.push(e[s]), s++;
+			if (s >= e.length) return {
+				expr: null,
+				pathIndex: s,
+				error: "find: missing argument to `-exec'\n",
+				actions: []
+			};
+			let p = e[s] === "+";
+			a.push({
+				type: "exec",
+				command: r,
+				batchMode: p
+			});
+		} else if (i === "-print") n.push({
+			type: "expr",
+			expr: { type: "print" }
+		}), a.push({ type: "print" });
+		else if (i === "-print0") a.push({ type: "print0" });
+		else if (i === "-printf" && s + 1 < e.length) {
+			let r = e[++s];
+			a.push({
+				type: "printf",
+				format: r
+			});
+		} else if (i === "-delete") a.push({ type: "delete" });
+		else {
+			if (i.startsWith("-")) return {
+				expr: null,
+				pathIndex: s,
+				error: `find: unknown predicate '${i}'
+`,
+				actions: []
+			};
+			if (n.length === 0) {
+				s++;
+				continue;
+			}
+			break;
+		}
+		s++;
+	}
+	if (n.length === 0) return {
+		expr: null,
+		pathIndex: s,
+		actions: a
+	};
+	let o = Fe(n);
+	return o.error ? {
+		expr: null,
+		pathIndex: s,
+		error: o.error,
+		actions: a
+	} : {
+		expr: o.expr,
+		pathIndex: s,
+		actions: a
+	};
+}
+function Fe(e) {
+	let t = 0;
+	function n() {
+		let r = a();
+		if (!r) return null;
+		for (; t < e.length;) {
+			let p = e[t];
+			if (p.type === "op" && p.op === "or") {
+				t++;
+				let l = a();
+				if (!l) return r;
+				r = {
+					type: "or",
+					left: r,
+					right: l
+				};
+			} else break;
+		}
+		return r;
+	}
+	function a() {
+		let r = s();
+		if (!r) return null;
+		for (; t < e.length;) {
+			let p = e[t];
+			if (p.type === "op" && p.op === "and") {
+				t++;
+				let l = s();
+				if (!l) return r;
+				r = {
+					type: "and",
+					left: r,
+					right: l
+				};
+			} else if (p.type === "expr" || p.type === "not" || p.type === "lparen") {
+				let l = s();
+				if (!l) return r;
+				r = {
+					type: "and",
+					left: r,
+					right: l
+				};
+			} else break;
+		}
+		return r;
+	}
+	function s() {
+		if (t < e.length && e[t].type === "not") {
+			t++;
+			let r = s();
+			return r ? {
+				type: "not",
+				expr: r
+			} : null;
+		}
+		return o();
+	}
+	function o() {
+		if (t >= e.length) return null;
+		let r = e[t];
+		if (r.type === "lparen") {
+			t++;
+			let p = n();
+			return t < e.length && e[t].type === "rparen" && t++, p;
+		}
+		return r.type === "expr" ? (t++, r.expr) : (r.type, null);
+	}
+	return { expr: n() };
+}
+var ye = 500;
+function Ie() {
+	return {
+		readdirCalls: 0,
+		readdirTime: 0,
+		statCalls: 0,
+		statTime: 0,
+		evalCalls: 0,
+		evalTime: 0,
+		nodeCount: 0,
+		batchCount: 0,
+		batchTime: 0,
+		earlyPrunes: 0
+	};
+}
+function xe(e, t, n) {
+	e({
+		category: "find",
+		name: "summary",
+		durationMs: n,
+		details: {
+			readdirCalls: t.readdirCalls,
+			readdirTimeMs: t.readdirTime,
+			statCalls: t.statCalls,
+			statTimeMs: t.statTime,
+			evalCalls: t.evalCalls,
+			evalTimeMs: t.evalTime,
+			nodeCount: t.nodeCount,
+			batchCount: t.batchCount,
+			batchTimeMs: t.batchTime,
+			earlyPrunes: t.earlyPrunes,
+			otherTimeMs: n - t.readdirTime - t.statTime - t.evalTime - t.batchTime
+		}
+	});
+}
+var $e = {
+	name: "find",
+	summary: "search for files in a directory hierarchy",
+	usage: "find [path...] [expression]",
+	options: [
+		"-name PATTERN    file name matches shell pattern PATTERN",
+		"-iname PATTERN   like -name but case insensitive",
+		"-path PATTERN    file path matches shell pattern PATTERN",
+		"-ipath PATTERN   like -path but case insensitive",
+		"-regex PATTERN   file path matches regular expression PATTERN",
+		"-iregex PATTERN  like -regex but case insensitive",
+		"-type TYPE       file is of type: f (regular file), d (directory)",
+		"-empty           file is empty or directory is empty",
+		"-mtime N         file's data was modified N*24 hours ago",
+		"-newer FILE      file was modified more recently than FILE",
+		"-size N[ckMGb]   file uses N units of space (c=bytes, k=KB, M=MB, G=GB, b=512B blocks)",
+		"-perm MODE       file's permission bits are exactly MODE (octal)",
+		"-perm -MODE      all permission bits MODE are set",
+		"-perm /MODE      any permission bits MODE are set",
+		"-maxdepth LEVELS descend at most LEVELS directories",
+		"-mindepth LEVELS do not apply tests at levels less than LEVELS",
+		"-depth           process directory contents before directory itself",
+		"-prune           do not descend into this directory",
+		"-not, !          negate the following expression",
+		"-a, -and         logical AND (default)",
+		"-o, -or          logical OR",
+		"-exec CMD {} ;   execute CMD on each file ({} is replaced by filename)",
+		"-exec CMD {} +   execute CMD with multiple files at once",
+		"-print           print the full file name (default action)",
+		"-print0          print the full file name followed by a null character",
+		"-printf FORMAT   print FORMAT with directives: %f %h %p %P %s %d %m %M %t",
+		"-delete          delete found files/directories",
+		"    --help       display this help and exit"
+	]
+}, Re = new Set([
+	"-name",
+	"-iname",
+	"-path",
+	"-ipath",
+	"-regex",
+	"-iregex",
+	"-type",
+	"-maxdepth",
+	"-mindepth",
+	"-mtime",
+	"-newer",
+	"-size",
+	"-perm"
+]), je = {
+	name: "find",
+	async execute(e, t) {
+		if (o(e)) return s($e);
+		let n = [], a = null, s$1 = null, o$1 = !1, i = !1;
+		for (let c = 0; c < e.length; c++) {
+			let f = e[c];
+			if (f === "-maxdepth" && c + 1 < e.length) i = !0, a = parseInt(e[++c], 10);
+			else if (f === "-mindepth" && c + 1 < e.length) i = !0, s$1 = parseInt(e[++c], 10);
+			else if (f === "-depth") i = !0, o$1 = !0;
+			else if (f === "-exec") for (i = !0, c++; c < e.length && e[c] !== ";" && e[c] !== "+";) c++;
+			else !f.startsWith("-") && f !== ";" && f !== "+" && f !== "(" && f !== ")" && f !== "\\(" && f !== "\\)" && f !== "!" ? i || n.push(f) : Re.has(f) ? (i = !0, c++) : (f.startsWith("-") || f === "(" || f === "\\(" || f === "!") && (i = !0);
+		}
+		n.length === 0 && n.push(".");
+		let { expr: r$2, error: p, actions: l } = me(e, 0);
+		if (p) return {
+			stdout: "",
+			stderr: p,
+			exitCode: 1
+		};
+		let d = l.some((c) => c.type === "print"), O = l.length === 0, x = [], ge = l.some((c) => c.type === "printf"), re = [], B = "", q = 0, we = he(r$2), U = /* @__PURE__ */ new Map();
+		for (let c of we) {
+			let f = t.fs.resolvePath(t.cwd, c);
+			try {
+				let u = await t.fs.stat(f);
+				U.set(c, u.mtime?.getTime() ?? Date.now());
+			} catch {}
+		}
+		let De = l.some((c) => {
+			if (c.type !== "printf") return !1;
+			let f = c.format.replace(/%%/g, "");
+			return /%[-+]?[0-9]*\.?[0-9]*(s|m|M|t|T)/.test(f);
+		}), Te = _(r$2) || De, Ce = j(r$2), K = ue(r$2), ae = V(r$2), Pe = J(r$2), Se = typeof t.fs.readdirWithFileTypes == "function";
+		for (let c of n) {
+			let G = function(h) {
+				let $ = s$1 === null || h.depth >= s$1, P = !1;
+				if ($ && r$2 !== null) {
+					let S = Date.now(), y;
+					if (Pe) y = L(r$2, h.name, h.relativePath, h.isFile, h.isDirectory);
+					else y = k(r$2, {
+						name: h.name,
+						relativePath: h.relativePath,
+						isFile: h.isFile,
+						isDirectory: h.isDirectory,
+						isEmpty: h.isEmpty,
+						mtime: h.stat?.mtime?.getTime() ?? Date.now(),
+						size: h.stat?.size ?? 0,
+						mode: h.stat?.mode ?? 420,
+						newerRefTimes: U
+					});
+					$ = y.matches, P = d ? y.printed : $, u.evalCalls++, u.evalTime += Date.now() - S;
+				} else $ && (P = !0);
+				return P ? {
+					print: !0,
+					printfData: ge ? {
+						path: h.relativePath,
+						name: h.name,
+						size: h.stat?.size ?? 0,
+						mtime: h.stat?.mtime?.getTime() ?? Date.now(),
+						mode: h.stat?.mode ?? 420,
+						isDirectory: h.isDirectory,
+						depth: h.depth,
+						startingPoint: c
+					} : null
+				} : {
+					print: !1,
+					printfData: null
+				};
+			};
+			c.length > 1 && c.endsWith("/") && (c = c.slice(0, -1));
+			let f = t.fs.resolvePath(t.cwd, c);
+			try {
+				await t.fs.stat(f);
+			} catch {
+				B += `find: ${c}: No such file or directory
+`, q = 1;
+				continue;
+			}
+			let u = Ie(), M = Date.now();
+			async function N(h) {
+				let { path: b, depth: $, typeInfo: P } = h;
+				if (u.nodeCount++, $ > (a ?? 256)) return null;
+				let v, S, y;
+				if (P && !Te) v = P.isFile, S = P.isDirectory;
+				else {
+					try {
+						let A = Date.now();
+						y = await t.fs.stat(b), u.statCalls++, u.statTime += Date.now() - A;
+					} catch {
+						return null;
+					}
+					if (!y) return null;
+					v = y.isFile, S = y.isDirectory;
+				}
+				let m;
+				b === f ? m = c.split("/").pop() || c : m = b.split("/").pop() || "";
+				let g = b === f ? c : c === "." ? `./${b.slice(f === "/" ? f.length : f.length + 1)}` : c + b.slice(f.length), T = [], C = null, w = null, D = !1;
+				S && ae && !o$1 && (D = de(r$2, {
+					name: m,
+					relativePath: g,
+					isFile: v,
+					isDirectory: S
+				}).shouldPrune, D && u.earlyPrunes++);
+				let F = $ >= (a ?? 256), I = K.terminalDirName !== null && m === K.terminalDirName, Z = !F && !I && !D;
+				if (S && (Z || Ce || I) && !D) {
+					let A = Date.now();
+					if (Se && t.fs.readdirWithFileTypes) {
+						if (C = await t.fs.readdirWithFileTypes(b), w = C.map((E) => E.name), u.readdirCalls++, u.readdirTime += Date.now() - A, Z) T = C.map((E, R) => ({
+							path: b === "/" ? `/${E.name}` : `${b}/${E.name}`,
+							depth: $ + 1,
+							typeInfo: {
+								isFile: E.isFile,
+								isDirectory: E.isDirectory
+							},
+							resultIndex: R
+						}));
+						else if (I) {
+							let E = K.requiredExtension;
+							T = C.filter((R) => R.isFile && (!E || R.name.endsWith(E))).map((R, ve) => ({
+								path: b === "/" ? `/${R.name}` : `${b}/${R.name}`,
+								depth: $ + 1,
+								typeInfo: {
+									isFile: R.isFile,
+									isDirectory: R.isDirectory
+								},
+								resultIndex: ve
+							}));
+						}
+					} else w = await t.fs.readdir(b), u.readdirCalls++, u.readdirTime += Date.now() - A, Z && (T = w.map((E, R) => ({
+						path: b === "/" ? `/${E}` : `${b}/${E}`,
+						depth: $ + 1,
+						resultIndex: R
+					})));
+				}
+				let Q = v ? (y?.size ?? 0) === 0 : w !== null && w.length === 0, H = D;
+				if (!o$1 && r$2 !== null && !D && ae) {
+					let A = Date.now();
+					H = k(r$2, {
+						name: m,
+						relativePath: g,
+						isFile: v,
+						isDirectory: S,
+						isEmpty: Q,
+						mtime: y?.mtime?.getTime() ?? Date.now(),
+						size: y?.size ?? 0,
+						mode: y?.mode ?? 420,
+						newerRefTimes: U
+					}).pruned, u.evalCalls++, u.evalTime += Date.now() - A;
+				}
+				return {
+					relativePath: g,
+					name: m,
+					isFile: v,
+					isDirectory: S,
+					isEmpty: Q,
+					stat: y,
+					depth: $,
+					children: H ? [] : T,
+					pruned: H
+				};
+			}
+			async function be() {
+				let h = {
+					paths: [],
+					printfData: []
+				};
+				if (o$1) {
+					let y = function(m) {
+						let g = {
+							paths: [],
+							printfData: []
+						}, T = P[m];
+						if (!T) return g;
+						for (let D of T.childIndices) {
+							let F = y(D);
+							g.paths.push(...F.paths), g.printfData.push(...F.printfData);
+						}
+						let { print: C, printfData: w } = G(T.node);
+						return C && (g.paths.push(T.node.relativePath), w && g.printfData.push(w)), g;
+					};
+					let P = [], v = [{
+						item: {
+							path: f,
+							depth: 0,
+							resultIndex: 0
+						},
+						parentIndex: -1,
+						childOrderInParent: 0
+					}], S = /* @__PURE__ */ new Map();
+					for (; v.length > 0;) {
+						let m = Date.now(), g = v.splice(0, ye), T = await Promise.all(g.map((C) => N(C.item)));
+						u.batchCount++, u.batchTime += Date.now() - m;
+						for (let C = 0; C < g.length; C++) {
+							let w = T[C], D = g[C];
+							if (!w) continue;
+							let F = P.length;
+							if (D.parentIndex >= 0) {
+								let I = S.get(D.parentIndex) || [];
+								I.push(F), S.set(D.parentIndex, I);
+							}
+							P.push({
+								node: w,
+								parentIndex: D.parentIndex,
+								childIndices: []
+							});
+							for (let I = 0; I < w.children.length; I++) v.push({
+								item: w.children[I],
+								parentIndex: F,
+								childOrderInParent: I
+							});
+						}
+					}
+					for (let [m, g] of S) m >= 0 && m < P.length && (P[m].childIndices = g);
+					if (P.length > 0) {
+						let m = y(0);
+						h.paths.push(...m.paths), h.printfData.push(...m.printfData);
+					}
+				} else {
+					let m = function(g) {
+						let T = P.get(g);
+						T && (h.paths.push(T.path), T.printfData && h.printfData.push(T.printfData));
+						let C = y.get(g);
+						if (C) for (let w of C) m(w);
+					};
+					let P = /* @__PURE__ */ new Map(), v = 0, S = [{
+						item: {
+							path: f,
+							depth: 0,
+							resultIndex: 0
+						},
+						orderIndex: v++
+					}], y = /* @__PURE__ */ new Map();
+					for (; S.length > 0;) {
+						let g = Date.now(), T = S.splice(0, ye), C = await Promise.all(T.map(async ({ item: w, orderIndex: D }) => {
+							let F = await N(w);
+							return F ? {
+								node: F,
+								orderIndex: D
+							} : null;
+						}));
+						u.batchCount++, u.batchTime += Date.now() - g;
+						for (let w of C) {
+							if (!w) continue;
+							let { node: D, orderIndex: F } = w, { print: I, printfData: Z } = G(D);
+							if (I && P.set(F, {
+								path: D.relativePath,
+								printfData: Z
+							}), D.children.length > 0) {
+								let ee = [];
+								for (let Q of D.children) {
+									let H = v++;
+									ee.push(H), S.push({
+										item: Q,
+										orderIndex: H
+									});
+								}
+								y.set(F, ee);
+							}
+						}
+					}
+					m(0);
+				}
+				return h;
+			}
+			let X = await be();
+			if (x.push(...X.paths), re.push(...X.printfData), t.trace) {
+				let h = Date.now() - M;
+				xe(t.trace, u, h), t.trace({
+					category: "find",
+					name: "searchPath",
+					durationMs: h,
+					details: {
+						path: c,
+						resultsFound: X.paths.length
+					}
+				});
+			}
+		}
+		let W = "";
+		if (l.length > 0) for (let c of l) switch (c.type) {
+			case "print":
+				W += x.length > 0 ? `${x.join(`
+`)}
+` : "";
+				break;
+			case "print0":
+				W += x.length > 0 ? `${x.join("\0")}\0` : "";
+				break;
+			case "delete": {
+				let f = [...x].sort((u, M) => M.length - u.length);
+				for (let u of f) {
+					let M = t.fs.resolvePath(t.cwd, u);
+					try {
+						await t.fs.rm(M, { recursive: !1 });
+					} catch (N) {
+						let G = N instanceof Error ? N.message : String(N);
+						B += `find: cannot delete '${u}': ${G}
+`, q = 1;
+					}
+				}
+				break;
+			}
+			case "printf":
+				for (let f of re) W += ke(c.format, f);
+				break;
+			case "exec":
+				if (!t.exec) return {
+					stdout: "",
+					stderr: `find: -exec not supported in this context
+`,
+					exitCode: 1
+				};
+				if (c.batchMode) {
+					let f = [];
+					for (let M of c.command) M === "{}" ? f.push(...x) : f.push(M);
+					let u = await t.exec(r([f[0]]), {
+						cwd: t.cwd,
+						signal: t.signal,
+						args: f.slice(1)
+					});
+					W += u.stdout, B += u.stderr, u.exitCode !== 0 && (q = u.exitCode);
+				} else for (let f of x) {
+					let u = c.command.map((N) => N === "{}" ? f : N), M = await t.exec(r([u[0]]), {
+						cwd: t.cwd,
+						signal: t.signal,
+						args: u.slice(1)
+					});
+					W += M.stdout, B += M.stderr, M.exitCode !== 0 && (q = M.exitCode);
+				}
+				break;
+		}
+		else O && (W = x.length > 0 ? `${x.join(`
+`)}
+` : "");
+		return {
+			stdout: W,
+			stderr: B,
+			exitCode: q
+		};
+	}
+};
+function ke(e, t) {
+	let n = r$1(e), a = "", s = 0;
+	for (; s < n.length;) if (n[s] === "%" && s + 1 < n.length) {
+		if (s++, n[s] === "%") {
+			a += "%", s++;
+			continue;
+		}
+		let [o, i$1, r] = h(n, s);
+		if (s += r, s >= n.length) {
+			a += "%";
+			break;
+		}
+		let p = n[s], l;
+		switch (p) {
+			case "f":
+				l = t.name, s++;
+				break;
+			case "h": {
+				let d = t.path.lastIndexOf("/");
+				l = d > 0 ? t.path.slice(0, d) : ".", s++;
+				break;
+			}
+			case "p":
+				l = t.path, s++;
+				break;
+			case "P": {
+				let d = t.startingPoint;
+				t.path === d ? l = "" : t.path.startsWith(`${d}/`) ? l = t.path.slice(d.length + 1) : d === "." && t.path.startsWith("./") ? l = t.path.slice(2) : l = t.path, s++;
+				break;
+			}
+			case "s":
+				l = String(t.size), s++;
+				break;
+			case "d":
+				l = String(t.depth), s++;
+				break;
+			case "m":
+				l = (t.mode & 511).toString(8), s++;
+				break;
+			case "M":
+				l = x(t.mode, t.isDirectory), s++;
+				break;
+			case "t":
+				l = Ne(new Date(t.mtime)), s++;
+				break;
+			case "T":
+				if (s + 1 < n.length) {
+					let d = n[s + 1];
+					l = ze(new Date(t.mtime), d), s += 2;
+				} else l = "%T", s++;
+				break;
+			default:
+				a += `%${o !== 0 || i$1 !== -1 ? `${o}.${i$1}` : ""}${p}`, s++;
+				continue;
+		}
+		a += i(l, o, i$1);
+	} else a += n[s], s++;
+	return a;
+}
+function Ne(e) {
+	return `${[
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	][e.getDay()]} ${[
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	][e.getMonth()]} ${String(e.getDate()).padStart(2, " ")} ${String(e.getHours()).padStart(2, "0")}:${String(e.getMinutes()).padStart(2, "0")}:${String(e.getSeconds()).padStart(2, "0")} ${e.getFullYear()}`;
+}
+function ze(e, t) {
+	switch (t) {
+		case "@": return String(e.getTime() / 1e3);
+		case "Y": return String(e.getFullYear());
+		case "m": return String(e.getMonth() + 1).padStart(2, "0");
+		case "d": return String(e.getDate()).padStart(2, "0");
+		case "H": return String(e.getHours()).padStart(2, "0");
+		case "M": return String(e.getMinutes()).padStart(2, "0");
+		case "S": return String(e.getSeconds()).padStart(2, "0");
+		case "T": return `${String(e.getHours()).padStart(2, "0")}:${String(e.getMinutes()).padStart(2, "0")}:${String(e.getSeconds()).padStart(2, "0")}`;
+		case "F": return `${e.getFullYear()}-${String(e.getMonth() + 1).padStart(2, "0")}-${String(e.getDate()).padStart(2, "0")}`;
+		default: return `%T${t}`;
+	}
+}
+var Je = {
+	name: "find",
+	flags: [
+		{
+			flag: "-name",
+			type: "value",
+			valueHint: "pattern"
+		},
+		{
+			flag: "-iname",
+			type: "value",
+			valueHint: "pattern"
+		},
+		{
+			flag: "-type",
+			type: "value",
+			valueHint: "string"
+		},
+		{
+			flag: "-maxdepth",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "-mindepth",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "-empty",
+			type: "boolean"
+		},
+		{
+			flag: "-print",
+			type: "boolean"
+		},
+		{
+			flag: "-print0",
+			type: "boolean"
+		}
+	],
+	needsFiles: !0
+};
+//#endregion
+export { je as n, Je as t };
+
+//# sourceMappingURL=chunk-ZZKH2ELC-Dm1TMkxv.mjs.map