@ls-stack/utils 1.13.2 → 2.0.1

package/dist/rsResult.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rsResult.ts
+var rsResult_exports = {};
+__export(rsResult_exports, {
+  Result: () => Result,
+  asyncResultify: () => asyncResultify,
+  createTypedResult: () => createTypedResult,
+  normalizeError: () => normalizeError,
+  resultify: () => resultify,
+  safeJsonStringify: () => safeJsonStringify
+});
+module.exports = __toCommonJS(rsResult_exports);
+
+// src/assertions.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/rsResult.ts
+function okUnwrapOr() {
+  return this.value;
+}
+function okMap(mapFn) {
+  return this.ok ? ok(mapFn(this.value)) : this;
+}
+function errMap(mapFn) {
+  return this.ok ? this : err(mapFn(this.error));
+}
+function mapOkAndErr({
+  ok: mapFn,
+  err: mapErrFn
+}) {
+  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
+}
+function returnResult() {
+  return this;
+}
+function ok(value = void 0) {
+  return {
+    ok: true,
+    error: false,
+    value,
+    unwrapOrNull: okUnwrapOr,
+    unwrapOr: okUnwrapOr,
+    unwrap: okUnwrapOr,
+    mapOk: okMap,
+    mapErr: returnResult,
+    mapOkAndErr
+  };
+}
+function err(error) {
+  return {
+    ok: false,
+    error,
+    unwrapOrNull: () => null,
+    unwrapOr: (defaultValue) => defaultValue,
+    errorResult() {
+      return err(error);
+    },
+    unwrap: () => {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw normalizeError(error);
+    },
+    mapOk: returnResult,
+    mapErr: errMap,
+    mapOkAndErr
+  };
+}
+function unknownToError(error) {
+  return err(normalizeError(error));
+}
+async function asyncUnwrap(result) {
+  const unwrapped = await result;
+  if (unwrapped.ok) {
+    return unwrapped.value;
+  }
+  if (unwrapped.error instanceof Error) {
+    throw unwrapped.error;
+  }
+  throw normalizeError(unwrapped.error);
+}
+function asyncMap(resultPromise) {
+  return {
+    err: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(result.value) : err(mapFn(result.error));
+    },
+    ok: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(result.error);
+    },
+    okAndErr: async ({
+      ok: mapFn,
+      err: mapErrFn
+    }) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
+    }
+  };
+}
+var Result = {
+  ok,
+  err,
+  unknownToError,
+  asyncUnwrap,
+  asyncMap
+};
+function resultify(fn, errorNormalizer) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(
+      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+    );
+  }
+}
+async function asyncResultify(fn, errorNormalizer) {
+  try {
+    return ok(await fn());
+  } catch (error) {
+    return err(
+      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+    );
+  }
+}
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error)) {
+    return new Error(
+      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
+      { cause: error }
+    );
+  }
+  return new Error(safeJsonStringify(error) ?? "unknown", { cause: error });
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return null;
+  }
+}
+function createTypedResult() {
+  return {
+    ok,
+    err
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Result,
+  asyncResultify,
+  createTypedResult,
+  normalizeError,
+  resultify,
+  safeJsonStringify
+});

package/dist/rsResult.d.cts

@@ -0,0 +1,83 @@
+type Ok<T> = {
+    ok: true;
+    error: false;
+    value: T;
+};
+type ResultValidErrors = Error | Record<string, unknown> | unknown[] | true;
+type Err<E extends ResultValidErrors> = {
+    ok: false;
+    error: E;
+    errorResult: () => Result<any, E>;
+};
+type ResultMethods<T, E extends ResultValidErrors> = {
+    /** Returns the value if the result is Ok, otherwise returns null */
+    unwrapOrNull: () => T | null;
+    /** Returns the value if the result is Ok, otherwise returns the provided default value */
+    unwrapOr: <R extends T>(defaultValue: R) => T | R;
+    unwrap: () => T;
+    mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
+    mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
+    mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
+        ok: (value: T) => NewValue;
+        err: (error: E) => NewError;
+    }) => Result<NewValue, NewError>;
+};
+type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
+declare function ok(): OkResult<void, any>;
+declare function ok<T>(value: T): OkResult<T, any>;
+type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
+declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
+declare function unknownToError(error: unknown): ErrResult<Error, any>;
+/** Unwraps a promise result */
+declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
+declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
+    err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Promise<Result<T, NewError>>;
+    ok: <NewValue>(mapFn: (value: T) => NewValue) => Promise<Result<NewValue, E>>;
+    okAndErr: <NewValue, NewError extends ResultValidErrors>({ ok: mapFn, err: mapErrFn, }: {
+        ok: (value: T) => NewValue;
+        err: (error: E) => NewError;
+    }) => Promise<Result<NewValue, NewError>>;
+};
+/**
+ * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
+ *
+ * Usage:
+ *
+ * @example
+ * function doSomething(): Result<string, Error> {
+ *  if (something) {
+ *    return ok('success');
+ *  }
+ *
+ *  return err(new Error('something went wrong'));
+ * }
+ *
+ * const result = doSomething();
+ *
+ * if (result.ok) {
+ *   // result.value is a string
+ * } else {
+ *   // result.error is an Error
+ * }
+ */
+type Result<T, E extends ResultValidErrors = Error> = OkResult<T, E, T> | ErrResult<E, T>;
+declare const Result: {
+    ok: typeof ok;
+    err: typeof err;
+    unknownToError: typeof unknownToError;
+    asyncUnwrap: typeof asyncUnwrap;
+    asyncMap: typeof asyncMap;
+};
+/** transform a function in a result function */
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+/** transform a async function in a result function */
+declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+declare function normalizeError(error: unknown): Error;
+declare function safeJsonStringify(value: unknown): string | null;
+type TypedResult<T, E extends ResultValidErrors = Error> = {
+    ok: (value: T) => OkResult<T, E, T>;
+    err: (error: E) => ErrResult<E, T>;
+};
+declare function createTypedResult<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
+
+export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify };

