@goodbyenjn/utils 26.1.3 → 26.2.0

package/dist/chunks/{chunk-fda806f4.js → chunk-5ed3bc8a.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;
@@ -848,7 +848,7 @@ const sleep = (ms, callback) => new Promise((resolve) => {
 const createSingleton = (fn) => {
 	let p;
 	const wrapper = () => {
-		if (!p) p = fn();
+		if (!p) p = Promise.resolve(fn());
 		return p;
 	};
 	wrapper.reset = async () => {
@@ -875,7 +875,7 @@ const createLock = () => {
 	const locks = [];
 	return {
 		async run(fn) {
-			const p = fn();
+			const p = Promise.resolve(fn());
 			locks.push(p);
 			try {
 				return await p;

package/dist/chunks/{chunk-4b76d1c4.d.ts → chunk-d1860346.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-e931fe39.js";
 
 //#region src/result/error.d.ts
 declare class ResultError extends Error {

package/dist/chunks/{chunk-a07ed28f.d.ts → chunk-e931fe39.d.ts}

@@ -3,12 +3,12 @@ type Fn<Return = any, Args extends readonly any[] = any[]> = (...args: Args) =>
 type FnWithThis<Return = any, Args extends readonly any[] = any[], This = unknown> = ((this: This, ...args: Args) => Return) & {
   prototype: This;
 };
-type AsyncFn<Return = any, Args extends readonly any[] = any[]> = (...args: Args) => Promise<Return>;
-type AsyncFnWithThis<Return = any, Args extends readonly any[] = any[], This = unknown> = ((this: This, ...args: Args) => Promise<Return>) & {
+type AsyncFn<Return = any, Args extends readonly any[] = any[]> = (...args: Args) => PromiseLike<Return>;
+type AsyncFnWithThis<Return = any, Args extends readonly any[] = any[], This = unknown> = ((this: This, ...args: Args) => PromiseLike<Return>) & {
   prototype: This;
 };
-type SyncFn<Return = any, Args extends readonly any[] = any[]> = (...args: Args) => Return extends Promise<any> ? never : Return;
-type SyncFnWithThis<Return = any, Args extends readonly any[] = any[], This = unknown> = ((this: This, ...args: Args) => Return extends Promise<any> ? never : Return) & {
+type SyncFn<Return = any, Args extends readonly any[] = any[]> = (...args: Args) => Return extends PromiseLike<any> ? never : Return;
+type SyncFnWithThis<Return = any, Args extends readonly any[] = any[], This = unknown> = ((this: This, ...args: Args) => Return extends PromiseLike<any> ? never : Return) & {
   prototype: This;
 };
 //#endregion

package/dist/common.d.ts

@@ -1,5 +1,5 @@
-import { i as Result } from "./chunks/chunk-4b76d1c4.js";
-import { ai as Fn, ri as AsyncFn } from "./chunks/chunk-a07ed28f.js";
+import { i as Result } from "./chunks/chunk-d1860346.js";
+import { ai as Fn, ri as AsyncFn } from "./chunks/chunk-e931fe39.js";
 
 //#region src/common/error.d.ts
 declare const normalizeError: (error: unknown, caller?: Function) => Error;

package/dist/common.js

@@ -1,3 +1,3 @@
-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-fda806f4.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-5ed3bc8a.js";
 
 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-d1860346.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 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-fda806f4.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-5ed3bc8a.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-e931fe39.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-d1860346.js";
 export { Err, ExtractErrTypes, ExtractOkTypes, InferErrType, InferOkType, Ok, Result, ResultAll, ResultError, err, ok, safeTry };

package/dist/result.js

@@ -1,3 +1,3 @@
-import { A as Result, M as ok, N as safeTry, P as ResultError, j as err } from "./chunks/chunk-fda806f4.js";
+import { A as Result, M as ok, N as safeTry, P as ResultError, j as err } from "./chunks/chunk-5ed3bc8a.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-5ed3bc8a.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-e931fe39.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.3",
+    "version": "26.2.0",
     "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"
         },