resultar 1.1.3 → 1.1.5

package/dist/{chunk-FBVQYZXO.js → chunk-3NDPPYVV.js}

@@ -15,4 +15,4 @@ var createResultarError = (message, result, config = defaultErrorConfig) => {
 export {
   createResultarError
 };
-//# sourceMappingURL=chunk-FBVQYZXO.js.map
+//# sourceMappingURL=chunk-3NDPPYVV.js.map

package/dist/chunk-3NDPPYVV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/error.ts"],"sourcesContent":["import type { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n    | {\n      type: string\n      value: T | undefined\n    }\n    | {\n      type: string\n      value: E | undefined\n    }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n"],"mappings":";AAMA,IAAM,qBAAkC;AAAA,EACtC,gBAAgB;AAClB;AAgBO,IAAM,sBAAsB,CACjC,SACA,QACA,SAAsB,uBACE;AACxB,QAAM,OAAO,OAAO,KAAK,IACrB,EAAE,MAAM,MAAM,OAAO,OAAO,MAAM,IAClC,EAAE,MAAM,OAAO,OAAO,OAAO,MAAM;AAEvC,QAAM,aAAa,OAAO,iBAAiB,IAAI,MAAM,EAAE,QAAQ;AAE/D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO;AAAA,EACT;AACF;","names":[]}

package/dist/{chunk-UCLMDNNV.js → chunk-UPMJ4PST.js}

@@ -1,45 +1,21 @@
 import {
   createResultarError
-} from "./chunk-FBVQYZXO.js";
-
-// src/utils.ts
-var appendValueToEndOfList = (value) => (list) => [...list, value];
-var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
-  combineResultList
-);
-var combineResultList = (resultList) => resultList.reduce(
-  // eslint-disable-line unicorn/no-array-reduce
-  (acc, result) => acc.isOk() ? result.isErr() ? err(result.error) : acc.map(appendValueToEndOfList(result.value)) : acc,
-  ok([])
-);
-var combineResultAsyncListWithAllErrors = (asyncResultList) => {
-  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
-    combineResultListWithAllErrors
-  );
-  return x;
-};
-var combineResultListWithAllErrors = (resultList) => resultList.reduce(
-  // eslint-disable-line unicorn/no-array-reduce
-  (acc, result) => result.isErr() ? acc.isErr() ? err([...acc.error, result.error]) : err([result.error]) : acc.isErr() ? acc : ok([...acc.value, result.value]),
-  ok([])
-);
+} from "./chunk-3NDPPYVV.js";
 
 // src/result.ts
 var Ok = class {
-  // eslint-disable-line @typescript-eslint/class-literal-property-style
   constructor(value) {
     this.value = value;
   }
   ok = true;
 };
 var Err = class {
-  // eslint-disable-line @typescript-eslint/class-literal-property-style
   constructor(error) {
     this.error = error;
   }
   ok = false;
 };