package/dist/rsResult.d.ts

@@ -3,47 +3,41 @@ type Ok<T> = {
     error: false;
     value: T;
 };
-type NormalizedErrorResultProps = {
-    id: string;
-    message: string;
-    code?: number;
-    metadata?: ValidErrorMetadata;
-};
-type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+type ResultValidErrors = Error | Record<string, unknown> | unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
     errorResult: () => Result<any, E>;
-    normalizedErrorResult: (normalizedErr: E extends NormalizedError ? {
-        withMetadata: ValidErrorMetadata;
-    } | NormalizedErrorResultProps : NormalizedErrorResultProps) => Result<any, NormalizedError>;
 };
-type Unwrap<E, T> = IsExactlyAny<E> extends true ? any : E extends Error ? () => T : unknown;
-type ResultMethods<T, E> = {
+type ResultMethods<T, E extends ResultValidErrors> = {
     /** Returns the value if the result is Ok, otherwise returns null */
     unwrapOrNull: () => T | null;
     /** Returns the value if the result is Ok, otherwise returns the provided default value */
     unwrapOr: <R extends T>(defaultValue: R) => T | R;
-    unwrap: Unwrap<E, T>;
+    unwrap: () => T;
+    mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
+    mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
+    mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
+        ok: (value: T) => NewValue;
+        err: (error: E) => NewError;
+    }) => Result<NewValue, NewError>;
 };
 type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
-type ResultValidErrors = Error | Record<string, unknown> | string[];
 declare function ok(): OkResult<void, any>;
 declare function ok<T>(value: T): OkResult<T, any>;
 type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
 declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
-declare function normalizedUnknownErr(error: unknown): ErrResult<NormalizedError<string>, any>;
-declare function normalizedErr(message: string): ErrResult<NormalizedError>;
-declare function normalizedErr<T extends string>(id: T, message: string): ErrResult<NormalizedError<T>>;
-declare function normalizedErr<T extends string>(errorProps: {
-    id: T;
-    message: string;
-    code?: number;
-    cause?: Error;
-    metadata?: ValidErrorMetadata;
-}): ErrResult<NormalizedError<T>>;
+declare function unknownToError(error: unknown): ErrResult<Error, any>;
 /** Unwraps a promise result */
-declare function unwrap<T>(result: Promise<Result<T, Error>>): Promise<T>;
+declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
+declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
+    err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Promise<Result<T, NewError>>;
+    ok: <NewValue>(mapFn: (value: T) => NewValue) => Promise<Result<NewValue, E>>;
+    okAndErr: <NewValue, NewError extends ResultValidErrors>({ ok: mapFn, err: mapErrFn, }: {
+        ok: (value: T) => NewValue;
+        err: (error: E) => NewError;
+    }) => Promise<Result<NewValue, NewError>>;
+};
 /**
  * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
  *
@@ -66,53 +60,24 @@ declare function unwrap<T>(result: Promise<Result<T, Error>>): Promise<T>;
  *   // result.error is an Error
  * }
  */
-type Result<T, E extends ResultValidErrors = NormalizedError> = OkResult<T, E, T> | ErrResult<E, T>;
+type Result<T, E extends ResultValidErrors = Error> = OkResult<T, E, T> | ErrResult<E, T>;
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
-    normalizedErr: typeof normalizedErr;
-    normalizedUnknownErr: typeof normalizedUnknownErr;
-    unwrap: typeof unwrap;
+    unknownToError: typeof unknownToError;
+    asyncUnwrap: typeof asyncUnwrap;
+    asyncMap: typeof asyncMap;
 };
