@maltty/cli 1.0.0-rc.0

package/dist/node-C91xGGqn.js

@@ -0,0 +1,644 @@
+import { n as err, r as ok, t as attemptAsync } from "./attemptAsync-BdXzRSIT.js";
+import * as fsNative from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { execFile, spawn } from "node:child_process";
+//#region ../../node_modules/.pnpm/ts-pattern@5.9.0/node_modules/ts-pattern/dist/index.js
+const t = Symbol.for("@ts-pattern/matcher"), e = Symbol.for("@ts-pattern/isVariadic"), n = "@ts-pattern/anonymous-select-key", r = (t) => Boolean(t && "object" == typeof t), i = (e) => e && !!e[t], o = (n, s, c) => {
+	if (i(n)) {
+		const { matched: r, selections: i } = n[t]().match(s);
+		return r && i && Object.keys(i).forEach((t) => c(t, i[t])), r;
+	}
+	if (r(n)) {
+		if (!r(s)) return !1;
+		if (Array.isArray(n)) {
+			if (!Array.isArray(s)) return !1;
+			let t = [], r = [], u = [];
+			for (const o of n.keys()) {
+				const s = n[o];
+				i(s) && s[e] ? u.push(s) : u.length ? r.push(s) : t.push(s);
+			}
+			if (u.length) {
+				if (u.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+				if (s.length < t.length + r.length) return !1;
+				const e = s.slice(0, t.length), n = 0 === r.length ? [] : s.slice(-r.length), i = s.slice(t.length, 0 === r.length ? Infinity : -r.length);
+				return t.every((t, n) => o(t, e[n], c)) && r.every((t, e) => o(t, n[e], c)) && (0 === u.length || o(u[0], i, c));
+			}
+			return n.length === s.length && n.every((t, e) => o(t, s[e], c));
+		}
+		return Reflect.ownKeys(n).every((e) => {
+			const r = n[e];
+			return (e in s || i(u = r) && "optional" === u[t]().matcherType) && o(r, s[e], c);
+			var u;
+		});
+	}
+	return Object.is(s, n);
+}, s = (e) => {
+	var n, o, u;
+	return r(e) ? i(e) ? null != (n = null == (o = (u = e[t]()).getSelectionKeys) ? void 0 : o.call(u)) ? n : [] : Array.isArray(e) ? c(e, s) : c(Object.values(e), s) : [];
+}, c = (t, e) => t.reduce((t, n) => t.concat(e(n)), []);
+function u(...t) {
+	if (1 === t.length) {
+		const [e] = t;
+		return (t) => o(e, t, () => {});
+	}
+	if (2 === t.length) {
+		const [e, n] = t;
+		return o(e, n, () => {});
+	}
+	throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t.length}.`);
+}
+function a(t) {
+	return Object.assign(t, {
+		optional: () => h(t),
+		and: (e) => d(t, e),
+		or: (e) => y(t, e),
+		select: (e) => void 0 === e ? v(t) : v(e, t)
+	});
+}
+function l(t) {
+	return Object.assign(((t) => Object.assign(t, { [Symbol.iterator]() {
+		let n = 0;
+		const r = [{
+			value: Object.assign(t, { [e]: !0 }),
+			done: !1
+		}, {
+			done: !0,
+			value: void 0
+		}];
+		return { next: () => {
+			var t;
+			return null != (t = r[n++]) ? t : r.at(-1);
+		} };
+	} }))(t), {
+		optional: () => l(h(t)),
+		select: (e) => l(void 0 === e ? v(t) : v(e, t))
+	});
+}
+function h(e) {
+	return a({ [t]: () => ({
+		match: (t) => {
+			let n = {};
+			const r = (t, e) => {
+				n[t] = e;
+			};
+			return void 0 === t ? (s(e).forEach((t) => r(t, void 0)), {
+				matched: !0,
+				selections: n
+			}) : {
+				matched: o(e, t, r),
+				selections: n
+			};
+		},
+		getSelectionKeys: () => s(e),
+		matcherType: "optional"
+	}) });
+}
+const f = (t, e) => {
+	for (const n of t) if (!e(n)) return !1;
+	return !0;
+}, g = (t, e) => {
+	for (const [n, r] of t.entries()) if (!e(r, n)) return !1;
+	return !0;
+}, m = (t, e) => {
+	const n = Reflect.ownKeys(t);
+	for (const r of n) if (!e(r, t[r])) return !1;
+	return !0;
+};
+function d(...e) {
+	return a({ [t]: () => ({
+		match: (t) => {
+			let n = {};
+			const r = (t, e) => {
+				n[t] = e;
+			};
+			return {
+				matched: e.every((e) => o(e, t, r)),
+				selections: n
+			};
+		},
+		getSelectionKeys: () => c(e, s),
+		matcherType: "and"
+	}) });
+}
+function y(...e) {
+	return a({ [t]: () => ({
+		match: (t) => {
+			let n = {};
+			const r = (t, e) => {
+				n[t] = e;
+			};
+			return c(e, s).forEach((t) => r(t, void 0)), {
+				matched: e.some((e) => o(e, t, r)),
+				selections: n
+			};
+		},
+		getSelectionKeys: () => c(e, s),
+		matcherType: "or"
+	}) });
+}
+function p(e) {
+	return { [t]: () => ({ match: (t) => ({ matched: Boolean(e(t)) }) }) };
+}
+function v(...e) {
+	const r = "string" == typeof e[0] ? e[0] : void 0, i = 2 === e.length ? e[1] : "string" == typeof e[0] ? void 0 : e[0];
+	return a({ [t]: () => ({
+		match: (t) => {
+			let e = { [null != r ? r : n]: t };
+			return {
+				matched: void 0 === i || o(i, t, (t, n) => {
+					e[t] = n;
+				}),
+				selections: e
+			};
+		},
+		getSelectionKeys: () => [null != r ? r : n].concat(void 0 === i ? [] : s(i))
+	}) });
+}
+function b(t) {
+	return !0;
+}
+function w(t) {
+	return "number" == typeof t;
+}
+function S(t) {
+	return "string" == typeof t;
+}
+function j(t) {
+	return "bigint" == typeof t;
+}
+const K = a(p(b)), O = a(p(b)), E = K, x = (t) => Object.assign(a(t), {
+	startsWith: (e) => {
+		return x(d(t, (n = e, p((t) => S(t) && t.startsWith(n)))));
+		var n;
+	},
+	endsWith: (e) => {
+		return x(d(t, (n = e, p((t) => S(t) && t.endsWith(n)))));
+		var n;
+	},
+	minLength: (e) => x(d(t, ((t) => p((e) => S(e) && e.length >= t))(e))),
+	length: (e) => x(d(t, ((t) => p((e) => S(e) && e.length === t))(e))),
+	maxLength: (e) => x(d(t, ((t) => p((e) => S(e) && e.length <= t))(e))),
+	includes: (e) => {
+		return x(d(t, (n = e, p((t) => S(t) && t.includes(n)))));
+		var n;
+	},
+	regex: (e) => {
+		return x(d(t, (n = e, p((t) => S(t) && Boolean(t.match(n))))));
+		var n;
+	}
+}), A = x(p(S)), N = (t) => Object.assign(a(t), {
+	between: (e, n) => N(d(t, ((t, e) => p((n) => w(n) && t <= n && e >= n))(e, n))),
+	lt: (e) => N(d(t, ((t) => p((e) => w(e) && e < t))(e))),
+	gt: (e) => N(d(t, ((t) => p((e) => w(e) && e > t))(e))),
+	lte: (e) => N(d(t, ((t) => p((e) => w(e) && e <= t))(e))),
+	gte: (e) => N(d(t, ((t) => p((e) => w(e) && e >= t))(e))),
+	int: () => N(d(t, p((t) => w(t) && Number.isInteger(t)))),
+	finite: () => N(d(t, p((t) => w(t) && Number.isFinite(t)))),
+	positive: () => N(d(t, p((t) => w(t) && t > 0))),
+	negative: () => N(d(t, p((t) => w(t) && t < 0)))
+}), P = N(p(w)), k = (t) => Object.assign(a(t), {
+	between: (e, n) => k(d(t, ((t, e) => p((n) => j(n) && t <= n && e >= n))(e, n))),
+	lt: (e) => k(d(t, ((t) => p((e) => j(e) && e < t))(e))),
+	gt: (e) => k(d(t, ((t) => p((e) => j(e) && e > t))(e))),
+	lte: (e) => k(d(t, ((t) => p((e) => j(e) && e <= t))(e))),
+	gte: (e) => k(d(t, ((t) => p((e) => j(e) && e >= t))(e))),
+	positive: () => k(d(t, p((t) => j(t) && t > 0))),
+	negative: () => k(d(t, p((t) => j(t) && t < 0)))
+});
+var z = {
+	__proto__: null,
+	matcher: t,
+	optional: h,
+	array: function(...e) {
+		return l({ [t]: () => ({
+			match: (t) => {
+				if (!Array.isArray(t)) return { matched: !1 };
+				if (0 === e.length) return { matched: !0 };
+				const n = e[0];
+				let r = {};
+				if (0 === t.length) return s(n).forEach((t) => {
+					r[t] = [];
+				}), {
+					matched: !0,
+					selections: r
+				};
+				const i = (t, e) => {
+					r[t] = (r[t] || []).concat([e]);
+				};
+				return {
+					matched: t.every((t) => o(n, t, i)),
+					selections: r
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : s(e[0])
+		}) });
+	},
+	set: function(...e) {
+		return a({ [t]: () => ({
+			match: (t) => {
+				if (!(t instanceof Set)) return { matched: !1 };
+				let n = {};
+				if (0 === t.size) return {
+					matched: !0,
+					selections: n
+				};
+				if (0 === e.length) return { matched: !0 };
+				const r = (t, e) => {
+					n[t] = (n[t] || []).concat([e]);
+				}, i = e[0];
+				return {
+					matched: f(t, (t) => o(i, t, r)),
+					selections: n
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : s(e[0])
+		}) });
+	},
+	map: function(...e) {
+		return a({ [t]: () => ({
+			match: (t) => {
+				if (!(t instanceof Map)) return { matched: !1 };
+				let n = {};
+				if (0 === t.size) return {
+					matched: !0,
+					selections: n
+				};
+				const r = (t, e) => {
+					n[t] = (n[t] || []).concat([e]);
+				};
+				if (0 === e.length) return { matched: !0 };
+				var i;
+				if (1 === e.length) throw new Error(`\`P.map\` wasn't given enough arguments. Expected (key, value), received ${null == (i = e[0]) ? void 0 : i.toString()}`);
+				const [s, c] = e;
+				return {
+					matched: g(t, (t, e) => {
+						const n = o(s, e, r), i = o(c, t, r);
+						return n && i;
+					}),
+					selections: n
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : [...s(e[0]), ...s(e[1])]
+		}) });
+	},
+	record: function(...e) {
+		return a({ [t]: () => ({
+			match: (t) => {
+				if (null === t || "object" != typeof t || Array.isArray(t)) return { matched: !1 };
+				var n;
+				if (0 === e.length) throw new Error(`\`P.record\` wasn't given enough arguments. Expected (value) or (key, value), received ${null == (n = e[0]) ? void 0 : n.toString()}`);
+				let r = {};
+				const i = (t, e) => {
+					r[t] = (r[t] || []).concat([e]);
+				}, [s, c] = 1 === e.length ? [A, e[0]] : e;
+				return {
+					matched: m(t, (t, e) => {
+						const n = "string" != typeof t || Number.isNaN(Number(t)) ? null : Number(t), r = null !== n && o(s, n, i), u = o(s, t, i), a = o(c, e, i);
+						return (u || r) && a;
+					}),
+					selections: r
+				};
+			},
+			getSelectionKeys: () => 0 === e.length ? [] : [...s(e[0]), ...s(e[1])]
+		}) });
+	},
+	intersection: d,
+	union: y,
+	not: function(e) {
+		return a({ [t]: () => ({
+			match: (t) => ({ matched: !o(e, t, () => {}) }),
+			getSelectionKeys: () => [],
+			matcherType: "not"
+		}) });
+	},
+	when: p,
+	select: v,
+	any: K,
+	unknown: O,
+	_: E,
+	string: A,
+	number: P,
+	bigint: k(p(j)),
+	boolean: a(p(function(t) {
+		return "boolean" == typeof t;
+	})),
+	symbol: a(p(function(t) {
+		return "symbol" == typeof t;
+	})),
+	nullish: a(p(function(t) {
+		return null == t;
+	})),
+	nonNullable: a(p(function(t) {
+		return null != t;
+	})),
+	instanceOf: function(t) {
+		return a(p(function(t) {
+			return (e) => e instanceof t;
+		}(t)));
+	},
+	shape: function(t) {
+		return a(p(u(t)));
+	}
+};
+var I = class extends Error {
+	constructor(t) {
+		let e;
+		try {
+			e = JSON.stringify(t);
+		} catch (n) {
+			e = t;
+		}
+		super(`Pattern matching error: no pattern matches value ${e}`), this.input = void 0, this.input = t;
+	}
+};
+const L = {
+	matched: !1,
+	value: void 0
+};
+function M(t) {
+	return new R(t, L);
+}
+var R = class R {
+	constructor(t, e) {
+		this.input = void 0, this.state = void 0, this.input = t, this.state = e;
+	}
+	with(...t) {
+		if (this.state.matched) return this;
+		const e = t[t.length - 1], r = [t[0]];
+		let i;
+		3 === t.length && "function" == typeof t[1] ? i = t[1] : t.length > 2 && r.push(...t.slice(1, t.length - 1));
+		let s = !1, c = {};
+		const u = (t, e) => {
+			s = !0, c[t] = e;
+		}, a = !r.some((t) => o(t, this.input, u)) || i && !Boolean(i(this.input)) ? L : {
+			matched: !0,
+			value: e(s ? n in c ? c[n] : c : this.input, this.input)
+		};
+		return new R(this.input, a);
+	}
+	when(t, e) {
+		if (this.state.matched) return this;
+		const n = Boolean(t(this.input));
+		return new R(this.input, n ? {
+			matched: !0,
+			value: e(this.input, this.input)
+		} : L);
+	}
+	otherwise(t) {
+		return this.state.matched ? this.state.value : t(this.input);
+	}
+	exhaustive(t = F) {
+		return this.state.matched ? this.state.value : t(this.input);
+	}
+	run() {
+		return this.exhaustive();
+	}
+	returnType() {
+		return this;
+	}
+	narrow() {
+		return this;
+	}
+};
+function F(t) {
+	throw new I(t);
+}
+//#endregion
+//#region ../utils/dist/chunk-pbuEa-1d.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region ../utils/dist/fs-6FuEguuO.js
+var fs_exports = /* @__PURE__ */ __exportAll({
+	exists: () => exists$1,
+	list: () => list,
+	mkdir: () => mkdir$1,
+	read: () => read,
+	remove: () => remove,
+	write: () => write
+});
+/**
+* Check whether a path exists and is accessible.
+*
+* Wraps `fs.access` into a boolean check — never throws.
+*
+* @param path - The absolute path to check.
+* @returns True when the path exists and is accessible.
+*/
+async function exists$1(path) {
+	const [error] = await attemptAsync(() => fsNative.access(path));
+	return error === null;
+}
+/**
+* Read a file's contents as a UTF-8 string.
+*
+* @param path - The absolute file path to read.
+* @returns A result tuple with the file contents or an Error.
+*/
+async function read(path) {
+	const [error, contents] = await attemptAsync(() => fsNative.readFile(path, "utf8"));
+	if (error || contents === null) return err(new Error(`failed to read ${path}`, { cause: error }));
+	return ok(contents);
+}
+/**
+* Write a UTF-8 string to a file.
+*
+* @param path - The absolute file path to write.
+* @param content - The string content to write.
+* @returns A result tuple with void on success or an Error.
+*/
+async function write(path, content) {
+	const [error] = await attemptAsync(() => fsNative.writeFile(path, content, "utf8"));
+	if (error) return err(new Error(`failed to write ${path}`, { cause: error }));
+	return ok();
+}
+/**
+* List filenames in a directory.
+*
+* @param path - The absolute directory path to list.
+* @returns A result tuple with filenames or an Error.
+*/
+async function list(path) {
+	const [error, entries] = await attemptAsync(() => fsNative.readdir(path));
+	if (error || entries === null) return err(new Error(`failed to list ${path}`, { cause: error }));
+	return ok(entries);
+}
+/**
+* Create a directory, including parent directories.
+*
+* @param path - The absolute directory path to create.
+* @returns A result tuple with void on success or an Error.
+*/
+async function mkdir$1(path) {
+	const [error] = await attemptAsync(() => fsNative.mkdir(path, { recursive: true }));
+	if (error) return err(new Error(`failed to create directory ${path}`, { cause: error }));
+	return ok();
+}
+/**
+* Remove a file or directory. Silently succeeds if the path does not exist.
+*
+* @param path - The absolute path to remove.
+* @returns A result tuple with void on success or an Error.
+*/
+async function remove(path) {
+	const [error] = await attemptAsync(() => fsNative.rm(path, {
+		recursive: true,
+		force: true
+	}));
+	if (error) return err(new Error(`failed to remove ${path}`, { cause: error }));
+	return ok();
+}
+//#endregion
+//#region ../utils/dist/node.js
+var path_exports = /* @__PURE__ */ __exportAll({
+	toImportUrl: () => toImportUrl,
+	toPosixPath: () => toPosixPath
+});
+/**
+* Convert a filesystem path to an ESM import specifier (a `file://` URL).
+*
+* Required wherever a filesystem path becomes a JavaScript import string —
+* dynamic `import()` calls or static import specifiers embedded in generated
+* source code. On Windows, raw paths like `C:\foo\bar.ts` contain `\f`, `\b`,
+* `\u`, and other sequences that JavaScript parses as string escapes, which
+* either crashes the bundler or breaks runtime resolution. The `file://` URL
+* form is platform-neutral (`file:///C:/foo/bar.ts` on Windows,
+* `file:///foo/bar.ts` on POSIX).
+*
+* @param filePath - An absolute filesystem path.
+* @returns A `file://` URL string suitable as an ESM import specifier.
+*/
+function toImportUrl(filePath) {
+	return pathToFileURL(filePath).href;
+}
+/**
+* Normalize a native path string to use forward-slash separators.
+*
+* `path.relative()` and `path.join()` return separators native to the OS
+* (`\` on Windows, `/` elsewhere). When paths flow into string operations —
+* regex matching, `includes()` / `startsWith()` checks, template-engine
+* lookups — Windows backslashes silently break POSIX-shaped patterns.
+* Normalizing once at the boundary lets downstream code assume `/`.
+*
+* Node's `path.join()` accepts forward slashes on Windows and produces
+* correct native paths during filesystem operations, so the normalized form
+* remains usable for subsequent path composition.
+*
+* @param p - A native path string.
+* @returns The path with all `\` replaced by `/`.
+*/
+function toPosixPath(p) {
+	return p.replaceAll("\\", "/");
+}
+var process_exports = /* @__PURE__ */ __exportAll({
+	exec: () => exec,
+	exists: () => exists,
+	spawn: () => spawn$1
+});
+/**
+* Execute a command with arguments and return the result.
+*
+* Wraps `child_process.execFile` into an async Result tuple. On failure,
+* the error includes stderr as a property for diagnostic access.
+*
+* @param params - The command and arguments to execute.
+* @returns A result tuple with stdout/stderr on success or an Error on failure.
+*/
+function exec(params) {
+	const { cmd, args = [], cwd } = params;
+	return new Promise((resolve) => {
+		execFile(cmd, [...args], {
+			cwd,
+			shell: needsShell()
+		}, (error, stdout, stderr) => {
+			if (error) {
+				const enriched = new Error(`${cmd} failed: ${error.message}`, { cause: error });
+				Object.defineProperty(enriched, "stderr", {
+					enumerable: true,
+					value: stderr
+				});
+				resolve(err(enriched));
+				return;
+			}
+			resolve(ok({
+				stdout,
+				stderr
+			}));
+		});
+	});
+}
+/**
+* Spawn an interactive process with inherited stdio.
+*
+* Returns the exit code of the child process. Stdio is inherited so the
+* child process shares the parent's terminal.
+*
+* @param cmd - The command to spawn.
+* @param args - Arguments to pass to the command.
+* @param cwd - Working directory for the child process.
+* @returns The exit code of the spawned process.
+*/
+function spawn$1(params) {
+	return new Promise((resolve) => {
+		const child = spawn(params.cmd, [...params.args], {
+			cwd: params.cwd,
+			shell: needsShell(),
+			stdio: "inherit"
+		});
+		child.on("error", () => {
+			resolve(1);
+		});
+		child.on("close", (code) => {
+			resolve(code ?? 1);
+		});
+	});
+}
+/**
+* Check whether a binary is available on the system PATH.
+*
+* Uses `which` (unix) or `where` (windows) to resolve the binary
+* without executing it.
+*
+* @param cmd - The command name to check.
+* @returns `true` when the command is found on PATH.
+*/
+function exists(cmd) {
+	const lookup = M(process.platform).with("win32", () => "where").otherwise(() => "which");
+	return new Promise((resolve) => {
+		execFile(lookup, [cmd], (error) => {
+			resolve(error === null);
+		});
+	});
+}
+/**
+* Whether the current platform requires `shell: true` for `child_process`
+* calls.
+*
+* Evaluated at call time rather than captured at module load so tests that
+* stub `process.platform` get a fresh value, and so the result is never
+* frozen against a value that was true only at startup.
+*
+* On Windows, npm/pnpm-installed CLIs (e.g. `tsx`) ship as `.cmd` shim
+* files that Node's `child_process` can't launch via `CreateProcess` —
+* only `cmd.exe` can. `shell: true` routes through `cmd.exe` so the shim
+* runs. On POSIX it's unnecessary and changes argument escaping, so it's
+* gated to Windows.
+*
+* @private
+* @returns `true` on Windows, `false` elsewhere.
+*/
+function needsShell() {
+	return process.platform === "win32";
+}
+//#endregion
+export { z as a, M as i, process_exports as n, fs_exports as r, path_exports as t };
+
+//# sourceMappingURL=node-C91xGGqn.js.map