resultar 1.3.1 → 1.4.1

package/README.md

@@ -665,8 +665,6 @@ const result = Result.combineWithAllErrors(resultList)
 
 #### `Result.safeUnwrap()`
 
-**⚠️ You must use `.safeUnwrap` in a generator context with `safeTry`**. Please see [safeTry](#safeTry).
-
 Allows for unwrapping a `Result` or returning an `Err` implicitly, thereby reducing boilerplate.
 
 
@@ -1392,8 +1390,6 @@ const result = ResultAsync.combineWithAllErrors(resultList)
 
 #### `ResultAsync.safeUnwrap()`
 
-**⚠️ You must use `.safeUnwrap` in a generator context with `safeTry`**. Please see [safeTry](#safeTry).
-
 Allows for unwrapping a `Result` or returning an `Err` implicitly, thereby reducing boilerplate.
 
 [⬆️  Back to top](#toc)

package/dist/{chunk-RYUAKJBO.js → chunk-TU4HOJKA.js}

@@ -256,6 +256,12 @@ var Result = class _Result {
       resultDisposable[Symbol.dispose]();
     }
   }
+  unwrapOrThrow() {
+    if (this.state.ok) {
+      return this.value;
+    }
+    throw this.error;
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -283,6 +289,14 @@ var Result = class _Result {
     }
     return this.error;
   }
+  *[Symbol.iterator]() {
+    if (this.state.ok) {
+      return this.value;
+    }
+    const self = this;
+    yield self;
+    return self;
+  }
   safeUnwrap() {
     if (this.state.ok) {
       const { value } = this;
@@ -483,6 +497,9 @@ var ResultAsync = class _ResultAsync {
   async unwrapOr(t) {
     return this.innerPromise.then((res) => res.unwrapOr(t));
   }
+  async unwrapOrThrow() {
+    return this.innerPromise.then((res) => res.unwrapOrThrow());
+  }
   /**
    * Performs a side effect for the `Ok` variant of `ResultAsync`.
    * This function can be used for control flow based on result values.
@@ -560,7 +577,23 @@ var ResultAsync = class _ResultAsync {
       })
     );
   }
+  async *[Symbol.asyncIterator]() {
+    const result = await this.innerPromise;
+    if (result.isErr()) {
+      yield errAsync(result.error);
+    }
+    return result.value;
+  }
   /**
+   * @deprecated will be removed in 2.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
   async *safeUnwrap() {
@@ -640,4 +673,4 @@ export {
   unitAsync,
   fromThrowableAsync
 };
-//# sourceMappingURL=chunk-RYUAKJBO.js.map
+//# sourceMappingURL=chunk-TU4HOJKA.js.map

package/dist/chunk-TU4HOJKA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/result.ts","../src/result-async.ts","../src/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/unbound-method */\nimport type { ErrorConfig } from './error.js'\nimport { createResultarError } from './error.js'\nimport { errAsync, ResultAsync } from './result-async.js'\nimport type { ExtractErrTypes, ExtractOkTypes, InferErrTypes, InferOkTypes } from './utils.js'\nimport { combineResultList, combineResultListWithAllErrors } from './utils.js'\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  /**\n   * Creates a new `Result` instance representing a successful operation.\n   *\n   * @param {T} value - The value to be wrapped in the `Result` instance.\n   * @return {Result<T, E>} A new `Result` instance with the provided value.\n   */\n  static ok<T, E = never>(value: T): Result<T, E> {\n    return new Result<T, E>(new Ok(value))\n  }\n\n  /**\n   * Creates a new `Result` instance representing a successful operation with an undefined value.\n   *\n   * @return {Result<undefined, E>} A new `Result` instance with an undefined value.\n   */\n  static unit<E = never>(): Result<undefined, E> {\n    return new Result<undefined, E>(new Ok(undefined))\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>, ...Result<unknown, unknown>[]],\n  >(resultList: T): CombineResults<T>\n  static combine<T extends readonly Result<unknown, unknown>[]>(\n    resultList: T,\n  ): CombineResults<T>\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...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>, ...Result<unknown, unknown>[]],\n  >(resultList: T): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends readonly 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    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    }\n  } {\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<A, B = A>(fnOk: (t: T) => A, fnErr: (e: E) => B): A | B {\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 for the `Ok` or `Err` 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  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  unwrapOrThrow(): T | E {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    // eslint-disable-next-line @typescript-eslint/only-throw-error\n    throw this.error\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  *[Symbol.iterator](): Generator<Result<never, E>, T> {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias\n    const self: Result<T, E> = this\n    yield self as Result<never, E>\n    return self as T\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): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  _unsafeUnwrapErr(config?: ErrorConfig): 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/**\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>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n  body: () => Generator<YieldErr, GeneratorReturnResult>,\n): Result<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\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()` 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 */\nexport function safeTry<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n  body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>,\n): ResultAsync<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\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> | ResultAsync<T, E> {\n  const n = body().next()\n  if (n instanceof Promise) {\n    return new ResultAsync(n.then((r) => r.value))\n  }\n\n  return n.value\n}\n\nexport const ok = Result.ok\nexport const err = Result.err\nexport const fromThrowable = Result.fromThrowable\nexport const unit = Result.unit\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  ...0[],\n]\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// 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// 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// 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// 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// 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// 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// 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> = Traverse<T, Depth> extends Result<\n  infer Oks,\n  infer Errs\n> ? Result<Oks, Errs[]>\n  : never\n\n// Combines the array of results into one result.\nexport type CombineResults<\n  T extends readonly 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 readonly Result<unknown, unknown>[],\n> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T>\n  : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>\n\n// #endregion\n","/* eslint-disable @typescript-eslint/unbound-method */\nimport type { Combine, Dedup, EmptyArrayToNever, IsLiteralArray, MemberListOf, MembersToUnion } from './result.js'\nimport { Result } from './result.js'\nimport type {\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes,\n  InferAsyncOkTypes,\n  InferErrTypes,\n  InferOkTypes,\n} from './utils.js'\nimport { combineResultAsyncList, combineResultAsyncListWithAllErrors } from './utils.js'\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\n/**\n * The ResultAsync type.\n * This is a union of `Result` and `PromiseLike<Result>`\n */\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  /**\n   * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).\n   *\n   * @param {T} value - The value to be wrapped in a Result.ok.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.\n   */\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  /**\n   * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.\n   *\n   * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.\n   */\n  static unitAsync<E = never>(): ResultAsync<undefined, E> {\n    return new ResultAsync<undefined, E>(Promise.resolve(Result.unit()))\n  }\n\n  /**\n   * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).\n   *\n   * @param {E} error - The error to be wrapped in a Result.err.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.\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  /**\n   * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)\n   * based on the provided promise.\n   *\n   * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\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  /**\n   * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)\n   * based on the provided promise.\n   *\n   * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.\n   * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type E.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\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>, ...ResultAsync<unknown, unknown>[]],\n  >(asyncResultList: T): CombineResultAsyncs<T>\n  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  static combine<T extends readonly 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>, ...ResultAsync<unknown, unknown>[]],\n  >(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends readonly 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    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    }\n  } {\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<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B> {\n    return this.innerPromise.then(res => res.match(ok, fnErr))\n  }\n\n  async unwrapOr<A>(t: A): Promise<T | A> {\n    return this.innerPromise.then(res => res.unwrapOr(t))\n  }\n\n  async unwrapOrThrow(): Promise<T | E> {\n    return this.innerPromise.then(res => res.unwrapOrThrow())\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  async *[Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T> {\n    const result = await this.innerPromise\n\n    if (result.isErr()) {\n      yield errAsync(result.error)\n    }\n\n    return result.value\n  }\n\n  /**\n   * @deprecated will be removed in 2.0.0.\n   *\n   * You can use `safeTry` without this method.\n   * @example\n   * ```typescript\n   * safeTry(async function* () {\n   *   const okValue = yield* yourResult\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/**\n * @deprecated Use `safeTry` instead.\n * @see `safeTry`\n *\n * This will be removed in the next major version.\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\nexport const okAsync = ResultAsync.okAsync\nexport const errAsync = ResultAsync.errAsync\nexport const fromPromise = ResultAsync.fromPromise\nexport const fromSafePromise = ResultAsync.fromSafePromise\nexport const unitAsync = ResultAsync.unitAsync\nexport const fromThrowableAsync = ResultAsync.fromThrowable\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<\n  T extends readonly 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 readonly ResultAsync<unknown, unknown>[],\n> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, 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 (infer A)[] ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? 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 (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[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>>\n        : ResultAsync<EmptyArrayToNever<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<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 a list. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<\n  T,\n  Depth\n> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]>\n  : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n","import { ResultAsync } from './result-async.js'\nimport type { Result } from './result.js'\nimport { err, ok } from './result.js'\n\n// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends readonly 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 readonly 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 readonly 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 readonly 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/**\n * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n  resultList: readonly 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\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: readonly 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 * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n  resultList: readonly 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\nexport const combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E[]> =>\n  ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultListWithAllErrors,\n  ) as ResultAsync<T[], E[]>\n"],"mappings":"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","names":["ok"]}

package/dist/error.d.cts

@@ -1 +1 @@
-export { K as ErrorConfig, L as createResultarError } from './index-DUO8gZOZ.cjs';
+export { K as ErrorConfig, L as createResultarError } from './index-Ct3o3to5.cjs';

package/dist/error.d.ts

@@ -1 +1 @@
-export { K as ErrorConfig, L as createResultarError } from './index-DUO8gZOZ.js';
+export { K as ErrorConfig, L as createResultarError } from './index-Ct3o3to5.js';

package/dist/{index-DUO8gZOZ.d.cts → index-Ct3o3to5.d.cts}

@@ -105,6 +105,7 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
     match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
     unwrapOr<A>(t: A): Promise<T | A>;
+    unwrapOrThrow(): Promise<T | E>;
     /**
      * Performs a side effect for the `Ok` variant of `ResultAsync`.
      * This function can be used for control flow based on result values.
@@ -128,7 +129,17 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
      */
     tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
     finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
+    [Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T>;
     /**
+     * @deprecated will be removed in 2.0.0.
+     *
+     * You can use `safeTry` without this method.
+     * @example
+     * ```typescript
+     * safeTry(async function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * ```
      * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
      */
     safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
@@ -355,6 +366,7 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param f The function that will be called to clean up the resources
      */
     finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>;
+    unwrapOrThrow(): T | E;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -372,6 +384,7 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param config
      */
     _unsafeUnwrapErr(config?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Result<never, E>, T>;
     safeUnwrap(): Generator<Result<never, E>, T>;
 }
 /**

package/dist/{index-DUO8gZOZ.d.ts → index-Ct3o3to5.d.ts}

@@ -105,6 +105,7 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
     match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
     unwrapOr<A>(t: A): Promise<T | A>;
+    unwrapOrThrow(): Promise<T | E>;
     /**
      * Performs a side effect for the `Ok` variant of `ResultAsync`.
      * This function can be used for control flow based on result values.
@@ -128,7 +129,17 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
      */
     tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
     finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
+    [Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T>;
     /**
+     * @deprecated will be removed in 2.0.0.
+     *
+     * You can use `safeTry` without this method.
+     * @example
+     * ```typescript
+     * safeTry(async function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * ```
      * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
      */
     safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
@@ -355,6 +366,7 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param f The function that will be called to clean up the resources
      */
     finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>;
+    unwrapOrThrow(): T | E;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -372,6 +384,7 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param config
      */
     _unsafeUnwrapErr(config?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Result<never, E>, T>;
     safeUnwrap(): Generator<Result<never, E>, T>;
 }
 /**

package/dist/index.cjs

@@ -339,6 +339,12 @@ var Result = class _Result {
       resultDisposable[Symbol.dispose]();
     }
   }
+  unwrapOrThrow() {
+    if (this.state.ok) {
+      return this.value;
+    }
+    throw this.error;
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -366,6 +372,14 @@ var Result = class _Result {
     }
     return this.error;
   }
+  *[Symbol.iterator]() {
+    if (this.state.ok) {
+      return this.value;
+    }
+    const self = this;
+    yield self;
+    return self;
+  }
   safeUnwrap() {
     if (this.state.ok) {
       const { value } = this;
@@ -566,6 +580,9 @@ var ResultAsync = class _ResultAsync {
   async unwrapOr(t) {
     return this.innerPromise.then((res) => res.unwrapOr(t));
   }
+  async unwrapOrThrow() {
+    return this.innerPromise.then((res) => res.unwrapOrThrow());
+  }
   /**
    * Performs a side effect for the `Ok` variant of `ResultAsync`.
    * This function can be used for control flow based on result values.
@@ -643,7 +660,23 @@ var ResultAsync = class _ResultAsync {
       })
     );
   }
+  async *[Symbol.asyncIterator]() {
+    const result = await this.innerPromise;
+    if (result.isErr()) {
+      yield errAsync(result.error);
+    }
+    return result.value;
+  }
   /**
+   * @deprecated will be removed in 2.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
   async *safeUnwrap() {