-/** transfor a function in a result function */
-declare function resultify<T, E extends ResultValidErrors = NormalizedError>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+/** transform a function in a result function */
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
 /** transform a async function in a result function */
-declare function asyncResultify<T, E extends Error = NormalizedError>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
-type ValidErrorMetadata = Record<string, unknown> | undefined;
-declare function setNormalizedErrorSideEffects(callback: (normalizedError: NormalizedError) => void): void;
-declare class NormalizedError<T = string> extends Error {
-    id: T;
-    metadata?: ValidErrorMetadata;
-    cause?: Error;
-    code: number;
-    constructor({ id, message, metadata, cause, code, }: {
-        id: T;
-        message: string;
-        metadata?: ValidErrorMetadata;
-        cause?: Error;
-        code?: number;
-    });
-    toString(): string;
-    toJSON(): {
-        id: T;
-        message: string;
-        metadata: ValidErrorMetadata;
-        code: number;
-        cause: string | (Error & Record<"toJSON", unknown>) | undefined;
-    };
-}
-declare class NormalizedErrorWithMetadata<M extends ValidErrorMetadata, T = string> extends NormalizedError<T> {
-    metadata: M;
-    constructor(props: {
-        id: T;
-        message: string;
-        metadata: M;
-        cause?: Error;
-    } | {
-        error: NormalizedError<T>;
-        metadata: M;
-    });
-}
-declare function normalizeError(error: unknown): NormalizedError;
+declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+declare function normalizeError(error: unknown): Error;
+declare function safeJsonStringify(value: unknown): string | null;
+type TypedResult<T, E extends ResultValidErrors = Error> = {
+    ok: (value: T) => OkResult<T, E, T>;
+    err: (error: E) => ErrResult<E, T>;
+};
+declare function createTypedResult<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
 
-export { NormalizedError, NormalizedErrorWithMetadata, Result, type ValidErrorMetadata, asyncResultify, normalizeError, resultify, setNormalizedErrorSideEffects };
+export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify };

package/dist/rsResult.js

@@ -1,21 +1,17 @@
 import {
-  NormalizedError,
-  NormalizedErrorWithMetadata,
   Result,
   asyncResultify,
+  createTypedResult,
   normalizeError,
   resultify,
-  setNormalizedErrorSideEffects
-} from "./chunk-I7ZDKDUM.js";
-import "./chunk-GLZ5MZC5.js";
-import "./chunk-FYMTZQ42.js";
+  safeJsonStringify
+} from "./chunk-3PXKYWJF.js";
+import "./chunk-4UGSP3L3.js";
 export {
-  NormalizedError,
-  NormalizedErrorWithMetadata,
   Result,
   asyncResultify,
+  createTypedResult,
   normalizeError,
   resultify,
-  setNormalizedErrorSideEffects
+  safeJsonStringify
 };
-//# sourceMappingURL=rsResult.js.map

