@keystrokehq/keystroke 1.0.5 → 1.0.6

package/dist/chunk-FX7KQCEA-BQU3KSWz.mjs

@@ -0,0 +1,1629 @@
+import { T as r, y as x } from "./dist-CRsUBf24.mjs";
+import { t as I1 } from "./chunk-4RUAZWKT-CISqwIli.mjs";
+import { n as r$1, r as s, t as o } from "./chunk-QAYAQNCG-B1r1SmqS.mjs";
+import { s as x$1 } from "./chunk-4WKZNNJK-x25SBHbd.mjs";
+import { n as Q$1, r as ue$1, t as H$1 } from "./chunk-CHFEPBH4-frsHsnTZ.mjs";
+import { createRequire } from "node:module";
+import { gunzipSync } from "node:zlib";
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-FX7KQCEA.js
+createRequire(import.meta.url);
+var H = x$1({
+	js: {
+		extensions: [
+			".js",
+			".mjs",
+			".cjs",
+			".jsx"
+		],
+		globs: []
+	},
+	ts: {
+		extensions: [
+			".ts",
+			".tsx",
+			".mts",
+			".cts"
+		],
+		globs: []
+	},
+	html: {
+		extensions: [
+			".html",
+			".htm",
+			".xhtml"
+		],
+		globs: []
+	},
+	css: {
+		extensions: [
+			".css",
+			".scss",
+			".sass",
+			".less"
+		],
+		globs: []
+	},
+	json: {
+		extensions: [
+			".json",
+			".jsonc",
+			".json5"
+		],
+		globs: []
+	},
+	xml: {
+		extensions: [
+			".xml",
+			".xsl",
+			".xslt"
+		],
+		globs: []
+	},
+	c: {
+		extensions: [".c", ".h"],
+		globs: []
+	},
+	cpp: {
+		extensions: [
+			".cpp",
+			".cc",
+			".cxx",
+			".hpp",
+			".hh",
+			".hxx",
+			".h"
+		],
+		globs: []
+	},
+	rust: {
+		extensions: [".rs"],
+		globs: []
+	},
+	go: {
+		extensions: [".go"],
+		globs: []
+	},
+	zig: {
+		extensions: [".zig"],
+		globs: []
+	},
+	java: {
+		extensions: [".java"],
+		globs: []
+	},
+	kotlin: {
+		extensions: [".kt", ".kts"],
+		globs: []
+	},
+	scala: {
+		extensions: [".scala", ".sc"],
+		globs: []
+	},
+	clojure: {
+		extensions: [
+			".clj",
+			".cljc",
+			".cljs",
+			".edn"
+		],
+		globs: []
+	},
+	py: {
+		extensions: [
+			".py",
+			".pyi",
+			".pyw"
+		],
+		globs: []
+	},
+	rb: {
+		extensions: [
+			".rb",
+			".rake",
+			".gemspec"
+		],
+		globs: ["Rakefile", "Gemfile"]
+	},
+	php: {
+		extensions: [
+			".php",
+			".phtml",
+			".php3",
+			".php4",
+			".php5"
+		],
+		globs: []
+	},
+	perl: {
+		extensions: [
+			".pl",
+			".pm",
+			".pod",
+			".t"
+		],
+		globs: []
+	},
+	lua: {
+		extensions: [".lua"],
+		globs: []
+	},
+	sh: {
+		extensions: [
+			".sh",
+			".bash",
+			".zsh",
+			".fish"
+		],
+		globs: [
+			".bashrc",
+			".zshrc",
+			".profile"
+		]
+	},
+	bat: {
+		extensions: [".bat", ".cmd"],
+		globs: []
+	},
+	ps: {
+		extensions: [
+			".ps1",
+			".psm1",
+			".psd1"
+		],
+		globs: []
+	},
+	yaml: {
+		extensions: [".yaml", ".yml"],
+		globs: []
+	},
+	toml: {
+		extensions: [".toml"],
+		globs: ["Cargo.toml", "pyproject.toml"]
+	},
+	ini: {
+		extensions: [
+			".ini",
+			".cfg",
+			".conf"
+		],
+		globs: []
+	},
+	csv: {
+		extensions: [".csv", ".tsv"],
+		globs: []
+	},
+	md: {
+		extensions: [
+			".md",
+			".mdx",
+			".markdown",
+			".mdown",
+			".mkd"
+		],
+		globs: []
+	},
+	markdown: {
+		extensions: [
+			".md",
+			".mdx",
+			".markdown",
+			".mdown",
+			".mkd"
+		],
+		globs: []
+	},
+	rst: {
+		extensions: [".rst"],
+		globs: []
+	},
+	txt: {
+		extensions: [".txt", ".text"],
+		globs: []
+	},
+	tex: {
+		extensions: [
+			".tex",
+			".ltx",
+			".sty",
+			".cls"
+		],
+		globs: []
+	},
+	sql: {
+		extensions: [".sql"],
+		globs: []
+	},
+	graphql: {
+		extensions: [".graphql", ".gql"],
+		globs: []
+	},
+	proto: {
+		extensions: [".proto"],
+		globs: []
+	},
+	make: {
+		extensions: [".mk", ".mak"],
+		globs: [
+			"Makefile",
+			"GNUmakefile",
+			"makefile"
+		]
+	},
+	docker: {
+		extensions: [],
+		globs: [
+			"Dockerfile",
+			"Dockerfile.*",
+			"*.dockerfile"
+		]
+	},
+	tf: {
+		extensions: [".tf", ".tfvars"],
+		globs: []
+	}
+}), M = class {
+	types;
+	constructor() {
+		this.types = new Map(Object.entries(H).map(([t, n]) => [t, {
+			extensions: [...n.extensions],
+			globs: [...n.globs]
+		}]));
+	}
+	addType(t) {
+		let n = t.indexOf(":");
+		if (n === -1) return;
+		let s = t.slice(0, n), r = t.slice(n + 1);
+		if (r.startsWith("include:")) {
+			let l = r.slice(8), i = this.types.get(l);
+			if (i) {
+				let a = this.types.get(s) || {
+					extensions: [],
+					globs: []
+				};
+				a.extensions.push(...i.extensions), a.globs.push(...i.globs), this.types.set(s, a);
+			}
+		} else {
+			let l = this.types.get(s) || {
+				extensions: [],
+				globs: []
+			};
+			if (r.startsWith("*.") && !r.slice(2).includes("*")) {
+				let i = r.slice(1);
+				l.extensions.includes(i) || l.extensions.push(i);
+			} else l.globs.includes(r) || l.globs.push(r);
+			this.types.set(s, l);
+		}
+	}
+	clearType(t) {
+		let n = this.types.get(t);
+		n && (n.extensions = [], n.globs = []);
+	}
+	getType(t) {
+		return this.types.get(t);
+	}
+	getAllTypes() {
+		return this.types;
+	}
+	matchesType(t, n) {
+		let s = t.toLowerCase();
+		for (let r of n) {
+			if (r === "all") {
+				if (this.matchesAnyType(t)) return !0;
+				continue;
+			}
+			let l = this.types.get(r);
+			if (l) {
+				for (let i of l.extensions) if (s.endsWith(i)) return !0;
+				for (let i of l.globs) if (i.includes("*")) {
+					if (I1(`^${i.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`, "i").test(t)) return !0;
+				} else if (s === i.toLowerCase()) return !0;
+			}
+		}
+		return !1;
+	}
+	matchesAnyType(t) {
+		let n = t.toLowerCase();
+		for (let s of this.types.values()) {
+			for (let r of s.extensions) if (n.endsWith(r)) return !0;
+			for (let r of s.globs) if (r.includes("*")) {
+				if (I1(`^${r.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`, "i").test(t)) return !0;
+			} else if (n === r.toLowerCase()) return !0;
+		}
+		return !1;
+	}
+};
+function V() {
+	let e = [];
+	for (let [t, n] of Object.entries(H).sort()) {
+		let s = [];
+		for (let r of n.extensions) s.push(`*${r}`);
+		for (let r of n.globs) s.push(r);
+		e.push(`${t}: ${s.join(", ")}`);
+	}
+	return `${e.join(`
+`)}
+`;
+}
+function Z() {
+	return {
+		ignoreCase: !1,
+		caseSensitive: !1,
+		smartCase: !0,
+		fixedStrings: !1,
+		wordRegexp: !1,
+		lineRegexp: !1,
+		invertMatch: !1,
+		multiline: !1,
+		multilineDotall: !1,
+		patterns: [],
+		patternFiles: [],
+		count: !1,
+		countMatches: !1,
+		files: !1,
+		filesWithMatches: !1,
+		filesWithoutMatch: !1,
+		stats: !1,
+		onlyMatching: !1,
+		maxCount: 0,
+		lineNumber: !0,
+		noFilename: !1,
+		withFilename: !1,
+		nullSeparator: !1,
+		byteOffset: !1,
+		column: !1,
+		vimgrep: !1,
+		replace: null,
+		afterContext: 0,
+		beforeContext: 0,
+		contextSeparator: "--",
+		quiet: !1,
+		heading: !1,
+		passthru: !1,
+		includeZero: !1,
+		sort: "path",
+		json: !1,
+		globs: [],
+		iglobs: [],
+		globCaseInsensitive: !1,
+		types: [],
+		typesNot: [],
+		typeAdd: [],
+		typeClear: [],
+		hidden: !1,
+		noIgnore: !1,
+		noIgnoreDot: !1,
+		noIgnoreVcs: !1,
+		ignoreFiles: [],
+		maxDepth: 256,
+		maxFilesize: 0,
+		followSymlinks: !1,
+		searchZip: !1,
+		searchBinary: !1,
+		preprocessor: null,
+		preprocessorGlobs: []
+	};
+}
+function se(e) {
+	let t = e.match(/^(\d+)([KMG])?$/i);
+	if (!t) return 0;
+	let n = parseInt(t[1], 10);
+	switch ((t[2] || "").toUpperCase()) {
+		case "K": return n * 1024;
+		case "M": return n * 1024 * 1024;
+		case "G": return n * 1024 * 1024 * 1024;
+		default: return n;
+	}
+}
+function ne(e) {
+	return /^\d+[KMG]?$/i.test(e) ? null : {
+		stdout: "",
+		stderr: `rg: invalid --max-filesize value: ${e}
+`,
+		exitCode: 1
+	};
+}
+function J(e) {
+	return null;
+}
+var Y = [
+	{
+		short: "g",
+		long: "glob",
+		target: "globs",
+		multi: !0
+	},
+	{
+		long: "iglob",
+		target: "iglobs",
+		multi: !0
+	},
+	{
+		short: "t",
+		long: "type",
+		target: "types",
+		multi: !0,
+		validate: J
+	},
+	{
+		short: "T",
+		long: "type-not",
+		target: "typesNot",
+		multi: !0,
+		validate: J
+	},
+	{
+		long: "type-add",
+		target: "typeAdd",
+		multi: !0
+	},
+	{
+		long: "type-clear",
+		target: "typeClear",
+		multi: !0
+	},
+	{
+		short: "m",
+		long: "max-count",
+		target: "maxCount",
+		parse: parseInt
+	},
+	{
+		short: "e",
+		long: "regexp",
+		target: "patterns",
+		multi: !0
+	},
+	{
+		short: "f",
+		long: "file",
+		target: "patternFiles",
+		multi: !0
+	},
+	{
+		short: "r",
+		long: "replace",
+		target: "replace"
+	},
+	{
+		short: "d",
+		long: "max-depth",
+		target: "maxDepth",
+		parse: parseInt
+	},
+	{
+		long: "max-filesize",
+		target: "maxFilesize",
+		parse: se,
+		validate: ne
+	},
+	{
+		long: "context-separator",
+		target: "contextSeparator"
+	},
+	{
+		short: "j",
+		long: "threads",
+		ignored: !0
+	},
+	{
+		long: "ignore-file",
+		target: "ignoreFiles",
+		multi: !0
+	},
+	{
+		long: "pre",
+		target: "preprocessor"
+	},
+	{
+		long: "pre-glob",
+		target: "preprocessorGlobs",
+		multi: !0
+	}
+], re = new Map([
+	["i", (e) => {
+		e.ignoreCase = !0, e.caseSensitive = !1, e.smartCase = !1;
+	}],
+	["--ignore-case", (e) => {
+		e.ignoreCase = !0, e.caseSensitive = !1, e.smartCase = !1;
+	}],
+	["s", (e) => {
+		e.caseSensitive = !0, e.ignoreCase = !1, e.smartCase = !1;
+	}],
+	["--case-sensitive", (e) => {
+		e.caseSensitive = !0, e.ignoreCase = !1, e.smartCase = !1;
+	}],
+	["S", (e) => {
+		e.smartCase = !0, e.ignoreCase = !1, e.caseSensitive = !1;
+	}],
+	["--smart-case", (e) => {
+		e.smartCase = !0, e.ignoreCase = !1, e.caseSensitive = !1;
+	}],
+	["F", (e) => {
+		e.fixedStrings = !0;
+	}],
+	["--fixed-strings", (e) => {
+		e.fixedStrings = !0;
+	}],
+	["w", (e) => {
+		e.wordRegexp = !0;
+	}],
+	["--word-regexp", (e) => {
+		e.wordRegexp = !0;
+	}],
+	["x", (e) => {
+		e.lineRegexp = !0;
+	}],
+	["--line-regexp", (e) => {
+		e.lineRegexp = !0;
+	}],
+	["v", (e) => {
+		e.invertMatch = !0;
+	}],
+	["--invert-match", (e) => {
+		e.invertMatch = !0;
+	}],
+	["U", (e) => {
+		e.multiline = !0;
+	}],
+	["--multiline", (e) => {
+		e.multiline = !0;
+	}],
+	["--multiline-dotall", (e) => {
+		e.multilineDotall = !0, e.multiline = !0;
+	}],
+	["c", (e) => {
+		e.count = !0;
+	}],
+	["--count", (e) => {
+		e.count = !0;
+	}],
+	["--count-matches", (e) => {
+		e.countMatches = !0;
+	}],
+	["l", (e) => {
+		e.filesWithMatches = !0;
+	}],
+	["--files", (e) => {
+		e.files = !0;
+	}],
+	["--files-with-matches", (e) => {
+		e.filesWithMatches = !0;
+	}],
+	["--files-without-match", (e) => {
+		e.filesWithoutMatch = !0;
+	}],
+	["--stats", (e) => {
+		e.stats = !0;
+	}],
+	["o", (e) => {
+		e.onlyMatching = !0;
+	}],
+	["--only-matching", (e) => {
+		e.onlyMatching = !0;
+	}],
+	["q", (e) => {
+		e.quiet = !0;
+	}],
+	["--quiet", (e) => {
+		e.quiet = !0;
+	}],
+	["N", (e) => {
+		e.lineNumber = !1;
+	}],
+	["--no-line-number", (e) => {
+		e.lineNumber = !1;
+	}],
+	["H", (e) => {
+		e.withFilename = !0;
+	}],
+	["--with-filename", (e) => {
+		e.withFilename = !0;
+	}],
+	["I", (e) => {
+		e.noFilename = !0;
+	}],
+	["--no-filename", (e) => {
+		e.noFilename = !0;
+	}],
+	["0", (e) => {
+		e.nullSeparator = !0;
+	}],
+	["--null", (e) => {
+		e.nullSeparator = !0;
+	}],
+	["b", (e) => {
+		e.byteOffset = !0;
+	}],
+	["--byte-offset", (e) => {
+		e.byteOffset = !0;
+	}],
+	["--column", (e) => {
+		e.column = !0, e.lineNumber = !0;
+	}],
+	["--no-column", (e) => {
+		e.column = !1;
+	}],
+	["--vimgrep", (e) => {
+		e.vimgrep = !0, e.column = !0, e.lineNumber = !0;
+	}],
+	["--json", (e) => {
+		e.json = !0;
+	}],
+	["--hidden", (e) => {
+		e.hidden = !0;
+	}],
+	["--no-ignore", (e) => {
+		e.noIgnore = !0;
+	}],
+	["--no-ignore-dot", (e) => {
+		e.noIgnoreDot = !0;
+	}],
+	["--no-ignore-vcs", (e) => {
+		e.noIgnoreVcs = !0;
+	}],
+	["L", (e) => {
+		e.followSymlinks = !0;
+	}],
+	["--follow", (e) => {
+		e.followSymlinks = !0;
+	}],
+	["z", (e) => {
+		e.searchZip = !0;
+	}],
+	["--search-zip", (e) => {
+		e.searchZip = !0;
+	}],
+	["a", (e) => {
+		e.searchBinary = !0;
+	}],
+	["--text", (e) => {
+		e.searchBinary = !0;
+	}],
+	["--heading", (e) => {
+		e.heading = !0;
+	}],
+	["--passthru", (e) => {
+		e.passthru = !0;
+	}],
+	["--include-zero", (e) => {
+		e.includeZero = !0;
+	}],
+	["--glob-case-insensitive", (e) => {
+		e.globCaseInsensitive = !0;
+	}]
+]), ie = new Set(["n", "--line-number"]);
+function le(e) {
+	e.hidden ? e.searchBinary = !0 : e.noIgnore ? e.hidden = !0 : e.noIgnore = !0;
+}
+function oe(e, t, n) {
+	let s = e[t];
+	for (let r of Y) {
+		if (s.startsWith(`--${r.long}=`)) {
+			let i = P(n, r, s.slice(`--${r.long}=`.length));
+			return i ? {
+				newIndex: t,
+				error: i
+			} : { newIndex: t };
+		}
+		if (r.short && s.startsWith(`-${r.short}`) && s.length > 2) {
+			let i = P(n, r, s.slice(2));
+			return i ? {
+				newIndex: t,
+				error: i
+			} : { newIndex: t };
+		}
+		if (r.short && s === `-${r.short}` || s === `--${r.long}`) {
+			if (t + 1 >= e.length) return null;
+			let l = e[t + 1], i = P(n, r, l);
+			return i ? {
+				newIndex: t + 1,
+				error: i
+			} : { newIndex: t + 1 };
+		}
+	}
+	return null;
+}
+function ae(e) {
+	return Y.find((t) => t.short === e);
+}
+function P(e, t, n) {
+	if (t.validate) {
+		let r = t.validate(n);
+		if (r) return r;
+	}
+	if (t.ignored || !t.target) return;
+	let s = t.parse ? t.parse(n) : n;
+	t.multi ? e[t.target].push(s) : e[t.target] = s;
+}
+function ce(e, t) {
+	let n = e[t];
+	if (n === "--sort" && t + 1 < e.length) {
+		let s = e[t + 1];
+		if (s === "path" || s === "none") return {
+			value: s,
+			newIndex: t + 1
+		};
+	}
+	if (n.startsWith("--sort=")) {
+		let s = n.slice(7);
+		if (s === "path" || s === "none") return {
+			value: s,
+			newIndex: t
+		};
+	}
+	return null;
+}
+function fe(e, t) {
+	let n = e[t], s = n.match(/^-([ABC])(\d+)$/);
+	return s ? {
+		flag: s[1],
+		value: parseInt(s[2], 10),
+		newIndex: t
+	} : (n === "-A" || n === "-B" || n === "-C") && t + 1 < e.length ? {
+		flag: n[1],
+		value: parseInt(e[t + 1], 10),
+		newIndex: t + 1
+	} : null;
+}
+function ue(e) {
+	let t = e.match(/^-m(\d+)$/);
+	return t ? parseInt(t[1], 10) : null;
+}
+function K(e) {
+	let t = Z(), n = null, s = [], r = -1, l = -1, i = -1, a = !1;
+	for (let c = 0; c < e.length; c++) {
+		let o = e[c];
+		if (o.startsWith("-") && o !== "-") {
+			let u = fe(e, c);
+			if (u) {
+				let { flag: f, value: x, newIndex: b } = u;
+				f === "A" ? r = Math.max(r, x) : f === "B" ? l = Math.max(l, x) : i = x, c = b;
+				continue;
+			}
+			let d = ue(o);
+			if (d !== null) {
+				t.maxCount = d;
+				continue;
+			}
+			let p = oe(e, c, t);
+			if (p) {
+				if (p.error) return {
+					success: !1,
+					error: p.error
+				};
+				c = p.newIndex;
+				continue;
+			}
+			let g = ce(e, c);
+			if (g) {
+				t.sort = g.value, c = g.newIndex;
+				continue;
+			}
+			let w = o.startsWith("--") ? [o] : o.slice(1).split("");
+			for (let f of w) {
+				if (ie.has(f)) {
+					t.lineNumber = !0, a = !0;
+					continue;
+				}
+				if (f === "u" || f === "--unrestricted") {
+					le(t);
+					continue;
+				}
+				if (f === "P" || f === "--pcre2") return {
+					success: !1,
+					error: {
+						stdout: "",
+						stderr: `rg: PCRE2 is not supported. Use standard regex syntax instead.
+`,
+						exitCode: 1
+					}
+				};
+				if (f.length === 1) {
+					let b = ae(f);
+					if (b) {
+						if (c + 1 >= e.length) return {
+							success: !1,
+							error: r$1("rg", `-${f}`)
+						};
+						let h = P(t, b, e[c + 1]);
+						if (h) return {
+							success: !1,
+							error: h
+						};
+						c++;
+						continue;
+					}
+				}
+				let x = re.get(f);
+				if (x) {
+					x(t);
+					continue;
+				}
+				if (f.startsWith("--")) return {
+					success: !1,
+					error: r$1("rg", f)
+				};
+				if (f.length === 1) return {
+					success: !1,
+					error: r$1("rg", `-${f}`)
+				};
+			}
+		} else n === null && t.patterns.length === 0 && t.patternFiles.length === 0 ? n = o : s.push(o);
+	}
+	return (r >= 0 || i >= 0) && (t.afterContext = Math.max(r >= 0 ? r : 0, i >= 0 ? i : 0)), (l >= 0 || i >= 0) && (t.beforeContext = Math.max(l >= 0 ? l : 0, i >= 0 ? i : 0)), n !== null && t.patterns.push(n), (t.column || t.vimgrep) && (a = !0), {
+		success: !0,
+		options: t,
+		paths: s,
+		explicitLineNumbers: a
+	};
+}
+var T = class {
+	patterns = [];
+	basePath;
+	constructor(t = "/") {
+		this.basePath = t;
+	}
+	parse(t) {
+		let n = t.split(`
+`);
+		for (let s of n) {
+			let r = s.replace(/\s+$/, "");
+			if (!r || r.startsWith("#")) continue;
+			let l = !1;
+			r.startsWith("!") && (l = !0, r = r.slice(1));
+			let i = !1;
+			r.endsWith("/") && (i = !0, r = r.slice(0, -1));
+			let a = !1;
+			r.startsWith("/") ? (a = !0, r = r.slice(1)) : r.includes("/") && !r.startsWith("**/") && (a = !0);
+			let c = this.patternToRegex(r, a);
+			this.patterns.push({
+				pattern: s,
+				regex: c,
+				negated: l,
+				directoryOnly: i,
+				rooted: a
+			});
+		}
+	}
+	patternToRegex(t, n) {
+		let s = "";
+		n ? s = "^" : s = "(?:^|/)";
+		let r = 0;
+		for (; r < t.length;) {
+			let l = t[r];
+			if (l === "*") t[r + 1] === "*" ? t[r + 2] === "/" ? (s += "(?:.*/)?", r += 3) : (r + 2, t.length, s += ".*", r += 2) : (s += "[^/]*", r++);
+			else if (l === "?") s += "[^/]", r++;
+			else if (l === "[") {
+				let i = r + 1;
+				for (i < t.length && t[i] === "!" && i++, i < t.length && t[i] === "]" && i++; i < t.length && t[i] !== "]";) i++;
+				if (i < t.length) {
+					let a = t.slice(r, i + 1);
+					a.startsWith("[!") && (a = `[^${a.slice(2)}`), s += a, r = i + 1;
+				} else s += "\\[", r++;
+			} else l === "/" ? (s += "/", r++) : (s += l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), r++);
+		}
+		return s += "(?:/.*)?$", I1(s);
+	}
+	matches(t, n) {
+		let s = t.replace(/^\.\//, "");
+		s = s.replace(/^\//, "");
+		let r = !1;
+		for (let l of this.patterns) l.directoryOnly && !n || l.regex.test(s) && (r = !l.negated);
+		return r;
+	}
+	isWhitelisted(t, n) {
+		let s = t.replace(/^\.\//, "");
+		s = s.replace(/^\//, "");
+		for (let r of this.patterns) if (!(r.directoryOnly && !n) && r.negated && r.regex.test(s)) return !0;
+		return !1;
+	}
+	getBasePath() {
+		return this.basePath;
+	}
+}, k = class {
+	parsers = [];
+	fs;
+	skipDotIgnore;
+	skipVcsIgnore;
+	loadedDirs = /* @__PURE__ */ new Set();
+	constructor(t, n, s = !1, r = !1) {
+		this.fs = t, this.skipDotIgnore = s, this.skipVcsIgnore = r;
+	}
+	async load(t) {
+		let n = [], s = t;
+		for (;;) {
+			n.unshift(s);
+			let l = this.fs.resolvePath(s, "..");
+			if (l === s) break;
+			s = l;
+		}
+		let r = [];
+		this.skipVcsIgnore || r.push(".gitignore"), this.skipDotIgnore || r.push(".rgignore", ".ignore");
+		for (let l of n) {
+			this.loadedDirs.add(l);
+			for (let i of r) {
+				let a = this.fs.resolvePath(l, i);
+				try {
+					let c = await this.fs.readFile(a), o = new T(l);
+					o.parse(c), this.parsers.push(o);
+				} catch {}
+			}
+		}
+	}
+	async loadForDirectory(t) {
+		if (this.loadedDirs.has(t)) return;
+		this.loadedDirs.add(t);
+		let n = [];
+		this.skipVcsIgnore || n.push(".gitignore"), this.skipDotIgnore || n.push(".rgignore", ".ignore");
+		for (let s of n) {
+			let r = this.fs.resolvePath(t, s);
+			try {
+				let l = await this.fs.readFile(r), i = new T(t);
+				i.parse(l), this.parsers.push(i);
+			} catch {}
+		}
+	}
+	addPatternsFromContent(t, n) {
+		let s = new T(n);
+		s.parse(t), this.parsers.push(s);
+	}
+	matches(t, n) {
+		for (let s of this.parsers) {
+			let r = s.getBasePath();
+			if (!t.startsWith(r)) continue;
+			let l = t.slice(r.length).replace(/^\//, "");
+			if (s.matches(l, n)) return !0;
+		}
+		return !1;
+	}
+	isWhitelisted(t, n) {
+		for (let s of this.parsers) {
+			let r = s.getBasePath();
+			if (!t.startsWith(r)) continue;
+			let l = t.slice(r.length).replace(/^\//, "");
+			if (s.isWhitelisted(l, n)) return !0;
+		}
+		return !1;
+	}
+	static isCommonIgnored(t) {
+		return new Set([
+			"node_modules",
+			".git",
+			".svn",
+			".hg",
+			"__pycache__",
+			".pytest_cache",
+			".mypy_cache",
+			"venv",
+			".venv",
+			".next",
+			".nuxt",
+			".cargo"
+		]).has(t);
+	}
+};
+async function A(e, t, n = !1, s = !1, r = []) {
+	let l = new k(e, t, n, s);
+	await l.load(t);
+	for (let i of r) try {
+		let a = e.resolvePath(t, i), c = await e.readFile(a);
+		l.addPatternsFromContent(c, t);
+	} catch {}
+	return l;
+}
+function ge(e) {
+	return e.length >= 2 && e[0] === 31 && e[1] === 139;
+}
+function pe(e) {
+	let t = !1;
+	for (let n = 0; n < e.length; n++) {
+		let s = e[n];
+		s === "[" && !t ? t = !0 : s === "]" && t && (t = !1);
+	}
+	return t ? `rg: glob '${e}' has an unclosed character class` : null;
+}
+async function X(e) {
+	let { ctx: t, options: n, paths: s, explicitLineNumbers: r } = e;
+	for (let f of n.globs) {
+		let b = pe(f.startsWith("!") ? f.slice(1) : f);
+		if (b) return {
+			stdout: "",
+			stderr: `${b}
+`,
+			exitCode: 1
+		};
+	}
+	if (n.files) return xe(t, [...n.patterns, ...s], n);
+	let l = [...n.patterns];
+	for (let f of n.patternFiles) try {
+		let x$2;
+		if (f === "-") x$2 = x(t.stdin);
+		else {
+			let h = t.fs.resolvePath(t.cwd, f);
+			x$2 = await t.fs.readFile(h);
+		}
+		let b = x$2.split(`
+`).filter((h) => h.length > 0);
+		l.push(...b);
+	} catch {
+		return {
+			stdout: "",
+			stderr: `rg: ${f}: No such file or directory
+`,
+			exitCode: 2
+		};
+	}
+	if (l.length === 0) return n.patternFiles.length > 0 ? {
+		stdout: "",
+		stderr: "",
+		exitCode: 1
+	} : {
+		stdout: "",
+		stderr: `rg: no pattern given
+`,
+		exitCode: 2
+	};
+	let i = s.length === 0 ? ["."] : s, a = me(n, l), c, o;
+	try {
+		let f = de(l, n, a);
+		c = f.regex, o = f.kResetGroup;
+	} catch {
+		return {
+			stdout: "",
+			stderr: `rg: invalid regex: ${l.join(", ")}
+`,
+			exitCode: 2
+		};
+	}
+	let u = null;
+	n.noIgnore || (u = await A(t.fs, t.cwd, n.noIgnoreDot, n.noIgnoreVcs, n.ignoreFiles));
+	let d = new M();
+	for (let f of n.typeClear) d.clearType(f);
+	for (let f of n.typeAdd) d.addType(f);
+	let { files: p, singleExplicitFile: g } = await Q(t, i, n, u, d);
+	if (p.length === 0) return {
+		stdout: "",
+		stderr: "",
+		exitCode: 1
+	};
+	let w = !n.noFilename && (n.withFilename || !g || p.length > 1), m = n.lineNumber;
+	return r || (g && p.length === 1 && (m = !1), n.onlyMatching && (m = !1)), we(t, p, c, n, w, m, o);
+}
+function me(e, t) {
+	return e.caseSensitive ? !1 : e.ignoreCase ? !0 : e.smartCase ? !t.some((n) => /[A-Z]/.test(n)) : !1;
+}
+function de(e, t, n) {
+	let s;
+	return e.length === 1 ? s = e[0] : s = e.map((r) => t.fixedStrings ? r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : `(?:${r})`).join("|"), H$1(s, {
+		mode: t.fixedStrings && e.length === 1 ? "fixed" : "perl",
+		ignoreCase: n,
+		wholeWord: t.wordRegexp,
+		lineRegexp: t.lineRegexp,
+		multiline: t.multiline,
+		multilineDotall: t.multilineDotall
+	});
+}
+async function Q(e, t, n, s, r) {
+	let l = [], i = 0, a = 0;
+	for (let o of t) {
+		let u = e.fs.resolvePath(e.cwd, o);
+		try {
+			let d = await e.fs.stat(u);
+			if (d.isFile) {
+				if (i++, n.maxFilesize > 0 && d.size > n.maxFilesize) continue;
+				te(o, n, s, u, r) && l.push(o);
+			} else d.isDirectory && (a++, await ee(e, o, u, 0, n, s, r, l));
+		} catch {}
+	}
+	return {
+		files: n.sort === "path" ? l.sort() : l,
+		singleExplicitFile: i === 1 && a === 0
+	};
+}
+async function ee(e, t, n, s, r, l, i, a) {
+	if (!(s >= r.maxDepth)) {
+		l && await l.loadForDirectory(n);
+		try {
+			let c = e.fs.readdirWithFileTypes ? await e.fs.readdirWithFileTypes(n) : (await e.fs.readdir(n)).map((o) => ({
+				name: o,
+				isFile: void 0
+			}));
+			for (let o of c) {
+				let u = o.name;
+				if (!r.noIgnore && k.isCommonIgnored(u)) continue;
+				let d = u.startsWith("."), p = t === "." ? u : t === "./" ? `./${u}` : t.endsWith("/") ? `${t}${u}` : `${t}/${u}`, g = e.fs.resolvePath(n, u), w, m, f = !1;
+				if (o.isFile !== void 0 && "isDirectory" in o) {
+					let h = o;
+					if (f = h.isSymbolicLink === !0, f && !r.followSymlinks) continue;
+					if (f && r.followSymlinks) try {
+						let y = await e.fs.stat(g);
+						w = y.isFile, m = y.isDirectory;
+					} catch {
+						continue;
+					}
+					else w = h.isFile, m = h.isDirectory;
+				} else try {
+					let h = e.fs.lstat ? await e.fs.lstat(g) : await e.fs.stat(g);
+					if (f = h.isSymbolicLink === !0, f && !r.followSymlinks) continue;
+					let y = f && r.followSymlinks ? await e.fs.stat(g) : h;
+					w = y.isFile, m = y.isDirectory;
+				} catch {
+					continue;
+				}
+				if (!l?.matches(g, m) && !(d && !r.hidden && !l?.isWhitelisted(g, m))) {
+					if (m) await ee(e, p, g, s + 1, r, l, i, a);
+					else if (w) {
+						if (r.maxFilesize > 0) try {
+							if ((await e.fs.stat(g)).size > r.maxFilesize) continue;
+						} catch {
+							continue;
+						}
+						te(p, r, l, g, i) && a.push(p);
+					}
+				}
+			}
+		} catch {}
+	}
+}
+function te(e, t, n, s, r) {
+	let l = e.split("/").pop() || e;
+	if (n?.matches(s, !1) || t.types.length > 0 && !r.matchesType(l, t.types) || t.typesNot.length > 0 && r.matchesType(l, t.typesNot)) return !1;
+	if (t.globs.length > 0) {
+		let i = t.globCaseInsensitive, a = t.globs.filter((o) => !o.startsWith("!")), c = t.globs.filter((o) => o.startsWith("!")).map((o) => o.slice(1));
+		if (a.length > 0) {
+			let o = !1;
+			for (let u of a) if (v(l, u, i) || v(e, u, i)) {
+				o = !0;
+				break;
+			}
+			if (!o) return !1;
+		}
+		for (let o of c) if (o.startsWith("/")) {
+			if (v(e, o.slice(1), i)) return !1;
+		} else if (v(l, o, i) || v(e, o, i)) return !1;
+	}
+	if (t.iglobs.length > 0) {
+		let i = t.iglobs.filter((c) => !c.startsWith("!")), a = t.iglobs.filter((c) => c.startsWith("!")).map((c) => c.slice(1));
+		if (i.length > 0) {
+			let c = !1;
+			for (let o of i) if (v(l, o, !0) || v(e, o, !0)) {
+				c = !0;
+				break;
+			}
+			if (!c) return !1;
+		}
+		for (let c of a) if (c.startsWith("/")) {
+			if (v(e, c.slice(1), !0)) return !1;
+		} else if (v(l, c, !0) || v(e, c, !0)) return !1;
+	}
+	return !0;
+}
+function v(e, t, n = !1) {
+	let s = "^";
+	for (let r = 0; r < t.length; r++) {
+		let l = t[r];
+		if (l === "*") t[r + 1] === "*" ? (s += ".*", r++) : s += "[^/]*";
+		else if (l === "?") s += "[^/]";
+		else if (l === "[") {
+			let i = r + 1;
+			for (i < t.length && t[i] === "!" && i++, i < t.length && t[i] === "]" && i++; i < t.length && t[i] !== "]";) i++;
+			if (i < t.length) {
+				let a = t.slice(r, i + 1);
+				a.startsWith("[!") && (a = `[^${a.slice(2)}`), s += a, r = i;
+			} else s += "\\[";
+		} else s += l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+	return s += "$", I1(s, n ? "i" : "").test(e);
+}
+async function xe(e, t, n) {
+	let s = null;
+	n.noIgnore || (s = await A(e.fs, e.cwd, n.noIgnoreDot, n.noIgnoreVcs, n.ignoreFiles));
+	let r = new M();
+	for (let o of n.typeClear) r.clearType(o);
+	for (let o of n.typeAdd) r.addType(o);
+	let { files: i } = await Q(e, t.length === 0 ? ["."] : t, n, s, r);
+	if (i.length === 0) return {
+		stdout: "",
+		stderr: "",
+		exitCode: 1
+	};
+	if (n.quiet) return {
+		stdout: "",
+		stderr: "",
+		exitCode: 0
+	};
+	let a = n.nullSeparator ? "\0" : `
+`;
+	return {
+		stdout: i.map((o) => o + a).join(""),
+		stderr: "",
+		exitCode: 0
+	};
+}
+function ye(e, t) {
+	if (t.length === 0) return !0;
+	for (let n of t) if (v(e, n, !1)) return !0;
+	return !1;
+}
+async function be(e, t, n, s) {
+	try {
+		if (s.preprocessor && e.exec) {
+			if (ye(n.split("/").pop() || n, s.preprocessorGlobs)) {
+				let a = await e.exec(r([s.preprocessor]), {
+					cwd: e.cwd,
+					signal: e.signal,
+					args: [t]
+				});
+				if (a.exitCode === 0 && a.stdout) {
+					let c = x(a.stdout);
+					return {
+						content: c,
+						isBinary: c.slice(0, 8192).includes("\0")
+					};
+				}
+			}
+		}
+		if (s.searchZip && n.endsWith(".gz")) {
+			let i = await e.fs.readFileBuffer(t);
+			if (ge(i)) try {
+				let a = gunzipSync(i), c = new TextDecoder().decode(a);
+				return {
+					content: c,
+					isBinary: c.slice(0, 8192).includes("\0")
+				};
+			} catch {
+				return null;
+			}
+		}
+		let r$2 = await e.fs.readFile(t);
+		return {
+			content: r$2,
+			isBinary: r$2.slice(0, 8192).includes("\0")
+		};
+	} catch {
+		return null;
+	}
+}
+async function we(e, t, n, s, r, l, i) {
+	let a = "", c = !1, o = [], u = 0, d = 0, p = 0, g = 50;
+	e: for (let f = 0; f < t.length; f += g) {
+		let x = t.slice(f, f + g), b = await Promise.all(x.map(async (h) => {
+			let F = await be(e, e.fs.resolvePath(e.cwd, h), h, s);
+			if (!F) return null;
+			let { content: C, isBinary: N } = F;
+			if (p += C.length, N && !s.searchBinary) return null;
+			let W = r && !s.heading ? h : "", S = Q$1(C, n, {
+				invertMatch: s.invertMatch,
+				showLineNumbers: l,
+				countOnly: s.count,
+				countMatches: s.countMatches,
+				filename: W,
+				onlyMatching: s.onlyMatching,
+				beforeContext: s.beforeContext,
+				afterContext: s.afterContext,
+				maxCount: s.maxCount,
+				contextSeparator: s.contextSeparator,
+				showColumn: s.column,
+				vimgrep: s.vimgrep,
+				showByteOffset: s.byteOffset,
+				replace: s.replace !== null ? ue$1(s.replace) : null,
+				passthru: s.passthru,
+				multiline: s.multiline,
+				kResetGroup: i
+			});
+			return s.json && S.matched ? {
+				file: h,
+				result: S,
+				content: C,
+				isBinary: !1
+			} : {
+				file: h,
+				result: S
+			};
+		}));
+		for (let h of b) {
+			if (!h) continue;
+			let { file: y, result: F } = h;
+			if (F.matched) {
+				if (c = !0, d++, u += F.matchCount, s.quiet && !s.json) break e;
+				if (s.json && !s.quiet) {
+					let C = h.content || "";
+					o.push(JSON.stringify({
+						type: "begin",
+						data: { path: { text: y } }
+					}));
+					let N = C.split(`
+`);
+					n.lastIndex = 0;
+					let W = 0;
+					for (let S = 0; S < N.length; S++) {
+						let j = N[S];
+						n.lastIndex = 0;
+						let O = [];
+						for (let I = n.exec(j); I !== null; I = n.exec(j)) {
+							let R = {
+								match: { text: I[0] },
+								start: I.index,
+								end: I.index + I[0].length
+							};
+							s.replace !== null && (R.replacement = { text: s.replace }), O.push(R), I[0].length === 0 && n.lastIndex++;
+						}
+						if (O.length > 0) {
+							let I = {
+								type: "match",
+								data: {
+									path: { text: y },
+									lines: { text: `${j}
+` },
+									line_number: S + 1,
+									absolute_offset: W,
+									submatches: O
+								}
+							};
+							o.push(JSON.stringify(I));
+						}
+						W += j.length + 1;
+					}
+					o.push(JSON.stringify({
+						type: "end",
+						data: {
+							path: { text: y },
+							binary_offset: null,
+							stats: {
+								elapsed: {
+									secs: 0,
+									nanos: 0,
+									human: "0s"
+								},
+								searches: 1,
+								searches_with_match: 1,
+								bytes_searched: C.length,
+								bytes_printed: 0,
+								matched_lines: F.matchCount,
+								matches: F.matchCount
+							}
+						}
+					}));
+				} else if (s.filesWithMatches) {
+					let C = s.nullSeparator ? "\0" : `
+`;
+					a += `${y}${C}`;
+				} else s.filesWithoutMatch || (s.heading && !s.noFilename && (a += `${y}
+`), a += F.output);
+			} else if (s.filesWithoutMatch) {
+				let C = s.nullSeparator ? "\0" : `
+`;
+				a += `${y}${C}`;
+			} else s.includeZero && (s.count || s.countMatches) && (a += F.output);
+		}
+	}
+	s.json && (o.push(JSON.stringify({
+		type: "summary",
+		data: {
+			elapsed_total: {
+				secs: 0,
+				nanos: 0,
+				human: "0s"
+			},
+			stats: {
+				elapsed: {
+					secs: 0,
+					nanos: 0,
+					human: "0s"
+				},
+				searches: t.length,
+				searches_with_match: d,
+				bytes_searched: p,
+				bytes_printed: 0,
+				matched_lines: u,
+				matches: u
+			}
+		}
+	})), a = `${o.join(`
+`)}
+`);
+	let w = s.quiet && !s.json ? "" : a;
+	if (s.stats && !s.json) {
+		let f = [
+			"",
+			`${u} matches`,
+			`${u} matched lines`,
+			`${d} files contained matches`,
+			`${t.length} files searched`,
+			`${p} bytes searched`
+		].join(`
+`);
+		w += `${f}
+`;
+	}
+	let m;
+	return s.filesWithoutMatch ? m = a.length > 0 ? 0 : 1 : m = c ? 0 : 1, {
+		stdout: w,
+		stderr: "",
+		exitCode: m
+	};
+}
+var ve = {
+	name: "rg",
+	summary: "recursively search for a pattern",
+	usage: "rg [OPTIONS] PATTERN [PATH ...]",
+	description: `rg (ripgrep) recursively searches directories for a regex pattern.
+Unlike grep, rg is recursive by default and respects .gitignore files.
+
+EXAMPLES:
+  rg foo                    Search for 'foo' in current directory
+  rg foo src/               Search in src/ directory
+  rg -i foo                 Case-insensitive search
+  rg -w foo                 Match whole words only
+  rg -t js foo              Search only JavaScript files
+  rg -g '*.ts' foo          Search files matching glob
+  rg --hidden foo           Include hidden files
+  rg -l foo                 List files with matches only`,
+	options: [
+		"-e, --regexp PATTERN    search for PATTERN (can be used multiple times)",
+		"-f, --file FILE         read patterns from FILE, one per line",
+		"-i, --ignore-case       case-insensitive search",
+		"-s, --case-sensitive    case-sensitive search (overrides smart-case)",
+		"-S, --smart-case        smart case (default: case-insensitive unless pattern has uppercase)",
+		"-F, --fixed-strings     treat pattern as literal string",
+		"-w, --word-regexp       match whole words only",
+		"-x, --line-regexp       match whole lines only",
+		"-v, --invert-match      select non-matching lines",
+		"-r, --replace TEXT      replace matches with TEXT",
+		"-c, --count             print count of matching lines per file",
+		"    --count-matches     print count of individual matches per file",
+		"-l, --files-with-matches print only file names with matches",
+		"    --files-without-match print file names without matches",
+		"    --files             list files that would be searched",
+		"-o, --only-matching     print only matching parts",
+		"-m, --max-count NUM     stop after NUM matches per file",
+		"-q, --quiet             suppress output, exit 0 on match",
+		"    --stats             print search statistics",
+		"-n, --line-number       print line numbers (default: on)",
+		"-N, --no-line-number    do not print line numbers",
+		"-I, --no-filename       suppress the prefixing of file names",
+		"-0, --null              use NUL as filename separator",
+		"-b, --byte-offset       show byte offset of each match",
+		"    --column            show column number of first match",
+		"    --vimgrep           show results in vimgrep format",
+		"    --json              show results in JSON Lines format",
+		"-A NUM                  print NUM lines after each match",
+		"-B NUM                  print NUM lines before each match",
+		"-C NUM                  print NUM lines before and after each match",
+		"    --context-separator SEP  separator for context groups (default: --)",
+		"-U, --multiline         match patterns across lines",
+		"-z, --search-zip        search in compressed files (gzip only)",
+		"-g, --glob GLOB         include files matching GLOB",
+		"-t, --type TYPE         only search files of TYPE (e.g., js, py, ts)",
+		"-T, --type-not TYPE     exclude files of TYPE",
+		"-L, --follow            follow symbolic links",
+		"-u, --unrestricted      reduce filtering (-u: no ignore, -uu: +hidden, -uuu: +binary)",
+		"-a, --text              search binary files as text",
+		"    --hidden            search hidden files and directories",
+		"    --no-ignore         don't respect .gitignore/.ignore files",
+		"-d, --max-depth NUM     maximum search depth",
+		"    --sort TYPE         sort files (path, none)",
+		"    --heading           show file path above matches",
+		"    --passthru          print all lines (non-matches use - separator)",
+		"    --include-zero      include files with 0 matches in count output",
+		"    --type-list         list all available file types",
+		"    --help              display this help and exit"
+	]
+}, Ge = {
+	name: "rg",
+	async execute(e, t) {
+		if (o(e)) return s(ve);
+		if (e.includes("--type-list")) return {
+			stdout: V(),
+			stderr: "",
+			exitCode: 0
+		};
+		let n = K(e);
+		return n.success ? X({
+			ctx: t,
+			options: n.options,
+			paths: n.paths,
+			explicitLineNumbers: n.explicitLineNumbers
+		}) : n.error;
+	}
+}, qe = {
+	name: "rg",
+	flags: [
+		{
+			flag: "-i",
+			type: "boolean"
+		},
+		{
+			flag: "-s",
+			type: "boolean"
+		},
+		{
+			flag: "-S",
+			type: "boolean"
+		},
+		{
+			flag: "-F",
+			type: "boolean"
+		},
+		{
+			flag: "-w",
+			type: "boolean"
+		},
+		{
+			flag: "-x",
+			type: "boolean"
+		},
+		{
+			flag: "-v",
+			type: "boolean"
+		},
+		{
+			flag: "-c",
+			type: "boolean"
+		},
+		{
+			flag: "-l",
+			type: "boolean"
+		},
+		{
+			flag: "-o",
+			type: "boolean"
+		},
+		{
+			flag: "-n",
+			type: "boolean"
+		},
+		{
+			flag: "-N",
+			type: "boolean"
+		},
+		{
+			flag: "--hidden",
+			type: "boolean"
+		},
+		{
+			flag: "--no-ignore",
+			type: "boolean"
+		},
+		{
+			flag: "-m",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "-A",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "-B",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "-C",
+			type: "value",
+			valueHint: "number"
+		},
+		{
+			flag: "-g",
+			type: "value",
+			valueHint: "pattern"
+		},
+		{
+			flag: "-t",
+			type: "value",
+			valueHint: "string"
+		},
+		{
+			flag: "-T",
+			type: "value",
+			valueHint: "string"
+		}
+	],
+	needsArgs: !0
+};
+//#endregion
+export { qe as n, Ge as t };
+
+//# sourceMappingURL=chunk-FX7KQCEA-BQU3KSWz.mjs.map