@goodbyenjn/utils 26.1.2 → 26.1.4

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://badge.fury.io/js/@goodbyenjn%2Futils.svg)](https://badge.fury.io/js/@goodbyenjn%2Futils)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A modern TypeScript/JavaScript utility library providing a comprehensive collection of type-safe utility functions, functional error handling with the Result pattern, and filesystem operations.
+A modern TypeScript/JavaScript utility library providing a comprehensive collection of type-safe utility functions, functional error handling with the Result pattern, filesystem operations, and shell command execution.
 
 ## Features
 
@@ -12,7 +12,8 @@ A modern TypeScript/JavaScript utility library providing a comprehensive collect
 - 📦 **Modular**: Import only what you need with tree-shakable exports and multiple entry points
 - 🛡️ **Result Pattern**: Functional error handling without exceptions, based on Rust-style Result types
 - 📁 **Safe File System**: Type-safe file system operations with Result-based error handling
-- 🧰 **Common Utilities**: String manipulation, math operations, promise utilities, shell commands, and error handling
+- 🐚 **Shell Execution**: Powerful and flexible shell command execution with piping support
+- 🧰 **Common Utilities**: String manipulation, math operations, promise utilities, and error handling
 - 📊 **Remeda Extensions**: Extended utilities built on top of [Remeda](https://remedajs.com/)
 
 ## Installation
@@ -31,7 +32,8 @@ yarn add @goodbyenjn/utils
 
 ```typescript
 // Import what you need from the main module
-import { sleep, template, $ } from "@goodbyenjn/utils";
+import { sleep, template } from "@goodbyenjn/utils";
+import { $ } from "@goodbyenjn/utils/shell";
 import { safeReadFile } from "@goodbyenjn/utils/fs";
 import { ok, Result } from "@goodbyenjn/utils/result";
 ```
@@ -151,30 +153,32 @@ const result = await promise;
 #### Shell Command Execution
 
 ```typescript
-import { $ } from "@goodbyenjn/utils";
-
-// Execute shell commands safely using template literals
-const result = await $`ls -la`;
-if (result.isOk()) {
-    console.log("Command succeeded:");
-    console.log("stdout:", result.unwrap().stdout);
-    console.log("stderr:", result.unwrap().stderr);
-} else if (result.isErr()) {
-    console.error("Command failed:", result.unwrapErr().message);
-}
+import { $ } from "@goodbyenjn/utils/shell";
+
+// Execute shell commands with template literals
+const result = await $`npm install`;
+console.log(result.stdout);
+console.log(result.stderr);
+
+// String command with args
+const output = await $("ls", ["-la"]);
+console.log(output.stdout);
 
-// Complex command with options
-const { $ } = await import("@goodbyenjn/utils");
-const deployResult = await $`docker build -t myapp .`;
-if (deployResult.isOk()) {
-    const { stdout, stderr } = deployResult.unwrap();
-    console.log("Build output:", stdout);
+// Pipe commands
+const piped = await $`echo "hello"`.pipe`cat`;
+console.log(piped.stdout);
+
+// Iterate output line by line
+for await (const line of $`cat large-file.txt`) {
+    console.log(line);
 }
 
-// Using quoteShellArg for safe argument escaping
-import { quoteShellArg } from "@goodbyenjn/utils";
-const userInput = "'; rm -rf /;";
-const safeArg = quoteShellArg(userInput); // Properly escaped for shell
+// Using options
+const result2 = await $("npm", ["install"], { cwd: "/path/to/project" });
+
+// Factory function with options
+const withCwd = $({ cwd: "/path/to/project" });
+const result3 = await withCwd`npm install`;
 ```
 
 #### Math Utilities

package/dist/chunks/{chunk-f4c5d38b.js → chunk-af8ca15e.js}

@@ -1,4 +1,4 @@
-import { Dr as t, F as isFunction, Fn as e$6, Nn as e$4, On as e, P as isPromiseLike, Pn as e$3, Sn as e$2, Tn as e$8, bn as e$7, gn as e$1, hn as e$5 } from "./chunk-267b337b.js";
+import { Dr as t, F as isFunction, Fn as e$6, Nn as e$4, On as e, P as isPromiseLike, Pn as e$3, Sn as e$2, Tn as e$8, bn as e$7, gn as e$1, hn as e$5 } from "./chunk-b970a8d0.js";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -1001,7 +1001,7 @@ const unindent = (...params) => {
 		return unindentImpl;
 	}
 	if (e$1(params[0]) || e$6(params[0])) return unindentImpl(...params);
-	throw new TypeError("Invalid arguments.");
+	throw new TypeError(`First parameter has an invalid type: "${typeof params[0]}"`);
 };
 /**
 * @example
@@ -1051,7 +1051,7 @@ const indent = (...params) => {
 		indentString = params[0];
 		return indentImpl;
 	}
-	throw new TypeError("Invalid arguments.");
+	throw new TypeError(`First parameter has an invalid type: "${typeof params[0]}"`);
 };
 function template(str, ...args) {
 	const [firstArg, fallback] = args;
@@ -1065,74 +1065,6 @@ function template(str, ...args) {
 	});
 }
 
-//#endregion
-//#region src/common/shell.ts
-const REGEXP_NULL_CHAR = /\x00+/g;
-const REGEXP_SAFE_CHARS = /^[A-Za-z0-9,:=_./-]+$/;
-const REGEXP_SINGLE_QUOTES = /'+/g;
-const noop = () => {};
-const pipeToStdout = (chunk) => process.stdout.write(chunk);
-const pipeToStderr = (chunk) => process.stderr.write(chunk);
-async function $(cmd, ...values) {
-	const { spawn } = await import("node:child_process");
-	const [command, options] = e$1(cmd) ? [cmd, values[0] || {}] : [concatTemplateStrings(cmd, values), {}];
-	const stdio = [
-		"inherit",
-		"pipe",
-		"pipe"
-	];
-	let onStdin = noop;
-	if (options.onStdin !== void 0) {
-		stdio[0] = "pipe";
-		if (isFunction(options.onStdin)) onStdin = options.onStdin;
-		else {
-			const chunk = options.onStdin;
-			onStdin = (stdin) => stdin.write(chunk);
-		}
-	}
-	const onStdout = options.onStdout === "ignore" ? noop : options.onStdout === "print" ? pipeToStdout : options.onStdout || noop;
-	const onStderr = options.onStderr === "ignore" ? noop : options.onStderr === "print" ? pipeToStderr : options.onStderr || noop;
-	const fn = async () => {
-		const { promise, reject, resolve } = createPromiseWithResolvers();
-		const child = spawn(command, {
-			shell: true,
-			stdio
-		});
-		if (stdio[0] === "pipe" && child.stdin) {
-			await onStdin(child.stdin);
-			child.stdin?.end();
-		}
-		let stdout = "";
-		let stderr = "";
-		child.stdout?.on("data", (data) => {
-			const chunk = data.toString();
-			stdout += chunk;
-			onStdout(chunk);
-		});
-		child.stderr?.on("data", (data) => {
-			const chunk = data.toString();
-			stderr += chunk;
-			onStderr(chunk);
-		});
-		child.on("error", reject);
-		child.on("close", (code) => {
-			if (code === 0) resolve({
-				stdout: stdout.trim(),
-				stderr: stderr.trim()
-			});
-			else reject(/* @__PURE__ */ new Error(`Command exited with code ${code}`));
-		});
-		return await promise;
-	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to execute command: ${cmd}`);
-}
-const quoteShellArg = (arg) => {
-	if (!arg) return "''";
-	const cleaned = String(arg).replace(REGEXP_NULL_CHAR, "");
-	if (REGEXP_SAFE_CHARS.exec(cleaned)?.[0].length === cleaned.length) return cleaned;
-	return `'${cleaned.replace(REGEXP_SINGLE_QUOTES, (matched) => matched.length === 1 ? `'\\''` : `'"${matched}"'`)}'`.replace(/^''/, "").replace(/''$/, "");
-};
-
 //#endregion
 //#region src/common/throttle.ts
 const wrap = (fn, wait, options) => {
@@ -1168,4 +1100,4 @@ const throttle = (fn, wait = 0, options = {}) => {
 };
 
 //#endregion
-export { stringify as A, parseKeyValuePairs as C, getErrorMessage as D, scale as E, safeTry as F, ResultError as I, __commonJSMin as L, Result as M, err as N, normalizeError as O, ok as P, __toESM as R, sleep as S, linear as T, toForwardSlash as _, addPrefix as a, createPromiseWithResolvers as b, indent as c, removePrefix as d, removeSuffix as f, template as g, splitWithSlash as h, quoteShellArg as i, unsafeParse as j, safeParse as k, join as l, splitByLineBreak as m, throttle as n, addSuffix as o, split as p, $ as r, concatTemplateStrings as s, debounce as t, joinWithSlash as u, unindent as v, parseValueToBoolean as w, createSingleton as x, createLock as y };
+export { Result as A, linear as C, safeParse as D, normalizeError as E, __commonJSMin as F, __toESM as I, ok as M, safeTry as N, stringify as O, ResultError as P, parseValueToBoolean as S, getErrorMessage as T, createLock as _, concatTemplateStrings as a, sleep as b, joinWithSlash as c, split as d, splitByLineBreak as f, unindent as g, toForwardSlash as h, addSuffix as i, err as j, unsafeParse as k, removePrefix as l, template as m, throttle as n, indent as o, splitWithSlash as p, addPrefix as r, join as s, debounce as t, removeSuffix as u, createPromiseWithResolvers as v, scale as w, parseKeyValuePairs as x, createSingleton as y };

package/dist/chunks/{chunk-4b76d1c4.d.ts → chunk-f11577d4.d.ts}

@@ -1,4 +1,4 @@
-import { jn as NonEmptyTuple, ri as AsyncFn, si as SyncFn } from "./chunk-a07ed28f.js";
+import { jn as NonEmptyTuple, ri as AsyncFn, si as SyncFn } from "./chunk-566a516c.js";
 
 //#region src/result/error.d.ts
 declare class ResultError extends Error {

package/dist/common.d.ts

@@ -1,5 +1,5 @@
-import { i as Result } from "./chunks/chunk-4b76d1c4.js";
-import { ai as Fn, on as Promisable, ri as AsyncFn } from "./chunks/chunk-a07ed28f.js";
+import { i as Result } from "./chunks/chunk-f11577d4.js";
+import { ai as Fn, ri as AsyncFn } from "./chunks/chunk-566a516c.js";
 
 //#region src/common/error.d.ts
 declare const normalizeError: (error: unknown, caller?: Function) => Error;
@@ -82,20 +82,6 @@ declare const createSingleton: <T>(fn: AsyncFn<T>) => Singleton<T>;
 declare const createLock: () => Lock;
 declare const createPromiseWithResolvers: <T>() => PromiseWithResolvers<T>;
 //#endregion
-//#region src/common/shell.d.ts
-interface ShellExecOptions {
-  onStdin?: string | Buffer | ((stdin: NodeJS.WritableStream) => Promisable<any>);
-  onStdout?: "ignore" | "print" | ((chunk: string) => Promisable<any>);
-  onStderr?: "ignore" | "print" | ((chunk: string) => Promisable<any>);
-}
-interface ShellExecResult {
-  stdout: string;
-  stderr: string;
-}
-declare function $(cmd: string, options?: ShellExecOptions): Promise<Result<ShellExecResult, Error>>;
-declare function $(cmd: TemplateStringsArray, ...values: any[]): Promise<Result<ShellExecResult, Error>>;
-declare const quoteShellArg: (arg: string) => string;
-//#endregion
 //#region src/common/string.d.ts
 declare const addPrefix: (prefix: string, str: string) => string;
 declare const addSuffix: (suffix: string, str: string) => string;
@@ -206,4 +192,4 @@ type ThrottleOptions = Options;
 declare const debounce: <T extends Fn>(fn: T, wait?: number, options?: DebounceOptions) => DebouncedFn<T>;
 declare const throttle: <T extends Fn>(fn: T, wait?: number, options?: ThrottleOptions) => ThrottledFn<T>;
 //#endregion
-export { $, type DebounceOptions, type DebouncedFn, type Lock, type PromiseWithResolvers, type ShellExecOptions, type ShellExecResult, type Singleton, type Stringify, type ThrottleOptions, type ThrottledFn, addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, quoteShellArg, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };
+export { type DebounceOptions, type DebouncedFn, type Lock, type PromiseWithResolvers, type Singleton, type Stringify, type ThrottleOptions, type ThrottledFn, addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };

package/dist/common.js

@@ -1,3 +1,3 @@
-import { A as stringify, C as parseKeyValuePairs, D as getErrorMessage, E as scale, O as normalizeError, S as sleep, T as linear, _ as toForwardSlash, a as addPrefix, b as createPromiseWithResolvers, c as indent, d as removePrefix, f as removeSuffix, g as template, h as splitWithSlash, i as quoteShellArg, j as unsafeParse, k as safeParse, l as join, m as splitByLineBreak, n as throttle, o as addSuffix, p as split, r as $, s as concatTemplateStrings, t as debounce, u as joinWithSlash, v as unindent, w as parseValueToBoolean, x as createSingleton, y as createLock } from "./chunks/chunk-f4c5d38b.js";
+import { C as linear, D as safeParse, E as normalizeError, O as stringify, S as parseValueToBoolean, T as getErrorMessage, _ as createLock, a as concatTemplateStrings, b as sleep, c as joinWithSlash, d as split, f as splitByLineBreak, g as unindent, h as toForwardSlash, i as addSuffix, k as unsafeParse, l as removePrefix, m as template, n as throttle, o as indent, p as splitWithSlash, r as addPrefix, s as join, t as debounce, u as removeSuffix, v as createPromiseWithResolvers, w as scale, x as parseKeyValuePairs, y as createSingleton } from "./chunks/chunk-af8ca15e.js";
 
-export { $, addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, quoteShellArg, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };
+export { addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };

package/dist/fs.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { i as Result } from "./chunks/chunk-4b76d1c4.js";
+import { i as Result } from "./chunks/chunk-f11577d4.js";
 import * as nativeFs$1 from "fs";
 
 //#region node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.3/node_modules/fdir/dist/index.d.mts

package/dist/fs.js

@@ -1,5 +1,5 @@
-import { A as stringify, F as safeTry, L as __commonJSMin, M as Result, N as err, P as ok, R as __toESM, d as removePrefix, k as safeParse } from "./chunks/chunk-f4c5d38b.js";
-import { Fn as e$1, Jt as n, Sn as e$2, gn as e } from "./chunks/chunk-267b337b.js";
+import { A as Result, D as safeParse, F as __commonJSMin, I as __toESM, M as ok, N as safeTry, O as stringify, j as err, l as removePrefix } from "./chunks/chunk-af8ca15e.js";
+import { Fn as e$1, Jt as n, Sn as e$2, gn as e } from "./chunks/chunk-b970a8d0.js";
 import * as nativeFs$1 from "fs";
 import nativeFs from "fs";
 import path, { basename, dirname, normalize, posix, relative, resolve, sep } from "path";
@@ -359,10 +359,10 @@ var Walker = class {
 	};
 };
 function promise(root, options) {
-	return new Promise((resolve$1, reject) => {
+	return new Promise((resolve$1$1, reject) => {
 		callback(root, options, (err$1, output) => {
 			if (err$1) return reject(err$1);
-			resolve$1(output);
+			resolve$1$1(output);
 		});
 	});
 }

package/dist/remeda.d.ts

@@ -1,4 +1,4 @@
-import { Pr as IsAny$1 } from "./chunks/chunk-a07ed28f.js";
+import { Pr as IsAny$1 } from "./chunks/chunk-566a516c.js";
 
 //#region src/remeda/types.d.ts
 

package/dist/remeda.js

@@ -1,3 +1,3 @@
-import { $ as t$84, $n as n$4, $t as e$24, A as awaitAll, An as e$9, Ar as t$4, At as t$62, B as t$89, Bn as e$3, Bt as t$53, C as toIteratorAsync, Cn as e$16, Cr as e, Ct as t$68, D as concurrency, Dn as e$12, Dr as t$6, Dt as n$13, E as buffer, En as e$13, Er as t$7, Et as t$65, F as isFunction, Fn as e$4, Fr as t$59, Ft as t$58, G as e$33, Gn as n$7, Gt as t$50, H as n$25, Hn as t$32, Ht as t$51, I as hasOwnProperty, In as t$31, It as e$28, J as n$22, Jn as t$24, Jt as n$12, K as t$87, Kn as t$26, Kt as e$25, L as t$91, Ln as n$9, Lt as t$57, M as toArrayAsync, Mn as e$7, Mr as t$2, Mt as t$60, N as compose, Nn as e$6, Nr as t$1, Nt as e$30, O as throttle, On as e$11, Or as t$5, Ot as t$64, P as isPromiseLike, Pn as e$5, Pr as t, Pt as e$29, Q as t$85, Qn as n$5, Qt as n$11, R as t$90, Rn as r$4, Rt as t$56, S as serializeAsync, Sn as e$17, Sr as t$10, St as e$31, T as chunkAsync, Tn as e$14, Tr as t$8, Tt as t$66, U as n$24, Un as t$28, Ut as e$27, V as n$26, Vn as n$8, Vt as t$52, W as t$88, Wn as t$27, Wt as e$26, X as n$21, Xn as n$6, Xt as a, Y as t$86, Yn as t$23, Yt as t$48, Z as n$20, Zn as t$22, Zt as t$47, _ as uniqueWithAsync, _n as t$34, _r as n$1, _t as n$16, a as forEachAsync, an as t$43, ar as n$2, at as t$80, b as uniqueAsync, bn as e$19, br as t$11, bt as t$70, c as everyAsync, cn as t$40, cr as t$16, ct as t$76, d as intersectionWithAsync, dn as t$37, dr as t$13, dt as t$73, en as t$46, er as n$3, et as t$83, f as intersectionByAsync, fn as t$36, fr as r$2, ft as t$72, g as differenceAsync, gn as e$21, gr as t$12, gt as n$17, h as differenceByAsync, hn as e$22, hr as e$2, ht as n$18, i as peekAsync, in as t$77, ir as r$3, it as n$19, j as executeAsync, jn as e$8, jr as t$3, jt as t$61, k as accumulateAsync, kn as e$10, kr as n, kt as t$63, l as mapAsync, ln as t$39, lr as t$15, lt as t$75, m as differenceWithAsync, mn as e$23, mr as r$1, mt as t$71, n as dropAsync, nn as t$44, nr as t$20, nt as t$81, o as reduceAsync, on as t$42, or as t$18, ot as t$79, p as intersectionAsync, pn as t$35, pr as t$29, pt as e$32, q as n$23, qn as t$25, qt as t$49, r as concatAsync, rn as n$10, rr as t$19, rt as r$5, s as findAsync, sn as t$41, sr as t$17, st as t$78, t as takeAsync, tn as t$45, tr as t$21, tt as t$82, u as flatMapAsync, un as t$38, ur as t$14, ut as t$74, v as someAsync, vn as t$33, vr as r, vt as n$15, w as flattenAsync, wn as e$15, wr as t$9, wt as t$67, x as filterAsync, xn as e$18, xr as e$1, xt as t$69, y as uniqueByAsync, yn as e$20, yr as t$55, yt as n$14, z as e$34, zn as t$30, zt as t$54 } from "./chunks/chunk-267b337b.js";
+import { $ as t$84, $n as n$4, $t as e$24, A as awaitAll, An as e$9, Ar as t$4, At as t$62, B as t$89, Bn as e$3, Bt as t$53, C as toIteratorAsync, Cn as e$16, Cr as e, Ct as t$68, D as concurrency, Dn as e$12, Dr as t$6, Dt as n$13, E as buffer, En as e$13, Er as t$7, Et as t$65, F as isFunction, Fn as e$4, Fr as t$59, Ft as t$58, G as e$33, Gn as n$7, Gt as t$50, H as n$25, Hn as t$32, Ht as t$51, I as hasOwnProperty, In as t$31, It as e$28, J as n$22, Jn as t$24, Jt as n$12, K as t$87, Kn as t$26, Kt as e$25, L as t$91, Ln as n$9, Lt as t$57, M as toArrayAsync, Mn as e$7, Mr as t$2, Mt as t$60, N as compose, Nn as e$6, Nr as t$1, Nt as e$30, O as throttle, On as e$11, Or as t$5, Ot as t$64, P as isPromiseLike, Pn as e$5, Pr as t, Pt as e$29, Q as t$85, Qn as n$5, Qt as n$11, R as t$90, Rn as r$4, Rt as t$56, S as serializeAsync, Sn as e$17, Sr as t$10, St as e$31, T as chunkAsync, Tn as e$14, Tr as t$8, Tt as t$66, U as n$24, Un as t$28, Ut as e$27, V as n$26, Vn as n$8, Vt as t$52, W as t$88, Wn as t$27, Wt as e$26, X as n$21, Xn as n$6, Xt as a, Y as t$86, Yn as t$23, Yt as t$48, Z as n$20, Zn as t$22, Zt as t$47, _ as uniqueWithAsync, _n as t$34, _r as n$1, _t as n$16, a as forEachAsync, an as t$43, ar as n$2, at as t$80, b as uniqueAsync, bn as e$19, br as t$11, bt as t$70, c as everyAsync, cn as t$40, cr as t$16, ct as t$76, d as intersectionWithAsync, dn as t$37, dr as t$13, dt as t$73, en as t$46, er as n$3, et as t$83, f as intersectionByAsync, fn as t$36, fr as r$2, ft as t$72, g as differenceAsync, gn as e$21, gr as t$12, gt as n$17, h as differenceByAsync, hn as e$22, hr as e$2, ht as n$18, i as peekAsync, in as t$77, ir as r$3, it as n$19, j as executeAsync, jn as e$8, jr as t$3, jt as t$61, k as accumulateAsync, kn as e$10, kr as n, kt as t$63, l as mapAsync, ln as t$39, lr as t$15, lt as t$75, m as differenceWithAsync, mn as e$23, mr as r$1, mt as t$71, n as dropAsync, nn as t$44, nr as t$20, nt as t$81, o as reduceAsync, on as t$42, or as t$18, ot as t$79, p as intersectionAsync, pn as t$35, pr as t$29, pt as e$32, q as n$23, qn as t$25, qt as t$49, r as concatAsync, rn as n$10, rr as t$19, rt as r$5, s as findAsync, sn as t$41, sr as t$17, st as t$78, t as takeAsync, tn as t$45, tr as t$21, tt as t$82, u as flatMapAsync, un as t$38, ur as t$14, ut as t$74, v as someAsync, vn as t$33, vr as r, vt as n$15, w as flattenAsync, wn as e$15, wr as t$9, wt as t$67, x as filterAsync, xn as e$18, xr as e$1, xt as t$69, y as uniqueByAsync, yn as e$20, yr as t$55, yt as n$14, z as e$34, zn as t$30, zt as t$54 } from "./chunks/chunk-b970a8d0.js";
 
 export { accumulateAsync as accumulateP, t as add, t$1 as addProp, t$2 as allPass, t$3 as anyPass, awaitAll, buffer, t$4 as capitalize, n as ceil, t$5 as chunk, chunkAsync as chunkP, t$6 as clamp, t$7 as clone, compose, t$8 as concat, concatAsync as concatP, concurrency, t$9 as conditional, e as constant, t$10 as countBy, e$1 as debounce, t$11 as defaultTo, r as difference, differenceByAsync as differenceByP, differenceAsync as differenceP, n$1 as differenceWith, differenceWithAsync as differenceWithP, t$12 as divide, e$2 as doNothing, r$1 as drop, r$2 as dropFirstBy, t$13 as dropLast, t$14 as dropLastWhile, dropAsync as dropP, t$15 as dropWhile, t$16 as endsWith, t$17 as entries, everyAsync as everyP, t$18 as evolve, executeAsync as executeP, n$2 as filter, filterAsync as filterP, r$3 as find, t$19 as findIndex, t$20 as findLast, t$21 as findLastIndex, findAsync as findP, n$3 as first, n$4 as firstBy, n$5 as flat, t$22 as flatMap, flatMapAsync as flatMapP, flattenAsync as flattenP, n$6 as floor, t$23 as forEach, t$24 as forEachObj, forEachAsync as forEachP, t$25 as fromEntries, t$26 as fromKeys, n$7 as funnel, t$27 as groupBy, t$28 as groupByProp, t$29 as hasAtLeast, hasOwnProperty, n$8 as hasSubObject, e$3 as identity, t$30 as indexBy, r$4 as intersection, intersectionByAsync as intersectionByP, intersectionAsync as intersectionP, n$9 as intersectionWith, intersectionWithAsync as intersectionWithP, t$31 as invert, e$4 as isArray, e$5 as isBigInt, e$6 as isBoolean, e$7 as isDate, t$32 as isDeepEqual, e$8 as isDefined, e$9 as isEmpty, e$10 as isEmptyish, e$11 as isError, isFunction, e$12 as isIncludedIn, e$13 as isNonNull, e$14 as isNonNullish, e$15 as isNot, e$16 as isNullish, e$17 as isNumber, e$18 as isObjectType, e$19 as isPlainObject, e$20 as isPromise, isPromiseLike, t$33 as isShallowEqual, t$34 as isStrictEqual, e$21 as isString, e$22 as isSymbol, e$23 as isTruthy, t$35 as join, t$36 as keys, t$37 as last, t$38 as length, t$39 as map, t$40 as mapKeys, mapAsync as mapP, t$41 as mapToObj, t$42 as mapValues, t$43 as mapWithFeedback, n$10 as mean, t$44 as meanBy, t$45 as median, t$46 as merge, e$24 as mergeAll, n$11 as mergeDeep, t$47 as multiply, a as nthBy, t$48 as objOf, n$12 as omit, t$49 as omitBy, e$25 as once, t$50 as only, e$26 as partialBind, e$27 as partialLastBind, t$51 as partition, t$52 as pathOr, t$53 as pick, t$54 as pickBy, t$55 as pipe, t$56 as piped, t$57 as product, e$28 as prop, t$58 as pullObject, t$59 as purry, e$29 as randomBigInt, e$30 as randomInteger, t$60 as randomString, t$61 as range, t$62 as rankBy, t$63 as reduce, reduceAsync as reduceP, t$64 as reverse, n$13 as round, t$65 as sample, serializeAsync as serializeP, t$66 as set, t$67 as setPath, t$68 as shuffle, e$31 as sliceString, someAsync as someP, t$69 as sort, t$70 as sortBy, n$14 as sortedIndex, n$15 as sortedIndexBy, n$16 as sortedIndexWith, n$17 as sortedLastIndex, n$18 as sortedLastIndexBy, t$71 as splice, e$32 as split, t$72 as splitAt, t$73 as splitWhen, t$74 as startsWith, t$75 as stringToPath, t$76 as subtract, t$77 as sum, t$78 as sumBy, t$79 as swapIndices, t$80 as swapProps, n$19 as take, r$5 as takeFirstBy, t$81 as takeLast, t$82 as takeLastWhile, takeAsync as takeP, t$83 as takeWhile, t$84 as tap, peekAsync as tapP, throttle, t$85 as times, toArrayAsync as toArrayP, n$20 as toCamelCase, toIteratorAsync as toIteratorP, n$21 as toKebabCase, t$86 as toLowerCase, n$22 as toSnakeCase, n$23 as toTitleCase, t$87 as toUpperCase, e$33 as truncate, t$88 as uncapitalize, n$24 as unique, n$25 as uniqueBy, uniqueByAsync as uniqueByP, uniqueAsync as uniqueP, n$26 as uniqueWith, uniqueWithAsync as uniqueWithP, t$89 as values, e$34 as when, t$90 as zip, t$91 as zipWith };

package/dist/result.d.ts

@@ -1,2 +1,2 @@
-import { a as err, c as ExtractOkTypes, d as ResultAll, f as ResultError, i as Result, l as InferErrType, n as Err, o as ok, r as Ok, s as ExtractErrTypes, t as safeTry, u as InferOkType } from "./chunks/chunk-4b76d1c4.js";
+import { a as err, c as ExtractOkTypes, d as ResultAll, f as ResultError, i as Result, l as InferErrType, n as Err, o as ok, r as Ok, s as ExtractErrTypes, t as safeTry, u as InferOkType } from "./chunks/chunk-f11577d4.js";
 export { Err, ExtractErrTypes, ExtractOkTypes, InferErrType, InferOkType, Ok, Result, ResultAll, ResultError, err, ok, safeTry };

package/dist/result.js

@@ -1,3 +1,3 @@
-import { F as safeTry, I as ResultError, M as Result, N as err, P as ok } from "./chunks/chunk-f4c5d38b.js";
+import { A as Result, M as ok, N as safeTry, P as ResultError, j as err } from "./chunks/chunk-af8ca15e.js";
 
 export { Result, ResultError, err, ok, safeTry };

package/dist/shell.d.ts

@@ -0,0 +1,111 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ChildProcess, SpawnOptions } from "node:child_process";
+import { Readable } from "node:stream";
+
+//#region node_modules/.pnpm/tinyexec@1.0.2/node_modules/tinyexec/dist/main.d.ts
+
+//#region src/non-zero-exit-error.d.ts
+declare class NonZeroExitError extends Error {
+  readonly result: Result;
+  readonly output?: Output;
+  get exitCode(): number | undefined;
+  constructor(result: Result, output?: Output);
+}
+
+//#endregion
+//#region src/main.d.ts
+interface Output {
+  stderr: string;
+  stdout: string;
+  exitCode: number | undefined;
+}
+interface PipeOptions extends Options {}
+type KillSignal = Parameters<ChildProcess['kill']>[0];
+interface OutputApi extends AsyncIterable<string> {
+  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  process: ChildProcess | undefined;
+  kill(signal?: KillSignal): boolean;
+  get pid(): number | undefined;
+  get aborted(): boolean;
+  get killed(): boolean;
+  get exitCode(): number | undefined;
+}
+type Result = PromiseLike<Output> & OutputApi;
+interface Options {
+  signal: AbortSignal;
+  nodeOptions: SpawnOptions;
+  timeout: number;
+  persist: boolean;
+  stdin: ExecProcess;
+  throwOnError: boolean;
+}
+declare class ExecProcess implements Result {
+  protected _process?: ChildProcess;
+  protected _aborted: boolean;
+  protected _options: Partial<Options>;
+  protected _command: string;
+  protected _args: string[];
+  protected _resolveClose?: () => void;
+  protected _processClosed: Promise<void>;
+  protected _thrownError?: Error;
+  get process(): ChildProcess | undefined;
+  get pid(): number | undefined;
+  get exitCode(): number | undefined;
+  constructor(command: string, args?: string[], options?: Partial<Options>);
+  kill(signal?: KillSignal): boolean;
+  get aborted(): boolean;
+  get killed(): boolean;
+  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+  protected _waitForOutput(): Promise<Output>;
+  then<TResult1 = Output, TResult2 = never>(onfulfilled?: ((value: Output) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+  protected _streamOut?: Readable;
+  protected _streamErr?: Readable;
+  spawn(): void;
+  protected _resetState(): void;
+  protected _onError: (err: Error) => void;
+  protected _onClose: () => void;
+}
+//#endregion
+//#region src/shell/types.d.ts
+interface StringOrTemplateFunction {
+  (command: string): ShellResult;
+  (template: TemplateStringsArray, ...values: any[]): ShellResult;
+}
+interface ShellExec {
+  (command: string, args?: string[], options?: Partial<PipeOptions>): ShellResult;
+  (template: TemplateStringsArray, ...values: any[]): ShellResult;
+  (options: Partial<Options>): StringOrTemplateFunction;
+}
+interface ShellOutputApi extends OutputApi {
+  pipe: ShellExec;
+}
+type ShellResult = PromiseLike<Output> & ShellOutputApi;
+//#endregion
+//#region src/shell/exec.d.ts
+declare class ShellExecProcess extends ExecProcess implements ShellResult {
+  constructor(command: string, args?: string[], options?: Partial<Options>);
+  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): ShellResult;
+  pipe(template: TemplateStringsArray, ...values: any[]): ShellResult;
+  pipe(options: Partial<Options>): StringOrTemplateFunction;
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+  protected _waitForOutput(): Promise<Output>;
+}
+declare const exec: ShellExec;
+//#endregion
+//#region src/shell/error.d.ts
+declare class ShellNonZeroExitError extends NonZeroExitError {
+  readonly result: ShellResult;
+  constructor(result: ShellResult, output?: Output);
+}
+//#endregion
+//#region node_modules/.pnpm/args-tokenizer@0.3.0/node_modules/args-tokenizer/dist/args-tokenizer.d.ts
+type Options$1 = {
+  loose?: boolean;
+};
+/**
+ * Tokenize a shell string into argv array
+ */
+declare const tokenizeArgs: (argsString: string, options?: Options$1) => string[];
+//#endregion
+export { exec as $, exec, exec as x, type ShellExec, ShellExecProcess, type KillSignal as ShellKillSignal, ShellNonZeroExitError, type Options as ShellOptions, type Output as ShellOutput, type ShellOutputApi, type PipeOptions as ShellPipeOptions, type ShellResult, tokenizeArgs as splitShellCommand };

package/dist/shell.js

@@ -0,0 +1,781 @@
+import { T as getErrorMessage, a as concatTemplateStrings } from "./chunks/chunk-af8ca15e.js";
+import { Fn as e$1, bn as e$2, gn as e } from "./chunks/chunk-b970a8d0.js";
+import { createRequire } from "module";
+import { delimiter, dirname, normalize, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { cwd } from "node:process";
+import { PassThrough } from "node:stream";
+import c from "node:readline";
+
+//#region node_modules/.pnpm/args-tokenizer@0.3.0/node_modules/args-tokenizer/dist/args-tokenizer.js
+var spaceRegex = /\s/;
+var tokenizeArgs = (argsString, options) => {
+	const tokens = [];
+	let currentToken = "";
+	let openningQuote;
+	let escaped = false;
+	for (let index = 0; index < argsString.length; index += 1) {
+		const char = argsString[index];
+		if (escaped) {
+			escaped = false;
+			if (openningQuote || char !== "\n") currentToken += char;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (openningQuote === void 0 && spaceRegex.test(char)) {
+			if (currentToken.length > 0) {
+				tokens.push(currentToken);
+				currentToken = "";
+			}
+			continue;
+		}
+		if (char === "'" || char === "\"") {
+			if (openningQuote === void 0) {
+				openningQuote = char;
+				continue;
+			}
+			if (openningQuote === char) {
+				openningQuote = void 0;
+				continue;
+			}
+		}
+		currentToken += char;
+	}
+	if (currentToken.length > 0) tokens.push(currentToken);
+	if (options?.loose) return tokens;
+	if (openningQuote) throw Error("Unexpected end of string. Closing quote is missing.");
+	return tokens;
+};
+
+//#endregion
+//#region node_modules/.pnpm/tinyexec@1.0.2/node_modules/tinyexec/dist/main.js
+var l = Object.create;
+var u = Object.defineProperty;
+var d = Object.getOwnPropertyDescriptor;
+var f = Object.getOwnPropertyNames;
+var p = Object.getPrototypeOf;
+var m = Object.prototype.hasOwnProperty;
+var h = (e$3, t) => () => (t || e$3((t = { exports: {} }).exports, t), t.exports);
+var g = (e$3, t, n, r) => {
+	if (t && typeof t === "object" || typeof t === "function") for (var i = f(t), a = 0, o = i.length, s; a < o; a++) {
+		s = i[a];
+		if (!m.call(e$3, s) && s !== n) u(e$3, s, {
+			get: ((e$4) => t[e$4]).bind(null, s),
+			enumerable: !(r = d(t, s)) || r.enumerable
+		});
+	}
+	return e$3;
+};
+var _ = (e$3, t, n) => (n = e$3 != null ? l(p(e$3)) : {}, g(t || !e$3 || !e$3.__esModule ? u(n, "default", {
+	value: e$3,
+	enumerable: true
+}) : n, e$3));
+var v = /* @__PURE__ */ createRequire(import.meta.url);
+const y = /^path$/i;
+const b = {
+	key: "PATH",
+	value: ""
+};
+function x(e$3) {
+	for (const t in e$3) {
+		if (!Object.prototype.hasOwnProperty.call(e$3, t) || !y.test(t)) continue;
+		const n = e$3[t];
+		if (!n) return b;
+		return {
+			key: t,
+			value: n
+		};
+	}
+	return b;
+}
+function S(e$3, t) {
+	const i = t.value.split(delimiter);
+	let o = e$3;
+	let s;
+	do {
+		i.push(resolve(o, "node_modules", ".bin"));
+		s = o;
+		o = dirname(o);
+	} while (o !== s);
+	return {
+		key: t.key,
+		value: i.join(delimiter)
+	};
+}
+function C(e$3, t) {
+	const n = {
+		...process.env,
+		...t
+	};
+	const r = S(e$3, x(n));
+	n[r.key] = r.value;
+	return n;
+}
+const w = (e$3) => {
+	let t = e$3.length;
+	const n = new PassThrough();
+	const r = () => {
+		if (--t === 0) n.emit("end");
+	};
+	for (const t$1 of e$3) {
+		t$1.pipe(n, { end: false });
+		t$1.on("end", r);
+	}
+	return n;
+};
+var T = h((exports, t) => {
+	t.exports = a;
+	a.sync = o;
+	var n = v("fs");
+	function r(e$3, t$1) {
+		var n$1 = t$1.pathExt !== void 0 ? t$1.pathExt : process.env.PATHEXT;
+		if (!n$1) return true;
+		n$1 = n$1.split(";");
+		if (n$1.indexOf("") !== -1) return true;
+		for (var r$1 = 0; r$1 < n$1.length; r$1++) {
+			var i$1 = n$1[r$1].toLowerCase();
+			if (i$1 && e$3.substr(-i$1.length).toLowerCase() === i$1) return true;
+		}
+		return false;
+	}
+	function i(e$3, t$1, n$1) {
+		if (!e$3.isSymbolicLink() && !e$3.isFile()) return false;
+		return r(t$1, n$1);
+	}
+	function a(e$3, t$1, r$1) {
+		n.stat(e$3, function(n$1, a$1) {
+			r$1(n$1, n$1 ? false : i(a$1, e$3, t$1));
+		});
+	}
+	function o(e$3, t$1) {
+		return i(n.statSync(e$3), e$3, t$1);
+	}
+});
+var E = h((exports, t) => {
+	t.exports = r;
+	r.sync = i;
+	var n = v("fs");
+	function r(e$3, t$1, r$1) {
+		n.stat(e$3, function(e$4, n$1) {
+			r$1(e$4, e$4 ? false : a(n$1, t$1));
+		});
+	}
+	function i(e$3, t$1) {
+		return a(n.statSync(e$3), t$1);
+	}
+	function a(e$3, t$1) {
+		return e$3.isFile() && o(e$3, t$1);
+	}
+	function o(e$3, t$1) {
+		var n$1 = e$3.mode;
+		var r$1 = e$3.uid;
+		var i$1 = e$3.gid;
+		var a$1 = t$1.uid !== void 0 ? t$1.uid : process.getuid && process.getuid();
+		var o$1 = t$1.gid !== void 0 ? t$1.gid : process.getgid && process.getgid();
+		var s = parseInt("100", 8);
+		var c$1 = parseInt("010", 8);
+		var l$1 = parseInt("001", 8);
+		var u$1 = s | c$1;
+		return n$1 & l$1 || n$1 & c$1 && i$1 === o$1 || n$1 & s && r$1 === a$1 || n$1 & u$1 && a$1 === 0;
+	}
+});
+var D = h((exports, t) => {
+	v("fs");
+	var r;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) r = T();
+	else r = E();
+	t.exports = i;
+	i.sync = a;
+	function i(e$3, t$1, n) {
+		if (typeof t$1 === "function") {
+			n = t$1;
+			t$1 = {};
+		}
+		if (!n) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(n$1, r$1) {
+				i(e$3, t$1 || {}, function(e$4, t$2) {
+					if (e$4) r$1(e$4);
+					else n$1(t$2);
+				});
+			});
+		}
+		r(e$3, t$1 || {}, function(e$4, r$1) {
+			if (e$4) {
+				if (e$4.code === "EACCES" || t$1 && t$1.ignoreErrors) {
+					e$4 = null;
+					r$1 = false;
+				}
+			}
+			n(e$4, r$1);
+		});
+	}
+	function a(e$3, t$1) {
+		try {
+			return r.sync(e$3, t$1 || {});
+		} catch (e$4) {
+			if (t$1 && t$1.ignoreErrors || e$4.code === "EACCES") return false;
+			else throw e$4;
+		}
+	}
+});
+var O = h((exports, t) => {
+	const n = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const r = v("path");
+	const i = n ? ";" : ":";
+	const a = D();
+	const o = (e$3) => Object.assign(/* @__PURE__ */ new Error(`not found: ${e$3}`), { code: "ENOENT" });
+	const s = (e$3, t$1) => {
+		const r$1 = t$1.colon || i;
+		const a$1 = e$3.match(/\//) || n && e$3.match(/\\/) ? [""] : [...n ? [process.cwd()] : [], ...(t$1.path || process.env.PATH || "").split(r$1)];
+		const o$1 = n ? t$1.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const s$1 = n ? o$1.split(r$1) : [""];
+		if (n) {
+			if (e$3.indexOf(".") !== -1 && s$1[0] !== "") s$1.unshift("");
+		}
+		return {
+			pathEnv: a$1,
+			pathExt: s$1,
+			pathExtExe: o$1
+		};
+	};
+	const c$1 = (e$3, t$1, n$1) => {
+		if (typeof t$1 === "function") {
+			n$1 = t$1;
+			t$1 = {};
+		}
+		if (!t$1) t$1 = {};
+		const { pathEnv: i$1, pathExt: c$2, pathExtExe: l$2 } = s(e$3, t$1);
+		const u$1 = [];
+		const d$1 = (n$2) => new Promise((a$1, s$1) => {
+			if (n$2 === i$1.length) return t$1.all && u$1.length ? a$1(u$1) : s$1(o(e$3));
+			const c$3 = i$1[n$2];
+			const l$3 = /^".*"$/.test(c$3) ? c$3.slice(1, -1) : c$3;
+			const d$2 = r.join(l$3, e$3);
+			a$1(f$1(!l$3 && /^\.[\\\/]/.test(e$3) ? e$3.slice(0, 2) + d$2 : d$2, n$2, 0));
+		});
+		const f$1 = (e$4, n$2, r$1) => new Promise((i$2, o$1) => {
+			if (r$1 === c$2.length) return i$2(d$1(n$2 + 1));
+			const s$1 = c$2[r$1];
+			a(e$4 + s$1, { pathExt: l$2 }, (a$1, o$2) => {
+				if (!a$1 && o$2) if (t$1.all) u$1.push(e$4 + s$1);
+				else return i$2(e$4 + s$1);
+				return i$2(f$1(e$4, n$2, r$1 + 1));
+			});
+		});
+		return n$1 ? d$1(0).then((e$4) => n$1(null, e$4), n$1) : d$1(0);
+	};
+	const l$1 = (e$3, t$1) => {
+		t$1 = t$1 || {};
+		const { pathEnv: n$1, pathExt: i$1, pathExtExe: c$2 } = s(e$3, t$1);
+		const l$2 = [];
+		for (let o$1 = 0; o$1 < n$1.length; o$1++) {
+			const s$1 = n$1[o$1];
+			const u$1 = /^".*"$/.test(s$1) ? s$1.slice(1, -1) : s$1;
+			const d$1 = r.join(u$1, e$3);
+			const f$1 = !u$1 && /^\.[\\\/]/.test(e$3) ? e$3.slice(0, 2) + d$1 : d$1;
+			for (let e$4 = 0; e$4 < i$1.length; e$4++) {
+				const n$2 = f$1 + i$1[e$4];
+				try {
+					if (a.sync(n$2, { pathExt: c$2 })) if (t$1.all) l$2.push(n$2);
+					else return n$2;
+				} catch (e$5) {}
+			}
+		}
+		if (t$1.all && l$2.length) return l$2;
+		if (t$1.nothrow) return null;
+		throw o(e$3);
+	};
+	t.exports = c$1;
+	c$1.sync = l$1;
+});
+var k = h((exports, t) => {
+	const n = (e$3 = {}) => {
+		const t$1 = e$3.env || process.env;
+		if ((e$3.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(t$1).reverse().find((e$4) => e$4.toUpperCase() === "PATH") || "Path";
+	};
+	t.exports = n;
+	t.exports.default = n;
+});
+var A = h((exports, t) => {
+	const n = v("path");
+	const r = O();
+	const i = k();
+	function a(e$3, t$1) {
+		const a$1 = e$3.options.env || process.env;
+		const o$1 = process.cwd();
+		const s = e$3.options.cwd != null;
+		const c$1 = s && process.chdir !== void 0 && !process.chdir.disabled;
+		if (c$1) try {
+			process.chdir(e$3.options.cwd);
+		} catch (e$4) {}
+		let l$1;
+		try {
+			l$1 = r.sync(e$3.command, {
+				path: a$1[i({ env: a$1 })],
+				pathExt: t$1 ? n.delimiter : void 0
+			});
+		} catch (e$4) {} finally {
+			if (c$1) process.chdir(o$1);
+		}
+		if (l$1) l$1 = n.resolve(s ? e$3.options.cwd : "", l$1);
+		return l$1;
+	}
+	function o(e$3) {
+		return a(e$3) || a(e$3, true);
+	}
+	t.exports = o;
+});
+var j = h((exports, t) => {
+	const n = /([()\][%!^"`<>&|;, *?])/g;
+	function r(e$3) {
+		e$3 = e$3.replace(n, "^$1");
+		return e$3;
+	}
+	function i(e$3, t$1) {
+		e$3 = `${e$3}`;
+		e$3 = e$3.replace(/(\\*)"/g, "$1$1\\\"");
+		e$3 = e$3.replace(/(\\*)$/, "$1$1");
+		e$3 = `"${e$3}"`;
+		e$3 = e$3.replace(n, "^$1");
+		if (t$1) e$3 = e$3.replace(n, "^$1");
+		return e$3;
+	}
+	t.exports.command = r;
+	t.exports.argument = i;
+});
+var M = h((exports, t) => {
+	t.exports = /^#!(.*)/;
+});
+var N = h((exports, t) => {
+	const n = M();
+	t.exports = (e$3 = "") => {
+		const t$1 = e$3.match(n);
+		if (!t$1) return null;
+		const [r, i] = t$1[0].replace(/#! ?/, "").split(" ");
+		const a = r.split("/").pop();
+		if (a === "env") return i;
+		return i ? `${a} ${i}` : a;
+	};
+});
+var P = h((exports, t) => {
+	const n = v("fs");
+	const r = N();
+	function i(e$3) {
+		const t$1 = 150;
+		const i$1 = Buffer.alloc(t$1);
+		let a;
+		try {
+			a = n.openSync(e$3, "r");
+			n.readSync(a, i$1, 0, t$1, 0);
+			n.closeSync(a);
+		} catch (e$4) {}
+		return r(i$1.toString());
+	}
+	t.exports = i;
+});
+var F = h((exports, t) => {
+	const n = v("path");
+	const r = A();
+	const i = j();
+	const a = P();
+	const o = process.platform === "win32";
+	const s = /\.(?:com|exe)$/i;
+	const c$1 = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function l$1(e$3) {
+		e$3.file = r(e$3);
+		const t$1 = e$3.file && a(e$3.file);
+		if (t$1) {
+			e$3.args.unshift(e$3.file);
+			e$3.command = t$1;
+			return r(e$3);
+		}
+		return e$3.file;
+	}
+	function u$1(e$3) {
+		if (!o) return e$3;
+		const t$1 = l$1(e$3);
+		const r$1 = !s.test(t$1);
+		if (e$3.options.forceShell || r$1) {
+			const r$2 = c$1.test(t$1);
+			e$3.command = n.normalize(e$3.command);
+			e$3.command = i.command(e$3.command);
+			e$3.args = e$3.args.map((e$4) => i.argument(e$4, r$2));
+			e$3.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[e$3.command].concat(e$3.args).join(" ")}"`
+			];
+			e$3.command = process.env.comspec || "cmd.exe";
+			e$3.options.windowsVerbatimArguments = true;
+		}
+		return e$3;
+	}
+	function d$1(e$3, t$1, n$1) {
+		if (t$1 && !Array.isArray(t$1)) {
+			n$1 = t$1;
+			t$1 = null;
+		}
+		t$1 = t$1 ? t$1.slice(0) : [];
+		n$1 = Object.assign({}, n$1);
+		const r$1 = {
+			command: e$3,
+			args: t$1,
+			options: n$1,
+			file: void 0,
+			original: {
+				command: e$3,
+				args: t$1
+			}
+		};
+		return n$1.shell ? r$1 : u$1(r$1);
+	}
+	t.exports = d$1;
+});
+var I = h((exports, t) => {
+	const n = process.platform === "win32";
+	function r(e$3, t$1) {
+		return Object.assign(/* @__PURE__ */ new Error(`${t$1} ${e$3.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${t$1} ${e$3.command}`,
+			path: e$3.command,
+			spawnargs: e$3.args
+		});
+	}
+	function i(e$3, t$1) {
+		if (!n) return;
+		const r$1 = e$3.emit;
+		e$3.emit = function(n$1, i$1) {
+			if (n$1 === "exit") {
+				const n$2 = a(i$1, t$1, "spawn");
+				if (n$2) return r$1.call(e$3, "error", n$2);
+			}
+			return r$1.apply(e$3, arguments);
+		};
+	}
+	function a(e$3, t$1) {
+		if (n && e$3 === 1 && !t$1.file) return r(t$1.original, "spawn");
+		return null;
+	}
+	function o(e$3, t$1) {
+		if (n && e$3 === 1 && !t$1.file) return r(t$1.original, "spawnSync");
+		return null;
+	}
+	t.exports = {
+		hookChildProcess: i,
+		verifyENOENT: a,
+		verifyENOENTSync: o,
+		notFoundError: r
+	};
+});
+var R = _(h((exports, t) => {
+	const n = v("child_process");
+	const r = F();
+	const i = I();
+	function a(e$3, t$1, a$1) {
+		const o$1 = r(e$3, t$1, a$1);
+		const s = n.spawn(o$1.command, o$1.args, o$1.options);
+		i.hookChildProcess(s, o$1);
+		return s;
+	}
+	function o(e$3, t$1, a$1) {
+		const o$1 = r(e$3, t$1, a$1);
+		const s = n.spawnSync(o$1.command, o$1.args, o$1.options);
+		s.error = s.error || i.verifyENOENTSync(s.status, o$1);
+		return s;
+	}
+	t.exports = a;
+	t.exports.spawn = a;
+	t.exports.sync = o;
+	t.exports._parse = r;
+	t.exports._enoent = i;
+})(), 1);
+var z = class extends Error {
+	result;
+	output;
+	get exitCode() {
+		if (this.result.exitCode !== null) return this.result.exitCode;
+	}
+	constructor(e$3, t) {
+		super(`Process exited with non-zero status (${e$3.exitCode})`);
+		this.result = e$3;
+		this.output = t;
+	}
+};
+const B = {
+	timeout: void 0,
+	persist: false
+};
+const V = { windowsHide: true };
+function H(e$3, t) {
+	return {
+		command: normalize(e$3),
+		args: t ?? []
+	};
+}
+function U(e$3) {
+	const t = new AbortController();
+	for (const n of e$3) {
+		if (n.aborted) {
+			t.abort();
+			return n;
+		}
+		const e$4 = () => {
+			t.abort(n.reason);
+		};
+		n.addEventListener("abort", e$4, { signal: t.signal });
+	}
+	return t.signal;
+}
+async function W(e$3) {
+	let t = "";
+	for await (const n of e$3) t += n.toString();
+	return t;
+}
+var G = class {
+	_process;
+	_aborted = false;
+	_options;
+	_command;
+	_args;
+	_resolveClose;
+	_processClosed;
+	_thrownError;
+	get process() {
+		return this._process;
+	}
+	get pid() {
+		return this._process?.pid;
+	}
+	get exitCode() {
+		if (this._process && this._process.exitCode !== null) return this._process.exitCode;
+	}
+	constructor(e$3, t, n) {
+		this._options = {
+			...B,
+			...n
+		};
+		this._command = e$3;
+		this._args = t ?? [];
+		this._processClosed = new Promise((e$4) => {
+			this._resolveClose = e$4;
+		});
+	}
+	kill(e$3) {
+		return this._process?.kill(e$3) === true;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get killed() {
+		return this._process?.killed === true;
+	}
+	pipe(e$3, t, n) {
+		return q(e$3, t, {
+			...n,
+			stdin: this
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		const e$3 = this._process;
+		if (!e$3) return;
+		const t = [];
+		if (this._streamErr) t.push(this._streamErr);
+		if (this._streamOut) t.push(this._streamOut);
+		const n = w(t);
+		const r = c.createInterface({ input: n });
+		for await (const e$4 of r) yield e$4.toString();
+		await this._processClosed;
+		e$3.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new z(this);
+	}
+	async _waitForOutput() {
+		const e$3 = this._process;
+		if (!e$3) throw new Error("No process was started");
+		const [t, n] = await Promise.all([this._streamOut ? W(this._streamOut) : "", this._streamErr ? W(this._streamErr) : ""]);
+		await this._processClosed;
+		if (this._options?.stdin) await this._options.stdin;
+		e$3.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		const r = {
+			stderr: n,
+			stdout: t,
+			exitCode: this.exitCode
+		};
+		if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new z(this, r);
+		return r;
+	}
+	then(e$3, t) {
+		return this._waitForOutput().then(e$3, t);
+	}
+	_streamOut;
+	_streamErr;
+	spawn() {
+		const e$3 = cwd();
+		const n = this._options;
+		const r = {
+			...V,
+			...n.nodeOptions
+		};
+		const i = [];
+		this._resetState();
+		if (n.timeout !== void 0) i.push(AbortSignal.timeout(n.timeout));
+		if (n.signal !== void 0) i.push(n.signal);
+		if (n.persist === true) r.detached = true;
+		if (i.length > 0) r.signal = U(i);
+		r.env = C(e$3, r.env);
+		const { command: a, args: s } = H(this._command, this._args);
+		const c$1 = (0, R._parse)(a, s, r);
+		const l$1 = spawn(c$1.command, c$1.args, c$1.options);
+		if (l$1.stderr) this._streamErr = l$1.stderr;
+		if (l$1.stdout) this._streamOut = l$1.stdout;
+		this._process = l$1;
+		l$1.once("error", this._onError);
+		l$1.once("close", this._onClose);
+		if (n.stdin !== void 0 && l$1.stdin && n.stdin.process) {
+			const { stdout: e$4 } = n.stdin.process;
+			if (e$4) e$4.pipe(l$1.stdin);
+		}
+	}
+	_resetState() {
+		this._aborted = false;
+		this._processClosed = new Promise((e$3) => {
+			this._resolveClose = e$3;
+		});
+		this._thrownError = void 0;
+	}
+	_onError = (e$3) => {
+		if (e$3.name === "AbortError" && (!(e$3.cause instanceof Error) || e$3.cause.name !== "TimeoutError")) {
+			this._aborted = true;
+			return;
+		}
+		this._thrownError = e$3;
+	};
+	_onClose = () => {
+		if (this._resolveClose) this._resolveClose();
+	};
+};
+const K = (e$3, t, n) => {
+	const r = new G(e$3, t, n);
+	r.spawn();
+	return r;
+};
+const q = K;
+
+//#endregion
+//#region src/shell/error.ts
+var ShellNonZeroExitError = class extends z {
+	result;
+	constructor(result, output) {
+		super(result, output);
+		this.result = result;
+	}
+};
+
+//#endregion
+//#region src/shell/exec.ts
+const normalizeParams = (...params) => {
+	const [commandOrTemplateOrOptions, argsOrTemplateValue, optionsOrTemplateValue, ...rest] = params;
+	let command;
+	let args;
+	let options;
+	let factory = false;
+	if (e(commandOrTemplateOrOptions)) {
+		command = commandOrTemplateOrOptions;
+		if (argsOrTemplateValue) args = argsOrTemplateValue;
+		else {
+			let tokens;
+			try {
+				tokens = tokenizeArgs(commandOrTemplateOrOptions);
+			} catch (error) {
+				throw new Error(`Failed to parse command string: "${commandOrTemplateOrOptions}". ${getErrorMessage(error)}`);
+			}
+			if (!tokens[0]) throw new Error(`Failed to extract command from string: "${commandOrTemplateOrOptions}"`);
+			command = tokens[0];
+			args = tokens.slice(1);
+		}
+		if (optionsOrTemplateValue) options = optionsOrTemplateValue;
+	} else if (e$1(commandOrTemplateOrOptions)) {
+		const input = concatTemplateStrings(commandOrTemplateOrOptions, [
+			argsOrTemplateValue,
+			optionsOrTemplateValue,
+			...rest
+		]);
+		let tokens;
+		try {
+			tokens = tokenizeArgs(input);
+		} catch (error) {
+			throw new Error(`Failed to parse input template string: "${input}". ${getErrorMessage(error)}`);
+		}
+		if (!tokens[0]) throw new Error(`Failed to extract command from template string: "${input}"`);
+		command = tokens[0];
+		args = tokens.slice(1);
+	} else if (e$2(commandOrTemplateOrOptions)) {
+		command = "";
+		options = commandOrTemplateOrOptions;
+		factory = true;
+	} else throw new TypeError(`First parameter has an invalid type: "${typeof commandOrTemplateOrOptions}"`);
+	return {
+		command,
+		args,
+		options,
+		factory
+	};
+};
+var ShellExecProcess = class extends G {
+	constructor(command, args, options) {
+		const normalized = normalizeParams(command, args, options);
+		super(normalized.command, normalized.args, normalized.options);
+	}
+	pipe(...params) {
+		const { command, args, options, factory } = normalizeParams(...params);
+		const pipeOptions = {
+			...options,
+			stdin: this
+		};
+		if (!factory) return execImpl(command, args, pipeOptions);
+		return (...params$1) => {
+			const normalized = normalizeParams(...params$1, void 0);
+			return execImpl(normalized.command, normalized.args, pipeOptions);
+		};
+	}
+	async *[Symbol.asyncIterator]() {
+		try {
+			yield* super[Symbol.asyncIterator]();
+		} catch (error) {
+			if (error instanceof z) throw new ShellNonZeroExitError(this);
+			throw error;
+		}
+	}
+	async _waitForOutput() {
+		try {
+			return await super._waitForOutput();
+		} catch (error) {
+			if (error instanceof z) throw new ShellNonZeroExitError(this);
+			throw error;
+		}
+	}
+};
+const exec = (...params) => {
+	const { command, args, options, factory } = normalizeParams(...params);
+	if (!factory) return execImpl(command, args, options);
+	return (...params$1) => {
+		const normalized = normalizeParams(...params$1, void 0);
+		return execImpl(normalized.command, normalized.args, options);
+	};
+};
+const execImpl = (...params) => {
+	const p$1 = new ShellExecProcess(...params);
+	p$1.spawn();
+	return p$1;
+};
+
+//#endregion
+export { exec as $, exec, exec as x, ShellExecProcess, ShellNonZeroExitError, tokenizeArgs as splitShellCommand };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { $ as IntRange, $n as Simplify, $r as Constructor, $t as SetNonNullable, A as RemovePrefix, An as ArrayTail, Ar as HasRequiredKeys, At as Entries, B as Xor, Bn as NonEmptyObject, Br as KeysOfUnion, Bt as Join, C as PascalCase, Cn as RequireOneOrNone, Cr as NonNegativeInteger, Ct as FindGlobalInstanceType, D as DelimiterCasedProperties, Dn as MergeDeep, Dr as UnknownArray, Dt as Asyncify, E as KebabCasedProperties, En as MergeExclusive, Er as IsFloat, Et as Jsonify, F as ExclusifyUnion, Fn as TaggedUnion, Fr as IfEmptyObject, Ft as FixedLengthArray, G as SharedUnionFields, Gn as GreaterThan, Gr as UppercaseLetter, Gt as ConditionalExcept, H as IfNull, Hn as Except, Hr as Alphanumeric, Ht as ConditionalPickDeep, I as IsNullable, In as UnknownMap, Ir as EmptyObject, It as StringSlice, J as ArrayIndices, Jn as Or, Jr as JsonPrimitive, Jt as IsTuple, K as SetFieldType, Kn as And, Kr as JsonArray, Kt as ConditionalKeys, L as IsOptional, Ln as UnknownSet, Lr as IsEmptyObject, Lt as ArraySlice, M as CamelCasedProperties, Mn as ConditionalSimplifyDeep, Mr as OptionalKeysOf, Mt as IterableElement, N as CamelCase, Nn as WritableDeep, Nr as IsOptionalKeyOf, Nt as MultidimensionalReadonlyArray, O as KebabCase, On as MergeDeepOptions, Or as If, Ot as SetParameterType, P as Words, Pn as Writable, Pr as IsAny, Pt as MultidimensionalArray, Q as IntClosedRange, Qn as IsEqual, Qr as Class, Qt as SetNonNullableDeep, R as IsUppercase, Rn as UnknownRecord, Rr as DistributedPick, Rt as LessThanOrEqual, S as PascalCasedProperties, Sn as IsUnion, Sr as NonNegative, St as StructuredCloneable, T as DelimiterCasedPropertiesDeep, Tn as RequireExactlyOne, Tr as IsInteger, Tt as Jsonifiable, U as SharedUnionFieldsDeep, Un as LessThan, Ur as DigitCharacter, Ut as ConditionalPickDeepOptions, V as IsUndefined, Vn as RequireAtLeastOne, Vr as UnionToIntersection, Vt as Stringified, W as AllUnionFields, Wn as GreaterThanOrEqual, Wr as LowercaseLetter, Wt as ConditionalPick, X as IfNever, Xn as PickIndexSignature, Xr as AbstractClass, Xt as AsyncReturnType, Y as IfUnknown, Yn as Merge, Yr as JsonValue, Yt as ExtendsStrict, Z as IfAny, Zn as OmitIndexSignature, Zr as AbstractConstructor, Zt as ValueOf, _ as ScreamingSnakeCase, _n as Subtract, _r as IsNegative, _t as KeyAsString, a as ExcludeStrict, ai as Fn, an as Arrayable, ar as IsLiteral, at as HasWritableKeys, b as SnakeCase, bn as PartialDeepOptions, br as NegativeInfinity, bt as Schema, c as PackageJson, ci as SyncFnWithThis, cn as UndefinedOnPartialDeep, cr as IsSymbolLiteral, ct as HasReadonlyKeys, d as LastArrayElement, dn as OmitDeep, dr as Tagged, dt as IsRequiredKeyOf, ei as TypedArray, en as SetRequiredDeep, er as Trim, et as TupleToUnion, f as Get, fn as UnionToTuple, fr as UnwrapOpaque, ft as HasOptionalKeys, g as Split, gn as Paths, gr as Integer, gt as ArrayElement, h as Replace, hn as PickDeep, hr as Float, ht as Exact, i as OmitByKey, ii as AsyncFnWithThis, in as InvariantOf, ir as IsBooleanLiteral, it as Spread, j as CamelCasedPropertiesDeep, jn as NonEmptyTuple, jr as RequiredKeysOf, jt as Entry, k as DelimiterCase, kn as SimplifyDeep, kr as IsNever, kt as SetReturnType, l as GlobalThis, ln as PartialOnUndefinedDeep, lr as GetTagMetadata, lt as ReadonlyKeysOf, m as StringRepeat, mn as ArraySplice, mr as Finite, mt as ReadonlyTuple, n as SetNullable, ni as Nullable, nn as SetReadonly, nr as IsUnknown, nt as ExtractRestElement, o as ExtractStrict, oi as FnWithThis, on as Promisable, or as IsNumericLiteral, ot as IsWritableKeyOf, p as Includes, pn as LiteralUnion, pr as UnwrapTagged, pt as OverrideProperties, q as ArrayValues, qn as AllExtend, qr as JsonObject, qt as TupleToObject, r as Optional, ri as AsyncFn, rn as SetOptional, rr as IsNull, rt as SplitOnRestElement, s as TsConfigJson, si as SyncFn, sn as ReadonlyDeep, sr as IsStringLiteral, st as WritableKeysOf, t as YieldType, ti as Primitive, tn as SetRequired, tr as TupleOf, tt as ExcludeRestElement, u as ConditionalSimplify, un as PartialOnUndefinedDeepOptions, ur as Opaque, ut as IsReadonlyKeyOf, v as SnakeCasedPropertiesDeep, vn as RequiredDeep, vr as Negative, vt as LiteralToPrimitiveDeep, w as KebabCasedPropertiesDeep, wn as RequireAllOrNone, wr as PositiveInfinity, wt as FindGlobalType, x as PascalCasedPropertiesDeep, xn as SingleKeyObject, xr as NegativeInteger, xt as SchemaOptions, y as SnakeCasedProperties, yn as PartialDeep, yr as NegativeFloat, yt as LiteralToPrimitive, z as IsLowercase, zn as NonEmptyString, zr as DistributedOmit, zt as Sum } from "./chunks/chunk-a07ed28f.js";
+import { $ as IntRange, $n as Simplify, $r as Constructor, $t as SetNonNullable, A as RemovePrefix, An as ArrayTail, Ar as HasRequiredKeys, At as Entries, B as Xor, Bn as NonEmptyObject, Br as KeysOfUnion, Bt as Join, C as PascalCase, Cn as RequireOneOrNone, Cr as NonNegativeInteger, Ct as FindGlobalInstanceType, D as DelimiterCasedProperties, Dn as MergeDeep, Dr as UnknownArray, Dt as Asyncify, E as KebabCasedProperties, En as MergeExclusive, Er as IsFloat, Et as Jsonify, F as ExclusifyUnion, Fn as TaggedUnion, Fr as IfEmptyObject, Ft as FixedLengthArray, G as SharedUnionFields, Gn as GreaterThan, Gr as UppercaseLetter, Gt as ConditionalExcept, H as IfNull, Hn as Except, Hr as Alphanumeric, Ht as ConditionalPickDeep, I as IsNullable, In as UnknownMap, Ir as EmptyObject, It as StringSlice, J as ArrayIndices, Jn as Or, Jr as JsonPrimitive, Jt as IsTuple, K as SetFieldType, Kn as And, Kr as JsonArray, Kt as ConditionalKeys, L as IsOptional, Ln as UnknownSet, Lr as IsEmptyObject, Lt as ArraySlice, M as CamelCasedProperties, Mn as ConditionalSimplifyDeep, Mr as OptionalKeysOf, Mt as IterableElement, N as CamelCase, Nn as WritableDeep, Nr as IsOptionalKeyOf, Nt as MultidimensionalReadonlyArray, O as KebabCase, On as MergeDeepOptions, Or as If, Ot as SetParameterType, P as Words, Pn as Writable, Pr as IsAny, Pt as MultidimensionalArray, Q as IntClosedRange, Qn as IsEqual, Qr as Class, Qt as SetNonNullableDeep, R as IsUppercase, Rn as UnknownRecord, Rr as DistributedPick, Rt as LessThanOrEqual, S as PascalCasedProperties, Sn as IsUnion, Sr as NonNegative, St as StructuredCloneable, T as DelimiterCasedPropertiesDeep, Tn as RequireExactlyOne, Tr as IsInteger, Tt as Jsonifiable, U as SharedUnionFieldsDeep, Un as LessThan, Ur as DigitCharacter, Ut as ConditionalPickDeepOptions, V as IsUndefined, Vn as RequireAtLeastOne, Vr as UnionToIntersection, Vt as Stringified, W as AllUnionFields, Wn as GreaterThanOrEqual, Wr as LowercaseLetter, Wt as ConditionalPick, X as IfNever, Xn as PickIndexSignature, Xr as AbstractClass, Xt as AsyncReturnType, Y as IfUnknown, Yn as Merge, Yr as JsonValue, Yt as ExtendsStrict, Z as IfAny, Zn as OmitIndexSignature, Zr as AbstractConstructor, Zt as ValueOf, _ as ScreamingSnakeCase, _n as Subtract, _r as IsNegative, _t as KeyAsString, a as ExcludeStrict, ai as Fn, an as Arrayable, ar as IsLiteral, at as HasWritableKeys, b as SnakeCase, bn as PartialDeepOptions, br as NegativeInfinity, bt as Schema, c as PackageJson, ci as SyncFnWithThis, cn as UndefinedOnPartialDeep, cr as IsSymbolLiteral, ct as HasReadonlyKeys, d as LastArrayElement, dn as OmitDeep, dr as Tagged, dt as IsRequiredKeyOf, ei as TypedArray, en as SetRequiredDeep, er as Trim, et as TupleToUnion, f as Get, fn as UnionToTuple, fr as UnwrapOpaque, ft as HasOptionalKeys, g as Split, gn as Paths, gr as Integer, gt as ArrayElement, h as Replace, hn as PickDeep, hr as Float, ht as Exact, i as OmitByKey, ii as AsyncFnWithThis, in as InvariantOf, ir as IsBooleanLiteral, it as Spread, j as CamelCasedPropertiesDeep, jn as NonEmptyTuple, jr as RequiredKeysOf, jt as Entry, k as DelimiterCase, kn as SimplifyDeep, kr as IsNever, kt as SetReturnType, l as GlobalThis, ln as PartialOnUndefinedDeep, lr as GetTagMetadata, lt as ReadonlyKeysOf, m as StringRepeat, mn as ArraySplice, mr as Finite, mt as ReadonlyTuple, n as SetNullable, ni as Nullable, nn as SetReadonly, nr as IsUnknown, nt as ExtractRestElement, o as ExtractStrict, oi as FnWithThis, on as Promisable, or as IsNumericLiteral, ot as IsWritableKeyOf, p as Includes, pn as LiteralUnion, pr as UnwrapTagged, pt as OverrideProperties, q as ArrayValues, qn as AllExtend, qr as JsonObject, qt as TupleToObject, r as Optional, ri as AsyncFn, rn as SetOptional, rr as IsNull, rt as SplitOnRestElement, s as TsConfigJson, si as SyncFn, sn as ReadonlyDeep, sr as IsStringLiteral, st as WritableKeysOf, t as YieldType, ti as Primitive, tn as SetRequired, tr as TupleOf, tt as ExcludeRestElement, u as ConditionalSimplify, un as PartialOnUndefinedDeepOptions, ur as Opaque, ut as IsReadonlyKeyOf, v as SnakeCasedPropertiesDeep, vn as RequiredDeep, vr as Negative, vt as LiteralToPrimitiveDeep, w as KebabCasedPropertiesDeep, wn as RequireAllOrNone, wr as PositiveInfinity, wt as FindGlobalType, x as PascalCasedPropertiesDeep, xn as SingleKeyObject, xr as NegativeInteger, xt as SchemaOptions, y as SnakeCasedProperties, yn as PartialDeep, yr as NegativeFloat, yt as LiteralToPrimitive, z as IsLowercase, zn as NonEmptyString, zr as DistributedOmit, zt as Sum } from "./chunks/chunk-566a516c.js";
 export { AbstractClass, AbstractConstructor, AllExtend, AllUnionFields, Alphanumeric, And, ArrayElement, ArrayIndices, ArraySlice, ArraySplice, ArrayTail, ArrayValues, Arrayable, AsyncFn, AsyncFnWithThis, AsyncReturnType, Asyncify, CamelCase, CamelCasedProperties, CamelCasedPropertiesDeep, Class, ConditionalExcept, ConditionalKeys, ConditionalPick, ConditionalPickDeep, ConditionalPickDeepOptions, ConditionalSimplify, ConditionalSimplifyDeep, Constructor, DelimiterCase, DelimiterCasedProperties, DelimiterCasedPropertiesDeep, DigitCharacter, DistributedOmit, DistributedPick, EmptyObject, Entries, Entry, Exact, Except, ExcludeRestElement, ExcludeStrict, ExclusifyUnion, ExtendsStrict, ExtractRestElement, ExtractStrict, FindGlobalInstanceType, FindGlobalType, Finite, FixedLengthArray, Float, Fn, FnWithThis, Get, GetTagMetadata, GlobalThis, GreaterThan, GreaterThanOrEqual, HasOptionalKeys, HasReadonlyKeys, HasRequiredKeys, HasWritableKeys, If, IfAny, IfEmptyObject, IfNever, IfNull, IfUnknown, Includes, IntClosedRange, IntRange, Integer, InvariantOf, IsAny, IsBooleanLiteral, IsEmptyObject, IsEqual, IsFloat, IsInteger, IsLiteral, IsLowercase, IsNegative, IsNever, IsNull, IsNullable, IsNumericLiteral, IsOptional, IsOptionalKeyOf, IsReadonlyKeyOf, IsRequiredKeyOf, IsStringLiteral, IsSymbolLiteral, IsTuple, IsUndefined, IsUnion, IsUnknown, IsUppercase, IsWritableKeyOf, IterableElement, Join, JsonArray, JsonObject, JsonPrimitive, JsonValue, Jsonifiable, Jsonify, KebabCase, KebabCasedProperties, KebabCasedPropertiesDeep, KeyAsString, KeysOfUnion, LastArrayElement, LessThan, LessThanOrEqual, LiteralToPrimitive, LiteralToPrimitiveDeep, LiteralUnion, LowercaseLetter, Merge, MergeDeep, MergeDeepOptions, MergeExclusive, MultidimensionalArray, MultidimensionalReadonlyArray, Negative, NegativeFloat, NegativeInfinity, NegativeInteger, NonEmptyObject, NonEmptyString, NonEmptyTuple, NonNegative, NonNegativeInteger, Nullable, OmitByKey, OmitDeep, OmitIndexSignature, Opaque, Optional, OptionalKeysOf, Or, OverrideProperties, PackageJson, PartialDeep, PartialDeepOptions, PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions, PascalCase, PascalCasedProperties, PascalCasedPropertiesDeep, Paths, PickDeep, PickIndexSignature, PositiveInfinity, Primitive, Promisable, ReadonlyDeep, ReadonlyKeysOf, ReadonlyTuple, RemovePrefix, Replace, RequireAllOrNone, RequireAtLeastOne, RequireExactlyOne, RequireOneOrNone, RequiredDeep, RequiredKeysOf, Schema, SchemaOptions, ScreamingSnakeCase, SetFieldType, SetNonNullable, SetNonNullableDeep, SetNullable, SetOptional, SetParameterType, SetReadonly, SetRequired, SetRequiredDeep, SetReturnType, SharedUnionFields, SharedUnionFieldsDeep, Simplify, SimplifyDeep, SingleKeyObject, SnakeCase, SnakeCasedProperties, SnakeCasedPropertiesDeep, Split, SplitOnRestElement, Spread, StringRepeat, StringSlice, Stringified, StructuredCloneable, Subtract, Sum, SyncFn, SyncFnWithThis, Tagged, TaggedUnion, Trim, TsConfigJson, TupleOf, TupleToObject, TupleToUnion, TypedArray, UndefinedOnPartialDeep, UnionToIntersection, UnionToTuple, UnknownArray, UnknownMap, UnknownRecord, UnknownSet, UnwrapOpaque, UnwrapTagged, UppercaseLetter, ValueOf, Words, Writable, WritableDeep, WritableKeysOf, Xor, YieldType };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@goodbyenjn/utils",
-    "version": "26.1.2",
+    "version": "26.1.4",
     "description": "GoodbyeNJN's utils for typescript and javascript",
     "keywords": [
         "utils",
@@ -35,6 +35,10 @@
             "types": "./dist/result.d.ts",
             "import": "./dist/result.js"
         },
+        "./shell": {
+            "types": "./dist/shell.d.ts",
+            "import": "./dist/shell.js"
+        },
         "./types": {
             "types": "./dist/types.d.ts"
         },
@@ -60,6 +64,7 @@
         "@goodbyenjn/configs": "^6.1.4",
         "@goodbyenjn/utils": "file:",
         "@types/node": "^25.0.3",
+        "args-tokenizer": "^0.3.0",
         "eslint": "^9.39.2",
         "prettier": "^3.7.4",
         "remeda": "^2.33.1",
@@ -67,6 +72,7 @@
         "rolldown-plugin-dts": "^0.20.0",
         "rotery": "^0.7.0",
         "safe-stable-stringify": "^2.5.0",
+        "tinyexec": "^1.0.2",
         "tinyglobby": "^0.2.15",
         "type-fest": "^5.3.1",
         "typescript": "^5.9.3",