@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/chunk-KWGBQNTV-Ba-YzffV.cjs

@@ -0,0 +1,719 @@
+const require_chunk_QAYAQNCG = require("./chunk-QAYAQNCG-ROQh1hrZ.cjs");
+const require_chunk_QIQMJJZ4 = require("./chunk-QIQMJJZ4-Cm4e9-4O.cjs");
+let node_module = require("node:module");
+let node_zlib = require("node:zlib");
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-KWGBQNTV.js
+(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+var O = {
+	name: "gzip",
+	summary: "compress or expand files",
+	usage: "gzip [OPTION]... [FILE]...",
+	description: `Compress FILEs (by default, in-place).
+
+When no FILE is given, or when FILE is -, read from standard input.
+
+With -d, decompress instead.`,
+	options: [
+		"-c, --stdout      write to standard output, keep original files",
+		"-d, --decompress  decompress",
+		"-f, --force       force overwrite of output file",
+		"-k, --keep        keep (don't delete) input files",
+		"-l, --list        list compressed file contents",
+		"-n, --no-name     do not save or restore the original name and timestamp",
+		"-N, --name        save or restore the original file name and timestamp",
+		"-q, --quiet       suppress all warnings",
+		"-r, --recursive   operate recursively on directories",
+		"-S, --suffix=SUF  use suffix SUF on compressed files (default: .gz)",
+		"-t, --test        test compressed file integrity",
+		"-v, --verbose     verbose mode",
+		"-1, --fast        compress faster",
+		"-9, --best        compress better",
+		"    --help        display this help and exit"
+	]
+}, U = {
+	name: "gunzip",
+	summary: "decompress files",
+	usage: "gunzip [OPTION]... [FILE]...",
+	description: `Decompress FILEs (by default, in-place).
+
+When no FILE is given, or when FILE is -, read from standard input.`,
+	options: [
+		"-c, --stdout      write to standard output, keep original files",
+		"-f, --force       force overwrite of output file",
+		"-k, --keep        keep (don't delete) input files",
+		"-l, --list        list compressed file contents",
+		"-n, --no-name     do not restore the original name and timestamp",
+		"-N, --name        restore the original file name and timestamp",
+		"-q, --quiet       suppress all warnings",
+		"-r, --recursive   operate recursively on directories",
+		"-S, --suffix=SUF  use suffix SUF on compressed files (default: .gz)",
+		"-t, --test        test compressed file integrity",
+		"-v, --verbose     verbose mode",
+		"    --help        display this help and exit"
+	]
+}, D = {
+	name: "zcat",
+	summary: "decompress files to stdout",
+	usage: "zcat [OPTION]... [FILE]...",
+	description: `Decompress FILEs to standard output.
+
+When no FILE is given, or when FILE is -, read from standard input.`,
+	options: [
+		"-f, --force       force; read compressed data even from a terminal",
+		"-l, --list        list compressed file contents",
+		"-q, --quiet       suppress all warnings",
+		"-S, --suffix=SUF  use suffix SUF on compressed files (default: .gz)",
+		"-t, --test        test compressed file integrity",
+		"-v, --verbose     verbose mode",
+		"    --help        display this help and exit"
+	]
+}, T = {
+	stdout: {
+		short: "c",
+		long: "stdout",
+		type: "boolean"
+	},
+	toStdout: {
+		long: "to-stdout",
+		type: "boolean"
+	},
+	decompress: {
+		short: "d",
+		long: "decompress",
+		type: "boolean"
+	},
+	uncompress: {
+		long: "uncompress",
+		type: "boolean"
+	},
+	force: {
+		short: "f",
+		long: "force",
+		type: "boolean"
+	},
+	keep: {
+		short: "k",
+		long: "keep",
+		type: "boolean"
+	},
+	list: {
+		short: "l",
+		long: "list",
+		type: "boolean"
+	},
+	noName: {
+		short: "n",
+		long: "no-name",
+		type: "boolean"
+	},
+	name: {
+		short: "N",
+		long: "name",
+		type: "boolean"
+	},
+	quiet: {
+		short: "q",
+		long: "quiet",
+		type: "boolean"
+	},
+	recursive: {
+		short: "r",
+		long: "recursive",
+		type: "boolean"
+	},
+	suffix: {
+		short: "S",
+		long: "suffix",
+		type: "string",
+		default: ".gz"
+	},
+	test: {
+		short: "t",
+		long: "test",
+		type: "boolean"
+	},
+	verbose: {
+		short: "v",
+		long: "verbose",
+		type: "boolean"
+	},
+	fast: {
+		short: "1",
+		long: "fast",
+		type: "boolean"
+	},
+	level2: {
+		short: "2",
+		type: "boolean"
+	},
+	level3: {
+		short: "3",
+		type: "boolean"
+	},
+	level4: {
+		short: "4",
+		type: "boolean"
+	},
+	level5: {
+		short: "5",
+		type: "boolean"
+	},
+	level6: {
+		short: "6",
+		type: "boolean"
+	},
+	level7: {
+		short: "7",
+		type: "boolean"
+	},
+	level8: {
+		short: "8",
+		type: "boolean"
+	},
+	best: {
+		short: "9",
+		long: "best",
+		type: "boolean"
+	}
+};
+function E(e) {
+	return e.best ? node_zlib.constants.Z_BEST_COMPRESSION : e.level8 ? 8 : e.level7 ? 7 : e.level6 ? 6 : e.level5 ? 5 : e.level4 ? 4 : e.level3 ? 3 : e.level2 ? 2 : e.fast ? node_zlib.constants.Z_BEST_SPEED : node_zlib.constants.Z_DEFAULT_COMPRESSION;
+}
+function k(e) {
+	if (e.length < 10) return {
+		originalName: null,
+		mtime: null,
+		headerSize: 0
+	};
+	if (e[0] !== 31 || e[1] !== 139) return {
+		originalName: null,
+		mtime: null,
+		headerSize: 0
+	};
+	let t = e[3], r = e[4] | e[5] << 8 | e[6] << 16 | e[7] << 24, o = 10;
+	if (t & 4) {
+		if (o + 2 > e.length) return {
+			originalName: null,
+			mtime: null,
+			headerSize: 0
+		};
+		let n = e[o] | e[o + 1] << 8;
+		o += 2 + n;
+	}
+	let s = null;
+	if (t & 8) {
+		let n = o;
+		for (; o < e.length && e[o] !== 0;) o++;
+		o < e.length && (s = new TextDecoder().decode(e.slice(n, o)), o++);
+	}
+	if (t & 16) {
+		for (; o < e.length && e[o] !== 0;) o++;
+		o++;
+	}
+	return t & 2 && (o += 2), {
+		originalName: s,
+		mtime: r > 0 ? /* @__PURE__ */ new Date(r * 1e3) : null,
+		headerSize: o
+	};
+}
+function q(e) {
+	if (e.length < 4) return 0;
+	let t = e.length;
+	return e[t - 4] | e[t - 3] << 8 | e[t - 2] << 16 | e[t - 1] << 24;
+}
+function b(e) {
+	return e.length >= 2 && e[0] === 31 && e[1] === 139;
+}
+function m(e) {
+	return Buffer.from(e).toString("latin1");
+}
+function I(e) {
+	return e.limits?.maxOutputSize ?? 0;
+}
+function v(e, t) {
+	if (t > 0) {
+		if (q(e) > t) throw new Error(`decompressed data exceeds limit (${t} bytes)`);
+		return (0, node_zlib.gunzipSync)(e, { maxOutputLength: t });
+	}
+	return (0, node_zlib.gunzipSync)(e);
+}
+async function L(e, t, r, o, s, n) {
+	let a = r.suffix, f, p, d, c = I(e);
+	if (t === "-" || t === "") if (d = Uint8Array.from(e.stdin, (i) => i.charCodeAt(0)), s) {
+		if (!b(d)) return r.quiet ? {
+			stdout: "",
+			stderr: "",
+			exitCode: 1
+		} : {
+			stdout: "",
+			stderr: `${o}: stdin: not in gzip format
+`,
+			exitCode: 1
+		};
+		try {
+			return {
+				stdout: m(v(d, c)),
+				stderr: "",
+				exitCode: 0
+			};
+		} catch (i) {
+			return {
+				stdout: "",
+				stderr: `${o}: stdin: ${i instanceof Error ? i.message : "unknown error"}
+`,
+				exitCode: 1
+			};
+		}
+	} else {
+		let i = E(r);
+		return {
+			stdout: m((0, node_zlib.gzipSync)(d, { level: i })),
+			stderr: "",
+			exitCode: 0
+		};
+	}
+	f = e.fs.resolvePath(e.cwd, t);
+	try {
+		if ((await e.fs.stat(f)).isDirectory) return r.recursive ? await P(e, f, r, o, s, n) : r.quiet ? {
+			stdout: "",
+			stderr: "",
+			exitCode: 1
+		} : {
+			stdout: "",
+			stderr: `${o}: ${t}: is a directory -- ignored
+`,
+			exitCode: 1
+		};
+	} catch {
+		return {
+			stdout: "",
+			stderr: `${o}: ${t}: No such file or directory
+`,
+			exitCode: 1
+		};
+	}
+	try {
+		d = await e.fs.readFileBuffer(f);
+	} catch {
+		return {
+			stdout: "",
+			stderr: `${o}: ${t}: No such file or directory
+`,
+			exitCode: 1
+		};
+	}
+	if (s) {
+		if (!t.endsWith(a)) return r.quiet ? {
+			stdout: "",
+			stderr: "",
+			exitCode: 1
+		} : {
+			stdout: "",
+			stderr: `${o}: ${t}: unknown suffix -- ignored
+`,
+			exitCode: 1
+		};
+		if (!b(d)) return r.quiet ? {
+			stdout: "",
+			stderr: "",
+			exitCode: 1
+		} : {
+			stdout: "",
+			stderr: `${o}: ${t}: not in gzip format
+`,
+			exitCode: 1
+		};
+		let i;
+		try {
+			i = v(d, c);
+		} catch (l) {
+			return {
+				stdout: "",
+				stderr: `${o}: ${t}: ${l instanceof Error ? l.message : "unknown error"}
+`,
+				exitCode: 1
+			};
+		}
+		if (n) return {
+			stdout: m(i),
+			stderr: "",
+			exitCode: 0
+		};
+		if (r.name) {
+			let l = k(d);
+			l.originalName ? p = e.fs.resolvePath(e.cwd, l.originalName) : p = f.slice(0, -a.length);
+		} else p = f.slice(0, -a.length);
+		if (!r.force) try {
+			return await e.fs.stat(p), {
+				stdout: "",
+				stderr: `${o}: ${p} already exists; not overwritten
+`,
+				exitCode: 1
+			};
+		} catch {}
+		if (await e.fs.writeFile(p, i), !r.keep && !n && await e.fs.rm(f), r.verbose) return {
+			stdout: "",
+			stderr: `${t}:	${d.length > 0 ? ((1 - d.length / i.length) * 100).toFixed(1) : "0.0"}% -- replaced with ${p.split("/").pop()}
+`,
+			exitCode: 0
+		};
+		return {
+			stdout: "",
+			stderr: "",
+			exitCode: 0
+		};
+	} else {
+		if (t.endsWith(a)) return r.quiet ? {
+			stdout: "",
+			stderr: "",
+			exitCode: 1
+		} : {
+			stdout: "",
+			stderr: `${o}: ${t} already has ${a} suffix -- unchanged
+`,
+			exitCode: 1
+		};
+		let i = E(r), l;
+		try {
+			l = (0, node_zlib.gzipSync)(d, { level: i });
+		} catch (u) {
+			return {
+				stdout: "",
+				stderr: `${o}: ${t}: ${u instanceof Error ? u.message : "unknown error"}
+`,
+				exitCode: 1
+			};
+		}
+		if (n) return {
+			stdout: m(l),
+			stderr: "",
+			exitCode: 0
+		};
+		if (p = f + a, !r.force) try {
+			return await e.fs.stat(p), {
+				stdout: "",
+				stderr: `${o}: ${p} already exists; not overwritten
+`,
+				exitCode: 1
+			};
+		} catch {}
+		if (await e.fs.writeFile(p, l), !r.keep && !n && await e.fs.rm(f), r.verbose) return {
+			stdout: "",
+			stderr: `${t}:	${d.length > 0 ? ((1 - l.length / d.length) * 100).toFixed(1) : "0.0"}% -- replaced with ${p.split("/").pop()}
+`,
+			exitCode: 0
+		};
+		return {
+			stdout: "",
+			stderr: "",
+			exitCode: 0
+		};
+	}
+}
+async function P(e, t, r, o, s, n) {
+	let a = await e.fs.readdir(t), f = "", p = "", d = 0;
+	for (let c of a) {
+		let i = e.fs.resolvePath(t, c), l = await e.fs.stat(i);
+		if (l.isDirectory) {
+			let u = await P(e, i, r, o, s, n);
+			f += u.stdout, p += u.stderr, u.exitCode !== 0 && (d = u.exitCode);
+		} else if (l.isFile) {
+			let u = r.suffix;
+			if (s && !c.endsWith(u) || !s && c.endsWith(u)) continue;
+			let y = await L(e, i.startsWith(`${e.cwd}/`) ? i.slice(e.cwd.length + 1) : i, r, o, s, n);
+			f += y.stdout, p += y.stderr, y.exitCode !== 0 && (d = y.exitCode);
+		}
+	}
+	return {
+		stdout: f,
+		stderr: p,
+		exitCode: d
+	};
+}
+async function W(e, t, r, o) {
+	let s;
+	if (t === "-" || t === "") s = Uint8Array.from(e.stdin, (i) => i.charCodeAt(0));
+	else {
+		let i = e.fs.resolvePath(e.cwd, t);
+		try {
+			s = await e.fs.readFileBuffer(i);
+		} catch {
+			return {
+				stdout: "",
+				stderr: `${o}: ${t}: No such file or directory
+`,
+				exitCode: 1
+			};
+		}
+	}
+	if (!b(s)) return r.quiet ? {
+		stdout: "",
+		stderr: "",
+		exitCode: 1
+	} : {
+		stdout: "",
+		stderr: `${o}: ${t}: not in gzip format
+`,
+		exitCode: 1
+	};
+	let n = s.length, a = q(s), f = a > 0 ? ((1 - n / a) * 100).toFixed(1) : "0.0", d = k(s).originalName || (t === "-" ? "" : t.replace(/\.gz$/, ""));
+	return {
+		stdout: `${n.toString().padStart(10)} ${a.toString().padStart(10)} ${f.padStart(5)}% ${d}
+`,
+		stderr: "",
+		exitCode: 0
+	};
+}
+async function A(e, t, r, o) {
+	let s;
+	if (t === "-" || t === "") s = Uint8Array.from(e.stdin, (n) => n.charCodeAt(0));
+	else {
+		let n = e.fs.resolvePath(e.cwd, t);
+		try {
+			s = await e.fs.readFileBuffer(n);
+		} catch {
+			return {
+				stdout: "",
+				stderr: `${o}: ${t}: No such file or directory
+`,
+				exitCode: 1
+			};
+		}
+	}
+	if (!b(s)) return r.quiet ? {
+		stdout: "",
+		stderr: "",
+		exitCode: 1
+	} : {
+		stdout: "",
+		stderr: `${o}: ${t}: not in gzip format
+`,
+		exitCode: 1
+	};
+	try {
+		return v(s, I(e)), r.verbose ? {
+			stdout: "",
+			stderr: `${t}:	OK
+`,
+			exitCode: 0
+		} : {
+			stdout: "",
+			stderr: "",
+			exitCode: 0
+		};
+	} catch (n) {
+		return {
+			stdout: "",
+			stderr: `${o}: ${t}: ${n instanceof Error ? n.message : "invalid"}
+`,
+			exitCode: 1
+		};
+	}
+}
+async function C(e, t, r) {
+	let o$1 = r === "zcat" ? D : r === "gunzip" ? U : O;
+	if (require_chunk_QAYAQNCG.o(e)) return require_chunk_QAYAQNCG.s(o$1);
+	let s$1 = require_chunk_QIQMJJZ4.x(r, e, T);
+	if (!s$1.ok) return s$1.error.stderr.includes("unrecognized option"), s$1.error;
+	let n = s$1.result.flags, a = s$1.result.positional, f = r === "gunzip" || r === "zcat" || n.decompress || n.uncompress, p = r === "zcat" || n.stdout || n.toStdout;
+	if (n.list) {
+		a.length === 0 && (a = ["-"]);
+		let l = `  compressed uncompressed  ratio uncompressed_name
+`, u = "", g = 0;
+		for (let y of a) {
+			let h = await W(t, y, n, r);
+			l += h.stdout, u += h.stderr, h.exitCode !== 0 && (g = h.exitCode);
+		}
+		return {
+			stdout: l,
+			stderr: u,
+			exitCode: g
+		};
+	}
+	if (n.test) {
+		a.length === 0 && (a = ["-"]);
+		let l = "", u = "", g = 0;
+		for (let y of a) {
+			let h = await A(t, y, n, r);
+			l += h.stdout, u += h.stderr, h.exitCode !== 0 && (g = h.exitCode);
+		}
+		return {
+			stdout: l,
+			stderr: u,
+			exitCode: g
+		};
+	}
+	a.length === 0 && (a = ["-"]);
+	let d = "", c = "", i = 0;
+	for (let l of a) {
+		let u = await L(t, l, n, r, f, p);
+		d += u.stdout, c += u.stderr, u.exitCode !== 0 && (i = u.exitCode);
+	}
+	return {
+		stdout: d,
+		stderr: c,
+		exitCode: i
+	};
+}
+var Z = {
+	name: "gzip",
+	async execute(e, t) {
+		return {
+			...await C(e, t, "gzip"),
+			stdoutEncoding: "binary"
+		};
+	}
+}, R = {
+	name: "gunzip",
+	async execute(e, t) {
+		return {
+			...await C(e, t, "gunzip"),
+			stdoutEncoding: "binary"
+		};
+	}
+}, K = {
+	name: "zcat",
+	async execute(e, t) {
+		return {
+			...await C(e, t, "zcat"),
+			stdoutEncoding: "binary"
+		};
+	}
+}, j = {
+	name: "gzip",
+	flags: [
+		{
+			flag: "-c",
+			type: "boolean"
+		},
+		{
+			flag: "-d",
+			type: "boolean"
+		},
+		{
+			flag: "-f",
+			type: "boolean"
+		},
+		{
+			flag: "-k",
+			type: "boolean"
+		},
+		{
+			flag: "-l",
+			type: "boolean"
+		},
+		{
+			flag: "-n",
+			type: "boolean"
+		},
+		{
+			flag: "-q",
+			type: "boolean"
+		},
+		{
+			flag: "-r",
+			type: "boolean"
+		},
+		{
+			flag: "-t",
+			type: "boolean"
+		},
+		{
+			flag: "-v",
+			type: "boolean"
+		},
+		{
+			flag: "-1",
+			type: "boolean"
+		},
+		{
+			flag: "-9",
+			type: "boolean"
+		}
+	],
+	stdinType: "binary",
+	needsFiles: !0
+}, J = {
+	name: "gunzip",
+	flags: [
+		{
+			flag: "-c",
+			type: "boolean"
+		},
+		{
+			flag: "-f",
+			type: "boolean"
+		},
+		{
+			flag: "-k",
+			type: "boolean"
+		},
+		{
+			flag: "-q",
+			type: "boolean"
+		},
+		{
+			flag: "-v",
+			type: "boolean"
+		}
+	],
+	stdinType: "binary",
+	needsFiles: !0
+}, Q = {
+	name: "zcat",
+	flags: [
+		{
+			flag: "-f",
+			type: "boolean"
+		},
+		{
+			flag: "-q",
+			type: "boolean"
+		},
+		{
+			flag: "-v",
+			type: "boolean"
+		}
+	],
+	stdinType: "binary",
+	needsFiles: !0
+};
+//#endregion
+Object.defineProperty(exports, "J", {
+	enumerable: true,
+	get: function() {
+		return J;
+	}
+});
+Object.defineProperty(exports, "K", {
+	enumerable: true,
+	get: function() {
+		return K;
+	}
+});
+Object.defineProperty(exports, "Q", {
+	enumerable: true,
+	get: function() {
+		return Q;
+	}
+});
+Object.defineProperty(exports, "R", {
+	enumerable: true,
+	get: function() {
+		return R;
+	}
+});
+Object.defineProperty(exports, "Z", {
+	enumerable: true,
+	get: function() {
+		return Z;
+	}
+});
+Object.defineProperty(exports, "j", {
+	enumerable: true,
+	get: function() {
+		return j;
+	}
+});
+
+//# sourceMappingURL=chunk-KWGBQNTV-Ba-YzffV.cjs.map