-var Result2 = class _Result {
+var Result = class _Result {
   constructor(state) {
     this.state = state;
     if (state.ok) {
@@ -57,6 +33,7 @@ var Result2 = class _Result {
    * @param fn function to wrap with ok on success or err on failure
    * @param errorFn when an error is thrown, this will wrap the error result if provided
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static fromThrowable(fn, errorFn) {
     return (...args) => {
       try {
@@ -196,7 +173,6 @@ var Result2 = class _Result {
     return defaultValue;
   }
   /**
-   *
    * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
    * execute the function that matches the `Result` variant.
    *
@@ -215,6 +191,19 @@ var Result2 = class _Result {
     }
     return fnErr(this.error);
   }
+  /**
+   * Performs a side effect no matter what the `Result` variant is.
+   *
+   * @param fn The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  log(fn) {
+    try {
+      fn(this.value, this.error);
+    } catch {
+    }
+    return this;
+  }
   /**
    * Performs a side effect for the `Ok` variant of `Result`.
    *
@@ -227,9 +216,8 @@ var Result2 = class _Result {
         fn(this.value);
       } catch {
       }
-      return ok(this.value);
     }
-    return err(this.error);
+    return this;
   }
   /**
    * Performs a side effect for the `Err` variant of `Result`.
@@ -238,14 +226,13 @@ var Result2 = class _Result {
    * @returns the result of applying `f` or an `Ok` untouched
    */
   tapError(fn) {
-    if (this.state.ok) {
-      return ok(this.value);
-    }
-    try {
-      fn(this.error);
-    } catch {
+    if (!this.state.ok) {
+      try {
+        fn(this.error);
+      } catch {
+      }
     }
-    return err(this.error);
+    return this;
   }
   finally(f) {
     const resultDisposable = new DisposableResult(this, f);
@@ -326,7 +313,7 @@ var DisposableResult = class {
     this.finalizer(this.result.value, this.result.error);
   }
 };
-var { ok, err, fromThrowable } = Result2;
+var { ok, err, fromThrowable } = Result;
 function safeTry(body) {
   const n = body().next();
   if (n instanceof Promise) {
@@ -347,17 +334,17 @@ var DisposableResultAsync = class {
 };
 var ResultAsync = class _ResultAsync {
   static okAsync(value) {
-    return new _ResultAsync(Promise.resolve(Result2.ok(value)));
+    return new _ResultAsync(Promise.resolve(Result.ok(value)));
   }
   static errAsync(error) {
-    return new _ResultAsync(Promise.resolve(Result2.err(error)));
+    return new _ResultAsync(Promise.resolve(Result.err(error)));
   }
   static fromSafePromise(promise) {
-    const newPromise = promise.then((value) => Result2.ok(value));
+    const newPromise = promise.then((value) => Result.ok(value));
     return new _ResultAsync(newPromise);
   }
   static fromPromise(promise, errorFn) {
-    const newPromise = promise.then((value) => Result2.ok(value)).catch((error) => Result2.err(errorFn(error)));
+    const newPromise = promise.then((value) => Result.ok(value)).catch((error) => Result.err(errorFn(error)));
     return new _ResultAsync(newPromise);
   }
   static combine(asyncResultList) {
@@ -369,22 +356,23 @@ var ResultAsync = class _ResultAsync {
     );
   }
   /**
-  * Wraps a async function with a try catch, creating a new function with the same
-  * arguments but returning `Ok` if successful, `Err` if the function throws
-  *
-  * @param fn function to wrap with ok on success or err on failure
-  * @param errorFn when an error is thrown, this will wrap the error result if provided
-  * @returns a new function that returns a `ResultAsync`
-  */
+   * Wraps a async function with a try catch, creating a new function with the same
+   * arguments but returning `Ok` if successful, `Err` if the function throws
+   *
+   * @param fn function to wrap with ok on success or err on failure
+   * @param errorFn when an error is thrown, this will wrap the error result if provided
+   * @returns a new function that returns a `ResultAsync`
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static fromThrowable(fn, errorFn) {
     return (...args) => new _ResultAsync(
       (async () => {
         try {
           const v = await fn(...args);
-          return Result2.ok(v);
+          return Result.ok(v);
         } catch (error) {
           const e = errorFn ? errorFn(error) : error;
-          return Result2.err(e);
+          return Result.err(e);
         }
       })()
     );
@@ -415,6 +403,7 @@ var ResultAsync = class _ResultAsync {
     );
     return x;
   }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   andThen(f) {
     return new _ResultAsync(
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
@@ -440,6 +429,7 @@ var ResultAsync = class _ResultAsync {
       })
     };
   }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   orElse(f) {
     return new _ResultAsync(
       this.innerPromise.then(async (res) => {
@@ -456,6 +446,30 @@ var ResultAsync = class _ResultAsync {
   async unwrapOr(t) {
     return this.innerPromise.then((res) => res.unwrapOr(t));
   }
+  /**
+   * Performs a side effect for the `Ok` variant of `ResultAsync`.
+   * This function can be used for control flow based on result values.
+   * @param f The function to call if the result is `Ok`
+   * @returns `self` if the result is `Err`, otherwise the result of `f`
+   */
+  log(f) {
+    return new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isOk()) {
+          try {
+            await f(res.value);
+          } catch {
+          }
+          return okAsync(res.value);
+        }
+        try {
+          await f(void 0, res.error);
+        } catch {
+        }
+        return errAsync(res.error);
+      })
+    );
+  }
   /**
    * Performs a side effect for the `Ok` variant of `ResultAsync`.
    * This function can be used for control flow based on result values.
@@ -477,12 +491,12 @@ var ResultAsync = class _ResultAsync {
     );
   }
   /**
-  * Performs a side effect for the `Err` variant of `ResultAsync`.
-  * This function can be used for control flow based on result values.
-  * @param f The function to call if the result is `Err`
-  * @returns `self` if the result is `Ok`, otherwise the result of `f`
-  * @example
-  */
+   * Performs a side effect for the `Err` variant of `ResultAsync`.
+   * This function can be used for control flow based on result values.
+   * @param f The function to call if the result is `Err`
+   * @returns `self` if the result is `Ok`, otherwise the result of `f`
+   * @example
+   */
   tapError(f) {
     return new _ResultAsync(
       this.innerPromise.then(async (res) => {
@@ -499,6 +513,7 @@ var ResultAsync = class _ResultAsync {
   }
   finally(f) {
     return new DisposableResultAsync(
+      // eslint-disable-next-line @typescript-eslint/require-await
       this.innerPromise.then(async (res) => {
         try {
           res.finally(f);
@@ -529,24 +544,60 @@ function safeTryAsync(body) {
   );
 }
 
+// src/utils.ts
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
+  combineResultList
+);
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => {
+  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
+    combineResultListWithAllErrors
+  );
+  return x;
+};
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+
 export {
-  DisposableResultAsync,
-  ResultAsync,
-  okAsync,
-  errAsync,
-  fromPromise,
-  fromSafePromise,
-  fromThrowableAsync,
-  safeTryAsync,
   combineResultAsyncList,
   combineResultList,
   combineResultAsyncListWithAllErrors,
   combineResultListWithAllErrors,
-  Result2 as Result,
+  Result,
   DisposableResult,
   ok,
   err,
   fromThrowable,
-  safeTry
+  safeTry,
+  DisposableResultAsync,
+  ResultAsync,
+  okAsync,
+  errAsync,
+  fromPromise,
+  fromSafePromise,
+  fromThrowableAsync,
+  safeTryAsync
 };
-//# sourceMappingURL=chunk-UCLMDNNV.js.map
+//# sourceMappingURL=chunk-UPMJ4PST.js.map

package/dist/chunk-UPMJ4PST.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/result.ts","../src/result-async.ts","../src/utils.ts"],"sourcesContent":["import type { ErrorConfig } from './error.js'\nimport { createResultarError } from './error.js'\nimport { errAsync, ResultAsync } from './result-async.js'\nimport type { CombineResults, CombineResultsWithAllErrorsArray, InferErrTypes, InferOkTypes } from './utils.js'\nimport { combineResultList, combineResultListWithAllErrors } from './utils.js'\n\nclass Ok<T> {\n  readonly ok = true\n  constructor(public readonly value: T) {}\n}\n\nclass Err<E> {\n  readonly ok = false\n  constructor(public readonly error: E) {}\n}\n\n/**\n * A Result interface that is used to define the methods that are available on a\n * `Result` object.\n *\n * The immutability of the `Result` object is maintained by the interface.\n */\ninterface Resultable<T, E> {\n  get value(): T\n  get error(): E\n\n  /**\n   * Used to check if a `Result` is an `OK`\n   *\n   * @returns `true` if the result is an `OK` variant of Result\n   */\n  isOk(): boolean\n\n  /**\n   * Used to check if a `Result` is an `Err`\n   *\n   * @returns `true` if the result is an `Err` variant of Result\n   */\n  isErr(): boolean\n  /**\n   * Unwrap the `Ok` value, or return the default if there is an `Err`\n   *\n   * @param v the default value to return if there is an `Err`\n   */\n\n  unwrapOr<A>(defaultValue: A): T | A\n\n  // safeUnwrap(): Generator<Result<never, E>, T>\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrap(config?: ErrorConfig): T\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,\n   * otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrapErr(config?: ErrorConfig): E\n}\n\n/**\n * A `Result` is a type that represents either success (`Ok`) or failure (`Err`).\n * It is often used to replace exceptions or `null` returns.\n * `Result` is often used to handle errors in a functional way.\n * The `Result` type is often used to handle errors in a functional way.\n */\nexport class Result<T, E> implements Resultable<T, E> {\n  /**\n   * Wraps a function with a try catch, creating a new function with the same\n   * arguments but returning `Ok` if successful, `Err` if the function throws\n   *\n   * @param fn function to wrap with ok on success or err on failure\n   * @param errorFn when an error is thrown, this will wrap the error result if provided\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(\n    fn: Fn,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    errorFn?: (e: any) => E,\n  ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E> {\n    return (...args) => {\n      try {\n        const result = fn(...args)\n        return ok(result as ReturnType<Fn>)\n      } catch (error) {\n        if (errorFn) {\n          return err(errorFn(error))\n        }\n\n        return err(error as E)\n      }\n    }\n  }\n\n  static ok<T, E = never>(value: T): Result<T, E> {\n    return new Result<T, E>(new Ok(value))\n  }\n\n  static err<T = never, E = unknown>(error: E): Result<T, E> {\n    return new Result<T, E>(new Err(error))\n  }\n\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T>\n  static combine<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResults<T>\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T> {\n    return combineResultList(resultList) as CombineResults<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T> {\n    return combineResultListWithAllErrors(resultList) as CombineResultsWithAllErrorsArray<T>\n  }\n\n  readonly value: T\n  readonly error: E\n\n  private constructor(private readonly state: Ok<T> | Err<E>) {\n    if (state.ok) {\n      this.value = state.value\n      this.error = undefined as E\n    } else {\n      this.error = state.error\n      this.value = undefined as T\n    }\n  }\n\n  /**\n   * Used to check if a `Result` is an `OK`\n   *\n   * @returns `true` if the result is an `OK` variant of Result\n   */\n  isOk(): boolean {\n    return this.state.ok\n  }\n\n  /**\n   * Used to check if a `Result` is an `Err`\n   *\n   * @returns `true` if the result is an `Err` variant of Result\n   */\n  isErr(): boolean {\n    return !this.state.ok\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<U, E>`\n   * by applying a function to a contained `Ok` value, leaving an `Err` value\n   * untouched.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  map<X>(f: (t: T) => X): Result<X, E> {\n    if (this.state.ok) {\n      const value = f(this.value)\n      return ok(value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a\n   * contained `Err` value, leaving an `Ok` value untouched.\n   *\n   * This function can be used to pass through a successful result while\n   * handling an error.\n   *\n   * @param f a function to apply to the error `Err` value\n   */\n  mapErr<X>(fn: (t: E) => X): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value)\n    }\n\n    return err(fn(this.error))\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent computation using the\n   * inner `T` value, but that computation might fail.\n   * Additionally, `andThen` is really useful as a tool to flatten a\n   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).\n   *\n   * @param f The function to apply to the current value\n   */\n  andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error)\n  }\n\n  if(fCondition: (t: T) => boolean) {\n    return {\n      true: <X1, Y1>(fTrue: (t: T) => Result<X1, Y1>) => ({\n        false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>): Result<X1 | X2, Y1 | Y2 | E> => {\n          if (this.state.ok) {\n            const condition = fCondition(this.value)\n            return condition ? fTrue(this.value) : fFalse(this.value)\n          }\n\n          return err(this.error)\n        },\n      }),\n    }\n  }\n\n  /**\n   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.\n   *\n   * This is useful for error recovery.\n   *\n   * @param f  A function to apply to an `Err` value, leaving `Ok` values\n   * untouched.\n   */\n  orElse<R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ): Result<InferOkTypes<R> | T, InferErrTypes<R>>\n  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A> {\n    if (this.state.ok) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return f(this.error)\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent async computation using\n   * the inner `T` value, but that computation might fail. Must return a ResultAsync\n   *\n   * @param f The function that returns a `ResultAsync` to apply to the current\n   * value\n   */\n  asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return errAsync(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `ResultAsync<U, E>`\n   * by applying an async function to a contained `Ok` value, leaving an `Err`\n   * value untouched.\n   *\n   * @param f An async function to apply an `OK` value\n   */\n  asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E> {\n    if (this.state.ok) {\n      return ResultAsync.fromSafePromise(f(this.value))\n    }\n\n    return errAsync(this.error)\n  }\n\n  /**\n   * Unwrap the `Ok` value, or return the default if there is an `Err`\n   *\n   * @param v the default value to return if there is an `Err`\n   */\n  unwrapOr<A>(defaultValue: A): T | A {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    return defaultValue\n  }\n\n  /**\n   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)\n   * execute the function that matches the `Result` variant.\n   *\n   * Match callbacks do not necessitate to return a `Result`, however you can\n   * return a `Result` if you want to.\n   *\n   * `match` is like chaining `map` and `mapErr`, with the distinction that\n   * with `match` both functions must have the same return type.\n   *\n   * @param ok\n   * @param err\n   */\n  match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X {\n    if (this.state.ok) {\n      return fnOk(this.value)\n    }\n\n    return fnErr(this.error)\n  }\n\n  /**\n   * Performs a side effect no matter what the `Result` variant is.\n   *\n   * @param fn The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  log(fn: (t?: T, e?: E) => void): this {\n    try {\n      fn(this.value, this.error)\n    } catch { /* empty */ }\n\n    return this\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `Result`.\n   *\n   * @param fn The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  tap(fn: (t: T) => void): this {\n    if (this.state.ok) {\n      try {\n        fn(this.value)\n      } catch { /* empty */ }\n    }\n\n    return this\n  }\n\n  /**\n   * Performs a side effect for the `Err` variant of `Result`.\n   *\n   * @param fn The function to apply an `Err` value\n   * @returns the result of applying `f` or an `Ok` untouched\n   */\n  tapError(fn: (e: E) => void): this {\n    if (!this.state.ok) {\n      try {\n        fn(this.error)\n      } catch { /* empty */ }\n    }\n\n    return this\n  }\n\n  /**\n   * This method is used to clean up and release any resources that the `Result`\n   * @param f The function that will be called to clean up the resources\n   */\n  finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>\n  finally(f: (value: T, error: E) => void): DisposableResult<T, E> {\n    const resultDisposable = new DisposableResult(this, f)\n    try {\n      return resultDisposable\n    } finally {\n      resultDisposable[Symbol.dispose]()\n    }\n  }\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrap(config?: ErrorConfig): T {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    throw createResultarError('Called `_unsafeUnwrap` on an Err', this, config)\n  }\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,\n   * otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrapErr(config?: ErrorConfig): E {\n    if (this.state.ok) {\n      throw createResultarError('Called `_unsafeUnwrapErr` on an Ok', this, config)\n    }\n\n    return this.error\n  }\n\n  safeUnwrap(): Generator<Result<never, E>, T> {\n    if (this.state.ok) {\n      const { value } = this\n      /* eslint-disable-next-line require-yield */\n      return (function*() {\n        return value\n      })()\n    }\n\n    const { error } = this\n    return (function*() {\n      yield err(error)\n\n      throw new Error('Do not use this generator out of `safeTry`')\n    })()\n  }\n}\n\n/**\n * A `Disposable` is an object that has a `dispose` method that can be used to\n * clean up resources.\n */\nexport class DisposableResult<T, E> implements Resultable<T, E>, Disposable {\n  constructor(readonly result: Resultable<T, E>, private readonly finalizer: (value: T, error: E) => void) {}\n\n  get value(): T {\n    return this.result.value\n  }\n\n  get error(): E {\n    return this.result.error\n  }\n\n  _unsafeUnwrap(config?: ErrorConfig | undefined): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  _unsafeUnwrapErr(config?: ErrorConfig | undefined): E {\n    return this.result._unsafeUnwrapErr(config)\n  }\n\n  isOk(): boolean {\n    return this.result.isOk()\n  }\n\n  isErr(): boolean {\n    return this.result.isErr()\n  }\n\n  unwrapOr<A>(defaultValue: A): T | A {\n    return this.result.unwrapOr(defaultValue)\n  }\n\n  [Symbol.dispose](): void {\n    this.finalizer(this.result.value, this.result.error)\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nexport const { ok, err, fromThrowable } = Result\n\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as\n * Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\nexport function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` and\n * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\n// NOTE:\n// Since body is potentially throwable because `await` can be used in it,\n// Promise<Result<T, E>>, not ResultAsync<T, E>, is used as the return type.\nexport function safeTry<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): Promise<Result<T, E>>\nexport function safeTry<T, E>(\n  body:\n    | (() => Generator<Result<never, E>, Result<T, E>>)\n    | (() => AsyncGenerator<Result<never, E>, Result<T, E>>),\n): Result<T, E> | Promise<Result<T, E>> {\n  const n = body().next()\n  if (n instanceof Promise) {\n    return n.then(r => r.value)\n  }\n\n  return n.value\n}\n","import { Result } from './result.js'\nimport type {\n  Combine,\n  Dedup,\n  EmptyArrayToNever,\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes,\n  InferAsyncOkTypes,\n  InferErrTypes,\n  InferOkTypes,\n  IsLiteralArray,\n  MemberListOf,\n  MembersToUnion,\n} from './utils.js'\nimport { combineResultAsyncList, combineResultAsyncListWithAllErrors } from './utils.js'\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<\n  T extends ReadonlyArray<ResultAsync<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>\n\n// Combines the array of async results into one result with all errors.\nexport type CombineResultsWithAllErrorsArrayAsync<\n  T extends ReadonlyArray<ResultAsync<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>\n\n// Unwraps the inner `Result` from a `ResultAsync` for all elements.\ntype UnwrapAsync<T> = IsLiteralArray<T> extends 1\n  ? Writable<T> extends [infer H, ...infer Rest]\n    ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>]\n      : never\n    : never\n  : []\n  // If we got something too general such as ResultAsync<X, Y>[] then we\n  // simply need to map it to ResultAsync<X[], Y[]>. Yet `ResultAsync`\n  // itself is a union therefore it would be enough to cast it to Ok.\n  : T extends Array<infer A>\n    ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Array<Result<L, R>>\n      : never\n    : never\n  : never\n\n// Traverse through the tuples of the async results and create one\n// `ResultAsync` where the collected tuples are merged.\ntype TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1\n  ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>>\n  : never\n  // The following check is important if we somehow reach to the point of\n  // checking something similar to ResultAsync<X, Y>[]. In this case we don't\n  // know the length of the elements, therefore we need to traverse the X and Y\n  // in a way that the result should contain X[] and Y[].\n  : T extends Array<infer I>\n  // The MemberListOf<I> here is to include all possible types. Therefore\n  // if we face (ResultAsync<X, Y> | ResultAsync<A, B>)[] this type should\n  // handle the case.\n    ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n      // The following `extends unknown[]` checks are just to satisfy the TS.\n      // we already expect them to be an array.\n      ? Oks extends unknown[]\n        ? Errs extends unknown[]\n          ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>>\n        : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs>\n        // The rest of the conditions are to satisfy the TS and support\n        // the edge cases which are not really expected to happen.\n      : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Array<Errs[number]>>>\n      : ResultAsync<Oks, Errs>\n    : never\n  : never\n\n// This type is similar to the `TraverseAsync` while the errors are also\n// collected in order. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1\n  ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n  : never\n  : Writable<T> extends Array<infer I>\n    ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n      ? Oks extends unknown[]\n        ? Errs extends unknown[]\n          ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>>\n        : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs>\n      : Errs extends unknown[] ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>>\n      : ResultAsync<Oks, Errs>\n    : never\n  : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n\nexport class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  private readonly innerPromise: Promise<Result<T, E>>\n\n  constructor(res: Promise<Result<T, E>>) {\n    this.innerPromise = res\n  }\n\n  then<A, B>( // eslint-disable-line unicorn/no-thenable\n    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,\n    failureCallback?: (reason: unknown) => B | PromiseLike<B>,\n  ): PromiseLike<A | B> {\n    return this.innerPromise.then(successCallback, failureCallback)\n  }\n}\n\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  static okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(Result.ok(value)))\n  }\n\n  static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(Result.err(error)))\n  }\n\n  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>\n  static fromSafePromise<T, E = never>(promise: Promise<T>): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>\n  static fromPromise<T, E>(promise: Promise<T>, errorFn: (e: unknown) => E): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n      .catch(error => Result.err(errorFn(error)))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static combine<\n    T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T> {\n    return (combineResultAsyncList(asyncResultList) as unknown) as CombineResultAsyncs<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T> {\n    return combineResultAsyncListWithAllErrors(\n      asyncResultList,\n    ) as CombineResultsWithAllErrorsArrayAsync<T>\n  }\n\n  /**\n   * Wraps a async function with a try catch, creating a new function with the same\n   * arguments but returning `Ok` if successful, `Err` if the function throws\n   *\n   * @param fn function to wrap with ok on success or err on failure\n   * @param errorFn when an error is thrown, this will wrap the error result if provided\n   * @returns a new function that returns a `ResultAsync`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static fromThrowable<A extends readonly any[], T, E>(\n    fn: (...args: A) => Promise<T>,\n    errorFn?: (err: unknown) => E,\n  ): (...args: A) => ResultAsync<T, E> {\n    return (...args) =>\n      new ResultAsync<T, E>(\n        (async () => {\n          try {\n            const v = await fn(...args)\n            return Result.ok(v)\n          } catch (error) {\n            const e = errorFn ? errorFn(error) : error\n            return Result.err(e as E)\n          }\n        })(),\n      )\n  }\n\n  private readonly innerPromise: Promise<Result<T, E>>\n\n  constructor(res: Promise<Result<T, E>>) {\n    this.innerPromise = res\n  }\n\n  then<A, B>( // eslint-disable-line unicorn/no-thenable\n    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,\n    failureCallback?: (reason: unknown) => B | PromiseLike<B>,\n  ): PromiseLike<A | B> {\n    return this.innerPromise.then(successCallback, failureCallback)\n  }\n\n  mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U> {\n    return new ResultAsync<T, U>(this.innerPromise.then(async res => {\n      if (res.isOk()) {\n        return okAsync(res.value)\n      }\n\n      return errAsync(await f(res.error))\n    }))\n  }\n\n  map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E> {\n    const x = new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        return okAsync(await f(res.value))\n      }),\n    )\n\n    return x\n  }\n\n  andThen<R extends Result<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>\n  andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  andThen(f: any): any {\n    return new ResultAsync(\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        const newValue = f(res.value) // eslint-disable-line @typescript-eslint/no-unsafe-assignment\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue // eslint-disable-line @typescript-eslint/no-unsafe-return\n      }),\n    )\n  }\n\n  if(fCondition: (t: T) => boolean) {\n    return {\n      true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => ({\n        false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>): ResultAsync<X1 | X2, Y1 | Y2 | E> =>\n          new ResultAsync(this.innerPromise.then(async res => {\n            if (res.isOk()) {\n              const condition = fCondition(res.value)\n              return condition ? fTrue(res.value) : fFalse(res.value)\n            }\n\n            return errAsync(res.error)\n          })),\n      }),\n    }\n  }\n\n  orElse<R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>\n  orElse<R extends ResultAsync<unknown, unknown>>(\n    f: (e: E) => R,\n  ): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>\n  orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  orElse(f: any): any {\n    return new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => { // eslint-disable-line @typescript-eslint/no-unsafe-argument\n        if (res.isErr()) {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n          return f(res.error) // eslint-disable-line @typescript-eslint/no-unsafe-return\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  async match<X>(ok: (t: T) => X, err: (e: E) => X): Promise<X> {\n    return this.innerPromise.then(res => res.match(ok, err))\n  }\n\n  async unwrapOr<A>(t: A): Promise<T | A> {\n    return this.innerPromise.then(res => res.unwrapOr(t))\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `ResultAsync`.\n   * This function can be used for control flow based on result values.\n   * @param f The function to call if the result is `Ok`\n   * @returns `self` if the result is `Err`, otherwise the result of `f`\n   */\n  log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E> {\n    return new ResultAsync(\n      this.innerPromise.then(async res => {\n        if (res.isOk()) {\n          try {\n            await f(res.value)\n          } catch { /* empty */ }\n\n          return okAsync(res.value)\n        }\n\n        try {\n          await f(undefined, res.error)\n        } catch { /* empty */ }\n\n        return errAsync(res.error)\n      }),\n    )\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `ResultAsync`.\n   * This function can be used for control flow based on result values.\n   * @param f The function to call if the result is `Ok`\n   * @returns `self` if the result is `Err`, otherwise the result of `f`\n   */\n  tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E> {\n    return new ResultAsync(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        try {\n          await f(res.value)\n        } catch { /* empty */ }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  /**\n   * Performs a side effect for the `Err` variant of `ResultAsync`.\n   * This function can be used for control flow based on result values.\n   * @param f The function to call if the result is `Err`\n   * @returns `self` if the result is `Ok`, otherwise the result of `f`\n   * @example\n   */\n  tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E> {\n    return new ResultAsync(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          try {\n            await f(res.error)\n          } catch { /* empty */ }\n\n          return errAsync(res.error)\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E> {\n    return new DisposableResultAsync(\n      // eslint-disable-next-line @typescript-eslint/require-await\n      this.innerPromise.then(async res => {\n        try {\n          res.finally(f)\n        } catch {\n          // Dont do anything. Its just a finally\n        }\n\n        return res\n      }),\n    )\n  }\n\n  /**\n   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n   */\n  async *safeUnwrap(): AsyncGenerator<Result<never, E>, T> {\n    return yield* await this.innerPromise.then(res => res.safeUnwrap())\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nexport const { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync\n// eslint-disable-next-line @typescript-eslint/unbound-method\nexport const fromThrowableAsync = ResultAsync.fromThrowable\n\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as\n * Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned `ResultAsync`.\n */\nexport function safeTryAsync<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(\n    (async () => {\n      const n = await body().next()\n      if (n.value.isOk()) {\n        return okAsync(n.value.value)\n      }\n\n      return errAsync(n.value.error)\n    })(),\n  )\n}\n","import { ResultAsync } from './result-async.js'\nimport type { Result } from './result.js'\nimport { err, ok } from './result.js'\n\n// Deduplicates the result, as the result type is a union of Err and Ok types.\nexport type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR>\n  : T\n\n// Given a union, this gives the array of the union members.\nexport type MemberListOf<T> = (\n  (T extends unknown ? (t: T) => T : never) extends infer U\n    ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V\n    : never\n    : never\n) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W]\n  : []\n\n// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends ReadonlyArray<Result<unknown, unknown>>> = {\n  [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never\n}\n\n// Given a list of ResultAsyncs, this extracts all the different `T` types from that list\nexport type ExtractOkAsyncTypes<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = {\n  [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never\n}\n\n// Given a list of Results, this extracts all the different `E` types from that list\nexport type ExtractErrTypes<T extends ReadonlyArray<Result<unknown, unknown>>> = {\n  [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never\n}\n\n// Given a list of ResultAsyncs, this extracts all the different `E` types from that list\nexport type ExtractErrAsyncTypes<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = {\n  [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never\n}\n\nexport type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never\nexport type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never\n\nexport type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never\nexport type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never\n\n// Checks if the given type is a literal array.\nexport type IsLiteralArray<T> = T extends { length: infer L } ? L extends number ? number extends L ? 0\n    : 1\n  : 0\n  : 0\n\n// Converts an empty array to never.\n//\n// The second type parameter here will affect how to behave to `never[]`s.\n// If a precise type is required, pass `1` here so that it will resolve\n// a literal array such as `[ never, never ]`. Otherwise, set `0` or the default\n// type value will cause this to resolve the arrays containing only `never`\n// items as `never` only.\nexport type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never\n  : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never\n      : T\n    : T\n  : T\n\n// #region Combine - Types\n\n// This is a helper type to prevent infinite recursion in typing rules.\n//\n// Use this with your `depth` variable in your types.\ntype Prev = [\n  never,\n  0,\n  1,\n  2,\n  3,\n  4,\n  5,\n  6,\n  7,\n  8,\n  9,\n  10,\n  11,\n  12,\n  13,\n  14,\n  15,\n  16,\n  17,\n  18,\n  19,\n  20,\n  21,\n  22,\n  23,\n  24,\n  25,\n  26,\n  27,\n  28,\n  29,\n  30,\n  31,\n  32,\n  33,\n  34,\n  35,\n  36,\n  37,\n  38,\n  39,\n  40,\n  41,\n  42,\n  43,\n  44,\n  45,\n  46,\n  47,\n  48,\n  49,\n  ...Array<0>,\n]\n\n// Transposes an array\n//\n// A          - The array source\n// Transposed - The collected transposed array\n// Depth      - The maximum depth.\nexport type Transpose<\n  A,\n  Transposed extends unknown[][] = [],\n  Depth extends number = 10,\n> = A extends [infer T, ...infer Rest]\n  ? T extends [infer L, infer R]\n    ? Transposed extends [infer PL, infer PR]\n      ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]>\n        : never\n      : never\n    : Transpose<Rest, [[L], [R]], Prev[Depth]>\n  : Transposed\n  : Transposed\n\n// Collects the results array into separate tuple array.\n//\n// T         - The array of the results\n// Collected - The collected tuples.\n// Depth     - The maximum depth.\ntype CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [\n  Depth,\n] extends [never] ? []\n  : T extends [infer H, ...infer Rest]\n  // And test whether the head of the list is a result\n    ? H extends Result<infer L, infer R>\n      // Continue collecting...\n      ? CollectResults<\n        // the rest of the elements\n        Rest,\n        // The collected\n        [...Collected, [L, R]],\n        // and one less of the current depth\n        Prev[Depth]\n      >\n    : never // Impossible\n  : Collected\n\n// Converts the `unknown` items of an array to `never`s.\ntype UnknownMembersToNever<T> = T extends [infer H, ...infer R]\n  ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>]\n  : T\n\n// Gets the member type of the array or never.\nexport type MembersToUnion<T> = T extends unknown[] ? T[number] : never\n\n// Combines the both sides of the array of the results into a tuple of the\n// union of the ok types and the union of the err types.\n//\n// T     - The array of the results\n// Depth - The maximum depth.\nexport type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [\n  infer L,\n  infer R,\n] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n  : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []]\n  : never\n\n// Traverses an array of results and returns a single result containing\n// the oks and errs union-ed/combined.\ntype Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs]\n  ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>>\n  : never\n\n// Traverses an array of results and returns a single result containing\n// the oks combined and the array of errors combined.\ntype TraverseWithAllErrors<T, Depth extends number = 5> = Combine<T, Depth> extends [\n  infer Oks,\n  infer Errs,\n] ? Result<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n  : never\n\nexport type CombineResults<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1 ? Traverse<T>\n  : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>\n\n// Combines the array of results into one result with all errors.\nexport type CombineResultsWithAllErrorsArray<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T>\n  : Result<ExtractOkTypes<T>, Array<ExtractErrTypes<T>[number]>>\n\n/* This is the typesafe version of Promise.all\n *\n * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values\n * or fails if one (or more) of the inner results are Err values\n */\nexport const combineResultAsyncList = <T, E>(\n  asyncResultList: ReadonlyArray<ResultAsync<T, E>>,\n): ResultAsync<readonly T[], E> =>\n  ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultList,\n  ) as ResultAsync<T[], E>\n\n/**\n * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E> => {\n  let acc = ok([]) as Result<T[], E>\n\n  for (const result of resultList) {\n    if (result.isErr()) {\n      acc = err(result.error)\n      break\n    } else {\n      acc.map((list) => list.push(result.value))\n    }\n  }\n  return acc\n}\n/* This is the typesafe version of Promise.all\n *\n * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values\n * or fails if one (or more) of the inner results are Err values\n */\nexport const combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: ReadonlyArray<ResultAsync<T, E>>,\n): ResultAsync<readonly T[], E[]> => {\n  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultListWithAllErrors,\n  )\n  return x as ResultAsync<T[], E[]>\n}\n\n/**\n * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E[]> => {\n  let acc = ok([]) as Result<T[], E[]>\n\n  for (const result of resultList) {\n    if (result.isErr() && acc.isErr()) {\n      acc.error.push(result.error)\n    } else if (result.isErr() && acc.isOk()) {\n      acc = err([result.error])\n    } else if (result.isOk() && acc.isOk()) {\n      acc.value.push(result.value)\n    }\n    // do nothing when result.isOk() && acc.isErr()\n  }\n  return acc\n}\n"],"mappings":"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","names":["ok","err"]}

package/dist/error.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/error.ts"],"sourcesContent":["import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,IAAM,qBAAkC;AAAA,EACtC,gBAAgB;AAClB;AAgBO,IAAM,sBAAsB,CACjC,SACA,QACA,SAAsB,uBACE;AACxB,QAAM,OAAO,OAAO,KAAK,IACrB,EAAE,MAAM,MAAM,OAAO,OAAO,MAAM,IAClC,EAAE,MAAM,OAAO,OAAO,OAAO,MAAM;AAEvC,QAAM,aAAa,OAAO,iBAAiB,IAAI,MAAM,EAAE,QAAQ;AAE/D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO;AAAA,EACT;AACF;","names":[]}
+{"version":3,"sources":["../src/error.ts"],"sourcesContent":["import type { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n    | {\n      type: string\n      value: T | undefined\n    }\n    | {\n      type: string\n      value: E | undefined\n    }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,IAAM,qBAAkC;AAAA,EACtC,gBAAgB;AAClB;AAgBO,IAAM,sBAAsB,CACjC,SACA,QACA,SAAsB,uBACE;AACxB,QAAM,OAAO,OAAO,KAAK,IACrB,EAAE,MAAM,MAAM,OAAO,OAAO,MAAM,IAClC,EAAE,MAAM,OAAO,OAAO,OAAO,MAAM;AAEvC,QAAM,aAAa,OAAO,iBAAiB,IAAI,MAAM,EAAE,QAAQ;AAE/D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO;AAAA,EACT;AACF;","names":[]}

package/dist/error.d.cts

@@ -1 +1 @@
-export { H as ErrorConfig, J as createResultarError } from './index-BH-Kjtur.cjs';
+export { H as ErrorConfig, J as createResultarError } from './index-CKLj0kyj.cjs';

package/dist/error.d.ts

@@ -1 +1 @@
-export { H as ErrorConfig, J as createResultarError } from './index-BH-Kjtur.js';
+export { H as ErrorConfig, J as createResultarError } from './index-CKLj0kyj.js';

package/dist/error.js

@@ -1,6 +1,6 @@
 import {
   createResultarError
-} from "./chunk-FBVQYZXO.js";
+} from "./chunk-3NDPPYVV.js";
 export {
   createResultarError
 };