package/dist/runShellCmd.cjs

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runShellCmd.ts
+var runShellCmd_exports = {};
+__export(runShellCmd_exports, {
+  concurrentCmd: () => concurrentCmd,
+  runCmd: () => runCmd,
+  runCmdSilent: () => runCmdSilent,
+  runCmdSilentUnwrap: () => runCmdSilentUnwrap,
+  runCmdUnwrap: () => runCmdUnwrap
+});
+module.exports = __toCommonJS(runShellCmd_exports);
+var import_child_process = require("child_process");
+function runCmd(label, command, {
+  mock,
+  silent,
+  throwOnError,
+  cwd = process.cwd(),
+  noCiColorForce
+} = {}) {
+  if (mock) return Promise.resolve(mock);
+  if (label && (!silent || silent === "timeOnly")) {
+    console.log(`----${label}----`);
+    console.time("\u2705");
+  }
+  return new Promise((resolve) => {
+    const [cmd = "", ...args] = Array.isArray(command) ? command.flatMap(
+      (item) => item.startsWith("$") ? item.replace("$", "").split(" ") : item
+    ) : command.split(" ");
+    const child = (0, import_child_process.spawn)(cmd, args, {
+      cwd,
+      env: noCiColorForce ? void 0 : { ...process.env, CLICOLOR_FORCE: "1" }
+    });
+    let stdout = "";
+    let stderr = "";
+    let out = "";
+    child.stdout.on("data", (data) => {
+      stdout += String(data);
+      out += String(data);
+      if (!silent) {
+        console.log(String(data));
+      }
+    });
+    child.stderr.on("data", (data) => {
+      stderr += String(data);
+      out += String(data);
+      if (!silent) {
+        console.log(String(data));
+      }
+    });
+    child.on("close", (code) => {
+      const hasError = code !== 0;
+      if (!silent || silent === "timeOnly") {
+        if (!hasError) {
+          console.timeEnd("\u2705");
+        }
+        console.log("\n");
+      }
+      if (throwOnError && hasError) {
+        if (silent) {
+          if (label) {
+            console.log(`----${label}----`);
+          } else {
+            console.trace();
+          }
+          console.error(stderr);
+        }
+        process.exit(1);
+      }
+      resolve({ label, out, stderr, stdout, error: hasError });
+    });
+  });
+}
+async function concurrentCmd(label, cmd, onResult) {
+  const start = Date.now();
+  const result = await runCmd(label, cmd, { silent: true });
+  onResult(result);
+  const elapsedSeconds = (Date.now() - start) / 1e3;
+  console.log(
+    `${result.error ? "\u{1F534}" : "\u2705"} ${result.label} (${elapsedSeconds.toFixed(
+      1
+    )}s)`
+  );
+  return () => {
+    if (result.error) {
+      console.log(`\u274C ${result.label} errors:`);
+      console.log(result.out);
+      console.log("\n");
+    }
+  };
+}
+async function runCmdUnwrap(label, command, {
+  silent
+} = {}) {
+  return (await runCmd(label, command, { silent, throwOnError: true })).stdout;
+}
+function runCmdSilent(command) {
+  return runCmd(null, command, { silent: true });
+}
+function runCmdSilentUnwrap(command) {
+  return runCmdUnwrap(null, command, { silent: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  concurrentCmd,
+  runCmd,
+  runCmdSilent,
+  runCmdSilentUnwrap,
+  runCmdUnwrap
+});

package/dist/runShellCmd.d.cts

@@ -0,0 +1,23 @@
+type CmdResult = {
+    label: string | null;
+    out: string;
+    error: boolean;
+    stdout: string;
+    stderr: string;
+};
+type RunCmdOptions = {
+    mock?: CmdResult;
+    silent?: boolean | 'timeOnly';
+    cwd?: string;
+    throwOnError?: boolean;
+    noCiColorForce?: boolean;
+};
+declare function runCmd(label: string | null, command: string | string[], { mock, silent, throwOnError, cwd, noCiColorForce, }?: RunCmdOptions): Promise<CmdResult>;
+declare function concurrentCmd(label: string, cmd: string | string[], onResult: (result: CmdResult) => void): Promise<() => void>;
+declare function runCmdUnwrap(label: string | null, command: string | string[], { silent, }?: {
+    silent?: boolean | 'timeOnly';
+}): Promise<string>;
+declare function runCmdSilent(command: string | string[]): Promise<CmdResult>;
+declare function runCmdSilentUnwrap(command: string | string[]): Promise<string>;
+
+export { concurrentCmd, runCmd, runCmdSilent, runCmdSilentUnwrap, runCmdUnwrap };

package/dist/runShellCmd.d.ts

@@ -10,8 +10,9 @@ type RunCmdOptions = {
     silent?: boolean | 'timeOnly';
     cwd?: string;
     throwOnError?: boolean;
+    noCiColorForce?: boolean;
 };
-declare function runCmd(label: string | null, command: string | string[], { mock, silent, throwOnError, cwd }?: RunCmdOptions): Promise<CmdResult>;
+declare function runCmd(label: string | null, command: string | string[], { mock, silent, throwOnError, cwd, noCiColorForce, }?: RunCmdOptions): Promise<CmdResult>;
 declare function concurrentCmd(label: string, cmd: string | string[], onResult: (result: CmdResult) => void): Promise<() => void>;
 declare function runCmdUnwrap(label: string | null, command: string | string[], { silent, }?: {
     silent?: boolean | 'timeOnly';

package/dist/runShellCmd.js

@@ -1,7 +1,12 @@
 // src/runShellCmd.ts
 import { spawn } from "child_process";
-process.env.FORCE_COLOR = true;
-function runCmd(label, command, { mock, silent, throwOnError, cwd = process.cwd() } = {}) {
+function runCmd(label, command, {
+  mock,
+  silent,
+  throwOnError,
+  cwd = process.cwd(),
+  noCiColorForce
+} = {}) {
   if (mock) return Promise.resolve(mock);
   if (label && (!silent || silent === "timeOnly")) {
     console.log(`----${label}----`);
@@ -12,7 +17,8 @@ function runCmd(label, command, { mock, silent, throwOnError, cwd = process.cwd(
       (item) => item.startsWith("$") ? item.replace("$", "").split(" ") : item
     ) : command.split(" ");
     const child = spawn(cmd, args, {
-      cwd
+      cwd,
+      env: noCiColorForce ? void 0 : { ...process.env, CLICOLOR_FORCE: "1" }
     });
     let stdout = "";
     let stderr = "";
@@ -90,4 +96,3 @@ export {
   runCmdSilentUnwrap,
   runCmdUnwrap
 };
-//# sourceMappingURL=runShellCmd.js.map