resultar 3.4.0 → 3.5.0

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["isIterable","getReason","resultOk","resultErr"],"sources":["../src/abort-error.ts","../src/pipe.ts","../src/result-async-adapter.ts","../src/error.ts","../src/tagged-match.ts","../src/result.ts","../src/result-async.ts","../src/redacted.ts","../src/tagged-error.ts"],"sourcesContent":["/**\n * Standard cancellation error used by ResultAsync retry, race, timeout, and resource helpers.\n */\nexport class AbortError extends Error {\n  /**\n   * Creates an AbortError.\n   */\n  public constructor(message = 'Operation aborted', options?: ErrorOptions) {\n    super(message, options)\n    this.name = 'AbortError'\n  }\n}\n\nconst hasAbortName = (value: unknown): value is { readonly name: 'AbortError' } =>\n  typeof value === 'object' &&\n  value !== null &&\n  'name' in value &&\n  (value as { readonly name?: unknown }).name === 'AbortError'\n\nconst hasAbortCode = (value: unknown): value is { readonly code: 'ABORT_ERR' } =>\n  typeof value === 'object' &&\n  value !== null &&\n  'code' in value &&\n  (value as { readonly code?: unknown }).code === 'ABORT_ERR'\n\n/**\n * Checks whether a value is an AbortError or abort-shaped platform error.\n */\nexport const isAbortError = (value: unknown): value is AbortError =>\n  value instanceof AbortError || hasAbortName(value) || hasAbortCode(value)\n","export type PipeFn<Input, Output> = (input: Input) => Output\n\nconst runPipe = <Self>(self: Self, fns: readonly PipeFn<never, unknown>[]): unknown => {\n  const first = fns[0]\n\n  if (!first) {\n    return self\n  }\n\n  let input = first(self as never)\n\n  for (const fn of fns.slice(1)) {\n    input = (fn as PipeFn<unknown, unknown>)(input)\n  }\n\n  return input\n}\n\nexport abstract class Pipeable {\n  /**\n   * Passes this value through one or more transformation functions.\n   *\n   * Use `pipe` to package reusable Result or ResultAsync combinators without hiding the underlying\n   * type.\n   */\n  public pipe<A>(ab: PipeFn<this, A>): A\n  public pipe<A, B>(ab: PipeFn<this, A>, bc: PipeFn<A, B>): B\n  public pipe<A, B, C>(ab: PipeFn<this, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C\n  public pipe(...fns: readonly PipeFn<never, unknown>[]): unknown {\n    return runPipe(this, fns)\n  }\n}\n","type ResultAsyncFactory = (promise: Promise<unknown>) => unknown\n\nlet resultAsyncFactory: ResultAsyncFactory | undefined = undefined\n\nexport const registerResultAsyncFactory = (factory: ResultAsyncFactory): void => {\n  resultAsyncFactory = factory\n}\n\nexport const createResultAsync = <T>(promise: Promise<unknown>): T => {\n  if (resultAsyncFactory === undefined) {\n    throw new Error('ResultAsync is not registered')\n  }\n\n  return resultAsyncFactory(promise) as T\n}\n","import type { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = { withStackTrace: false }\n\ninterface ResultarError<T, E> extends Error {\n  data: { type: string; value: T | undefined } | { type: string; value: E | 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  const error = { name: 'ResultarError', data, message }\n\n  return maybeStack === undefined ? error : Object.assign(error, { stack: maybeStack })\n}\n","type TaggedValue = { readonly _tag: string }\n\nconst noTaggedHandlerMatch = Symbol('noTaggedHandlerMatch')\n\nexport type TaggedHandlerCall<R> = typeof noTaggedHandlerMatch | { readonly value: R }\n\nexport const isTaggedHandlerMatch = <R>(\n  call: TaggedHandlerCall<R>,\n): call is { readonly value: R } => call !== noTaggedHandlerMatch\n\nconst isTaggedValue = (value: unknown): value is TaggedValue =>\n  typeof value === 'object' && value !== null && '_tag' in value\n\nexport const hasTag = <Tag extends string>(\n  value: unknown,\n  tag: Tag,\n): value is { readonly _tag: Tag } => isTaggedValue(value) && value._tag === tag\n\nexport const callTaggedHandler = <R>(value: unknown, handlers: object): TaggedHandlerCall<R> => {\n  if (!isTaggedValue(value)) {\n    return noTaggedHandlerMatch\n  }\n\n  const handler = (handlers as Record<string, unknown>)[value._tag]\n\n  if (handler === undefined) {\n    return noTaggedHandlerMatch\n  }\n\n  return { value: (handler as (error: unknown) => R)(value) }\n}\n\nconst callErrorHandler = <E, R>(\n  error: E,\n  handlers: { readonly Error?: (error: E) => R },\n): TaggedHandlerCall<R> => {\n  const handler = handlers.Error\n\n  if (handler === undefined) {\n    return noTaggedHandlerMatch\n  }\n\n  return { value: handler(error) }\n}\n\nconst callTaggedOrErrorHandler = <E, R>(error: E, handlers: object): TaggedHandlerCall<R> => {\n  const tagged = callTaggedHandler<R>(error, handlers)\n\n  if (isTaggedHandlerMatch(tagged)) {\n    return tagged\n  }\n\n  return callErrorHandler(error, handlers as { readonly Error?: (error: E) => R })\n}\n\nexport const matchTaggedOr = <E, R, F>(\n  error: E,\n  handlers: object,\n  fallback: (error: E) => F,\n): R | F => {\n  const handled = callTaggedOrErrorHandler<E, R>(error, handlers)\n\n  return isTaggedHandlerMatch(handled) ? handled.value : fallback(error)\n}\n","import { type ErrorConfig, createResultarError } from './error.js'\nimport { Pipeable, type PipeFn } from './pipe.js'\nimport { createResultAsync } from './result-async-adapter.js'\nimport type { ResultAsync } from './result-async.js'\nimport type { ExtractErrTypes, ExtractOkTypes, InferErrTypes, InferOkTypes } from './utils.js'\nimport { callTaggedHandler, hasTag, isTaggedHandlerMatch, matchTaggedOr } from './tagged-match.js'\nimport type {\n  CatchTagHandlerResult,\n  CatchReasonHandlerResult,\n  ErrorForTag,\n  ExcludeReasonTag,\n  ExcludeTag,\n  MatchTagHandlerResult,\n  MatchTagHandlers,\n  PartialMatchTagHandlers,\n  ReasonForTag,\n  ReasonTagsOf,\n  ReasonsOf,\n  ResultCatchReasonHandlers as CatchReasonHandlers,\n  ResultCatchTagHandlers as CatchTagHandlers,\n  TagsOf,\n  TagsWithReasonOf,\n} from './tagged-types.js'\n\ntype ResultFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void\ntype MatchOkHandler<T, A> = (value: T) => A\ntype MatchErrorHandler<E, B> = (error: E) => B\ntype ResultCandidate = () => Result<unknown, unknown>\ntype ResultRecord = Readonly<Record<string, Result<unknown, unknown>>>\ntype CombineResultsRecord<T extends ResultRecord> = Result<\n  { readonly [Key in keyof T]: InferOkTypes<T[Key]> },\n  InferErrTypes<T[keyof T]>\n>\ntype CombineResultsRecordWithAllErrors<T extends ResultRecord> = Result<\n  { readonly [Key in keyof T]: InferOkTypes<T[Key]> },\n  InferErrTypes<T[keyof T]>[]\n>\ntype CombineResultsIterable<R extends Result<unknown, unknown>> = Result<\n  readonly InferOkTypes<R>[],\n  InferErrTypes<R>\n>\ntype CombineResultsIterableWithAllErrors<R extends Result<unknown, unknown>> = Result<\n  readonly InferOkTypes<R>[],\n  InferErrTypes<R>[]\n>\ntype ResultLoopCollected<R extends Result<unknown, unknown>> = Result<\n  readonly InferOkTypes<R>[],\n  InferErrTypes<R>\n>\ntype ResultLoopDiscarded<R extends Result<unknown, unknown>> = Result<void, InferErrTypes<R>>\ntype ResultIterated<State, R extends Result<State, unknown>> = Result<State, InferErrTypes<R>>\ntype ResultForEachCollected<R extends Result<unknown, unknown>> = Result<\n  readonly InferOkTypes<R>[],\n  InferErrTypes<R>\n>\ntype ResultForEachDiscarded<R extends Result<unknown, unknown>> = Result<void, InferErrTypes<R>>\ntype ResultValidatedAll<R extends Result<unknown, unknown>> = Result<\n  readonly InferOkTypes<R>[],\n  InferErrTypes<R>[]\n>\ntype ResultZipped<\n  Left extends Result<unknown, unknown>,\n  Right extends Result<unknown, unknown>,\n> = Result<[InferOkTypes<Left>, InferOkTypes<Right>], InferErrTypes<Left> | InferErrTypes<Right>>\ntype ResultBooleanCondition = boolean | (() => boolean)\ntype ResultIf<\n  ConditionErr,\n  OnTrue extends Result<unknown, unknown>,\n  OnFalse extends Result<unknown, unknown>,\n> = Result<\n  InferOkTypes<OnTrue> | InferOkTypes<OnFalse>,\n  ConditionErr | InferErrTypes<OnTrue> | InferErrTypes<OnFalse>\n>\ntype ResultWhen<R extends Result<unknown, unknown>> = Result<\n  InferOkTypes<R> | undefined,\n  InferErrTypes<R>\n>\ntype ResultWhenWithCondition<\n  Condition extends Result<boolean, unknown>,\n  R extends Result<unknown, unknown>,\n> = Result<InferOkTypes<R> | undefined, InferErrTypes<Condition> | InferErrTypes<R>>\ntype WidenLiteral<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T\n\nexport interface MatchHandlers<T, E, A, B = A> {\n  readonly error: MatchErrorHandler<E, B>\n  readonly ok: MatchOkHandler<T, A>\n}\n\ntype FirstSuccessOf<Candidates extends Iterable<ResultCandidate>> = Result<\n  InferOkTypes<ReturnType<IterableElement<Candidates>>>,\n  InferErrTypes<ReturnType<IterableElement<Candidates>>>\n>\n\ntype IterableElement<T> = T extends Iterable<infer Element> ? Element : never\n\ninterface ResultLoopOptions<State, BodyState extends State, R extends Result<unknown, unknown>> {\n  readonly body: (state: BodyState) => R\n  readonly discard?: false\n  readonly step: (state: BodyState) => State\n  readonly while: (state: State) => state is BodyState\n}\n\ninterface ResultLoopBooleanOptions<State, R extends Result<unknown, unknown>> {\n  readonly body: (state: State) => R\n  readonly discard?: false\n  readonly step: (state: State) => State\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultLoopDiscardOptions<\n  State,\n  BodyState extends State,\n  R extends Result<unknown, unknown>,\n> {\n  readonly body: (state: BodyState) => R\n  readonly discard: true\n  readonly step: (state: BodyState) => State\n  readonly while: (state: State) => state is BodyState\n}\n\ninterface ResultLoopBooleanDiscardOptions<State, R extends Result<unknown, unknown>> {\n  readonly body: (state: State) => R\n  readonly discard: true\n  readonly step: (state: State) => State\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultLoopRuntimeOptions<State, R extends Result<unknown, unknown>> {\n  readonly body: (state: State) => R\n  readonly discard?: boolean\n  readonly step: (state: State) => State\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultIterateOptions<State, BodyState extends State, R extends Result<State, unknown>> {\n  readonly body: (state: BodyState) => R\n  readonly while: (state: State) => state is BodyState\n}\n\ninterface ResultIterateBooleanOptions<State, R extends Result<State, unknown>> {\n  readonly body: (state: State) => R\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultIterateRuntimeOptions<State, R extends Result<State, unknown>> {\n  readonly body: (state: State) => R\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultForEachOptions {\n  readonly discard?: false\n}\n\ninterface ResultForEachDiscardOptions {\n  readonly discard: true\n}\n\ninterface ResultForEachRuntimeOptions {\n  readonly discard?: boolean\n}\n\ninterface ResultIfOptions<\n  OnTrue extends Result<unknown, unknown>,\n  OnFalse extends Result<unknown, unknown>,\n> {\n  readonly onFalse: () => OnFalse\n  readonly onTrue: () => OnTrue\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\nexport interface ResultOperations<T, E> {\n  /**\n   * Narrows this result to the Ok variant.\n   */\n  isOk: () => this is OkResult<T, E>\n  /**\n   * Narrows this result to the Err variant.\n   */\n  isErr: () => this is ErrResult<T, E>\n  /**\n   * Returns the Ok value, or `defaultValue` when this result is Err.\n   */\n  unwrapOr: <A>(defaultValue: A) => T | A\n  /**\n   * Returns the Ok value or throws a Resultar diagnostic error when this result is Err.\n   *\n   * Prefer `match`, `unwrapOr`, or explicit error handling in application code. This helper is\n   * intended for tests and trusted final boundaries.\n   */\n  _unsafeUnwrap: (config?: ErrorConfig) => T\n  /**\n   * Returns the Err value or throws a Resultar diagnostic error when this result is Ok.\n   *\n   * Prefer `match`, `isErr`, or explicit error handling in application code. This helper is intended\n   * for tests.\n   */\n  _unsafeUnwrapErr: (config?: ErrorConfig) => E\n  /**\n   * Maps the Ok value while preserving the error channel.\n   */\n  map: <X>(f: (t: T) => X) => Result<X, E>\n  /**\n   * Replaces the Ok value with a constant while preserving the error channel.\n   */\n  as: <X>(value: X) => Result<X, E>\n  /**\n   * Keeps the Ok value only when the predicate passes; otherwise returns an Err from `onFalse`.\n   */\n  filterOrElse: {\n    <U extends T, F>(\n      predicate: (value: T) => value is U,\n      onFalse: (value: T) => F,\n    ): Result<U, E | F>\n    <F>(predicate: (value: T) => boolean, onFalse: (value: T) => F): Result<T, E | F>\n  }\n  /**\n   * Maps the Err value while preserving the Ok value.\n   */\n  mapErr: <X>(fn: (t: E) => X) => Result<T, X>\n  /**\n   * Chains another fallible operation from the Ok value.\n   *\n   * Use this instead of `map` when the callback returns another `Result`.\n   */\n  andThen: <X, Y>(f: (t: T) => Result<X, Y>) => Result<X, E | Y>\n  /**\n   * Branches from the Ok value into one of two fallible Result branches.\n   */\n  if: (fCondition: (t: T) => boolean) => {\n    true: <X1, Y1>(\n      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   * Recovers from Err with another Result.\n   */\n  orElse: <R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ) => Result<InferOkTypes<R> | T, InferErrTypes<R>>\n  /**\n   * Recovers from a specific tagged error by `_tag`.\n   */\n  catchTag: <const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n    tag: Tag,\n    f: (error: ErrorForTag<E, Tag>) => R,\n  ) => Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>\n  /**\n   * Recovers from multiple tagged errors by `_tag`.\n   */\n  catchTags: <const Handlers extends object>(\n    handlers: Handlers & CatchTagHandlers<E, Handlers>,\n  ) => Result<\n    T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n    ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n  >\n  /**\n   * Recovers from a nested tagged `reason` on a specific tagged error.\n   */\n  catchReason: <\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n    R extends Result<unknown, unknown>,\n  >(\n    errorTag: ErrorTag,\n    reasonTag: ReasonTag,\n    f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag<E, ErrorTag>) => R,\n  ) => Result<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>>\n  /**\n   * Recovers from multiple nested tagged `reason` variants on a specific tagged error.\n   */\n  catchReasons: <const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(\n    errorTag: ErrorTag,\n    handlers: Handlers & CatchReasonHandlers<E, ErrorTag, Handlers>,\n  ) => Result<\n    T | InferOkTypes<CatchReasonHandlerResult<Handlers>>,\n    | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n    | InferErrTypes<CatchReasonHandlerResult<Handlers>>\n  >\n  /**\n   * Moves the nested `reason` of a tagged error into the Result error channel.\n   */\n  unwrapReason: <const ErrorTag extends TagsWithReasonOf<E>>(\n    errorTag: ErrorTag,\n  ) => Result<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>>\n  /**\n   * Chains an async fallible operation from the Ok value.\n   */\n  asyncAndThen: <X, Y>(f: (t: T) => ResultAsync<X, Y>) => ResultAsync<X, E | Y>\n  /**\n   * Maps the Ok value with an async function and returns a `ResultAsync`.\n   */\n  asyncMap: <X>(f: (t: T) => Promise<X>) => ResultAsync<X, E>\n  /**\n   * Converts this Result into a plain value by handling both Ok and Err.\n   */\n  match: {\n    <A, B = A>(handlers: MatchHandlers<T, E, A, B>): A | B\n    <A, B = A>(fnOk: MatchOkHandler<T, A>, fnErr: MatchErrorHandler<E, B>): A | B\n  }\n  /**\n   * Converts this Result into a plain value with exhaustive tagged-error handlers.\n   */\n  matchTags: <A, const Handlers extends object>(\n    fnOk: (t: T) => A,\n    handlers: Handlers & MatchTagHandlers<E, Handlers>,\n  ) => A | MatchTagHandlerResult<Handlers>\n  /**\n   * Converts this Result into a plain value with partial tagged-error handlers and a fallback.\n   */\n  matchTagsPartial: <A, B, const Handlers extends object>(\n    fnOk: (t: T) => A,\n    handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n    fallback: (error: E) => B,\n  ) => A | MatchTagHandlerResult<Handlers> | B\n  /**\n   * Pipes this Result through reusable transformation functions.\n   */\n  pipe: {\n    <A>(ab: PipeFn<Result<T, E>, A>): A\n    <A, B>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>): B\n    <A, B, C>(ab: PipeFn<Result<T, E>, A>, bc: PipeFn<A, B>, cd: PipeFn<B, C>): C\n  }\n  /**\n   * Runs a side effect with the Ok or Err value and returns this same Result.\n   *\n   * Exceptions thrown by the side effect are swallowed.\n   */\n  log: (fn: (t?: T, e?: E) => void) => this\n  /**\n   * Runs a side effect only when this result is Ok and returns this same Result.\n   *\n   * Exceptions thrown by the side effect are swallowed.\n   */\n  tap: (fn: (t: T) => void) => this\n  /**\n   * Runs a side effect only when this result is Err and returns this same Result.\n   *\n   * Exceptions thrown by the side effect are swallowed.\n   */\n  tapError: (fn: (e: E) => void) => this\n  /**\n   * Attaches a synchronous disposal finalizer to this Result.\n   */\n  toDisposable: (f: ResultFinalizer<T, E>) => DisposableResult<T, E>\n  /**\n   * Returns the Ok value or throws the Err value.\n   *\n   * Use this at final application boundaries after the error channel has been modeled.\n   */\n  unwrapOrThrow: () => T\n  /**\n   * Enables `yield* result` inside `safeTry` generators.\n   */\n  [Symbol.iterator]: () => Generator<Result<never, E>, T>\n  /**\n   * Compatibility generator for `safeTry`. Prefer `yield* result` in new code.\n   */\n  safeUnwrap: () => Generator<Result<never, E>, T>\n}\n\nexport interface OkResult<T, E> extends ResultOperations<T, E> {\n  /**\n   * Ok value carried by this result.\n   */\n  readonly value: T\n}\n\nexport interface ErrResult<T, E> extends ResultOperations<T, E> {\n  /**\n   * Err value carried by this result.\n   */\n  readonly error: E\n}\n\nexport type Result<T, E> = OkResult<T, E> | ErrResult<T, E>\nexport type StrictResult<T, E extends Error = Error> = Result<T, E>\n\n/**\n * Object form accepted by `tryResult`.\n *\n * Use this form when named `try` and `catch` fields make a synchronous boundary easier to read.\n */\nexport interface TryResultOptions<T, E = unknown> {\n  /**\n   * Runs the synchronous work whose thrown value should become `Err<E>`.\n   */\n  readonly try: () => Exclude<T, Promise<unknown>>\n  /**\n   * Converts a thrown `unknown` cause into the typed Resultar error channel.\n   *\n   * If omitted, the error channel is `unknown`.\n   */\n  readonly catch?: (e: unknown) => E\n}\n\nexport interface SafeTryOptions<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n  CatchErr = never,\n> {\n  /**\n   * Generator body evaluated by `safeTry`.\n   *\n   * Use `yield* result` to unwrap Resultar values and short-circuit on Err.\n   */\n  readonly try: () => Generator<YieldErr, GeneratorReturnResult>\n  /**\n   * Converts synchronous throws from the generator setup into the Result error channel.\n   */\n  readonly catch?: (e: unknown) => CatchErr\n}\n\nexport interface SafeTryAsyncOptions<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n  CatchErr = never,\n> {\n  /**\n   * Async generator body evaluated by `safeTry`.\n   *\n   * Use `yield* result` or `yield* resultAsync` to unwrap Resultar values and short-circuit on Err.\n   */\n  readonly try: () => AsyncGenerator<YieldErr, GeneratorReturnResult>\n  /**\n   * Converts synchronous throws or async rejections from the generator setup into the ResultAsync\n   * error channel.\n   */\n  readonly catch?: (e: unknown) => CatchErr\n}\n\nconst combineResultList = <T, E>(resultList: readonly Result<T, E>[]): Result<readonly T[], E> => {\n  const values: T[] = []\n\n  for (const result of resultList) {\n    if (result.isErr()) {\n      return err(result.error)\n    }\n\n    values.push(result.value)\n  }\n\n  return ok(values)\n}\n\nconst combineResultRecord = <T extends ResultRecord>(resultRecord: T): CombineResultsRecord<T> => {\n  const values: Record<string, unknown> = {}\n\n  for (const [key, result] of Object.entries(resultRecord)) {\n    if (result.isErr()) {\n      return err(result.error) as CombineResultsRecord<T>\n    }\n\n    values[key] = result.value\n  }\n\n  return ok(values) as CombineResultsRecord<T>\n}\n\nconst 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  }\n\n  return acc\n}\n\nconst combineResultRecordWithAllErrors = <T extends ResultRecord>(\n  resultRecord: T,\n): CombineResultsRecordWithAllErrors<T> => {\n  const errors: unknown[] = []\n  const values: Record<string, unknown> = {}\n\n  for (const [key, result] of Object.entries(resultRecord)) {\n    if (result.isErr()) {\n      errors.push(result.error)\n    } else {\n      values[key] = result.value\n    }\n  }\n\n  if (errors.length > 0) {\n    return err(errors) as CombineResultsRecordWithAllErrors<T>\n  }\n\n  return ok(values) as CombineResultsRecordWithAllErrors<T>\n}\n\nconst isIterable = (value: unknown): value is Iterable<unknown> =>\n  // Stryker disable next-line all: invalid null input still fails outside the iterable branch; this guard keeps the hot check explicit.\n  value !== null &&\n  // Stryker disable next-line all: iterable functions are valid iterables, but normal collection tests cover object iterables.\n  (typeof value === 'object' || typeof value === 'function') &&\n  typeof (value as { readonly [Symbol.iterator]?: unknown })[Symbol.iterator] === 'function'\n\nexport const createEmptyResultsCollectionError = (): Error => {\n  const error = new Error('Received an empty collection of results')\n  error.name = 'IllegalArgumentException'\n\n  return error\n}\n\nconst getReason = (value: unknown): unknown => (value as { readonly reason?: unknown }).reason\n\nconst loopResult = <State, R extends Result<unknown, unknown>>(\n  initial: State,\n  options: ResultLoopRuntimeOptions<State, R>,\n): ResultLoopCollected<R> | ResultLoopDiscarded<R> => {\n  let state = initial\n\n  if (options.discard === true) {\n    while (options.while(state)) {\n      const result = options.body(state)\n\n      if (result.isErr()) {\n        return err(result.error as InferErrTypes<R>) as\n          | ResultLoopCollected<R>\n          | ResultLoopDiscarded<R>\n      }\n\n      state = options.step(state)\n    }\n\n    return ok<void, InferErrTypes<R>>(undefined)\n  }\n\n  const values: InferOkTypes<R>[] = []\n\n  while (options.while(state)) {\n    const result = options.body(state)\n\n    if (result.isErr()) {\n      return err(result.error as InferErrTypes<R>) as\n        | ResultLoopCollected<R>\n        | ResultLoopDiscarded<R>\n    }\n\n    values.push(result.value as InferOkTypes<R>)\n    state = options.step(state)\n  }\n\n  return ok<readonly InferOkTypes<R>[], InferErrTypes<R>>(values)\n}\n\nconst iterateResult = <State, R extends Result<State, unknown>>(\n  initial: State,\n  options: ResultIterateRuntimeOptions<State, R>,\n): ResultIterated<State, R> => {\n  let state = initial\n\n  while (options.while(state)) {\n    const result = options.body(state)\n\n    if (result.isErr()) {\n      return err(result.error as InferErrTypes<R>) as ResultIterated<State, R>\n    }\n\n    state = result.value\n  }\n\n  return ok<State, InferErrTypes<R>>(state)\n}\n\nconst forEachResult = <Item, R extends Result<unknown, unknown>>(\n  items: Iterable<Item>,\n  f: (value: Item, index: number) => R,\n  options?: ResultForEachRuntimeOptions,\n): ResultForEachCollected<R> | ResultForEachDiscarded<R> => {\n  if (options?.discard === true) {\n    let index = 0\n\n    for (const item of items) {\n      const result = f(item, index)\n\n      if (result.isErr()) {\n        return err(result.error as InferErrTypes<R>) as\n          | ResultForEachCollected<R>\n          | ResultForEachDiscarded<R>\n      }\n\n      index += 1\n    }\n\n    return ok<void, InferErrTypes<R>>(undefined)\n  }\n\n  const values: InferOkTypes<R>[] = []\n  let index = 0\n\n  for (const item of items) {\n    const result = f(item, index)\n\n    if (result.isErr()) {\n      return err(result.error as InferErrTypes<R>) as\n        | ResultForEachCollected<R>\n        | ResultForEachDiscarded<R>\n    }\n\n    values.push(result.value as InferOkTypes<R>)\n    index += 1\n  }\n\n  return ok<readonly InferOkTypes<R>[], InferErrTypes<R>>(values)\n}\n\nconst callSyncSideEffect = (effect: () => void): void => {\n  try {\n    effect()\n  } catch {\n    /* empty */\n  }\n}\n\nexport const getMatchErrorHandler = <T, E, A, B>(\n  input: MatchHandlers<T, E, A, B> | MatchOkHandler<T, A>,\n  fnErr: MatchErrorHandler<E, B> | undefined,\n): MatchErrorHandler<E, B> => {\n  if (typeof input !== 'function') {\n    return input.error\n  }\n\n  if (fnErr === undefined) {\n    throw new TypeError('Result.match requires an error handler')\n  }\n\n  return fnErr\n}\n\ninterface ResultStatic {\n  /**\n   * Runtime `instanceof Result` support for Ok and Err values.\n   */\n  [Symbol.hasInstance]: (value: unknown) => boolean\n  /**\n   * Runs synchronous work and captures thrown values into a Result.\n   *\n   * Compatibility alias. Prefer the top-level `tryResult` helper in new code.\n   */\n  tryCatch: <T, E>(\n    this: void,\n    fn: () => Exclude<T, Promise<unknown>>,\n    errorFn?: (e: unknown) => E,\n  ) => Result<T, E>\n  /**\n   * Wraps a throwing synchronous function so every later call returns a Result.\n   */\n  fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(\n    this: void,\n    fn: Fn,\n    errorFn?: (e: any) => E,\n  ) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>\n  /**\n   * Creates an Ok result.\n   */\n  ok: {\n    <T, E = never>(this: void, value: T): OkResult<T, E>\n    <E = never>(this: void, value: void): OkResult<void, E>\n  }\n  /**\n   * Creates an Ok result with `undefined`.\n   */\n  unit: <E = never>(this: void) => Result<undefined, E>\n  /**\n   * Creates an Err result.\n   */\n  err: {\n    <T = never, E extends string = string>(this: void, err: E): ErrResult<T, E>\n    <T = never, E = unknown>(this: void, err: E): ErrResult<T, E>\n    <T = never>(this: void, err: void): ErrResult<T, void>\n  }\n  /**\n   * Combines many Result values and stops at the first Err.\n   *\n   * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return\n   * an Ok readonly array.\n   */\n  combine: {\n    <T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(\n      this: void,\n      resultList: T,\n    ): CombineResults<T>\n    <T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResults<T>\n    <T extends ResultRecord>(this: void, resultRecord: T): CombineResultsRecord<T>\n    <R extends Result<unknown, unknown>>(\n      this: void,\n      results: Iterable<R>,\n    ): CombineResultsIterable<R>\n  }\n  /**\n   * Combines many Result values and collects every Err instead of stopping at the first one.\n   */\n  combineWithAllErrors: {\n    <T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(\n      this: void,\n      resultList: T,\n    ): CombineResultsWithAllErrorsArray<T>\n    <T extends readonly Result<unknown, unknown>[]>(\n      this: void,\n      resultList: T,\n    ): CombineResultsWithAllErrorsArray<T>\n    <T extends ResultRecord>(this: void, resultRecord: T): CombineResultsRecordWithAllErrors<T>\n    <R extends Result<unknown, unknown>>(\n      this: void,\n      results: Iterable<R>,\n    ): CombineResultsIterableWithAllErrors<R>\n  }\n  /**\n   * Validates many Result values and collects every Err.\n   *\n   * When passed items plus a mapper, the mapper must return a Result for each item.\n   */\n  validateAll: {\n    <T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(\n      this: void,\n      resultList: T,\n    ): CombineResultsWithAllErrorsArray<T>\n    <T extends readonly Result<unknown, unknown>[]>(\n      this: void,\n      resultList: T,\n    ): CombineResultsWithAllErrorsArray<T>\n    <Item, R extends Result<unknown, unknown>>(\n      this: void,\n      items: Iterable<Item>,\n      f: (value: Item, index: number) => R,\n    ): ResultValidatedAll<R>\n  }\n  /**\n   * Combines exactly two Result values into an Ok tuple or the first Err.\n   */\n  zip: <Left extends Result<unknown, unknown>, Right extends Result<unknown, unknown>>(\n    this: void,\n    left: Left,\n    right: Right,\n  ) => ResultZipped<Left, Right>\n  /**\n   * Runs candidates until the first Ok and returns the last Err if every candidate fails.\n   */\n  firstSuccessOf: <Candidates extends Iterable<ResultCandidate>>(\n    this: void,\n    candidates: Candidates,\n  ) => FirstSuccessOf<Candidates>\n  /**\n   * Chooses one of two Result branches from a boolean or Result boolean condition.\n   */\n  if: {\n    <OnTrue extends Result<unknown, unknown>, OnFalse extends Result<unknown, unknown>>(\n      this: void,\n      condition: ResultBooleanCondition,\n      options: ResultIfOptions<OnTrue, OnFalse>,\n    ): ResultIf<never, OnTrue, OnFalse>\n    <\n      Condition extends Result<boolean, unknown>,\n      OnTrue extends Result<unknown, unknown>,\n      OnFalse extends Result<unknown, unknown>,\n    >(\n      this: void,\n      condition: Condition,\n      options: ResultIfOptions<OnTrue, OnFalse>,\n    ): ResultIf<InferErrTypes<Condition>, OnTrue, OnFalse>\n  }\n  /**\n   * Runs `body` only when the condition is true; otherwise returns Ok(undefined).\n   */\n  when: <R extends Result<unknown, unknown>>(\n    this: void,\n    condition: ResultBooleanCondition,\n    body: () => R,\n  ) => ResultWhen<R>\n  /**\n   * Runs `body` only when a Result boolean condition is Ok(true).\n   */\n  whenResult: <Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>>(\n    this: void,\n    condition: Condition,\n    body: () => R,\n  ) => ResultWhenWithCondition<Condition, R>\n  /**\n   * Runs `body` only when the condition is false; otherwise returns Ok(undefined).\n   */\n  unless: <R extends Result<unknown, unknown>>(\n    this: void,\n    condition: ResultBooleanCondition,\n    body: () => R,\n  ) => ResultWhen<R>\n  /**\n   * Runs `body` only when a Result boolean condition is Ok(false).\n   */\n  unlessResult: <Condition extends Result<boolean, unknown>, R extends Result<unknown, unknown>>(\n    this: void,\n    condition: Condition,\n    body: () => R,\n  ) => ResultWhenWithCondition<Condition, R>\n  /**\n   * Repeats a Result-producing body while a condition holds.\n   *\n   * Use `discard: true` when only failure matters and collected Ok values are not needed.\n   */\n  loop: {\n    <State, BodyState extends State, R extends Result<unknown, unknown>>(\n      this: void,\n      initial: State,\n      options: ResultLoopOptions<State, BodyState, R>,\n    ): ResultLoopCollected<R>\n    <State, R extends Result<unknown, unknown>>(\n      this: void,\n      initial: State,\n      options: ResultLoopBooleanOptions<State, R>,\n    ): ResultLoopCollected<R>\n    <State, BodyState extends State, R extends Result<unknown, unknown>>(\n      this: void,\n      initial: State,\n      options: ResultLoopDiscardOptions<State, BodyState, R>,\n    ): ResultLoopDiscarded<R>\n    <State, R extends Result<unknown, unknown>>(\n      this: void,\n      initial: State,\n      options: ResultLoopBooleanDiscardOptions<State, R>,\n    ): ResultLoopDiscarded<R>\n  }\n  /**\n   * Repeatedly transforms state with a Result-producing body until the condition fails.\n   */\n  iterate: {\n    <State, BodyState extends WidenLiteral<State>, R extends Result<WidenLiteral<State>, unknown>>(\n      this: void,\n      initial: State,\n      options: ResultIterateOptions<WidenLiteral<State>, BodyState, R>,\n    ): ResultIterated<WidenLiteral<State>, R>\n    <State, R extends Result<WidenLiteral<State>, unknown>>(\n      this: void,\n      initial: State,\n      options: ResultIterateBooleanOptions<WidenLiteral<State>, R>,\n    ): ResultIterated<WidenLiteral<State>, R>\n  }\n  /**\n   * Runs a Result-producing mapper for each item.\n   *\n   * Use `discard: true` when only failure matters and collected Ok values are not needed.\n   */\n  forEach: {\n    <Item, R extends Result<unknown, unknown>>(\n      this: void,\n      items: Iterable<Item>,\n      f: (value: Item, index: number) => R,\n      options?: ResultForEachOptions,\n    ): ResultForEachCollected<R>\n    <Item, R extends Result<unknown, unknown>>(\n      this: void,\n      items: Iterable<Item>,\n      f: (value: Item, index: number) => R,\n      options: ResultForEachDiscardOptions,\n    ): ResultForEachDiscarded<R>\n  }\n}\n\n/**\n * Runtime namespace for Result constructors and static helpers.\n */\n/* eslint-disable @typescript-eslint/no-extraneous-class, unicorn/no-static-only-class */\nclass ResultNamespace {\n  public static [Symbol.hasInstance](value: unknown): boolean {\n    return value instanceof Ok || value instanceof Err\n  }\n\n  /**\n   * Creates a `Result` by running a function that might throw.\n   * If the function throws, the error will be caught and returned as an `Err`.\n   * If the function succeeds, the value will be wrapped in an `Ok`.\n   *\n   * Compatibility alias. Prefer the top-level `tryResult` helper in new code.\n   *\n   * @param fn - The function to execute, which might throw an error\n   * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`\n   * @returns A `Result` containing either the function's return value or the caught error\n   */\n  public static tryCatch<T, E>(\n    this: void,\n    fn: () => Exclude<T, Promise<unknown>>,\n    errorFn?: (e: unknown) => E,\n  ): Result<T, E> {\n    try {\n      return ok(fn())\n    } catch (error) {\n      if (errorFn) {\n        return err(errorFn(error))\n      }\n      return err(error as E)\n    }\n  }\n\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  public static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(\n    this: void,\n    fn: Fn,\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\n  public static ok<T, E = never>(this: void, value: T): OkResult<T, E>\n  public static ok<E = never>(this: void, value: void): OkResult<void, E>\n  public static ok<T, E = never>(this: void, value: T): OkResult<T, E> {\n    return ok<T, E>(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  public static unit<E = never>(this: void): Result<undefined, E> {\n    return unit<E>()\n  }\n\n  public static err<T = never, E extends string = string>(this: void, err: E): ErrResult<T, E>\n  public static err<T = never, E = unknown>(this: void, err: E): ErrResult<T, E>\n  public static err<T = never>(this: void, err: void): ErrResult<T, void>\n  public static err<T = never, E = unknown>(this: void, error: E): ErrResult<T, E> {\n    return err<T, E>(error)\n  }\n\n  public static combine<\n    T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]],\n  >(this: void, resultList: T): CombineResults<T>\n  public static combine<T extends readonly Result<unknown, unknown>[]>(\n    this: void,\n    resultList: T,\n  ): CombineResults<T>\n  public static combine<T extends ResultRecord>(\n    this: void,\n    resultRecord: T,\n  ): CombineResultsRecord<T>\n  public static combine<R extends Result<unknown, unknown>>(\n    this: void,\n    results: Iterable<R>,\n  ): CombineResultsIterable<R>\n  public static combine<\n    T extends\n      | readonly Result<unknown, unknown>[]\n      | ResultRecord\n      | Iterable<Result<unknown, unknown>>,\n  >(\n    this: void,\n    input: T,\n  ):\n    | CombineResults<T & readonly Result<unknown, unknown>[]>\n    | CombineResultsRecord<ResultRecord>\n    | CombineResultsIterable<Result<unknown, unknown>> {\n    // Stryker disable next-line all: array fast path avoids cloning arrays through the iterable branch.\n    if (Array.isArray(input)) {\n      return combineResultList(input) as CombineResults<T & readonly Result<unknown, unknown>[]>\n    }\n\n    if (isIterable(input)) {\n      return combineResultList([...input] as readonly Result<unknown, unknown>[]) as\n        | CombineResults<T & readonly Result<unknown, unknown>[]>\n        | CombineResultsIterable<Result<unknown, unknown>>\n    }\n\n    return combineResultRecord(input)\n  }\n\n  public static combineWithAllErrors<\n    T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]],\n  >(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>\n  public static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n    this: void,\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  public static combineWithAllErrors<T extends ResultRecord>(\n    this: void,\n    resultRecord: T,\n  ): CombineResultsRecordWithAllErrors<T>\n  public static combineWithAllErrors<R extends Result<unknown, unknown>>(\n    this: void,\n    results: Iterable<R>,\n  ): CombineResultsIterableWithAllErrors<R>\n  public static combineWithAllErrors<\n    T extends\n      | readonly Result<unknown, unknown>[]\n      | ResultRecord\n      | Iterable<Result<unknown, unknown>>,\n  >(\n    this: void,\n    input: T,\n  ):\n    | CombineResultsWithAllErrorsArray<T & readonly Result<unknown, unknown>[]>\n    | CombineResultsRecordWithAllErrors<ResultRecord>\n    | CombineResultsIterableWithAllErrors<Result<unknown, unknown>> {\n    // Stryker disable next-line all: array fast path avoids cloning arrays through the iterable branch.\n    if (Array.isArray(input)) {\n      return combineResultListWithAllErrors(input) as CombineResultsWithAllErrorsArray<\n        T & readonly Result<unknown, unknown>[]\n      >\n    }\n\n    if (isIterable(input)) {\n      return combineResultListWithAllErrors([...input] as readonly Result<unknown, unknown>[]) as\n        | CombineResultsWithAllErrorsArray<T & readonly Result<unknown, unknown>[]>\n        | CombineResultsIterableWithAllErrors<Result<unknown, unknown>>\n    }\n\n    return combineResultRecordWithAllErrors(input)\n  }\n\n  public static validateAll<\n    T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]],\n  >(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>\n  public static validateAll<T extends readonly Result<unknown, unknown>[]>(\n    this: void,\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  public static validateAll<Item, R extends Result<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n  ): ResultValidatedAll<R>\n  public static validateAll<\n    T extends readonly Result<unknown, unknown>[],\n    Item,\n    R extends Result<unknown, unknown>,\n  >(\n    this: void,\n    resultListOrItems: T | Iterable<Item>,\n    f?: (value: Item, index: number) => R,\n  ): CombineResultsWithAllErrorsArray<T> | ResultValidatedAll<R> {\n    // Stryker disable next-line all: no-mapper fast path avoids Array.from identity mapping.\n    if (f === undefined) {\n      return combineResultListWithAllErrors(\n        resultListOrItems as T,\n      ) as CombineResultsWithAllErrorsArray<T>\n    }\n\n    const resultList = Array.from(resultListOrItems as Iterable<Item>, f)\n\n    return combineResultListWithAllErrors(resultList) as ResultValidatedAll<R>\n  }\n\n  public static zip<Left extends Result<unknown, unknown>, Right extends Result<unknown, unknown>>(\n    this: void,\n    left: Left,\n    right: Right,\n  ): ResultZipped<Left, Right> {\n    return combineResultList([left, right]) as ResultZipped<Left, Right>\n  }\n\n  public static firstSuccessOf<Candidates extends Iterable<ResultCandidate>>(\n    this: void,\n    candidates: Candidates,\n  ): FirstSuccessOf<Candidates> {\n    let latestError: Result<unknown, unknown> | undefined = undefined\n\n    for (const candidate of candidates) {\n      const result = candidate()\n\n      if (result.isOk()) {\n        return result as FirstSuccessOf<Candidates>\n      }\n\n      latestError = result\n    }\n\n    if (latestError === undefined) {\n      throw createEmptyResultsCollectionError()\n    }\n\n    return latestError as FirstSuccessOf<Candidates>\n  }\n\n  public static if<\n    OnTrue extends Result<unknown, unknown>,\n    OnFalse extends Result<unknown, unknown>,\n  >(\n    this: void,\n    condition: ResultBooleanCondition,\n    options: ResultIfOptions<OnTrue, OnFalse>,\n  ): ResultIf<never, OnTrue, OnFalse>\n  public static if<\n    Condition extends Result<boolean, unknown>,\n    OnTrue extends Result<unknown, unknown>,\n    OnFalse extends Result<unknown, unknown>,\n  >(\n    this: void,\n    condition: Condition,\n    options: ResultIfOptions<OnTrue, OnFalse>,\n  ): ResultIf<InferErrTypes<Condition>, OnTrue, OnFalse>\n  public static if<\n    Condition extends Result<boolean, unknown>,\n    OnTrue extends Result<unknown, unknown>,\n    OnFalse extends Result<unknown, unknown>,\n  >(\n    this: void,\n    condition: Condition | ResultBooleanCondition,\n    options: ResultIfOptions<OnTrue, OnFalse>,\n  ): ResultIf<InferErrTypes<Condition>, OnTrue, OnFalse> | ResultIf<never, OnTrue, OnFalse> {\n    if (typeof condition === 'boolean' || typeof condition === 'function') {\n      return (\n        (typeof condition === 'function' ? condition() : condition)\n          ? options.onTrue()\n          : options.onFalse()\n      ) as ResultIf<never, OnTrue, OnFalse>\n    }\n\n    if (condition.isErr()) {\n      return err(condition.error as InferErrTypes<Condition>) as ResultIf<\n        InferErrTypes<Condition>,\n        OnTrue,\n        OnFalse\n      >\n    }\n\n    return (condition.value ? options.onTrue() : options.onFalse()) as ResultIf<\n      InferErrTypes<Condition>,\n      OnTrue,\n      OnFalse\n    >\n  }\n\n  public static when<R extends Result<unknown, unknown>>(\n    this: void,\n    condition: ResultBooleanCondition,\n    body: () => R,\n  ): ResultWhen<R> {\n    if (typeof condition === 'function' ? condition() : condition) {\n      return body() as ResultWhen<R>\n    }\n\n    return ok<InferOkTypes<R> | undefined, InferErrTypes<R>>(undefined)\n  }\n\n  public static whenResult<\n    Condition extends Result<boolean, unknown>,\n    R extends Result<unknown, unknown>,\n  >(this: void, condition: Condition, body: () => R): ResultWhenWithCondition<Condition, R> {\n    if (condition.isErr()) {\n      return err(condition.error as InferErrTypes<Condition>) as ResultWhenWithCondition<\n        Condition,\n        R\n      >\n    }\n\n    if (condition.value) {\n      return body() as ResultWhenWithCondition<Condition, R>\n    }\n\n    return ok<InferOkTypes<R> | undefined, InferErrTypes<R>>(undefined) as ResultWhenWithCondition<\n      Condition,\n      R\n    >\n  }\n\n  public static unless<R extends Result<unknown, unknown>>(\n    this: void,\n    condition: ResultBooleanCondition,\n    body: () => R,\n  ): ResultWhen<R> {\n    if (typeof condition === 'function' ? !condition() : !condition) {\n      return body() as ResultWhen<R>\n    }\n\n    return ok<InferOkTypes<R> | undefined, InferErrTypes<R>>(undefined)\n  }\n\n  public static unlessResult<\n    Condition extends Result<boolean, unknown>,\n    R extends Result<unknown, unknown>,\n  >(this: void, condition: Condition, body: () => R): ResultWhenWithCondition<Condition, R> {\n    if (condition.isErr()) {\n      return err(condition.error as InferErrTypes<Condition>) as ResultWhenWithCondition<\n        Condition,\n        R\n      >\n    }\n\n    if (!condition.value) {\n      return body() as ResultWhenWithCondition<Condition, R>\n    }\n\n    return ok<InferOkTypes<R> | undefined, InferErrTypes<R>>(undefined) as ResultWhenWithCondition<\n      Condition,\n      R\n    >\n  }\n\n  public static loop<State, BodyState extends State, R extends Result<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultLoopOptions<State, BodyState, R>,\n  ): ResultLoopCollected<R>\n  public static loop<State, R extends Result<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultLoopBooleanOptions<State, R>,\n  ): ResultLoopCollected<R>\n  public static loop<State, BodyState extends State, R extends Result<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultLoopDiscardOptions<State, BodyState, R>,\n  ): ResultLoopDiscarded<R>\n  public static loop<State, R extends Result<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultLoopBooleanDiscardOptions<State, R>,\n  ): ResultLoopDiscarded<R>\n  public static loop<State, R extends Result<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options:\n      | ResultLoopBooleanOptions<State, R>\n      | ResultLoopBooleanDiscardOptions<State, R>\n      | ResultLoopOptions<State, State, R>\n      | ResultLoopDiscardOptions<State, State, R>,\n  ): ResultLoopCollected<R> | ResultLoopDiscarded<R> {\n    return loopResult(initial, options as ResultLoopRuntimeOptions<State, R>)\n  }\n\n  public static iterate<\n    State,\n    BodyState extends WidenLiteral<State>,\n    R extends Result<WidenLiteral<State>, unknown>,\n  >(\n    this: void,\n    initial: State,\n    options: ResultIterateOptions<WidenLiteral<State>, BodyState, R>,\n  ): ResultIterated<WidenLiteral<State>, R>\n  public static iterate<State, R extends Result<WidenLiteral<State>, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultIterateBooleanOptions<WidenLiteral<State>, R>,\n  ): ResultIterated<WidenLiteral<State>, R>\n  public static iterate<State, R extends Result<WidenLiteral<State>, unknown>>(\n    this: void,\n    initial: State,\n    options:\n      | ResultIterateBooleanOptions<WidenLiteral<State>, R>\n      | ResultIterateOptions<WidenLiteral<State>, WidenLiteral<State>, R>,\n  ): ResultIterated<WidenLiteral<State>, R> {\n    return iterateResult(\n      initial as WidenLiteral<State>,\n      options as ResultIterateRuntimeOptions<WidenLiteral<State>, R>,\n    )\n  }\n\n  public static forEach<Item, R extends Result<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options?: ResultForEachOptions,\n  ): ResultForEachCollected<R>\n  public static forEach<Item, R extends Result<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options: ResultForEachDiscardOptions,\n  ): ResultForEachDiscarded<R>\n  public static forEach<Item, R extends Result<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options?: ResultForEachOptions | ResultForEachDiscardOptions,\n  ): ResultForEachCollected<R> | ResultForEachDiscarded<R> {\n    return forEachResult(items, f, options)\n  }\n}\n\nexport const Result: ResultStatic = ResultNamespace\n\nabstract class ResultVariant<T, E> extends Pipeable {\n  public filterOrElse<U extends T, F>(\n    predicate: (value: T) => value is U,\n    onFalse: (value: T) => F,\n  ): Result<U, E | F>\n  public filterOrElse<F>(\n    predicate: (value: T) => boolean,\n    onFalse: (value: T) => F,\n  ): Result<T, E | F>\n  public filterOrElse<F>(\n    predicate: (value: T) => boolean,\n    onFalse: (value: T) => F,\n  ): Result<T, E | F> {\n    return this.filterOrElseResult(predicate, onFalse)\n  }\n\n  public if(fCondition: (t: T) => boolean): {\n    true: <X1, Y1>(\n      fTrue: (t: T) => Result<X1, Y1>,\n    ) => { false: <X2, Y2>(fFalse: (t: T) => Result<X2, Y2>) => Result<X1 | X2, Y1 | Y2 | E> }\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          this.branchResult(fCondition, fTrue, fFalse),\n      }),\n    }\n  }\n\n  public orElse<R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ): Result<InferOkTypes<R> | T, InferErrTypes<R>>\n  public orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>\n  public orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A> {\n    return this.orElseResult(f)\n  }\n\n  protected abstract filterOrElseResult<F>(\n    predicate: (value: T) => boolean,\n    onFalse: (value: T) => F,\n  ): Result<T, E | F>\n\n  protected abstract branchResult<X1, Y1, X2, Y2>(\n    fCondition: (t: T) => boolean,\n    fTrue: (t: T) => Result<X1, Y1>,\n    fFalse: (t: T) => Result<X2, Y2>,\n  ): Result<X1 | X2, Y1 | Y2 | E>\n\n  protected abstract orElseResult<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>\n}\n\nclass Ok<T, E> extends ResultVariant<T, E> {\n  public readonly value: T\n\n  public constructor(value: T) {\n    super()\n    this.value = value\n  }\n\n  public isOk(): this is OkResult<T, E> {\n    void this\n    return true\n  }\n\n  public isErr(): this is ErrResult<T, E> {\n    void this\n    return false\n  }\n\n  public map<X>(f: (t: T) => X): Result<X, E> {\n    return ok<X, E>(f(this.value))\n  }\n\n  public as<X>(value: X): Result<X, E> {\n    void this\n    return ok<X, E>(value)\n  }\n\n  protected filterOrElseResult<F>(\n    predicate: (value: T) => boolean,\n    onFalse: (value: T) => F,\n  ): Result<T, E | F> {\n    if (predicate(this.value)) {\n      return ok<T, E | F>(this.value)\n    }\n\n    return err<T, E | F>(onFalse(this.value))\n  }\n\n  public mapErr<X>(_fn: (t: E) => X): Result<T, X> {\n    return ok<T, X>(this.value)\n  }\n\n  public andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n    return f(this.value)\n  }\n\n  protected orElseResult<U, A>(_f: (e: E) => Result<U, A>): Result<U | T, A> {\n    return ok<U | T, A>(this.value as Exclude<T, Promise<any>>)\n  }\n\n  public catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n    _tag: Tag,\n    _f: (error: ErrorForTag<E, Tag>) => R,\n  ): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>> {\n    return ok(this.value)\n  }\n\n  public catchTags<const Handlers extends object>(\n    _handlers: Handlers & CatchTagHandlers<E, Handlers>,\n  ): Result<\n    T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n    ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n  > {\n    return ok(this.value)\n  }\n\n  public catchReason<\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n    R extends Result<unknown, unknown>,\n  >(\n    _errorTag: ErrorTag,\n    _reasonTag: ReasonTag,\n    _f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag<E, ErrorTag>) => R,\n  ): Result<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>> {\n    return ok(this.value)\n  }\n\n  public catchReasons<const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(\n    _errorTag: ErrorTag,\n    _handlers: Handlers & CatchReasonHandlers<E, ErrorTag, Handlers>,\n  ): Result<\n    T | InferOkTypes<CatchReasonHandlerResult<Handlers>>,\n    | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n    | InferErrTypes<CatchReasonHandlerResult<Handlers>>\n  > {\n    return ok(this.value)\n  }\n\n  public unwrapReason<const ErrorTag extends TagsWithReasonOf<E>>(\n    _errorTag: ErrorTag,\n  ): Result<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>> {\n    return ok(this.value)\n  }\n\n  protected branchResult<X1, Y1, X2, Y2>(\n    fCondition: (t: T) => boolean,\n    fTrue: (t: T) => Result<X1, Y1>,\n    fFalse: (t: T) => Result<X2, Y2>,\n  ): Result<X1 | X2, Y1 | Y2 | E> {\n    return fCondition(this.value) ? fTrue(this.value) : fFalse(this.value)\n  }\n\n  public asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  public asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return f(this.value)\n  }\n\n  public asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E> {\n    return createResultAsync<ResultAsync<X, E>>(\n      Promise.resolve(f(this.value)).then((value) => ok<X, E>(value)),\n    )\n  }\n\n  public unwrapOr<A>(_defaultValue: A): T | A {\n    return this.value\n  }\n\n  public match<A, B = A>(handlers: MatchHandlers<T, E, A, B>): A | B\n  public match<A, B = A>(fnOk: MatchOkHandler<T, A>, fnErr: MatchErrorHandler<E, B>): A | B\n  public match<A, B = A>(\n    input: MatchHandlers<T, E, A, B> | MatchOkHandler<T, A>,\n    _fnErr?: MatchErrorHandler<E, B>,\n  ): A | B {\n    const fnOk = typeof input === 'function' ? input : input.ok\n\n    return fnOk(this.value)\n  }\n\n  public matchTags<A, const Handlers extends object>(\n    fnOk: (t: T) => A,\n    _handlers: Handlers & MatchTagHandlers<E, Handlers>,\n  ): A | MatchTagHandlerResult<Handlers> {\n    return fnOk(this.value)\n  }\n\n  public matchTagsPartial<A, B, const Handlers extends object>(\n    fnOk: (t: T) => A,\n    _handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n    _fallback: (error: E) => B,\n  ): A | MatchTagHandlerResult<Handlers> | B {\n    return fnOk(this.value)\n  }\n\n  public log(fn: (t?: T, e?: E) => void): this {\n    callSyncSideEffect(() => {\n      fn(this.value, undefined)\n    })\n    return this\n  }\n\n  public tap(fn: (t: T) => void): this {\n    callSyncSideEffect(() => {\n      fn(this.value)\n    })\n    return this\n  }\n\n  public tapError(_fn: (e: E) => void): this {\n    return this\n  }\n\n  public toDisposable(f: ResultFinalizer<T, E>): DisposableResult<T, E> {\n    return new DisposableResult(this, f)\n  }\n\n  public unwrapOrThrow(): T {\n    return this.value\n  }\n\n  public _unsafeUnwrap(_config?: ErrorConfig): T {\n    return this.value\n  }\n\n  public _unsafeUnwrapErr(config?: ErrorConfig): E {\n    throw createResultarError('Called `_unsafeUnwrapErr` on an Ok', this, config)\n  }\n\n  /* eslint-disable-next-line require-yield */\n  public *[Symbol.iterator](): Generator<Result<never, E>, T> {\n    return this.value\n  }\n\n  public safeUnwrap(): Generator<Result<never, E>, T> {\n    const { value } = this\n    /* eslint-disable-next-line require-yield */\n    return (function* () {\n      return value\n    })()\n  }\n}\n\nclass Err<T, E> extends ResultVariant<T, E> {\n  public readonly error: E\n\n  public constructor(error: E) {\n    super()\n    this.error = error\n  }\n\n  public isOk(): this is OkResult<T, E> {\n    void this\n    return false\n  }\n\n  public isErr(): this is ErrResult<T, E> {\n    void this\n    return true\n  }\n\n  public map<X>(_f: (t: T) => X): Result<X, E> {\n    return err<X, E>(this.error)\n  }\n\n  public as<X>(_value: X): Result<X, E> {\n    return err<X, E>(this.error)\n  }\n\n  protected filterOrElseResult<F>(\n    _predicate: (value: T) => boolean,\n    _onFalse: (value: T) => F,\n  ): Result<T, E | F> {\n    return err<T, E | F>(this.error)\n  }\n\n  public mapErr<X>(fn: (t: E) => X): Result<T, X> {\n    return err<T, X>(fn(this.error))\n  }\n\n  public andThen<X, Y>(_f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n    return err<X, E | Y>(this.error)\n  }\n\n  protected orElseResult<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A> {\n    return f(this.error)\n  }\n\n  protected branchResult<X1, Y1, X2, Y2>(\n    _fCondition: (t: T) => boolean,\n    _fTrue: (t: T) => Result<X1, Y1>,\n    _fFalse: (t: T) => Result<X2, Y2>,\n  ): Result<X1 | X2, Y1 | Y2 | E> {\n    return err<X1 | X2, Y1 | Y2 | E>(this.error)\n  }\n\n  public catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n    tag: Tag,\n    f: (error: ErrorForTag<E, Tag>) => R,\n  ): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>> {\n    if (hasTag(this.error, tag)) {\n      return f(this.error as ErrorForTag<E, Tag>) as Result<\n        T | InferOkTypes<R>,\n        ExcludeTag<E, Tag> | InferErrTypes<R>\n      >\n    }\n\n    return err(this.error as ExcludeTag<E, Tag>)\n  }\n\n  public catchTags<const Handlers extends object>(\n    handlers: Handlers & CatchTagHandlers<E, Handlers>,\n  ): Result<\n    T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n    ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n  > {\n    const error = this.error\n    const handled = callTaggedHandler<CatchTagHandlerResult<Handlers>>(error, handlers)\n\n    if (isTaggedHandlerMatch(handled)) {\n      return handled.value as Result<\n        T | InferOkTypes<CatchTagHandlerResult<Handlers>>,\n        ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>\n      >\n    }\n\n    return err(error as ExcludeTag<E, keyof Handlers & string>)\n  }\n\n  public catchReason<\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n    R extends Result<unknown, unknown>,\n  >(\n    errorTag: ErrorTag,\n    reasonTag: ReasonTag,\n    f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag<E, ErrorTag>) => R,\n  ): Result<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>> {\n    if (hasTag(this.error, errorTag)) {\n      const reason = getReason(this.error)\n\n      if (hasTag(reason, reasonTag)) {\n        return f(\n          reason as ReasonForTag<E, ErrorTag, ReasonTag>,\n          this.error as ErrorForTag<E, ErrorTag>,\n        ) as Result<\n          T | InferOkTypes<R>,\n          ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>\n        >\n      }\n    }\n\n    return err(this.error as ExcludeReasonTag<E, ErrorTag, ReasonTag>)\n  }\n\n  public catchReasons<const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(\n    errorTag: ErrorTag,\n    handlers: Handlers & CatchReasonHandlers<E, ErrorTag, Handlers>,\n  ): Result<\n    T | InferOkTypes<CatchReasonHandlerResult<Handlers>>,\n    | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n    | InferErrTypes<CatchReasonHandlerResult<Handlers>>\n  > {\n    if (hasTag(this.error, errorTag)) {\n      const reason = getReason(this.error)\n\n      if (typeof reason === 'object' && reason !== null && '_tag' in reason) {\n        const handler = (handlers as Record<string, unknown>)[\n          (reason as { readonly _tag: string })._tag\n        ]\n\n        if (handler !== undefined) {\n          return (handler as (reason: unknown, error: unknown) => Result<unknown, unknown>)(\n            reason,\n            this.error,\n          ) as Result<\n            T | InferOkTypes<CatchReasonHandlerResult<Handlers>>,\n            | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n            | InferErrTypes<CatchReasonHandlerResult<Handlers>>\n          >\n        }\n      }\n    }\n\n    return err(this.error as ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>)\n  }\n\n  public unwrapReason<const ErrorTag extends TagsWithReasonOf<E>>(\n    errorTag: ErrorTag,\n  ): Result<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>> {\n    if (hasTag(this.error, errorTag)) {\n      return err(getReason(this.error) as ReasonsOf<E, ErrorTag>)\n    }\n\n    return err(this.error as ExcludeTag<E, ErrorTag>)\n  }\n\n  public asyncAndThen<X, Y>(_f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  public asyncAndThen<X, Y>(_f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return createResultAsync<ResultAsync<X, E | Y>>(Promise.resolve(err<X, E | Y>(this.error)))\n  }\n\n  public asyncMap<X>(_f: (t: T) => Promise<X>): ResultAsync<X, E> {\n    return createResultAsync<ResultAsync<X, E>>(Promise.resolve(err<X, E>(this.error)))\n  }\n\n  public unwrapOr<A>(defaultValue: A): T | A {\n    void this\n    return defaultValue\n  }\n\n  public match<A, B = A>(handlers: MatchHandlers<T, E, A, B>): A | B\n  public match<A, B = A>(fnOk: MatchOkHandler<T, A>, fnErr: MatchErrorHandler<E, B>): A | B\n  public match<A, B = A>(\n    input: MatchHandlers<T, E, A, B> | MatchOkHandler<T, A>,\n    fnErr?: MatchErrorHandler<E, B>,\n  ): A | B {\n    const errorHandler = getMatchErrorHandler(input, fnErr)\n\n    return errorHandler(this.error)\n  }\n\n  public matchTags<A, const Handlers extends object>(\n    _fnOk: (t: T) => A,\n    handlers: Handlers & MatchTagHandlers<E, Handlers>,\n  ): A | MatchTagHandlerResult<Handlers> {\n    return matchTaggedOr<E, MatchTagHandlerResult<Handlers>, never>(\n      this.error,\n      handlers,\n      (error) => {\n        // eslint-disable-next-line @typescript-eslint/only-throw-error\n        throw error\n      },\n    )\n  }\n\n  public matchTagsPartial<A, B, const Handlers extends object>(\n    _fnOk: (t: T) => A,\n    handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n    fallback: (error: E) => B,\n  ): A | MatchTagHandlerResult<Handlers> | B {\n    return matchTaggedOr<E, MatchTagHandlerResult<Handlers>, B>(this.error, handlers, fallback)\n  }\n\n  public log(fn: (t?: T, e?: E) => void): this {\n    callSyncSideEffect(() => {\n      fn(undefined, this.error)\n    })\n    return this\n  }\n\n  public tap(_fn: (t: T) => void): this {\n    return this\n  }\n\n  public tapError(fn: (e: E) => void): this {\n    callSyncSideEffect(() => {\n      fn(this.error)\n    })\n    return this\n  }\n\n  public toDisposable(f: ResultFinalizer<T, E>): DisposableResult<T, E> {\n    return new DisposableResult(this, f)\n  }\n\n  public unwrapOrThrow(): T {\n    // eslint-disable-next-line @typescript-eslint/only-throw-error\n    throw this.error as Error\n  }\n\n  public _unsafeUnwrap(config?: ErrorConfig): T {\n    throw createResultarError('Called `_unsafeUnwrap` on an Err', this, config)\n  }\n\n  public _unsafeUnwrapErr(_config?: ErrorConfig): E {\n    return this.error\n  }\n\n  public *[Symbol.iterator](): Generator<Result<never, E>, T> {\n    yield this as never\n    return this as never\n  }\n\n  public safeUnwrap(): Generator<Result<never, E>, T> {\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  private disposed = false\n  private readonly finalizer: (value: unknown, error: unknown) => void\n  /**\n   * Wrapped Result value.\n   */\n  public readonly result: Result<T, E>\n\n  /**\n   * Creates a disposable wrapper around a Result.\n   */\n  public constructor(result: Result<T, E>, finalizer: ResultFinalizer<T, E>) {\n    this.result = result\n    this.finalizer = finalizer as (value: unknown, error: unknown) => void\n  }\n\n  /**\n   * Ok value when present, otherwise undefined cast to `T` for compatibility.\n   */\n  public get value(): T {\n    return this.result.isOk() ? this.result.value : (undefined as T)\n  }\n\n  /**\n   * Err value when present, otherwise undefined cast to `E` for compatibility.\n   */\n  public get error(): E {\n    return this.result.isErr() ? this.result.error : (undefined as E)\n  }\n\n  /**\n   * Delegates to the wrapped Result `_unsafeUnwrap`.\n   */\n  public _unsafeUnwrap(config?: ErrorConfig): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  /**\n   * Delegates to the wrapped Result `_unsafeUnwrapErr`.\n   */\n  public _unsafeUnwrapErr(config?: ErrorConfig): E {\n    return this.result._unsafeUnwrapErr(config)\n  }\n\n  /**\n   * Returns whether the wrapped Result is Ok.\n   */\n  public isOk(): boolean {\n    return this.result.isOk()\n  }\n\n  /**\n   * Returns whether the wrapped Result is Err.\n   */\n  public isErr(): boolean {\n    return this.result.isErr()\n  }\n\n  /**\n   * Returns the wrapped Ok value, or `defaultValue` when Err.\n   */\n  public unwrapOr<A>(defaultValue: A): T | A {\n    return this.result.unwrapOr(defaultValue)\n  }\n\n  /**\n   * Runs the finalizer once.\n   *\n   * Finalizer exceptions are intentionally swallowed.\n   */\n  public [Symbol.dispose](): void {\n    if (this.disposed) {\n      return\n    }\n\n    this.disposed = true\n    try {\n      this.finalizer(\n        this.result.isOk() ? this.result.value : undefined,\n        this.result.isErr() ? this.result.error : undefined,\n      )\n    } catch {\n      /* empty */\n    }\n  }\n}\n\n/**\n * Evaluates a synchronous generator and returns the first yielded Err or returned Result.\n *\n * Inside the generator, use `yield* result` to unwrap Ok values and short-circuit on Err. The object\n * form can map thrown setup errors into the Result error channel.\n */\nexport function safeTry<T, E, CatchErr = E>(\n  input: SafeTryOptions<Result<never, E>, Result<T, E>, CatchErr> & {\n    readonly catch: (e: unknown) => CatchErr\n  },\n): Result<T, E | CatchErr>\nexport function safeTry<T, E>(\n  input:\n    | (() => Generator<Result<never, E>, Result<T, E>>)\n    | SafeTryOptions<Result<never, E>, Result<T, E>>,\n): Result<T, E>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n  CatchErr,\n>(\n  input: SafeTryOptions<YieldErr, GeneratorReturnResult, CatchErr> & {\n    readonly catch: (e: unknown) => CatchErr\n  },\n): Result<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult> | CatchErr\n>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n  input:\n    | (() => Generator<YieldErr, GeneratorReturnResult>)\n    | SafeTryOptions<YieldErr, GeneratorReturnResult>,\n): Result<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\n\n/**\n * Evaluates an async generator and returns a ResultAsync for the first yielded Err or returned\n * Result.\n *\n * Inside the generator, use `yield* result` or `yield* resultAsync` to unwrap Ok values and\n * short-circuit on Err. The object form can map thrown or rejected setup errors into the ResultAsync\n * error channel.\n */\nexport function safeTry<T, E, CatchErr = E>(\n  input: SafeTryAsyncOptions<Result<never, E>, Result<T, E>, CatchErr> & {\n    readonly catch: (e: unknown) => CatchErr\n  },\n): ResultAsync<T, E | CatchErr>\nexport function safeTry<T, E>(\n  input:\n    | (() => AsyncGenerator<Result<never, E>, Result<T, E>>)\n    | SafeTryAsyncOptions<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  CatchErr,\n>(\n  input: SafeTryAsyncOptions<YieldErr, GeneratorReturnResult, CatchErr> & {\n    readonly catch: (e: unknown) => CatchErr\n  },\n): ResultAsync<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult> | CatchErr\n>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n  input:\n    | (() => AsyncGenerator<YieldErr, GeneratorReturnResult>)\n    | SafeTryAsyncOptions<YieldErr, GeneratorReturnResult>,\n): ResultAsync<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\nexport function safeTry<T, E, CatchErr = never>(\n  input:\n    | (() => Generator<Result<never, E>, Result<T, E>>)\n    | (() => AsyncGenerator<Result<never, E>, Result<T, E>>)\n    | SafeTryOptions<Result<never, E>, Result<T, E>, CatchErr>\n    | SafeTryAsyncOptions<Result<never, E>, Result<T, E>, CatchErr>,\n): Result<T, E | CatchErr> | ResultAsync<T, E | CatchErr> {\n  const body = typeof input === 'function' ? input : input.try\n  const catchFn = typeof input === 'function' ? undefined : input.catch\n  let n:\n    | IteratorResult<Result<never, E>, Result<T, E>>\n    | Promise<IteratorResult<Result<never, E>, Result<T, E>>> = undefined as never\n\n  try {\n    n = body().next()\n  } catch (error) {\n    if (catchFn) {\n      return err<T, E | CatchErr>(catchFn(error))\n    }\n\n    throw error\n  }\n\n  if (n instanceof Promise) {\n    return createResultAsync<ResultAsync<T, E | CatchErr>>(\n      n\n        .then((r) => r.value)\n        .catch((error: unknown) => {\n          if (catchFn) {\n            return err<T, E | CatchErr>(catchFn(error))\n          }\n\n          throw error\n        }),\n    )\n  }\n\n  return n.value\n}\n\n/**\n * Creates an Ok result.\n */\nexport function ok<T, E = never>(value: T): OkResult<T, E>\nexport function ok<E = never>(value: void): OkResult<void, E>\nexport function ok<T, E = never>(value: T): OkResult<T, E> {\n  return new Ok<T, E>(value)\n}\n\n/**\n * Creates an Err result.\n */\nexport function err<T = never, E extends string = string>(err: E): ErrResult<T, E>\nexport function err<T = never, E = unknown>(err: E): ErrResult<T, E>\nexport function err<T = never>(err: void): ErrResult<T, void>\nexport function err<T = never, E = unknown>(error: E): ErrResult<T, E> {\n  return new Err<T, E>(error)\n}\n\n/**\n * Wraps a throwing synchronous function so every later call returns a Result.\n *\n * Prefer `tryResult` when you want to run the operation immediately.\n */\nexport const fromThrowable: typeof Result.fromThrowable = Result.fromThrowable\n\n/**\n * Runs synchronous work and captures thrown values into `Result<T, E>`.\n *\n * Use `tryResult` at the edge of uncontrolled synchronous code: JSON parsing, environment parsing,\n * platform APIs, or third-party functions that may throw. The mapper receives the thrown `unknown`\n * cause and returns the typed error for the Resultar channel.\n *\n * @example\n * ```ts\n * const config = tryResult(\n *   () => JSON.parse(input) as Config,\n *   (cause) => new ParseConfigError({ cause }),\n * )\n * ```\n */\nexport function tryResult<T, E>(\n  fn: () => Exclude<T, Promise<unknown>>,\n  errorFn: (e: unknown) => E,\n): Result<T, E>\n/**\n * Captures a synchronous boundary with named `try` and `catch` fields.\n *\n * This is equivalent to `tryResult(() => ..., toError)`, but it reads better when the boundary has\n * a clear domain name or label.\n */\nexport function tryResult<T, E>(\n  options: TryResultOptions<T, E> & { readonly catch: (e: unknown) => E },\n): Result<T, E>\n/**\n * Runs synchronous work and captures thrown values into `Result<T, unknown>`.\n *\n * Prefer the overload with a catch mapper in application code so the error channel stays documented.\n * This overload is useful while adapting unknown external failures or during migration.\n */\nexport function tryResult<T>(\n  input: (() => Exclude<T, Promise<unknown>>) | TryResultOptions<T>,\n): Result<T, unknown>\nexport function tryResult<T, E = unknown>(\n  input: (() => Exclude<T, Promise<unknown>>) | TryResultOptions<T, E>,\n  errorFn?: (e: unknown) => E,\n): Result<T, E> {\n  const fn = typeof input === 'function' ? input : input.try\n  const catchFn = typeof input === 'function' ? errorFn : input.catch\n\n  try {\n    return ok<T, E>(fn() as T)\n  } catch (error) {\n    if (catchFn) {\n      return err<T, E>(catchFn(error))\n    }\n\n    return err<T, E>(error as E)\n  }\n}\n\n/**\n * Creates an Ok result with `undefined`.\n */\nexport function unit<E = never>(): OkResult<undefined, E> {\n  return ok<undefined, E>(undefined)\n}\n\n/**\n * Runs a `Result` at an application boundary and returns the success value.\n *\n * If the result is `Err`, this throws the error. Use it at final framework, CLI, test, or bootstrap\n * boundaries after the error channel has already been modeled with Resultar.\n */\nexport const runSync = <T, E>(result: Result<T, E>): T => result.unwrapOrThrow()\n\n/** Compatibility alias. Prefer `tryResult` in new code. */\nexport const tryCatch: typeof tryResult = tryResult\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  ? []\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[]\n        ? PR extends unknown[]\n          ? 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> =\n  Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R]\n    ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n    : Transpose<CollectResults<T>, [], Depth> extends []\n      ? [[], []]\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> : 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\n      ? V\n      : never\n    : never\n) extends (_: unknown) => infer W\n  ? [...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 []\n  ? never\n  : NeverArrayToNever extends 1\n    ? T extends [never, ...infer Rest]\n      ? [EmptyArrayToNever<Rest>] extends [never]\n        ? 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 }\n  ? L extends number\n    ? number extends L\n      ? 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> =\n  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> =\n  Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never\n\n// Combines the array of results into one result.\ntype CombineResults<T extends readonly Result<unknown, unknown>[]> =\n  IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>\n\n// Combines the array of results into one result with all errors.\ntype CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> =\n  IsLiteralArray<T> extends 1\n    ? TraverseWithAllErrors<T>\n    : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>\n\n// #endregion\n","import type {\n  Combine,\n  Dedup,\n  EmptyArrayToNever,\n  IsLiteralArray,\n  MatchHandlers,\n  MemberListOf,\n  MembersToUnion,\n} from './result.js'\nimport type {\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes,\n  InferAsyncOkTypes,\n  InferErrTypes,\n  InferOkTypes,\n} from './utils.js'\n\nimport { AbortError } from './abort-error.js'\nimport { Pipeable } from './pipe.js'\nimport { registerResultAsyncFactory } from './result-async-adapter.js'\nimport {\n  Result,\n  createEmptyResultsCollectionError,\n  err,\n  getMatchErrorHandler,\n  ok as resultOk,\n} from './result.js'\nimport { callTaggedHandler, hasTag, isTaggedHandlerMatch, matchTaggedOr } from './tagged-match.js'\nimport type {\n  CatchTagHandlerResult,\n  CatchReasonHandlerResult,\n  ErrorForTag,\n  ExcludeReasonTag,\n  ExcludeTag,\n  MatchTagHandlerResult,\n  MatchTagHandlers,\n  PartialMatchTagHandlers,\n  ReasonForTag,\n  ReasonTagsOf,\n  ReasonsOf,\n  ResultAsyncCatchReasonHandlers as CatchReasonHandlers,\n  ResultAsyncCatchTagHandlers as CatchTagHandlers,\n  TagsOf,\n  TagsWithReasonOf,\n} from './tagged-types.js'\n\ntype ResultAsyncFinalizer<T, E> = (\n  value: T | undefined,\n  error: E | undefined,\n) => void | Promise<void>\n\n/**\n * Object form accepted by `tryResultAsync`.\n *\n * Use this form when named `try` and `catch` fields make an async boundary easier to read, or when\n * you want the mapper next to the promise factory.\n */\nexport interface TryResultAsyncOptions<T, E = unknown> {\n  /**\n   * Creates the promise whose rejection should become `Err<E>`.\n   *\n   * Synchronous throws from this function are also captured.\n   */\n  readonly try: () => Promise<T>\n  /**\n   * Converts a rejected or thrown `unknown` cause into the typed Resultar error channel.\n   *\n   * If omitted, the error channel is `unknown`.\n   */\n  readonly catch?: (e: unknown) => E\n}\n\nexport interface ResultAsyncAbortSignal {\n  /**\n   * Whether the cooperative async operation has been aborted.\n   */\n  readonly aborted: boolean\n  /**\n   * Optional abort cause provided by the losing race, timeout, or caller.\n   */\n  readonly reason?: unknown\n  /**\n   * Registers an abort listener.\n   */\n  addEventListener: (\n    type: 'abort',\n    listener: () => void,\n    options?: { readonly once?: boolean },\n  ) => void\n  /**\n   * Removes an abort listener.\n   */\n  removeEventListener: (type: 'abort', listener: () => void) => void\n}\n\n/**\n * Concurrency setting for async collection helpers.\n *\n * Use a number for bounded parallelism or `'unbounded'` when every task may start immediately.\n */\nexport type ResultAsyncConcurrency = number | 'unbounded'\n\ntype HandlerOk<R> = InferOkTypes<R> | InferAsyncOkTypes<R>\ntype HandlerErr<R> = InferErrTypes<R> | InferAsyncErrTypes<R>\ntype IterableElement<T> = T extends Iterable<infer Element> ? Element : never\n/**\n * Candidate used by `ResultAsync.firstSuccessOf`.\n */\nexport type ResultAsyncCandidate = () => ResultAsync<unknown, unknown>\ntype ResultAsyncRecord = Readonly<Record<string, ResultAsync<unknown, unknown>>>\ntype CombineResultAsyncsRecord<T extends ResultAsyncRecord> = ResultAsync<\n  { readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]> },\n  InferAsyncErrTypes<T[keyof T]>\n>\ntype CombineResultAsyncsRecordWithAllErrors<T extends ResultAsyncRecord> = ResultAsync<\n  { readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]> },\n  InferAsyncErrTypes<T[keyof T]>[]\n>\ntype CombineResultAsyncsIterable<R extends ResultAsync<unknown, unknown>> = ResultAsync<\n  readonly InferAsyncOkTypes<R>[],\n  InferAsyncErrTypes<R>\n>\ntype CombineResultAsyncsIterableWithAllErrors<R extends ResultAsync<unknown, unknown>> =\n  ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>\n/**\n * Task used by race, timeout, and retry helpers.\n *\n * The signal lets the task cooperate with cancellation when another task wins or a timeout fires.\n */\nexport type ResultAsyncRaceTask<T, E> = (signal: ResultAsyncAbortSignal) => ResultAsync<T, E>\ntype ResultAsyncRaceTaskOk<Task> = Task extends ResultAsyncRaceTask<infer T, unknown> ? T : never\ntype ResultAsyncRaceTaskErr<Task> = Task extends ResultAsyncRaceTask<unknown, infer E> ? E : never\ntype ResultAsyncRaceTasksOk<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> =\n  ResultAsyncRaceTaskOk<Tasks[number]>\ntype ResultAsyncRaceTasksErr<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> =\n  ResultAsyncRaceTaskErr<Tasks[number]>\nexport interface ResultAsyncRaceHandle<T, E> {\n  /**\n   * Abort signal associated with the running task.\n   */\n  readonly signal: ResultAsyncAbortSignal\n  /**\n   * Aborts the running task with an optional reason.\n   */\n  abort: (reason?: unknown) => void\n  /**\n   * Waits for the task to settle as a ResultAsync.\n   */\n  wait: () => ResultAsync<T, E>\n}\n\n/**\n * Options for `ResultAsync.timeout`.\n */\nexport interface ResultAsyncTimeoutOptions<E> {\n  /**\n   * Creates the typed timeout error when the timeout wins.\n   */\n  readonly onTimeout: () => E\n  /**\n   * Timeout duration in milliseconds.\n   */\n  readonly timeoutMs: number\n}\n\n/**\n * Metadata passed to retry predicates, delays, callbacks, and fallback handlers.\n */\nexport interface ResultAsyncRetryContext {\n  /**\n   * Current attempt number, starting at 1.\n   */\n  readonly attempt: number\n  /**\n   * Next attempt number if another retry is scheduled.\n   */\n  readonly nextAttempt: number\n  /**\n   * Number of retries still available after the current failure.\n   */\n  readonly retriesRemaining: number\n}\n\n/**\n * Task used by `ResultAsync.retry` and `ResultAsync.retryOrElse`.\n */\nexport type ResultAsyncRetryTask<T, E> = (\n  attempt: number,\n  signal: ResultAsyncAbortSignal,\n) => ResultAsync<T, E>\ntype ResultAsyncRetryTaskOk<Task> = Task extends ResultAsyncRetryTask<infer T, unknown> ? T : never\ntype ResultAsyncRetryTaskErr<Task> = Task extends ResultAsyncRetryTask<unknown, infer E> ? E : never\ntype ResultAsyncRetryDelay = number | ((context: ResultAsyncRetryContext) => number)\nexport interface ResultAsyncRetryOptions<E> {\n  /**\n   * Delay in milliseconds before retrying. Functions receive retry context.\n   */\n  readonly delayMs?: ResultAsyncRetryDelay\n  /**\n   * Randomizes the computed delay by this percentage factor.\n   *\n   * For example, `0.5` means 50% below to 50% above the computed delay.\n   */\n  readonly jittered?: number\n  /**\n   * Side effect called after a failed attempt that will be retried.\n   */\n  readonly onRetry?: (error: E, context: ResultAsyncRetryContext) => void | Promise<void>\n  /**\n   * Optional external abort signal for the retry loop.\n   */\n  readonly signal?: ResultAsyncAbortSignal\n  /**\n   * Maximum number of retries after the initial attempt.\n   */\n  readonly times: number\n  /**\n   * Predicate deciding whether a failure is retryable.\n   */\n  readonly while?: (error: E, context: ResultAsyncRetryContext) => boolean | Promise<boolean>\n}\n\n/**\n * Options for `ResultAsync.retryOrElse`.\n */\nexport interface ResultAsyncRetryOrElseOptions<E, F, U> extends ResultAsyncRetryOptions<E> {\n  /**\n   * Fallback Resultar operation used after retry exhaustion.\n   */\n  readonly orElse: (error: E, context: ResultAsyncRetryContext) => Result<U, F> | ResultAsync<U, F>\n}\n\n/**\n * Acquires a resource for `ResultAsync.withResource`.\n */\nexport type ResultAsyncResourceAcquire<Resource, E> = (\n  signal: ResultAsyncAbortSignal,\n) => ResultAsync<Resource, E>\n/**\n * Operation accepted by `ResultAsync.withResource` use/release callbacks.\n */\nexport type ResultAsyncResourceEffect<T, E> = Result<T, E> | ResultAsync<T, E>\n/**\n * Uses an acquired resource inside `ResultAsync.withResource`.\n */\nexport type ResultAsyncResourceUse<Resource, T, E> = (\n  resource: Resource,\n  signal: ResultAsyncAbortSignal,\n) => ResultAsyncResourceEffect<T, E>\n\n/**\n * Context passed to resource release callbacks.\n */\nexport interface ResultAsyncResourceReleaseContext {\n  /**\n   * Result produced by the use phase, or undefined when acquisition failed.\n   */\n  readonly result: Result<unknown, unknown> | undefined\n  /**\n   * Abort signal shared by the resource lifecycle.\n   */\n  readonly signal: ResultAsyncAbortSignal\n}\n/**\n * Releases a resource after use, regardless of success or failure.\n */\nexport type ResultAsyncResourceRelease<Resource> = (\n  resource: Resource,\n  context: ResultAsyncResourceReleaseContext,\n) => ResultAsyncResourceEffect<unknown, unknown> | Promise<void> | void\n\n/**\n * Options for `ResultAsync.withResource`.\n */\nexport interface ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError> {\n  /**\n   * Acquires the resource.\n   */\n  readonly acquire: ResultAsyncResourceAcquire<Resource, AcquireError>\n  /**\n   * Releases the resource after use.\n   */\n  readonly release: ResultAsyncResourceRelease<Resource>\n  /**\n   * Optional external abort signal for the full lifecycle.\n   */\n  readonly signal?: ResultAsyncAbortSignal\n  /**\n   * Uses the acquired resource.\n   */\n  readonly use: ResultAsyncResourceUse<Resource, T, UseError>\n}\nexport type FirstSuccessOfAsync<Candidates extends Iterable<ResultAsyncCandidate>> = ResultAsync<\n  InferAsyncOkTypes<ReturnType<IterableElement<Candidates>>>,\n  InferAsyncErrTypes<ReturnType<IterableElement<Candidates>>>\n>\ntype ResultAsyncLoopCollected<R extends ResultAsync<unknown, unknown>> = ResultAsync<\n  readonly InferAsyncOkTypes<R>[],\n  InferAsyncErrTypes<R>\n>\ntype ResultAsyncLoopDiscarded<R extends ResultAsync<unknown, unknown>> = ResultAsync<\n  void,\n  InferAsyncErrTypes<R>\n>\ntype ResultAsyncIterated<State, R extends ResultAsync<State, unknown>> = ResultAsync<\n  State,\n  InferAsyncErrTypes<R>\n>\ntype ResultAsyncForEachCollected<R extends ResultAsync<unknown, unknown>> = ResultAsync<\n  readonly InferAsyncOkTypes<R>[],\n  InferAsyncErrTypes<R>\n>\ntype ResultAsyncForEachDiscarded<R extends ResultAsync<unknown, unknown>> = ResultAsync<\n  void,\n  InferAsyncErrTypes<R>\n>\ntype ResultAsyncValidatedAll<R extends ResultAsync<unknown, unknown>> = ResultAsync<\n  readonly InferAsyncOkTypes<R>[],\n  InferAsyncErrTypes<R>[]\n>\ntype ResultAsyncZipped<\n  Left extends ResultAsync<unknown, unknown>,\n  Right extends ResultAsync<unknown, unknown>,\n> = ResultAsync<\n  [InferAsyncOkTypes<Left>, InferAsyncOkTypes<Right>],\n  InferAsyncErrTypes<Left> | InferAsyncErrTypes<Right>\n>\ntype ResultAsyncBooleanCondition = boolean | (() => boolean)\ntype ResultAsyncConditional = Result<unknown, unknown> | ResultAsync<unknown, unknown>\ntype ResultAsyncConditionResult = Result<boolean, unknown> | ResultAsync<boolean, unknown>\ntype ResultAsyncIf<\n  ConditionErr,\n  OnTrue extends ResultAsyncConditional,\n  OnFalse extends ResultAsyncConditional,\n> = ResultAsync<\n  HandlerOk<OnTrue> | HandlerOk<OnFalse>,\n  ConditionErr | HandlerErr<OnTrue> | HandlerErr<OnFalse>\n>\ntype ResultAsyncWhen<R extends ResultAsyncConditional> = ResultAsync<\n  HandlerOk<R> | undefined,\n  HandlerErr<R>\n>\ntype ResultAsyncWhenWithCondition<\n  Condition extends ResultAsyncConditionResult,\n  R extends ResultAsyncConditional,\n> = ResultAsync<HandlerOk<R> | undefined, HandlerErr<Condition> | HandlerErr<R>>\ntype WidenLiteral<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T\n\ninterface ResultAsyncLoopOptions<\n  State,\n  BodyState extends State,\n  R extends ResultAsync<unknown, unknown>,\n> {\n  readonly body: (state: BodyState) => R\n  readonly discard?: false\n  readonly step: (state: BodyState) => State\n  readonly while: (state: State) => state is BodyState\n}\n\ninterface ResultAsyncLoopBooleanOptions<State, R extends ResultAsync<unknown, unknown>> {\n  readonly body: (state: State) => R\n  readonly discard?: false\n  readonly step: (state: State) => State\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultAsyncLoopDiscardOptions<\n  State,\n  BodyState extends State,\n  R extends ResultAsync<unknown, unknown>,\n> {\n  readonly body: (state: BodyState) => R\n  readonly discard: true\n  readonly step: (state: BodyState) => State\n  readonly while: (state: State) => state is BodyState\n}\n\ninterface ResultAsyncLoopBooleanDiscardOptions<State, R extends ResultAsync<unknown, unknown>> {\n  readonly body: (state: State) => R\n  readonly discard: true\n  readonly step: (state: State) => State\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultAsyncLoopRuntimeOptions<State, R extends ResultAsync<unknown, unknown>> {\n  readonly body: (state: State) => R\n  readonly discard?: boolean\n  readonly step: (state: State) => State\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultAsyncIterateOptions<\n  State,\n  BodyState extends State,\n  R extends ResultAsync<State, unknown>,\n> {\n  readonly body: (state: BodyState) => R\n  readonly while: (state: State) => state is BodyState\n}\n\ninterface ResultAsyncIterateBooleanOptions<State, R extends ResultAsync<State, unknown>> {\n  readonly body: (state: State) => R\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultAsyncIterateRuntimeOptions<State, R extends ResultAsync<State, unknown>> {\n  readonly body: (state: State) => R\n  readonly while: (state: State) => boolean\n}\n\ninterface ResultAsyncForEachOptions {\n  readonly concurrency?: ResultAsyncConcurrency\n  readonly discard?: false\n}\n\ninterface ResultAsyncForEachDiscardOptions {\n  readonly concurrency?: ResultAsyncConcurrency\n  readonly discard: true\n}\n\ninterface ResultAsyncForEachRuntimeOptions {\n  readonly concurrency?: ResultAsyncConcurrency\n  readonly discard?: boolean\n}\n\ninterface ResultAsyncValidateAllOptions {\n  readonly concurrency?: ResultAsyncConcurrency\n}\n\ninterface ResultAsyncIfOptions<\n  OnTrue extends ResultAsyncConditional,\n  OnFalse extends ResultAsyncConditional,\n> {\n  readonly onFalse: () => OnFalse\n  readonly onTrue: () => OnTrue\n}\n\nfunction isTryResultAsyncOptions<T, E>(\n  input: Promise<T> | (() => Promise<T>) | TryResultAsyncOptions<T, E>,\n): input is TryResultAsyncOptions<T, E> {\n  // Stryker disable next-line all: guards prevent applying `in` to null/non-objects in invalid runtime calls.\n  return typeof input === 'object' && input !== null && 'try' in input\n}\n\nconst combineResultAsyncList = <T, E>(\n  asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E> =>\n  ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen((resultList) =>\n    Result.combine(resultList),\n  )\n\nconst collectResultAsyncRecord = async (\n  asyncResultRecord: ResultAsyncRecord,\n): Promise<Record<string, Result<unknown, unknown>>> => {\n  const entries = Object.entries(asyncResultRecord)\n  const resultList = await Promise.all(entries.map((entry) => entry[1]))\n  const resultRecord: Record<string, Result<unknown, unknown>> = {}\n\n  for (const [index, [key]] of entries.entries()) {\n    const result = resultList[index]\n\n    // Stryker disable next-line all: Promise.all preserves one result for each Object.entries item.\n    if (result !== undefined) {\n      resultRecord[key] = result\n    }\n  }\n\n  return resultRecord\n}\n\nconst combineResultAsyncRecord = <T extends ResultAsyncRecord>(\n  asyncResultRecord: T,\n): CombineResultAsyncsRecord<T> => {\n  const promise = collectResultAsyncRecord(asyncResultRecord).then((resultRecord) =>\n    Result.combine(resultRecord),\n  )\n  return new ResultAsync(promise) as CombineResultAsyncsRecord<T>\n}\n\nconst combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E[]> =>\n  ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen((resultList) =>\n    Result.combineWithAllErrors(resultList),\n  ) as ResultAsync<T[], E[]>\n\nconst combineResultAsyncRecordWithAllErrors = <T extends ResultAsyncRecord>(\n  asyncResultRecord: T,\n): CombineResultAsyncsRecordWithAllErrors<T> => {\n  const promise = collectResultAsyncRecord(asyncResultRecord).then((resultRecord) =>\n    Result.combineWithAllErrors(resultRecord),\n  )\n  return new ResultAsync(promise) as CombineResultAsyncsRecordWithAllErrors<T>\n}\n\nconst isIterable = (value: unknown): value is Iterable<unknown> =>\n  // Stryker disable next-line all: invalid null input still fails outside the iterable branch; this guard keeps the hot check explicit.\n  value !== null &&\n  // Stryker disable next-line all: iterable functions are valid iterables, but normal collection tests cover object iterables.\n  (typeof value === 'object' || typeof value === 'function') &&\n  typeof (value as { readonly [Symbol.iterator]?: unknown })[Symbol.iterator] === 'function'\n\ninterface IndexedResultAsyncError<E> {\n  readonly error: E\n  readonly index: number\n}\n\nconst createIllegalArgumentException = (message: string): Error => {\n  const error = new Error(message)\n  error.name = 'IllegalArgumentException'\n\n  return error\n}\n\nconst createInvalidResultAsyncConcurrencyError = (): Error =>\n  createIllegalArgumentException(\n    'ResultAsync concurrency must be a positive integer or \"unbounded\"',\n  )\n\nconst normalizeResultAsyncConcurrency = (concurrency?: ResultAsyncConcurrency): number => {\n  if (concurrency === undefined) {\n    return 1\n  }\n\n  if (concurrency === 'unbounded') {\n    return Number.POSITIVE_INFINITY\n  }\n\n  if (Number.isInteger(concurrency) && concurrency > 0) {\n    return concurrency\n  }\n\n  throw createInvalidResultAsyncConcurrencyError()\n}\n\nconst toResultAsyncRejectionError = (error: unknown): Error =>\n  error instanceof Error ? error : new Error(String(error))\n\nconst sortIndexedResultAsyncErrors = <E>(\n  errors: readonly IndexedResultAsyncError<E>[],\n): IndexedResultAsyncError<E>[] => [...errors].toSorted((left, right) => left.index - right.index)\n\ninterface ResultAsyncTraversalState<T, E> {\n  activeCount: number\n  readonly errors: IndexedResultAsyncError<E>[]\n  iteratorDone: boolean\n  nextIndex: number\n  stopScheduling: boolean\n  readonly values: T[]\n}\n\ninterface RunConcurrentResultAsyncItemsOptions<Item, T, E, Output, Failure> {\n  readonly concurrency: ResultAsyncConcurrency | undefined\n  readonly finish: (state: ResultAsyncTraversalState<T, E>) => Result<Output, Failure> | undefined\n  readonly items: Iterable<Item>\n  readonly onResult: (\n    result: Result<T, E>,\n    index: number,\n    state: ResultAsyncTraversalState<T, E>,\n  ) => void\n  readonly run: (value: Item, index: number) => ResultAsync<T, E>\n}\n\nconst createResultAsyncTraversalState = <T, E>(): ResultAsyncTraversalState<T, E> => ({\n  activeCount: 0,\n  errors: [],\n  iteratorDone: false,\n  nextIndex: 0,\n  stopScheduling: false,\n  values: [],\n})\n\nconst runConcurrentResultAsyncItems = <Item, T, E, Output, Failure>(\n  options: RunConcurrentResultAsyncItemsOptions<Item, T, E, Output, Failure>,\n): Promise<Result<Output, Failure>> =>\n  Promise.try(async () => {\n    const concurrency = normalizeResultAsyncConcurrency(options.concurrency)\n    const iterator = options.items[Symbol.iterator]()\n    const state = createResultAsyncTraversalState<T, E>()\n\n    return new Promise<Result<Output, Failure>>((resolve, reject) => {\n      let settled = false\n\n      const rejectOnce = (error: unknown): void => {\n        // Stryker disable next-line all: idempotent Promise rejection guard; repeated reject calls are ignored.\n        if (!settled) {\n          // Stryker disable next-line all: setting the guard prevents later state updates after rejection.\n          settled = true\n          reject(toResultAsyncRejectionError(error))\n        }\n      }\n\n      const resolveOnce = (result: Result<Output, Failure>): void => {\n        // Stryker disable next-line all: idempotent Promise resolution guard; repeated resolve calls are ignored.\n        if (!settled) {\n          // Stryker disable next-line all: setting the guard prevents later state updates after resolution.\n          settled = true\n          resolve(result)\n        }\n      }\n\n      const finishIfDone = (): void => {\n        const result = options.finish(state)\n\n        if (result !== undefined) {\n          resolveOnce(result)\n        }\n      }\n\n      const readNext = (): IteratorResult<Item> | undefined => {\n        try {\n          return iterator.next()\n        } catch (error) {\n          rejectOnce(error)\n          return undefined\n        }\n      }\n\n      const schedule = (): void => {\n        // Stryker disable next-line all: avoid rescheduling after rejectOnce/resolveOnce settled the traversal.\n        if (settled) {\n          return\n        }\n\n        if (state.stopScheduling) {\n          finishIfDone()\n          return\n        }\n\n        while (!state.iteratorDone && state.activeCount < concurrency) {\n          const next = readNext()\n\n          // Stryker disable next-line all: undefined means iterator.next threw and rejectOnce already settled.\n          if (next === undefined) {\n            return\n          }\n\n          if (next.done === true) {\n            state.iteratorDone = true\n            break\n          }\n\n          const currentIndex = state.nextIndex\n          state.nextIndex += 1\n          startItem(next.value, currentIndex)\n        }\n\n        finishIfDone()\n      }\n\n      const startItem = (item: Item, currentIndex: number): void => {\n        state.activeCount += 1\n\n        try {\n          const resultAsync = options.run(item, currentIndex)\n\n          void Promise.resolve(resultAsync)\n            .then((result) => {\n              options.onResult(result, currentIndex, state)\n            }, rejectOnce)\n            .finally(() => {\n              // Stryker disable next-line all: skip bookkeeping after rejectOnce/resolveOnce settled the promise.\n              if (settled) {\n                return\n              }\n\n              state.activeCount -= 1\n              schedule()\n              finishIfDone()\n            })\n        } catch (error) {\n          rejectOnce(error)\n        }\n      }\n\n      schedule()\n    })\n  })\n\nconst createResultAsyncRetryAbortError = (signal: ResultAsyncAbortSignal): AbortError =>\n  signal.reason === undefined\n    ? new AbortError('ResultAsync retry aborted')\n    : new AbortError('ResultAsync retry aborted', { cause: signal.reason })\n\nconst createResultAsyncResourceAbortError = (signal: ResultAsyncAbortSignal): AbortError =>\n  signal.reason === undefined\n    ? new AbortError('ResultAsync resource scope aborted')\n    : new AbortError('ResultAsync resource scope aborted', { cause: signal.reason })\n\nconst validateResultAsyncRetryTimes = (times: number): void => {\n  if (!Number.isInteger(times) || times < 0) {\n    throw createIllegalArgumentException('ResultAsync retry times must be a non-negative integer')\n  }\n}\n\nconst validateResultAsyncRetryDelayValue = (delayMs: number): void => {\n  if (!Number.isFinite(delayMs) || delayMs < 0) {\n    throw createIllegalArgumentException(\n      'ResultAsync retry delayMs must be a non-negative finite number',\n    )\n  }\n}\n\nconst validateResultAsyncRetryJittered = (jittered: number): void => {\n  if (!Number.isFinite(jittered) || jittered < 0) {\n    throw createIllegalArgumentException(\n      'ResultAsync retry jittered must be a non-negative finite number',\n    )\n  }\n}\n\nconst validateResultAsyncRetryJitterRandomValue = (value: number): void => {\n  if (!Number.isFinite(value) || value < 0 || value > 1) {\n    throw createIllegalArgumentException(\n      'ResultAsync retry jitter random value must be a finite number between 0 and 1',\n    )\n  }\n}\n\nconst validateResultAsyncRetryStaticJittered = (jittered: number | undefined): void => {\n  if (jittered !== undefined) {\n    validateResultAsyncRetryJittered(jittered)\n  }\n}\n\nconst validateResultAsyncRetryStaticDelay = (delay: ResultAsyncRetryDelay | undefined): void => {\n  if (typeof delay === 'number') {\n    validateResultAsyncRetryDelayValue(delay)\n  }\n}\n\nconst waitResultAsyncRetryDelay = async (\n  delayMs: number,\n  signal: ResultAsyncAbortSignal,\n): Promise<Result<void, AbortError>> => {\n  if (signal.aborted) {\n    return Result.err(createResultAsyncRetryAbortError(signal))\n  }\n\n  if (delayMs === 0) {\n    return Result.ok(undefined)\n  }\n\n  return new Promise((resolve) => {\n    const timeout = setTimeout(() => {\n      signal.removeEventListener('abort', abort)\n      resolve(Result.ok(undefined))\n    }, delayMs)\n    const abort = (): void => {\n      clearTimeout(timeout)\n      resolve(Result.err(createResultAsyncRetryAbortError(signal)))\n    }\n\n    signal.addEventListener('abort', abort, { once: true })\n  })\n}\n\n// Retry keeps branches inline to avoid helper calls in the retry loop.\n// fallow-ignore-next-line complexity\nconst runResultAsyncRetryAttempts = async <T, E, U, F>(\n  task: ResultAsyncRetryTask<T, E>,\n  options: ResultAsyncRetryOptions<E>,\n  recover: (error: E, context: ResultAsyncRetryContext) => Result<U, F> | ResultAsync<U, F>,\n): Promise<Result<T | U, F | AbortError>> => {\n  validateResultAsyncRetryTimes(options.times)\n  validateResultAsyncRetryStaticDelay(options.delayMs)\n  validateResultAsyncRetryStaticJittered(options.jittered)\n\n  const signal: ResultAsyncAbortSignal = options.signal ?? new AbortController().signal\n  let attempt = 0\n\n  while (true) {\n    if (signal.aborted) {\n      return Result.err(createResultAsyncRetryAbortError(signal))\n    }\n\n    // eslint-disable-next-line no-await-in-loop\n    const result = await task(attempt, signal)\n\n    if (result.isOk()) {\n      return Result.ok(result.value)\n    }\n\n    const context: ResultAsyncRetryContext = {\n      attempt,\n      nextAttempt: attempt + 1,\n      retriesRemaining: Math.max(0, options.times - attempt),\n    }\n\n    const shouldRetry = options.while\n    const canRetryError =\n      shouldRetry === undefined\n        ? true\n        : // eslint-disable-next-line no-await-in-loop\n          await shouldRetry(result.error, context)\n\n    if (!canRetryError || attempt >= options.times) {\n      const recovered = recover(result.error, context)\n      return recovered instanceof ResultAsync ? recovered : recovered\n    }\n\n    const onRetry = options.onRetry\n\n    // Stryker disable next-line all: skip a needless function call and await when no retry hook exists.\n    if (onRetry !== undefined) {\n      try {\n        // eslint-disable-next-line no-await-in-loop\n        await onRetry(result.error, context)\n      } catch {\n        /* empty */\n      }\n    }\n\n    let delayMs =\n      typeof options.delayMs === 'function' ? options.delayMs(context) : (options.delayMs ?? 0)\n    validateResultAsyncRetryDelayValue(delayMs)\n\n    const jittered = options.jittered\n\n    if (jittered !== undefined && jittered !== 0 && delayMs !== 0) {\n      const random = Math.random()\n      validateResultAsyncRetryJitterRandomValue(random)\n\n      const range = delayMs * jittered\n      const min = Math.max(0, delayMs - range)\n      const max = delayMs + range\n      delayMs = min + (max - min) * random\n    }\n\n    // eslint-disable-next-line no-await-in-loop\n    const delayResult = await waitResultAsyncRetryDelay(delayMs, signal)\n\n    if (delayResult.isErr()) {\n      return Result.err(delayResult.error)\n    }\n\n    attempt += 1\n  }\n}\n\nconst retryResultAsyncTask = <T, E>(\n  task: ResultAsyncRetryTask<T, E>,\n  options: ResultAsyncRetryOptions<E>,\n): ResultAsync<T, E | AbortError> =>\n  new ResultAsync(\n    runResultAsyncRetryAttempts<T, E, never, E>(task, options, (error) => Result.err(error)),\n  )\n\nconst retryOrElseResultAsyncTask = <T, E, U, F>(\n  task: ResultAsyncRetryTask<T, E>,\n  options: ResultAsyncRetryOrElseOptions<E, F, U>,\n): ResultAsync<T | U, F | AbortError> =>\n  new ResultAsync(\n    runResultAsyncRetryAttempts<T, E, U, F>(task, options, (error, context) =>\n      options.orElse(error, context),\n    ),\n  )\n\nconst callResultAsyncResourceRelease = async <Resource>(\n  release: ResultAsyncResourceRelease<Resource>,\n  resource: Resource,\n  context: ResultAsyncResourceReleaseContext,\n): Promise<void> => {\n  try {\n    await release(resource, context)\n  } catch {\n    /* empty */\n  }\n}\n\nconst runResultAsyncWithResource = async <Resource, AcquireError, T, UseError>(\n  options: ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError>,\n): Promise<Result<T, AcquireError | UseError | AbortError>> => {\n  const signal: ResultAsyncAbortSignal = options.signal ?? new AbortController().signal\n\n  if (signal.aborted) {\n    return Result.err(createResultAsyncResourceAbortError(signal))\n  }\n\n  const acquired = await options.acquire(signal)\n\n  if (acquired.isErr()) {\n    return Result.err(acquired.error)\n  }\n\n  let result: Result<T, UseError | AbortError> | undefined = undefined\n\n  try {\n    if (signal.aborted) {\n      result = Result.err(createResultAsyncResourceAbortError(signal))\n      return result\n    }\n\n    result = await toResultAsync(options.use(acquired.value, signal))\n\n    return result\n  } finally {\n    await callResultAsyncResourceRelease(options.release, acquired.value, { result, signal })\n  }\n}\n\nconst withResultAsyncResource = <Resource, AcquireError, T, UseError>(\n  options: ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError>,\n): ResultAsync<T, AcquireError | UseError | AbortError> =>\n  new ResultAsync(runResultAsyncWithResource(options))\n\nconst validateAllResultAsyncItems = <Item, R extends ResultAsync<unknown, unknown>>(\n  items: Iterable<Item>,\n  f: (value: Item, index: number) => R,\n  options?: ResultAsyncValidateAllOptions,\n): ResultAsyncValidatedAll<R> => {\n  const promise: Promise<Result<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>> =\n    runConcurrentResultAsyncItems({\n      concurrency: options?.concurrency,\n      finish: (state) => {\n        if (!state.iteratorDone || state.activeCount > 0) {\n          return undefined\n        }\n\n        if (state.errors.length > 0) {\n          return Result.err<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>(\n            sortIndexedResultAsyncErrors(state.errors).map((entry) => entry.error),\n          )\n        }\n\n        return Result.ok<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>(state.values)\n      },\n      items,\n      onResult: (result, currentIndex, state) => {\n        if (result.isErr()) {\n          state.errors.push({ error: result.error, index: currentIndex })\n          return\n        }\n\n        state.values[currentIndex] = result.value\n      },\n      run: f as (\n        value: Item,\n        index: number,\n      ) => ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R>>,\n    })\n\n  return new ResultAsync(promise) as ResultAsyncValidatedAll<R>\n}\n\nconst firstSuccessOfAsyncCandidates = <Candidates extends Iterable<ResultAsyncCandidate>>(\n  candidates: Candidates,\n): FirstSuccessOfAsync<Candidates> => {\n  const promise = Promise.try(async () => {\n    let latestError: Result<unknown, unknown> | undefined = undefined\n\n    for (const candidate of candidates) {\n      // eslint-disable-next-line no-await-in-loop\n      const result = await candidate()\n\n      if (result.isOk()) {\n        return result\n      }\n\n      latestError = result\n    }\n\n    if (latestError === undefined) {\n      throw createEmptyResultsCollectionError()\n    }\n\n    return latestError\n  })\n\n  return new ResultAsync(promise) as FirstSuccessOfAsync<Candidates>\n}\n\nconst getReason = (value: unknown): unknown => (value as { readonly reason?: unknown }).reason\n\ninterface StartedRaceTask<T, E> {\n  readonly controller: AbortController\n  readonly result: ResultAsync<T, E>\n  readonly settled: Promise<{ readonly index: number; readonly result: Result<T, E> }>\n}\n\nconst createRaceAbortReason = (): AbortError => new AbortError('ResultAsync race loser interrupted')\n\nconst startRaceTask = <T, E>(\n  task: ResultAsyncRaceTask<T, E>,\n  index: number,\n): StartedRaceTask<T, E> => {\n  const controller = new AbortController()\n  const result = task(controller.signal)\n  const settled = Promise.resolve(result).then((taskResult) => ({ index, result: taskResult }))\n\n  return { controller, result, settled }\n}\n\nconst createRaceHandle = <T, E>(task: StartedRaceTask<T, E>): ResultAsyncRaceHandle<T, E> => ({\n  get signal() {\n    return task.controller.signal\n  },\n  abort(reason = createRaceAbortReason()) {\n    task.controller.abort(reason)\n  },\n  wait() {\n    return task.result\n  },\n})\n\ninterface RaceSettlementState {\n  settled: boolean\n}\n\ninterface RaceSuccessState extends RaceSettlementState {\n  completedCount: number\n  completedIndexes: Set<number>\n  latestError: Result<unknown, unknown> | undefined\n}\n\ninterface RaceFirstObserverContext<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> {\n  readonly resolve: (\n    result: Result<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>,\n  ) => void\n  readonly startedTasks: readonly StartedRaceTask<unknown, unknown>[]\n  readonly state: RaceSettlementState\n}\n\ninterface RaceSuccessObserverContext<\n  Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[],\n> {\n  readonly resolve: (\n    result: Result<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>,\n  ) => void\n  readonly startedTasks: readonly StartedRaceTask<unknown, unknown>[]\n  readonly state: RaceSuccessState\n}\n\ntype RaceTaskResolve<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> = (\n  result: Result<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>,\n) => void\n\nconst observeRaceFirstTask = <Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]>(\n  task: StartedRaceTask<unknown, unknown>,\n  context: RaceFirstObserverContext<Tasks>,\n): void => {\n  void task.settled.then(({ index, result }) => {\n    if (context.state.settled) {\n      return\n    }\n\n    context.state.settled = true\n    const startedTasks = context.startedTasks\n\n    // Stryker disable next-line all: `<= length` only adds one guarded undefined iteration for noUncheckedIndexedAccess.\n    for (let loserIndex = 0; loserIndex < startedTasks.length; loserIndex += 1) {\n      const loser = startedTasks[loserIndex]\n\n      // Stryker disable next-line all: loop bounds guarantee the task; guard satisfies noUncheckedIndexedAccess without tuple allocation.\n      if (loser === undefined) {\n        /* empty */\n      } else if (loserIndex !== index) {\n        loser.controller.abort(createRaceAbortReason())\n      }\n    }\n\n    context.resolve(result as Result<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>)\n  })\n}\n\nconst observeRaceSuccessTask = <Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]>(\n  task: StartedRaceTask<unknown, unknown>,\n  context: RaceSuccessObserverContext<Tasks>,\n): void => {\n  void task.settled.then(({ index, result }) => {\n    // Stryker disable next-line all: ignore late settlements after the race already resolved.\n    if (context.state.settled) {\n      return\n    }\n\n    context.state.completedIndexes.add(index)\n\n    if (result.isOk()) {\n      // Stryker disable next-line all: marks the race as resolved before aborting pending losers.\n      context.state.settled = true\n      const startedTasks = context.startedTasks\n\n      // Stryker disable next-line all: `<= length` only adds one guarded undefined iteration for noUncheckedIndexedAccess.\n      for (let loserIndex = 0; loserIndex < startedTasks.length; loserIndex += 1) {\n        const loser = startedTasks[loserIndex]\n\n        // Stryker disable next-line all: loop bounds guarantee the task; guard satisfies noUncheckedIndexedAccess without tuple allocation.\n        if (loser === undefined) {\n          /* empty */\n        } else if (!context.state.completedIndexes.has(loserIndex)) {\n          loser.controller.abort(createRaceAbortReason())\n        }\n      }\n\n      context.resolve(\n        result as Result<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>,\n      )\n      return\n    }\n\n    context.state.completedCount += 1\n    context.state.latestError = result\n\n    if (context.state.completedCount === context.startedTasks.length) {\n      // Stryker disable next-line all: all tasks failed, so future late settlements must be ignored.\n      context.state.settled = true\n      context.resolve(\n        context.state.latestError as Result<\n          ResultAsyncRaceTasksOk<Tasks>,\n          ResultAsyncRaceTasksErr<Tasks>\n        >,\n      )\n    }\n  })\n}\n\nconst observeRaceResultAsyncTasks = <\n  Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[],\n  Context,\n>(\n  tasks: Tasks,\n  createContext: (\n    resolve: RaceTaskResolve<Tasks>,\n    startedTasks: readonly StartedRaceTask<unknown, unknown>[],\n  ) => Context,\n  observeTask: (task: StartedRaceTask<unknown, unknown>, context: Context) => void,\n): ResultAsync<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>> => {\n  const taskList = [...tasks]\n\n  if (taskList.length === 0) {\n    return new ResultAsync(\n      Promise.resolve(Result.err(createEmptyResultsCollectionError())),\n    ) as ResultAsync<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>\n  }\n\n  const promise = new Promise<\n    Result<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>\n  >((resolve) => {\n    const startedTasks = taskList.map((task, index) => startRaceTask(task, index))\n    const context = createContext(resolve, startedTasks)\n\n    for (const task of startedTasks) {\n      observeTask(task, context)\n    }\n  })\n\n  return new ResultAsync(promise)\n}\n\nconst raceResultAsyncTasks = <Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]>(\n  tasks: Tasks,\n): ResultAsync<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>> =>\n  observeRaceResultAsyncTasks<Tasks, RaceSuccessObserverContext<Tasks>>(\n    tasks,\n    (resolve, startedTasks) => ({\n      resolve,\n      startedTasks,\n      state: {\n        completedCount: 0,\n        completedIndexes: new Set<number>(),\n        latestError: undefined,\n        // Stryker disable next-line all: explicit false and missing value are equivalent before first settlement.\n        settled: false,\n      },\n    }),\n    observeRaceSuccessTask,\n  )\n\nconst loopResultAsync = <State, R extends ResultAsync<unknown, unknown>>(\n  initial: State,\n  options: ResultAsyncLoopRuntimeOptions<State, R>,\n): ResultAsyncLoopCollected<R> | ResultAsyncLoopDiscarded<R> => {\n  const promise: Promise<Result<readonly InferAsyncOkTypes<R>[] | void, InferAsyncErrTypes<R>>> =\n    Promise.try(async () => {\n      let state = initial\n\n      if (options.discard === true) {\n        while (options.while(state)) {\n          // eslint-disable-next-line no-await-in-loop\n          const result = await options.body(state)\n\n          if (result.isErr()) {\n            return Result.err(result.error as InferAsyncErrTypes<R>)\n          }\n\n          state = options.step(state)\n        }\n\n        return Result.ok<void, InferAsyncErrTypes<R>>(undefined)\n      }\n\n      const values: InferAsyncOkTypes<R>[] = []\n\n      while (options.while(state)) {\n        // eslint-disable-next-line no-await-in-loop\n        const result = await options.body(state)\n\n        if (result.isErr()) {\n          return Result.err(result.error as InferAsyncErrTypes<R>)\n        }\n\n        values.push(result.value as InferAsyncOkTypes<R>)\n        state = options.step(state)\n      }\n\n      return Result.ok<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>(values)\n    })\n\n  return new ResultAsync(promise) as ResultAsyncLoopCollected<R> | ResultAsyncLoopDiscarded<R>\n}\n\nconst iterateResultAsync = <State, R extends ResultAsync<State, unknown>>(\n  initial: State,\n  options: ResultAsyncIterateRuntimeOptions<State, R>,\n): ResultAsyncIterated<State, R> => {\n  const promise = Promise.try(async () => {\n    let state = initial\n\n    while (options.while(state)) {\n      // eslint-disable-next-line no-await-in-loop\n      const result = await options.body(state)\n\n      if (result.isErr()) {\n        return Result.err(result.error as InferAsyncErrTypes<R>)\n      }\n\n      state = result.value\n    }\n\n    return Result.ok<State, InferAsyncErrTypes<R>>(state)\n  })\n\n  return new ResultAsync(promise) as ResultAsyncIterated<State, R>\n}\n\nconst forEachResultAsync = <Item, R extends ResultAsync<unknown, unknown>>(\n  items: Iterable<Item>,\n  f: (value: Item, index: number) => R,\n  options?: ResultAsyncForEachRuntimeOptions,\n): ResultAsyncForEachCollected<R> | ResultAsyncForEachDiscarded<R> => {\n  if (options?.discard === true) {\n    const promise: Promise<Result<void, InferAsyncErrTypes<R>>> = runConcurrentResultAsyncItems({\n      concurrency: options.concurrency,\n      finish: (state) => {\n        if (state.activeCount > 0) {\n          return undefined\n        }\n\n        const firstError = sortIndexedResultAsyncErrors(state.errors)[0]\n\n        if (firstError !== undefined) {\n          return Result.err<void, InferAsyncErrTypes<R>>(firstError.error)\n        }\n\n        return Result.ok<void, InferAsyncErrTypes<R>>(undefined)\n      },\n      items,\n      onResult: (result, currentIndex, state) => {\n        if (result.isErr()) {\n          state.errors.push({ error: result.error, index: currentIndex })\n          state.stopScheduling = true\n        }\n      },\n      run: f as (\n        value: Item,\n        index: number,\n      ) => ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R>>,\n    })\n\n    return new ResultAsync(promise) as ResultAsyncForEachDiscarded<R>\n  }\n\n  const promise: Promise<Result<readonly InferAsyncOkTypes<R>[] | void, InferAsyncErrTypes<R>>> =\n    runConcurrentResultAsyncItems({\n      concurrency: options?.concurrency,\n      finish: (state) => {\n        if (state.activeCount > 0) {\n          return undefined\n        }\n\n        const firstError = sortIndexedResultAsyncErrors(state.errors)[0]\n\n        if (firstError !== undefined) {\n          return Result.err<readonly InferAsyncOkTypes<R>[] | void, InferAsyncErrTypes<R>>(\n            firstError.error,\n          )\n        }\n\n        return Result.ok<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>(state.values)\n      },\n      items,\n      onResult: (result, currentIndex, state) => {\n        if (result.isErr()) {\n          state.errors.push({ error: result.error, index: currentIndex })\n          state.stopScheduling = true\n          return\n        }\n\n        state.values[currentIndex] = result.value\n      },\n      run: f as (\n        value: Item,\n        index: number,\n      ) => ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R>>,\n    })\n\n  return new ResultAsync(promise) as ResultAsyncForEachCollected<R> | ResultAsyncForEachDiscarded<R>\n}\n\nconst resolveResultAsyncBooleanCondition = (condition: ResultAsyncBooleanCondition): boolean =>\n  typeof condition === 'function' ? condition() : condition\n\nconst toResultAsync = <R extends ResultAsyncConditional>(\n  result: R,\n): ResultAsync<HandlerOk<R>, HandlerErr<R>> => {\n  // Stryker disable next-line all: preserve existing ResultAsync instead of wrapping it in another thenable.\n  if (result instanceof ResultAsync) {\n    return result as ResultAsync<HandlerOk<R>, HandlerErr<R>>\n  }\n\n  return new ResultAsync(Promise.resolve(result as Result<HandlerOk<R>, HandlerErr<R>>))\n}\n\nconst ifResultAsync = <\n  OnTrue extends ResultAsyncConditional,\n  OnFalse extends ResultAsyncConditional,\n>(\n  condition: ResultAsyncBooleanCondition,\n  options: ResultAsyncIfOptions<OnTrue, OnFalse>,\n): ResultAsyncIf<never, OnTrue, OnFalse> => {\n  const promise: Promise<\n    Result<HandlerOk<OnTrue> | HandlerOk<OnFalse>, HandlerErr<OnTrue> | HandlerErr<OnFalse>>\n  > = Promise.try(async () => {\n    const result = resolveResultAsyncBooleanCondition(condition)\n      ? options.onTrue()\n      : options.onFalse()\n\n    return (await toResultAsync(result)) as Result<\n      HandlerOk<OnTrue> | HandlerOk<OnFalse>,\n      HandlerErr<OnTrue> | HandlerErr<OnFalse>\n    >\n  })\n\n  return new ResultAsync(promise) as ResultAsyncIf<never, OnTrue, OnFalse>\n}\n\nconst ifResultAsyncWithCondition = <\n  Condition extends ResultAsyncConditionResult,\n  OnTrue extends ResultAsyncConditional,\n  OnFalse extends ResultAsyncConditional,\n>(\n  condition: Condition,\n  options: ResultAsyncIfOptions<OnTrue, OnFalse>,\n): ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse> => {\n  const promise: Promise<\n    Result<\n      HandlerOk<OnTrue> | HandlerOk<OnFalse>,\n      HandlerErr<Condition> | HandlerErr<OnTrue> | HandlerErr<OnFalse>\n    >\n  > = Promise.try(async () => {\n    const conditionResult = await toResultAsync(condition)\n\n    if (conditionResult.isErr()) {\n      return Result.err(conditionResult.error)\n    }\n\n    const result = conditionResult.value ? options.onTrue() : options.onFalse()\n\n    return (await toResultAsync(result)) as Result<\n      HandlerOk<OnTrue> | HandlerOk<OnFalse>,\n      HandlerErr<Condition> | HandlerErr<OnTrue> | HandlerErr<OnFalse>\n    >\n  })\n\n  return new ResultAsync(promise) as ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse>\n}\n\nconst whenResultAsync = <R extends ResultAsyncConditional>(\n  condition: ResultAsyncBooleanCondition,\n  body: () => R,\n): ResultAsyncWhen<R> => {\n  const promise: Promise<Result<HandlerOk<R> | undefined, HandlerErr<R>>> = Promise.try(\n    async () => {\n      if (!resolveResultAsyncBooleanCondition(condition)) {\n        return Result.ok<HandlerOk<R> | undefined, HandlerErr<R>>(undefined)\n      }\n\n      return (await toResultAsync(body())) as Result<HandlerOk<R> | undefined, HandlerErr<R>>\n    },\n  )\n\n  return new ResultAsync(promise) as ResultAsyncWhen<R>\n}\n\nconst whenResultAsyncWithConditionByPredicate = <\n  Condition extends ResultAsyncConditionResult,\n  R extends ResultAsyncConditional,\n>(\n  condition: Condition,\n  body: () => R,\n  predicate: (condition: boolean) => boolean,\n): ResultAsyncWhenWithCondition<Condition, R> => {\n  const promise: Promise<Result<HandlerOk<R> | undefined, HandlerErr<Condition> | HandlerErr<R>>> =\n    Promise.try(async () => {\n      const conditionResult = await toResultAsync(condition)\n\n      if (conditionResult.isErr()) {\n        return Result.err(conditionResult.error)\n      }\n\n      if (!predicate(conditionResult.value)) {\n        return Result.ok<HandlerOk<R> | undefined, HandlerErr<Condition> | HandlerErr<R>>(undefined)\n      }\n\n      return (await toResultAsync(body())) as Result<\n        HandlerOk<R> | undefined,\n        HandlerErr<Condition> | HandlerErr<R>\n      >\n    })\n\n  return new ResultAsync(promise) as ResultAsyncWhenWithCondition<Condition, R>\n}\n\nconst whenResultAsyncWithCondition = <\n  Condition extends ResultAsyncConditionResult,\n  R extends ResultAsyncConditional,\n>(\n  condition: Condition,\n  body: () => R,\n): ResultAsyncWhenWithCondition<Condition, R> =>\n  whenResultAsyncWithConditionByPredicate(condition, body, (value) => value)\n\nconst unlessResultAsync = <R extends ResultAsyncConditional>(\n  condition: ResultAsyncBooleanCondition,\n  body: () => R,\n): ResultAsyncWhen<R> => whenResultAsync(() => !resolveResultAsyncBooleanCondition(condition), body)\n\nconst unlessResultAsyncWithCondition = <\n  Condition extends ResultAsyncConditionResult,\n  R extends ResultAsyncConditional,\n>(\n  condition: Condition,\n  body: () => R,\n): ResultAsyncWhenWithCondition<Condition, R> =>\n  whenResultAsyncWithConditionByPredicate(condition, body, (value) => !value)\n\ninterface MatchResolvedResultTagsOptions<T, E, A, F> {\n  readonly fallback: (error: E) => F\n  readonly handlers: object\n  readonly ok: (value: T) => A\n  readonly result: Result<T, E>\n}\n\nconst matchResolvedResultTags = <T, E, A, R, F>({\n  fallback,\n  handlers,\n  ok,\n  result,\n}: MatchResolvedResultTagsOptions<T, E, A, F>): A | R | F => {\n  if (result.isOk()) {\n    return ok(result.value)\n  }\n\n  return matchTaggedOr<E, R, F>(result.error, handlers, fallback)\n}\n\nconst callAsyncSideEffect = async (effect: () => void | Promise<void>): Promise<void> => {\n  try {\n    await effect()\n  } catch {\n    /* empty */\n  }\n}\n\nexport class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>, AsyncDisposable {\n  private readonly innerPromise: Promise<Result<T, E>>\n  private readonly finalizer: (value: unknown, error: unknown) => void | Promise<void>\n  private disposed = false\n\n  /**\n   * Creates an async disposable wrapper around a ResultAsync promise.\n   */\n  public constructor(res: Promise<Result<T, E>>, finalizer: ResultAsyncFinalizer<T, E>) {\n    this.innerPromise = res\n    this.finalizer = finalizer as (value: unknown, error: unknown) => void | Promise<void>\n  }\n\n  /**\n   * PromiseLike integration. Resolves to the wrapped Result.\n   */\n  public then<A, B>(\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   * Runs the finalizer once after the wrapped Result resolves.\n   *\n   * Finalizer exceptions and rejections are intentionally swallowed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.disposed) {\n      return\n    }\n\n    this.disposed = true\n    const result = await this.innerPromise\n\n    try {\n      await this.finalizer(\n        result.isOk() ? result.value : undefined,\n        result.isErr() ? result.error : undefined,\n      )\n    } catch {\n      /* empty */\n    }\n  }\n}\n\n/**\n * Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.\n * This class provides a way to handle asynchronous operations that may succeed with a value of type T\n * or fail with an error of type E.\n *\n * @template T - The type of the success value\n * @template E - The type of the error value\n *\n * @implements {PromiseLike<Result<T, E>>}\n *\n * @example\n * ```typescript\n * // Create a successful async result\n * const okAsync = ResultAsync.okAsync(42);\n *\n * // Create a failed async result\n * const errAsync = ResultAsync.errAsync(new Error(\"Something went wrong\"));\n *\n * // Transform a Promise into a ResultAsync\n * const resultFromPromise = ResultAsync.fromPromise(\n *   fetch(\"https://api.example.com/data\"),\n *   (error) => new Error(`API call failed: ${error}`)\n * );\n * ```\n *\n * @remarks\n * ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.\n * It provides various utility methods for transforming and combining results, similar to the Result type,\n * but operating in an asynchronous context.\n *\n * The class includes methods for:\n * - Creating ResultAsync instances (okAsync, errAsync, fromPromise)\n * - Transforming values (map, mapErr)\n * - Chaining operations (andThen, orElse)\n * - Error handling (tapError)\n * - Conditional branching (if)\n * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)\n */\nexport class ResultAsync<T, E> extends Pipeable 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  public static okAsync<T, E = never>(this: void, value: T): ResultAsync<T, E>\n  public static okAsync<E = never>(this: void, value: void): ResultAsync<void, E>\n  public static okAsync<T, E = never>(this: void, value: T): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(resultOk<T, E>(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  public static unitAsync<E = never>(this: void): 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  public static errAsync<T = never, E = unknown>(this: void, err: E): ResultAsync<T, E>\n  public static errAsync<T = never>(this: void, err: void): ResultAsync<T, void>\n  public static errAsync<T = never, E = unknown>(this: void, error: E): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(err<T, E>(error)))\n  }\n\n  /**\n   * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.\n   *\n   * Compatibility alias. Prefer the top-level `tryResultAsync` helper in new code.\n   *\n   * @param fn - The Promise or a function returning a Promise to be wrapped in a ResultAsync.\n   * @param errorFn - Optional function to transform the caught error into a specific error type.\n   *                  If not provided, the original error will be used.\n   * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,\n   *          or Err with either the transformed error (if errorFn is provided) or the original error.\n   *\n   * New code should use the top-level `tryResultAsync` helper instead.\n   */\n  public static tryCatch<T>(\n    this: void,\n    fn: Promise<T> | (() => Promise<T>),\n  ): ResultAsync<T, unknown>\n  public static tryCatch<T, E>(\n    this: void,\n    fn: Promise<T> | (() => Promise<T>),\n    errorFn: (e: unknown) => E,\n  ): ResultAsync<T, E>\n  public static tryCatch<T, E>(\n    this: void,\n    fn: Promise<T> | (() => Promise<T>),\n    errorFn?: (e: unknown) => E,\n  ): ResultAsync<T, unknown> {\n    const promiseToProcess = typeof fn === 'function' ? Promise.try(fn) : fn\n    const newPromise = promiseToProcess\n      .then((value: T) => resultOk<T, unknown>(value))\n      .catch((error: unknown) => {\n        if (errorFn) {\n          return err<T, unknown>(errorFn(error))\n        }\n        return err<T, unknown>(error)\n      })\n    return new ResultAsync<T, unknown>(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   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\n   */\n  public static fromSafePromise<T, E = never>(\n    this: void,\n    promise: PromiseLike<T>,\n  ): ResultAsync<T, E>\n  public static fromSafePromise<T, E = never>(this: void, promise: Promise<T>): ResultAsync<T, E> {\n    const newPromise = promise.then((value: T) => resultOk<T, E>(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  public static fromPromise<T, E>(\n    this: void,\n    promise: PromiseLike<T>,\n    errorFn: (e: unknown) => E,\n  ): ResultAsync<T, E>\n  public static fromPromise<T, E>(\n    this: void,\n    promise: Promise<T>,\n    errorFn: (e: unknown) => E,\n  ): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => resultOk<T, E>(value))\n      .catch((error: unknown) => err<T, E>(errorFn(error)))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  /**\n   * Combines many ResultAsync values and stops at the first Err.\n   *\n   * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return\n   * an Ok readonly array.\n   */\n  public static combine<\n    T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n  >(this: void, asyncResultList: T): CombineResultAsyncs<T>\n  public static combine<T extends readonly ResultAsync<unknown, unknown>[]>(\n    this: void,\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  public static combine<T extends ResultAsyncRecord>(\n    this: void,\n    asyncResultRecord: T,\n  ): CombineResultAsyncsRecord<T>\n  public static combine<R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    asyncResults: Iterable<R>,\n  ): CombineResultAsyncsIterable<R>\n  public static combine<\n    T extends\n      | readonly ResultAsync<unknown, unknown>[]\n      | ResultAsyncRecord\n      | Iterable<ResultAsync<unknown, unknown>>,\n  >(\n    this: void,\n    input: T,\n  ):\n    | CombineResultAsyncs<T & readonly ResultAsync<unknown, unknown>[]>\n    | CombineResultAsyncsRecord<ResultAsyncRecord>\n    | CombineResultAsyncsIterable<ResultAsync<unknown, unknown>> {\n    // Stryker disable next-line all: array fast path avoids cloning arrays through the iterable branch.\n    if (Array.isArray(input)) {\n      return combineResultAsyncList(input) as CombineResultAsyncs<\n        T & readonly ResultAsync<unknown, unknown>[]\n      >\n    }\n\n    if (isIterable(input)) {\n      return combineResultAsyncList([...input] as readonly ResultAsync<unknown, unknown>[]) as\n        | CombineResultAsyncs<T & readonly ResultAsync<unknown, unknown>[]>\n        | CombineResultAsyncsIterable<ResultAsync<unknown, unknown>>\n    }\n\n    return combineResultAsyncRecord(input)\n  }\n\n  /**\n   * Combines many ResultAsync values and collects every Err instead of stopping at the first one.\n   */\n  public static combineWithAllErrors<\n    T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n  >(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  public static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(\n    this: void,\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  public static combineWithAllErrors<T extends ResultAsyncRecord>(\n    this: void,\n    asyncResultRecord: T,\n  ): CombineResultAsyncsRecordWithAllErrors<T>\n  public static combineWithAllErrors<R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    asyncResults: Iterable<R>,\n  ): CombineResultAsyncsIterableWithAllErrors<R>\n  public static combineWithAllErrors<\n    T extends\n      | readonly ResultAsync<unknown, unknown>[]\n      | ResultAsyncRecord\n      | Iterable<ResultAsync<unknown, unknown>>,\n  >(\n    this: void,\n    input: T,\n  ):\n    | CombineResultsWithAllErrorsArrayAsync<T & readonly ResultAsync<unknown, unknown>[]>\n    | CombineResultAsyncsRecordWithAllErrors<ResultAsyncRecord>\n    | CombineResultAsyncsIterableWithAllErrors<ResultAsync<unknown, unknown>> {\n    // Stryker disable next-line all: array fast path avoids cloning arrays through the iterable branch.\n    if (Array.isArray(input)) {\n      return combineResultAsyncListWithAllErrors(input) as CombineResultsWithAllErrorsArrayAsync<\n        T & readonly ResultAsync<unknown, unknown>[]\n      >\n    }\n\n    if (isIterable(input)) {\n      return combineResultAsyncListWithAllErrors([...input] as readonly ResultAsync<\n        unknown,\n        unknown\n      >[]) as\n        | CombineResultsWithAllErrorsArrayAsync<T & readonly ResultAsync<unknown, unknown>[]>\n        | CombineResultAsyncsIterableWithAllErrors<ResultAsync<unknown, unknown>>\n    }\n\n    return combineResultAsyncRecordWithAllErrors(input)\n  }\n\n  /**\n   * Validates many ResultAsync values and collects every Err.\n   *\n   * When passed items plus a mapper, the mapper must return a ResultAsync for each item. Use the\n   * optional concurrency setting to bound parallel work.\n   */\n  public static validateAll<\n    T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n  >(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  public static validateAll<T extends readonly ResultAsync<unknown, unknown>[]>(\n    this: void,\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  public static validateAll<Item, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options?: ResultAsyncValidateAllOptions,\n  ): ResultAsyncValidatedAll<R>\n  public static validateAll<\n    T extends readonly ResultAsync<unknown, unknown>[],\n    Item,\n    R extends ResultAsync<unknown, unknown>,\n  >(\n    this: void,\n    asyncResultListOrItems: T | Iterable<Item>,\n    f?: (value: Item, index: number) => R,\n    options?: ResultAsyncValidateAllOptions,\n  ): CombineResultsWithAllErrorsArrayAsync<T> | ResultAsyncValidatedAll<R> {\n    if (f === undefined) {\n      return combineResultAsyncListWithAllErrors(\n        asyncResultListOrItems as T,\n      ) as CombineResultsWithAllErrorsArrayAsync<T>\n    }\n\n    return validateAllResultAsyncItems(asyncResultListOrItems as Iterable<Item>, f, options)\n  }\n\n  /**\n   * Combines exactly two ResultAsync values into an Ok tuple or the first Err.\n   */\n  public static zip<\n    Left extends ResultAsync<unknown, unknown>,\n    Right extends ResultAsync<unknown, unknown>,\n  >(this: void, left: Left, right: Right): ResultAsyncZipped<Left, Right> {\n    return combineResultAsyncList([left, right]) as ResultAsyncZipped<Left, Right>\n  }\n\n  /**\n   * Retries a ResultAsync task according to a typed retry policy.\n   *\n   * The returned error channel includes the task error and `AbortError`.\n   */\n  public static retry<Task extends ResultAsyncRetryTask<unknown, unknown>>(\n    this: void,\n    task: Task,\n    options: ResultAsyncRetryOptions<ResultAsyncRetryTaskErr<Task>>,\n  ): ResultAsync<ResultAsyncRetryTaskOk<Task>, ResultAsyncRetryTaskErr<Task> | AbortError> {\n    return retryResultAsyncTask(\n      task as ResultAsyncRetryTask<ResultAsyncRetryTaskOk<Task>, ResultAsyncRetryTaskErr<Task>>,\n      options,\n    )\n  }\n\n  /**\n   * Retries a ResultAsync task and falls back to another Resultar operation after retry exhaustion.\n   */\n  public static retryOrElse<Task extends ResultAsyncRetryTask<unknown, unknown>, U, F>(\n    this: void,\n    task: Task,\n    options: ResultAsyncRetryOrElseOptions<ResultAsyncRetryTaskErr<Task>, F, U>,\n  ): ResultAsync<ResultAsyncRetryTaskOk<Task> | U, F | AbortError> {\n    return retryOrElseResultAsyncTask(\n      task as ResultAsyncRetryTask<ResultAsyncRetryTaskOk<Task>, ResultAsyncRetryTaskErr<Task>>,\n      options,\n    )\n  }\n\n  /**\n   * Acquires, uses, and releases a resource with cleanup on every path.\n   *\n   * Release errors are intentionally not part of the success/error channel; model cleanup failures\n   * in `use` when they should affect control flow.\n   */\n  public static withResource<Resource, AcquireError, T, UseError>(\n    this: void,\n    options: ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError>,\n  ): ResultAsync<T, AcquireError | UseError | AbortError> {\n    return withResultAsyncResource(options)\n  }\n\n  /**\n   * Races two cooperative ResultAsync tasks and returns the first settled Result.\n   */\n  public static race<\n    Left extends ResultAsyncRaceTask<unknown, unknown>,\n    Right extends ResultAsyncRaceTask<unknown, unknown>,\n  >(\n    this: void,\n    left: Left,\n    right: Right,\n  ): ResultAsync<\n    ResultAsyncRaceTaskOk<Left> | ResultAsyncRaceTaskOk<Right>,\n    ResultAsyncRaceTaskErr<Left> | ResultAsyncRaceTaskErr<Right>\n  > {\n    return raceResultAsyncTasks([left, right] as const)\n  }\n\n  /**\n   * Races multiple cooperative ResultAsync tasks and returns the first settled Result.\n   */\n  public static raceAll<\n    Tasks extends readonly [\n      ResultAsyncRaceTask<unknown, unknown>,\n      ...ResultAsyncRaceTask<unknown, unknown>[],\n    ],\n  >(\n    this: void,\n    tasks: Tasks,\n  ): ResultAsync<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>> {\n    return raceResultAsyncTasks(tasks)\n  }\n\n  /**\n   * Races two cooperative ResultAsync tasks and returns the first successful Ok.\n   *\n   * If both fail, the returned error is the final observed Err.\n   */\n  public static raceFirst<\n    Left extends ResultAsyncRaceTask<unknown, unknown>,\n    Right extends ResultAsyncRaceTask<unknown, unknown>,\n  >(\n    this: void,\n    left: Left,\n    right: Right,\n  ): ResultAsync<\n    ResultAsyncRaceTaskOk<Left> | ResultAsyncRaceTaskOk<Right>,\n    ResultAsyncRaceTaskErr<Left> | ResultAsyncRaceTaskErr<Right>\n  > {\n    return observeRaceResultAsyncTasks<\n      readonly [Left, Right],\n      RaceFirstObserverContext<readonly [Left, Right]>\n    >(\n      [left, right] as const,\n      // Stryker disable next-line all: explicit false and missing value are equivalent before first settlement.\n      (resolve, startedTasks) => ({ resolve, startedTasks, state: { settled: false } }),\n      observeRaceFirstTask,\n    )\n  }\n\n  /**\n   * Races two cooperative ResultAsync tasks and lets handlers decide what to do when either side\n   * settles first.\n   *\n   * Handlers receive the settled Result and a handle to the still-running opposite task.\n   */\n  public static raceWith<\n    Left extends ResultAsyncRaceTask<unknown, unknown>,\n    Right extends ResultAsyncRaceTask<unknown, unknown>,\n    OnLeftDone extends ResultAsyncConditional,\n    OnRightDone extends ResultAsyncConditional,\n  >(\n    this: void,\n    left: Left,\n    right: Right,\n    handlers: {\n      readonly onLeftDone: (\n        result: Result<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>,\n        right: ResultAsyncRaceHandle<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>,\n      ) => OnLeftDone\n      readonly onRightDone: (\n        result: Result<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>,\n        left: ResultAsyncRaceHandle<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>,\n      ) => OnRightDone\n    },\n  ): ResultAsync<\n    HandlerOk<OnLeftDone> | HandlerOk<OnRightDone>,\n    HandlerErr<OnLeftDone> | HandlerErr<OnRightDone>\n  > {\n    const promise = new Promise<\n      Result<\n        HandlerOk<OnLeftDone> | HandlerOk<OnRightDone>,\n        HandlerErr<OnLeftDone> | HandlerErr<OnRightDone>\n      >\n    >((resolve) => {\n      const leftTask = startRaceTask(left, 0)\n      const rightTask = startRaceTask(right, 1)\n      const leftHandle = createRaceHandle(leftTask) as ResultAsyncRaceHandle<\n        ResultAsyncRaceTaskOk<Left>,\n        ResultAsyncRaceTaskErr<Left>\n      >\n      const rightHandle = createRaceHandle(rightTask) as ResultAsyncRaceHandle<\n        ResultAsyncRaceTaskOk<Right>,\n        ResultAsyncRaceTaskErr<Right>\n      >\n      let settled = false\n\n      void leftTask.settled.then(({ result }) => {\n        if (settled) {\n          return\n        }\n\n        settled = true\n        const handled = handlers.onLeftDone(\n          result as Result<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>,\n          rightHandle,\n        )\n\n        void Promise.resolve(toResultAsync(handled)).then((handledResult) => {\n          resolve(\n            handledResult as Result<\n              HandlerOk<OnLeftDone> | HandlerOk<OnRightDone>,\n              HandlerErr<OnLeftDone> | HandlerErr<OnRightDone>\n            >,\n          )\n        })\n      })\n\n      void rightTask.settled.then(({ result }) => {\n        if (settled) {\n          return\n        }\n\n        settled = true\n        const handled = handlers.onRightDone(\n          result as Result<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>,\n          leftHandle,\n        )\n\n        void Promise.resolve(toResultAsync(handled)).then((handledResult) => {\n          resolve(\n            handledResult as Result<\n              HandlerOk<OnLeftDone> | HandlerOk<OnRightDone>,\n              HandlerErr<OnLeftDone> | HandlerErr<OnRightDone>\n            >,\n          )\n        })\n      })\n    })\n\n    return new ResultAsync(promise)\n  }\n\n  /**\n   * Runs a cooperative ResultAsync task with a typed timeout error.\n   */\n  public static timeout<Task extends ResultAsyncRaceTask<unknown, unknown>, TimeoutError>(\n    this: void,\n    task: Task,\n    options: ResultAsyncTimeoutOptions<TimeoutError>,\n  ): ResultAsync<ResultAsyncRaceTaskOk<Task>, ResultAsyncRaceTaskErr<Task> | TimeoutError> {\n    const timeoutTask = (signal: ResultAsyncAbortSignal): ResultAsync<never, TimeoutError> => {\n      const promise = new Promise<Result<never, TimeoutError>>((resolve) => {\n        const timeout = setTimeout(() => {\n          resolve(Result.err(options.onTimeout()))\n        }, options.timeoutMs)\n\n        signal.addEventListener('abort', () => {\n          clearTimeout(timeout)\n        })\n      })\n\n      return new ResultAsync(promise)\n    }\n\n    return ResultAsync.raceWith(task, timeoutTask, {\n      onLeftDone: (result, timeoutHandle) => {\n        timeoutHandle.abort(createRaceAbortReason())\n        return result\n      },\n      onRightDone: (result, taskHandle) => {\n        // Stryker disable next-line all: timeoutTask has Ok type never and only resolves Err.\n        if (result.isErr()) {\n          taskHandle.abort(result.error)\n        }\n\n        return result\n      },\n    })\n  }\n\n  /**\n   * Runs async candidates until the first Ok and returns the last Err if every candidate fails.\n   */\n  public static firstSuccessOf<Candidates extends Iterable<ResultAsyncCandidate>>(\n    this: void,\n    candidates: Candidates,\n  ): FirstSuccessOfAsync<Candidates> {\n    return firstSuccessOfAsyncCandidates(candidates)\n  }\n\n  /**\n   * Chooses one of two Resultar async branches from a boolean or Resultar boolean condition.\n   */\n  public static if<OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(\n    this: void,\n    condition: ResultAsyncBooleanCondition,\n    options: ResultAsyncIfOptions<OnTrue, OnFalse>,\n  ): ResultAsyncIf<never, OnTrue, OnFalse>\n  public static if<\n    Condition extends ResultAsyncConditionResult,\n    OnTrue extends ResultAsyncConditional,\n    OnFalse extends ResultAsyncConditional,\n  >(\n    this: void,\n    condition: Condition,\n    options: ResultAsyncIfOptions<OnTrue, OnFalse>,\n  ): ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse>\n  public static if<\n    Condition extends ResultAsyncConditionResult,\n    OnTrue extends ResultAsyncConditional,\n    OnFalse extends ResultAsyncConditional,\n  >(\n    this: void,\n    condition: Condition | ResultAsyncBooleanCondition,\n    options: ResultAsyncIfOptions<OnTrue, OnFalse>,\n  ): ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse> | ResultAsyncIf<never, OnTrue, OnFalse> {\n    if (typeof condition === 'boolean' || typeof condition === 'function') {\n      return ifResultAsync(condition, options)\n    }\n\n    return ifResultAsyncWithCondition(condition, options)\n  }\n\n  /**\n   * Runs `body` only when the condition is true; otherwise returns Ok(undefined).\n   */\n  public static when<R extends ResultAsyncConditional>(\n    this: void,\n    condition: ResultAsyncBooleanCondition,\n    body: () => R,\n  ): ResultAsyncWhen<R> {\n    return whenResultAsync(condition, body)\n  }\n\n  /**\n   * Runs `body` only when a Resultar boolean condition is Ok(true).\n   */\n  public static whenResult<\n    Condition extends ResultAsyncConditionResult,\n    R extends ResultAsyncConditional,\n  >(this: void, condition: Condition, body: () => R): ResultAsyncWhenWithCondition<Condition, R> {\n    return whenResultAsyncWithCondition(condition, body)\n  }\n\n  /**\n   * Runs `body` only when the condition is false; otherwise returns Ok(undefined).\n   */\n  public static unless<R extends ResultAsyncConditional>(\n    this: void,\n    condition: ResultAsyncBooleanCondition,\n    body: () => R,\n  ): ResultAsyncWhen<R> {\n    return unlessResultAsync(condition, body)\n  }\n\n  /**\n   * Runs `body` only when a Resultar boolean condition is Ok(false).\n   */\n  public static unlessResult<\n    Condition extends ResultAsyncConditionResult,\n    R extends ResultAsyncConditional,\n  >(this: void, condition: Condition, body: () => R): ResultAsyncWhenWithCondition<Condition, R> {\n    return unlessResultAsyncWithCondition(condition, body)\n  }\n\n  /**\n   * Repeats a ResultAsync-producing body while a condition holds.\n   *\n   * Use `discard: true` when only failure matters and collected Ok values are not needed.\n   */\n  public static loop<State, BodyState extends State, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultAsyncLoopOptions<State, BodyState, R>,\n  ): ResultAsyncLoopCollected<R>\n  public static loop<State, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultAsyncLoopBooleanOptions<State, R>,\n  ): ResultAsyncLoopCollected<R>\n  public static loop<State, BodyState extends State, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultAsyncLoopDiscardOptions<State, BodyState, R>,\n  ): ResultAsyncLoopDiscarded<R>\n  public static loop<State, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultAsyncLoopBooleanDiscardOptions<State, R>,\n  ): ResultAsyncLoopDiscarded<R>\n  public static loop<State, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    initial: State,\n    options:\n      | ResultAsyncLoopBooleanOptions<State, R>\n      | ResultAsyncLoopBooleanDiscardOptions<State, R>\n      | ResultAsyncLoopOptions<State, State, R>\n      | ResultAsyncLoopDiscardOptions<State, State, R>,\n  ): ResultAsyncLoopCollected<R> | ResultAsyncLoopDiscarded<R> {\n    return loopResultAsync(initial, options as ResultAsyncLoopRuntimeOptions<State, R>)\n  }\n\n  /**\n   * Repeatedly transforms state with a ResultAsync-producing body until the condition fails.\n   */\n  public static iterate<\n    State,\n    BodyState extends WidenLiteral<State>,\n    R extends ResultAsync<WidenLiteral<State>, unknown>,\n  >(\n    this: void,\n    initial: State,\n    options: ResultAsyncIterateOptions<WidenLiteral<State>, BodyState, R>,\n  ): ResultAsyncIterated<WidenLiteral<State>, R>\n  public static iterate<State, R extends ResultAsync<WidenLiteral<State>, unknown>>(\n    this: void,\n    initial: State,\n    options: ResultAsyncIterateBooleanOptions<WidenLiteral<State>, R>,\n  ): ResultAsyncIterated<WidenLiteral<State>, R>\n  public static iterate<State, R extends ResultAsync<WidenLiteral<State>, unknown>>(\n    this: void,\n    initial: State,\n    options:\n      | ResultAsyncIterateBooleanOptions<WidenLiteral<State>, R>\n      | ResultAsyncIterateOptions<WidenLiteral<State>, WidenLiteral<State>, R>,\n  ): ResultAsyncIterated<WidenLiteral<State>, R> {\n    return iterateResultAsync(\n      initial as WidenLiteral<State>,\n      options as ResultAsyncIterateRuntimeOptions<WidenLiteral<State>, R>,\n    )\n  }\n\n  /**\n   * Runs a ResultAsync-producing mapper for each item.\n   *\n   * Use `discard: true` when only failure matters and collected Ok values are not needed. Use\n   * `concurrency` to bound parallel work.\n   */\n  public static forEach<Item, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options?: ResultAsyncForEachOptions,\n  ): ResultAsyncForEachCollected<R>\n  public static forEach<Item, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options: ResultAsyncForEachDiscardOptions,\n  ): ResultAsyncForEachDiscarded<R>\n  public static forEach<Item, R extends ResultAsync<unknown, unknown>>(\n    this: void,\n    items: Iterable<Item>,\n    f: (value: Item, index: number) => R,\n    options?: ResultAsyncForEachOptions | ResultAsyncForEachDiscardOptions,\n  ): ResultAsyncForEachCollected<R> | ResultAsyncForEachDiscarded<R> {\n    return forEachResultAsync(items, f, options)\n  }\n\n  /**\n   * Wraps an async function so every later call returns a ResultAsync.\n   *\n   * Prefer `tryResultAsync` when you want to run the operation immediately.\n   */\n  public static fromThrowable<A extends readonly unknown[], T, E>(\n    this: void,\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 resultOk<T, E>(v)\n          } catch (error) {\n            const e = errorFn ? errorFn(error) : error\n            return err<T, E>(e as E)\n          }\n        })(),\n      )\n  }\n\n  private readonly innerPromise: Promise<Result<T, E>>\n\n  /**\n   * Creates a ResultAsync from a Promise that resolves to a Result.\n   *\n   * Most application code should prefer `tryResultAsync`, `fromPromise`, `okAsync`, or `errAsync`.\n   */\n  public constructor(res: Promise<Result<T, E>>) {\n    super()\n    this.innerPromise = res\n  }\n\n  /**\n   * PromiseLike integration. Resolves to the underlying `Result<T, E>`.\n   *\n   * Prefer ResultAsync combinators for application flow; this exists so ResultAsync can be awaited\n   * and used by Promise APIs.\n   */\n  public then<A, B>(\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   * Maps the Err value while preserving the Ok value.\n   */\n  public mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U> {\n    return new ResultAsync<T, U>(\n      this.innerPromise.then(async (res) => {\n        if (res.isOk()) {\n          return resultOk<T, U>(res.value)\n        }\n\n        return err<T, U>(await f(res.error))\n      }),\n    )\n  }\n\n  /**\n   * Maps the Ok value while preserving the error channel.\n   */\n  public map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E> {\n    return new ResultAsync<X, E>(\n      this.innerPromise.then(async (res: Result<T, E>) => {\n        if (res.isErr()) {\n          return err<X, E>(res.error)\n        }\n\n        return resultOk<X, E>(await f(res.value))\n      }),\n    )\n  }\n\n  /**\n   * Replaces the Ok value with a constant while preserving the error channel.\n   */\n  public as<X>(value: X): ResultAsync<X, E> {\n    return new ResultAsync<X, E>(\n      this.innerPromise.then((res: Result<T, E>) => {\n        if (res.isErr()) {\n          return err<X, E>(res.error)\n        }\n\n        return resultOk<X, E>(value)\n      }),\n    )\n  }\n\n  /**\n   * Keeps the Ok value only when the predicate passes; otherwise returns an Err from `onFalse`.\n   */\n  public filterOrElse<U extends T, F>(\n    predicate: (value: T) => value is U,\n    onFalse: (value: T) => F | Promise<F>,\n  ): ResultAsync<U, E | F>\n  public filterOrElse<F>(\n    predicate: (value: T) => boolean | Promise<boolean>,\n    onFalse: (value: T) => F | Promise<F>,\n  ): ResultAsync<T, E | F>\n  public filterOrElse<F>(\n    predicate: (value: T) => boolean | Promise<boolean>,\n    onFalse: (value: T) => F | Promise<F>,\n  ): ResultAsync<T, E | F> {\n    return new ResultAsync<T, E | F>(\n      this.innerPromise.then(async (res) => {\n        if (res.isErr()) {\n          return err<T, E | F>(res.error)\n        }\n\n        if (await predicate(res.value)) {\n          return resultOk<T, E | F>(res.value)\n        }\n\n        return err<T, E | F>(await onFalse(res.value))\n      }),\n    )\n  }\n\n  /**\n   * Chains another fallible sync or async operation from the Ok value.\n   *\n   * Use this instead of `map` when the callback returns `Result` or `ResultAsync`.\n   */\n  public andThen<R extends Result<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>\n  public andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>\n  public andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>\n  public andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F> {\n    return new ResultAsync<U, E | F>(\n      this.innerPromise.then((res) => {\n        if (res.isErr()) {\n          return err<U, E | F>(res.error)\n        }\n\n        const next = f(res.value)\n        return next instanceof ResultAsync ? next.innerPromise : next\n      }),\n    )\n  }\n\n  /**\n   * Branches from the Ok value into one of two async fallible Result branches.\n   */\n  public if(fCondition: (t: T) => boolean): {\n    true: <X1, Y1>(\n      fTrue: (t: T) => ResultAsync<X1, Y1>,\n    ) => {\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(\n            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\n  /**\n   * Recovers from Err with another Result or ResultAsync.\n   */\n  public orElse<R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>\n  public orElse<R extends ResultAsync<unknown, unknown>>(\n    f: (e: E) => R,\n  ): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>\n  public orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>\n  public orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A> {\n    return new ResultAsync<U | T, A>(\n      this.innerPromise.then((res) => {\n        if (res.isErr()) {\n          const next = f(res.error)\n          return next instanceof ResultAsync ? next.innerPromise : next\n        }\n\n        return resultOk<U | T, A>(res.value)\n      }),\n    )\n  }\n\n  /**\n   * Recovers from a specific tagged error by `_tag`.\n   */\n  public catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(\n    tag: Tag,\n    f: (error: ErrorForTag<E, Tag>) => R,\n  ): ResultAsync<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>\n  public catchTag<const Tag extends TagsOf<E>, R extends ResultAsync<unknown, unknown>>(\n    tag: Tag,\n    f: (error: ErrorForTag<E, Tag>) => R,\n  ): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeTag<E, Tag> | InferAsyncErrTypes<R>>\n  public catchTag<U, F, const Tag extends TagsOf<E>>(\n    tag: Tag,\n    f: (error: ErrorForTag<E, Tag>) => Result<U, F> | ResultAsync<U, F>,\n  ): ResultAsync<T | U, ExcludeTag<E, Tag> | F>\n  public catchTag<U, F, const Tag extends TagsOf<E>>(\n    tag: Tag,\n    f: (error: ErrorForTag<E, Tag>) => Result<U, F> | ResultAsync<U, F>,\n  ): ResultAsync<T | U, ExcludeTag<E, Tag> | F> {\n    return new ResultAsync(\n      this.innerPromise.then((res) => {\n        if (res.isOk()) {\n          return Result.ok(res.value)\n        }\n\n        if (hasTag(res.error, tag)) {\n          const next = f(res.error as ErrorForTag<E, Tag>)\n          return next instanceof ResultAsync ? next.innerPromise : next\n        }\n\n        return Result.err(res.error as ExcludeTag<E, Tag>)\n      }),\n    )\n  }\n\n  /**\n   * Recovers from multiple tagged errors by `_tag`.\n   */\n  public catchTags<const Handlers extends object>(\n    handlers: Handlers & CatchTagHandlers<E, Handlers>,\n  ): ResultAsync<\n    T | HandlerOk<CatchTagHandlerResult<Handlers>>,\n    ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>\n  > {\n    return new ResultAsync<\n      T | HandlerOk<CatchTagHandlerResult<Handlers>>,\n      ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>\n    >(\n      this.innerPromise.then((res) => {\n        if (res.isOk()) {\n          return Result.ok(res.value)\n        }\n\n        const error = res.error\n        const handled = callTaggedHandler<CatchTagHandlerResult<Handlers>>(error, handlers)\n\n        if (isTaggedHandlerMatch(handled)) {\n          const next = handled.value as Result<unknown, unknown> | ResultAsync<unknown, unknown>\n          return next instanceof ResultAsync ? next.innerPromise : next\n        }\n\n        return Result.err(error as ExcludeTag<E, keyof Handlers & string>)\n      }) as Promise<\n        Result<\n          T | HandlerOk<CatchTagHandlerResult<Handlers>>,\n          ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>\n        >\n      >,\n    )\n  }\n\n  /**\n   * Recovers from a nested tagged `reason` on a specific tagged error.\n   */\n  public catchReason<\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n    R extends Result<unknown, unknown>,\n  >(\n    errorTag: ErrorTag,\n    reasonTag: ReasonTag,\n    f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag<E, ErrorTag>) => R,\n  ): ResultAsync<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>>\n  public catchReason<\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n    R extends ResultAsync<unknown, unknown>,\n  >(\n    errorTag: ErrorTag,\n    reasonTag: ReasonTag,\n    f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag<E, ErrorTag>) => R,\n  ): ResultAsync<\n    T | InferAsyncOkTypes<R>,\n    ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferAsyncErrTypes<R>\n  >\n  public catchReason<\n    U,\n    F,\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n  >(\n    errorTag: ErrorTag,\n    reasonTag: ReasonTag,\n    f: (\n      reason: ReasonForTag<E, ErrorTag, ReasonTag>,\n      error: ErrorForTag<E, ErrorTag>,\n    ) => Result<U, F> | ResultAsync<U, F>,\n  ): ResultAsync<T | U, ExcludeReasonTag<E, ErrorTag, ReasonTag> | F>\n  public catchReason<\n    const ErrorTag extends TagsWithReasonOf<E>,\n    const ReasonTag extends ReasonTagsOf<E, ErrorTag>,\n    R extends Result<unknown, unknown> | ResultAsync<unknown, unknown>,\n  >(\n    errorTag: ErrorTag,\n    reasonTag: ReasonTag,\n    f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag<E, ErrorTag>) => R,\n  ): ResultAsync<T | HandlerOk<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | HandlerErr<R>> {\n    return new ResultAsync<\n      T | HandlerOk<R>,\n      ExcludeReasonTag<E, ErrorTag, ReasonTag> | HandlerErr<R>\n    >(\n      this.innerPromise.then((res) => {\n        if (res.isOk()) {\n          return Result.ok(res.value)\n        }\n\n        if (hasTag(res.error, errorTag)) {\n          const reason = getReason(res.error)\n\n          if (hasTag(reason, reasonTag)) {\n            const next = f(\n              reason as ReasonForTag<E, ErrorTag, ReasonTag>,\n              res.error as ErrorForTag<E, ErrorTag>,\n            )\n            return next instanceof ResultAsync ? next.innerPromise : next\n          }\n        }\n\n        return Result.err(res.error as ExcludeReasonTag<E, ErrorTag, ReasonTag>)\n      }) as Promise<\n        Result<T | HandlerOk<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | HandlerErr<R>>\n      >,\n    )\n  }\n\n  /**\n   * Recovers from multiple nested tagged `reason` variants on a specific tagged error.\n   */\n  public catchReasons<const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(\n    errorTag: ErrorTag,\n    handlers: Handlers & CatchReasonHandlers<E, ErrorTag, Handlers>,\n  ): ResultAsync<\n    T | HandlerOk<CatchReasonHandlerResult<Handlers>>,\n    | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n    | HandlerErr<CatchReasonHandlerResult<Handlers>>\n  > {\n    return new ResultAsync<\n      T | HandlerOk<CatchReasonHandlerResult<Handlers>>,\n      | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n      | HandlerErr<CatchReasonHandlerResult<Handlers>>\n    >(\n      this.innerPromise.then((res) => {\n        if (res.isOk()) {\n          return Result.ok(res.value)\n        }\n\n        if (hasTag(res.error, errorTag)) {\n          const reason = getReason(res.error)\n\n          if (typeof reason === 'object' && reason !== null && '_tag' in reason) {\n            const handler = (handlers as Record<string, unknown>)[\n              (reason as { readonly _tag: string })._tag\n            ]\n\n            if (handler !== undefined) {\n              const next = (\n                handler as (\n                  reason: unknown,\n                  error: unknown,\n                ) => Result<unknown, unknown> | ResultAsync<unknown, unknown>\n              )(reason, res.error)\n              return next instanceof ResultAsync ? next.innerPromise : next\n            }\n          }\n        }\n\n        return Result.err(res.error as ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>)\n      }) as Promise<\n        Result<\n          T | HandlerOk<CatchReasonHandlerResult<Handlers>>,\n          | ExcludeReasonTag<E, ErrorTag, keyof Handlers & string>\n          | HandlerErr<CatchReasonHandlerResult<Handlers>>\n        >\n      >,\n    )\n  }\n\n  /**\n   * Moves the nested `reason` of a tagged error into the ResultAsync error channel.\n   */\n  public unwrapReason<const ErrorTag extends TagsWithReasonOf<E>>(\n    errorTag: ErrorTag,\n  ): ResultAsync<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>> {\n    return new ResultAsync(\n      this.innerPromise.then((res) => {\n        if (res.isOk()) {\n          return Result.ok(res.value)\n        }\n\n        if (hasTag(res.error, errorTag)) {\n          return Result.err(getReason(res.error) as ReasonsOf<E, ErrorTag>)\n        }\n\n        return Result.err(res.error as ExcludeTag<E, ErrorTag>)\n      }),\n    )\n  }\n\n  /**\n   * Converts this ResultAsync into a Promise of a plain value by handling both Ok and Err.\n   */\n  public async match<A, B = A>(handlers: MatchHandlers<T, E, A, B>): Promise<A | B>\n  public async match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>\n  public async match<A, B = A>(\n    input: MatchHandlers<T, E, A, B> | ((t: T) => A),\n    fnErr?: (e: E) => B,\n  ): Promise<A | B> {\n    return this.innerPromise.then((res) =>\n      // Stryker disable next-line all: positional match avoids allocating a handlers object.\n      typeof input === 'function'\n        ? res.match(input, getMatchErrorHandler(input, fnErr))\n        : res.match(input),\n    )\n  }\n\n  /**\n   * Converts this ResultAsync into a Promise of a plain value with exhaustive tagged-error handlers.\n   */\n  public async matchTags<A, const Handlers extends object>(\n    ok: (t: T) => A,\n    handlers: Handlers & MatchTagHandlers<E, Handlers>,\n  ): Promise<A | MatchTagHandlerResult<Handlers>> {\n    return this.innerPromise.then((res) =>\n      matchResolvedResultTags<T, E, A, MatchTagHandlerResult<Handlers>, never>({\n        result: res,\n        ok,\n        handlers,\n        fallback: (error) => {\n          // eslint-disable-next-line @typescript-eslint/only-throw-error\n          throw error\n        },\n      }),\n    )\n  }\n\n  /**\n   * Converts this ResultAsync into a Promise of a plain value with partial tagged-error handlers and\n   * a fallback.\n   */\n  public async matchTagsPartial<A, B, const Handlers extends object>(\n    ok: (t: T) => A,\n    handlers: Handlers & PartialMatchTagHandlers<E, Handlers>,\n    fallback: (error: E) => B,\n  ): Promise<A | MatchTagHandlerResult<Handlers> | B> {\n    return this.innerPromise.then((res) =>\n      matchResolvedResultTags<T, E, A, MatchTagHandlerResult<Handlers>, B>({\n        result: res,\n        ok,\n        handlers,\n        fallback,\n      }),\n    )\n  }\n\n  /**\n   * Resolves to the Ok value, or `t` when this ResultAsync is Err.\n   */\n  public async unwrapOr<A>(t: A): Promise<T | A> {\n    return this.innerPromise.then((res) => res.unwrapOr(t))\n  }\n\n  /**\n   * Resolves to the Ok value or rejects with the Err value.\n   *\n   * Use this at final application boundaries after the error channel has been modeled.\n   */\n  public async unwrapOrThrow(): Promise<T> {\n    return this.innerPromise.then((res) => res.unwrapOrThrow())\n  }\n\n  /**\n   * Runs a side effect for either variant and preserves the original async result.\n   *\n   * For `Ok`, the callback receives `(value, undefined)`.\n   * For `Err`, the callback receives `(undefined, error)`.\n   * Callback errors and rejected callback promises are intentionally ignored.\n   *\n   * Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should\n   * transform the result.\n   */\n  public 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          await callAsyncSideEffect(() => f(res.value))\n\n          return okAsync(res.value)\n        }\n\n        await callAsyncSideEffect(() => f(undefined, res.error))\n\n        return errAsync(res.error)\n      }),\n    )\n  }\n\n  /**\n   * Runs a side effect only for the `Ok` variant and preserves the original async result.\n   *\n   * Callback errors and rejected callback promises are intentionally ignored.\n   * Use `map` or `andThen` when the callback should transform the value.\n   */\n  public 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        await callAsyncSideEffect(() => f(res.value))\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  /**\n   * Runs a side effect only for the `Err` variant and preserves the original async result.\n   *\n   * Callback errors and rejected callback promises are intentionally ignored.\n   * Use `mapErr` or `orElse` when the callback should transform the error.\n   */\n  public 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          await callAsyncSideEffect(() => f(res.error))\n\n          return errAsync(res.error)\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  /**\n   * Attaches an async disposal finalizer to this ResultAsync.\n   */\n  public toAsyncDisposable(f: ResultAsyncFinalizer<T, E>): DisposableResultAsync<T, E> {\n    return new DisposableResultAsync(this.innerPromise, f)\n  }\n\n  /**\n   * Enables `yield* resultAsync` inside async `safeTry` generators.\n   */\n  public async *[Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T> {\n    const result = await this.innerPromise\n\n    if (result.isOk()) {\n      return result.value\n    }\n\n    yield err(result.error)\n\n    return undefined as T\n  }\n}\n\nregisterResultAsyncFactory(\n  (promise) => new ResultAsync(promise as Promise<Result<unknown, unknown>>),\n)\n\nexport type StrictResultAsync<T, E extends Error = Error> = ResultAsync<T, E>\n\n/**\n * Creates an Ok ResultAsync.\n */\nexport const okAsync: typeof ResultAsync.okAsync = ResultAsync.okAsync\n/**\n * Creates an Err ResultAsync.\n */\nexport const errAsync: typeof ResultAsync.errAsync = ResultAsync.errAsync\n/**\n * Converts an existing promise into a ResultAsync and maps rejection into a typed Err.\n */\nexport const fromPromise: typeof ResultAsync.fromPromise = ResultAsync.fromPromise\n/**\n * Converts an existing promise that is expected not to reject into a ResultAsync.\n *\n * Use `fromPromise` or `tryResultAsync` when rejection should become a typed Err.\n */\nexport const fromSafePromise: typeof ResultAsync.fromSafePromise = ResultAsync.fromSafePromise\n/**\n * Creates an Ok ResultAsync with `undefined`.\n */\nexport const unitAsync: typeof ResultAsync.unitAsync = ResultAsync.unitAsync\n/**\n * Wraps an async function so every later call returns a ResultAsync.\n */\nexport const fromThrowableAsync: typeof ResultAsync.fromThrowable = ResultAsync.fromThrowable\n\n/**\n * Captures a promise or async factory into `ResultAsync<T, E>`.\n *\n * Use `tryResultAsync` at the edge of uncontrolled async code: network calls, file I/O,\n * third-party SDKs, JSON parsing promises, and framework APIs that can reject. The mapper receives\n * the rejected or thrown `unknown` cause and returns the typed error for the Resultar channel.\n *\n * Passing a factory is preferred when creating the promise can throw synchronously.\n *\n * @example\n * ```ts\n * const user = tryResultAsync(\n *   () => fetchUser(id),\n *   (cause) => new FetchUserError({ cause, id }),\n * )\n * ```\n */\nexport function tryResultAsync<T, E>(\n  fn: Promise<T> | (() => Promise<T>),\n  errorFn: (e: unknown) => E,\n): ResultAsync<T, E>\n/**\n * Captures an async boundary with named `try` and `catch` fields.\n *\n * This is equivalent to `tryResultAsync(() => ..., toError)`, but it reads better for reusable\n * infrastructure helpers where the label, task, and mapper live together.\n *\n * @example\n * ```ts\n * const startup = tryResultAsync({\n *   try: () => fastify.register(plugin),\n *   catch: (cause) => new StartupTaskError({ cause, label: \"register plugin\" }),\n * })\n * ```\n */\nexport function tryResultAsync<T, E>(\n  options: TryResultAsyncOptions<T, E> & { readonly catch: (e: unknown) => E },\n): ResultAsync<T, E>\n/**\n * Captures a promise or async factory into `ResultAsync<T, unknown>`.\n *\n * Prefer the overload with a catch mapper in application code so the error channel stays documented.\n * This overload is useful while adapting unknown external failures or during migration.\n */\nexport function tryResultAsync<T>(\n  input: Promise<T> | (() => Promise<T>) | TryResultAsyncOptions<T>,\n): ResultAsync<T, unknown>\nexport function tryResultAsync<T, E = unknown>(\n  input: Promise<T> | (() => Promise<T>) | TryResultAsyncOptions<T, E>,\n  errorFn?: (e: unknown) => E,\n): ResultAsync<T, E> {\n  const promiseOrFn = isTryResultAsyncOptions(input) ? input.try : input\n  const catchFn = isTryResultAsyncOptions(input) ? input.catch : errorFn\n  const promiseToProcess =\n    typeof promiseOrFn === 'function' ? Promise.try(promiseOrFn) : promiseOrFn\n  const newPromise = promiseToProcess\n    .then((value: T) => Result.ok<T, E>(value))\n    .catch((error: unknown) => {\n      if (catchFn) {\n        return Result.err<T, E>(catchFn(error))\n      }\n\n      return Result.err<T, E>(error as E)\n    })\n\n  return new ResultAsync<T, E>(newPromise)\n}\n\n/**\n * Runs a `ResultAsync` at an application boundary and returns the success value.\n *\n * If the result is `Err`, this rejects with the error. Use it at final framework, CLI, test, or\n * bootstrap boundaries after the error channel has already been modeled with Resultar.\n */\nexport const runPromise = <T, E>(result: ResultAsync<T, E>): Promise<T> => result.unwrapOrThrow()\n\n/** Compatibility alias. Prefer `tryResultAsync` in new code. */\nexport const tryCatchAsync: typeof tryResultAsync = tryResultAsync\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> =\n  IsLiteralArray<T> extends 1\n    ? 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> =\n  IsLiteralArray<T> extends 1\n    ? 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> =\n  IsLiteralArray<T> extends 1\n    ? Writable<T> extends [infer H, ...infer Rest]\n      ? H extends PromiseLike<infer HI>\n        ? HI extends Result<unknown, unknown>\n          ? [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)[]\n      ? A extends PromiseLike<infer HI>\n        ? HI extends Result<infer L, infer R>\n          ? 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> =\n  IsLiteralArray<T> extends 1\n    ? Combine<T, Depth> extends [infer Oks, infer Errs]\n      ? 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[]\n            ? 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[]\n            ? 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> =\n  TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs>\n    ? 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","/**\n * String-like wrapper that hides a sensitive value in messages and JSON output.\n */\nexport type Redacted<T> = string & {\n  /**\n   * Internal marker used by `isRedacted`.\n   */\n  readonly __resultarRedacted: true\n  readonly __resultarRedactedType?: T\n  /**\n   * Optional label shown as `<redacted:label>`.\n   */\n  readonly label: string | undefined\n  /**\n   * Serializes to the redacted placeholder.\n   */\n  toJSON: () => string\n  /**\n   * Converts to the redacted placeholder.\n   */\n  toString: () => string\n}\n\nconst redactedValues = new WeakMap<object, unknown>()\n\nconst formatRedacted = (label: string | undefined): string =>\n  label === undefined ? '<redacted>' : `<redacted:${label}>`\n\nclass RedactedValue<T> {\n  public readonly __resultarRedacted = true\n  public readonly label: string | undefined\n\n  /**\n   * Stores a sensitive value behind a redacted string wrapper.\n   */\n  public constructor(value: T, label: string | undefined) {\n    this.label = label\n    redactedValues.set(this, value)\n  }\n\n  /**\n   * Serializes to the redacted placeholder.\n   */\n  public toJSON(): string {\n    return this.toString()\n  }\n\n  /**\n   * Converts to the redacted placeholder.\n   */\n  public toString(): string {\n    return formatRedacted(this.label)\n  }\n}\n\n/**\n * Wraps a sensitive value so tagged-error messages and JSON output show only a placeholder.\n */\nexport const redact = <T>(value: T, label?: string): Redacted<T> =>\n  new RedactedValue(value, label) as unknown as Redacted<T>\n\n/**\n * Checks whether a value was created by `redact`.\n */\nexport const isRedacted = (value: unknown): value is Redacted<unknown> =>\n  // Stryker disable next-line all: the object/null guard documents the WeakMap-key contract; WeakMap.has returns false for non-objects.\n  typeof value === 'object' && value !== null && redactedValues.has(value)\n\n/**\n * Returns the original sensitive value from a Redacted wrapper.\n */\nexport const revealRedacted = <T>(value: Redacted<T>): T =>\n  redactedValues.get(value as unknown as object) as T\n\n/**\n * Converts a Redacted wrapper to its placeholder string.\n */\nexport const stringifyRedacted = (value: Redacted<unknown>): string => value.toString()\n","import type { ErrResult } from './result.js'\n\nimport { isRedacted, stringifyRedacted } from './redacted.js'\nimport { err as resultErr } from './result.js'\n\ntype Alpha =\n  | 'a'\n  | 'b'\n  | 'c'\n  | 'd'\n  | 'e'\n  | 'f'\n  | 'g'\n  | 'h'\n  | 'i'\n  | 'j'\n  | 'k'\n  | 'l'\n  | 'm'\n  | 'n'\n  | 'o'\n  | 'p'\n  | 'q'\n  | 'r'\n  | 's'\n  | 't'\n  | 'u'\n  | 'v'\n  | 'w'\n  | 'x'\n  | 'y'\n  | 'z'\n  | 'A'\n  | 'B'\n  | 'C'\n  | 'D'\n  | 'E'\n  | 'F'\n  | 'G'\n  | 'H'\n  | 'I'\n  | 'J'\n  | 'K'\n  | 'L'\n  | 'M'\n  | 'N'\n  | 'O'\n  | 'P'\n  | 'Q'\n  | 'R'\n  | 'S'\n  | 'T'\n  | 'U'\n  | 'V'\n  | 'W'\n  | 'X'\n  | 'Y'\n  | 'Z'\n  | '_'\ntype Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'\ntype AlphaNumeric = Alpha | Digit\ntype ReservedTemplateVariable =\n  | '_tag'\n  | 'cause'\n  | 'fingerprint'\n  | 'message'\n  | 'messageTemplate'\n  | 'name'\n  | 'stack'\n\ntype ConsumeTemplateVariable<\n  Template extends string,\n  Accumulator extends string = '',\n> = Template extends `${infer Character}${infer Rest}`\n  ? Character extends AlphaNumeric\n    ? ConsumeTemplateVariable<Rest, `${Accumulator}${Character}`>\n    : { readonly rest: Template; readonly variable: Accumulator }\n  : { readonly rest: ''; readonly variable: Accumulator }\n\ntype ExtractTemplateVariables<Template extends string> =\n  Template extends `${string}$${infer AfterDollar}`\n    ? AfterDollar extends `${Alpha}${string}`\n      ? ConsumeTemplateVariable<AfterDollar> extends {\n          readonly rest: infer Rest extends string\n          readonly variable: infer Variable extends string\n        }\n        ? Variable | ExtractTemplateVariables<Rest>\n        : never\n      : ExtractTemplateVariables<AfterDollar>\n    : never\n\ntype TemplateProps<Template extends string> = [ExtractTemplateVariables<Template>] extends [never]\n  ? Record<never, never>\n  : Readonly<Record<ExtractTemplateVariables<Template>, string | number>>\ntype ReservedVariablesIn<Template extends string> = Extract<\n  ExtractTemplateVariables<Template>,\n  ReservedTemplateVariable\n>\ntype RejectReservedTemplateVariables<Template extends string> = [\n  ReservedVariablesIn<Template>,\n] extends [never]\n  ? Template\n  : never\n\ntype ErrorBaseConstructor<Base extends Error = Error> = new (\n  message?: string,\n  options?: ErrorOptions,\n) => Base\ntype ErrorClass<Base extends Error = Error> = new (...args: readonly any[]) => Base\ntype ErrorClassInstance<This> = This extends new (...args: readonly any[]) => infer Instance\n  ? Instance\n  : never\ntype ConstructorProps<Template extends string> = TemplateProps<Template> & {\n  readonly cause?: unknown\n}\ntype TaggedErrorConstructorArgs<Template extends string> = [\n  ExtractTemplateVariables<Template>,\n] extends [never]\n  ? [props?: { readonly cause?: unknown }]\n  : [props: ConstructorProps<Template>]\n\nexport interface TaggedErrorOptions<\n  Tag extends string,\n  MessageTemplate extends string,\n  Base extends Error = Error,\n> {\n  /**\n   * Optional base Error class to extend instead of native Error.\n   */\n  readonly extends?: ErrorBaseConstructor<Base>\n  /**\n   * Message template. `$prop` placeholders are filled from constructor props.\n   */\n  readonly message?: MessageTemplate\n  /**\n   * Stable runtime tag and Error name.\n   */\n  readonly name: Tag\n}\n\n/**\n * Instance type produced by `createTaggedError`.\n */\nexport type TaggedErrorInstance<\n  Tag extends string,\n  MessageTemplate extends string,\n  Base extends Error = Error,\n> = Base &\n  Readonly<TemplateProps<MessageTemplate>> & {\n    /**\n     * Stable runtime tag.\n     */\n    readonly _tag: Tag\n    /**\n     * Stable identity for grouping errors by tag and message template.\n     */\n    readonly fingerprint: readonly [Tag, MessageTemplate]\n    /**\n     * Original message template before interpolation.\n     */\n    readonly messageTemplate: MessageTemplate\n    /**\n     * Finds a matching cause in the error cause chain.\n     */\n    findCause: <T extends Error>(ErrorClass: ErrorClass<T>) => T | undefined\n    /**\n     * Serializes the tagged error, metadata, and cause chain.\n     */\n    toJSON: () => object\n  }\n\n/**\n * Class type returned by `createTaggedError`.\n */\nexport type TaggedErrorClass<\n  Tag extends string,\n  MessageTemplate extends string,\n  Base extends Error = Error,\n> = {\n  new (\n    ...args: TaggedErrorConstructorArgs<MessageTemplate>\n  ): TaggedErrorInstance<Tag, MessageTemplate, Base>\n  /**\n   * Stable runtime tag.\n   */\n  readonly tag: Tag\n  /**\n   * Creates an Err containing this tagged error.\n   */\n  err: <This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error>(\n    this: This,\n    ...args: TaggedErrorConstructorArgs<MessageTemplate>\n  ) => ErrResult<never, ErrorClassInstance<This>>\n  /**\n   * Narrows a value to this tagged error class.\n   */\n  is: (value: unknown) => value is TaggedErrorInstance<Tag, MessageTemplate, Base>\n}\n\n/**\n * Union of members produced by `taggedEnum`.\n */\nexport type TaggedEnum<Members extends Record<string, object>> = {\n  readonly [Tag in keyof Members]: Readonly<Members[Tag]> & { readonly _tag: Tag }\n}[keyof Members]\ntype TaggedEnumMember<Members extends Record<string, object>, Tag extends keyof Members> = Readonly<\n  Members[Tag]\n> & { readonly _tag: Tag }\ntype TaggedEnumConstructor<\n  Members extends Record<string, object>,\n  Tag extends keyof Members,\n> = keyof Members[Tag] extends never\n  ? (props?: Readonly<Members[Tag]>) => TaggedEnumMember<Members, Tag>\n  : (props: Readonly<Members[Tag]>) => TaggedEnumMember<Members, Tag>\n/**\n * Factory returned by `taggedEnum`.\n */\nexport type TaggedEnumFactory<Members extends Record<string, object>> = {\n  readonly [Tag in keyof Members]: TaggedEnumConstructor<Members, Tag>\n} & {\n  /**\n   * Narrows a value to a tagged enum member.\n   */\n  $is: <Tag extends keyof Members>(\n    tag: Tag,\n    value: unknown,\n  ) => value is TaggedEnumMember<Members, Tag>\n  /**\n   * Exhaustively matches a tagged enum value.\n   */\n  $match: <ReturnType>(\n    value: TaggedEnum<Members>,\n    handlers: {\n      readonly [Tag in keyof Members]: (value: TaggedEnumMember<Members, Tag>) => ReturnType\n    },\n  ) => ReturnType\n}\n\ntype TaggedErrorLike = Error & { readonly _tag: string }\ntype TaggedErrorTags<ErrorType extends Error> = Extract<ErrorType, TaggedErrorLike>['_tag']\ntype ErrorForTag<ErrorType extends Error, Tag extends string> = Extract<\n  ErrorType,\n  { readonly _tag: Tag }\n>\ntype UntaggedError<ErrorType extends Error> = Exclude<ErrorType, TaggedErrorLike>\ntype MatchHandlers<ErrorType extends Error, ReturnType> = {\n  readonly [Tag in TaggedErrorTags<ErrorType>]: (error: ErrorForTag<ErrorType, Tag>) => ReturnType\n} & ([UntaggedError<ErrorType>] extends [never]\n  ? { readonly Error?: (error: Error) => ReturnType }\n  : { readonly Error: (error: UntaggedError<ErrorType>) => ReturnType })\ntype PartialMatchHandlers<ErrorType extends Error, ReturnType> = Partial<\n  MatchHandlers<ErrorType, ReturnType>\n>\n\nconst defaultBaseError: ErrorBaseConstructor = Error\nconst defaultMessageTemplate = '$message'\n\nconst nativeError = Error as typeof Error & { isError?: (value: unknown) => boolean }\nconst templateVariableMatcher = /\\$(?<name>[a-zA-Z_][a-zA-Z0-9_]*)/gu\nconst reservedTemplateVariables = new Set<ReservedTemplateVariable>([\n  '_tag',\n  'cause',\n  'fingerprint',\n  'message',\n  'messageTemplate',\n  'name',\n  'stack',\n])\n\ntype TemplateValueStringifier = (value: unknown) => string\n\n/**\n * Narrows a value to native or platform-recognized Error.\n */\nexport function isError(value: unknown): value is Error\nexport function isError<Value>(value: Value): value is Extract<Value, Error>\nexport function isError(value: unknown): value is Error {\n  return nativeError.isError?.(value) ?? value instanceof Error\n}\n\nconst stringifyDirectTemplateValue: TemplateValueStringifier = String\n\nconst stringifySymbolTemplateValue = (value: unknown): string => {\n  const symbol = value as symbol\n\n  return symbol.description ?? symbol.toString()\n}\n\nconst stringifyFunctionTemplateValue = (value: unknown): string =>\n  (value as { readonly name: string }).name\n\nconst stringifyObjectTemplateValue = (value: unknown): string =>\n  JSON.stringify(value) ?? Object.prototype.toString.call(value)\n\ntype StringifiableTemplateValueType =\n  | 'bigint'\n  | 'boolean'\n  | 'function'\n  | 'number'\n  | 'object'\n  | 'string'\n  | 'symbol'\n\nconst templateValueStringifiers: Record<StringifiableTemplateValueType, TemplateValueStringifier> =\n  {\n    bigint: stringifyDirectTemplateValue,\n    boolean: stringifyDirectTemplateValue,\n    function: stringifyFunctionTemplateValue,\n    number: stringifyDirectTemplateValue,\n    object: stringifyObjectTemplateValue,\n    string: stringifyDirectTemplateValue,\n    symbol: stringifySymbolTemplateValue,\n  }\n\nconst stringifyTemplateValue = (value: unknown): string =>\n  isRedacted(value)\n    ? stringifyRedacted(value)\n    : templateValueStringifiers[typeof value as StringifiableTemplateValueType](value)\n\nconst compileMessageInterpolator =\n  (template: string): ((values?: Record<string, unknown>) => string) =>\n  (values) =>\n    template.replaceAll(templateVariableMatcher, (variable, key: string) => {\n      const value = values?.[key]\n      return value === undefined ? variable : stringifyTemplateValue(value)\n    })\n\nconst getTemplateVariableNames = (template: string): readonly string[] => {\n  templateVariableMatcher.lastIndex = 0\n  return [...template.matchAll(templateVariableMatcher)].map((match) =>\n    String(match.groups?.['name']),\n  )\n}\n\nconst assertNoReservedTemplateVariables = (tag: string, template: string): void => {\n  if (template === defaultMessageTemplate) {\n    return\n  }\n\n  const reservedVariables = getTemplateVariableNames(template).filter(\n    (variable): variable is ReservedTemplateVariable =>\n      reservedTemplateVariables.has(variable as ReservedTemplateVariable),\n  )\n\n  if (reservedVariables.length > 0) {\n    throw new Error(\n      `createTaggedError(${tag}): reserved template variable $${reservedVariables[0]} is not allowed`,\n    )\n  }\n}\n\nconst getErrorOptions = (cause: unknown): { cause?: unknown } =>\n  cause === undefined ? {} : { cause }\n\nconst assignReadonly = (target: object, key: PropertyKey, value: unknown): void => {\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: true,\n    value,\n    writable: false,\n  })\n}\n\nconst serializeTaggedValue = (value: unknown): unknown =>\n  isRedacted(value) ? stringifyRedacted(value) : value\n\nconst serializeCause = (cause: unknown, seen = new Set<Error>()): unknown => {\n  if (!isError(cause)) {\n    return serializeTaggedValue(cause)\n  }\n\n  if (seen.has(cause)) {\n    return { cause: '[Circular]', message: cause.message, name: cause.name, stack: cause.stack }\n  }\n\n  seen.add(cause)\n\n  const json: Record<string, unknown> = {\n    message: cause.message,\n    name: cause.name,\n    stack: cause.stack,\n  }\n\n  if (cause.cause !== undefined) {\n    json['cause'] = serializeCause(cause.cause, seen)\n  }\n\n  return json\n}\n\n/**\n * Finds the first cause in an Error cause chain that is an instance of `ErrorClass`.\n */\nexport const findCause = <T extends Error>(\n  error: Error,\n  ErrorClass: ErrorClass<T>,\n): T | undefined => {\n  const seen = new Set<Error>()\n  let current: unknown = error\n\n  while (isError(current)) {\n    if (seen.has(current)) {\n      break\n    }\n\n    seen.add(current)\n\n    if (current instanceof ErrorClass) {\n      return current\n    }\n\n    current = current.cause\n  }\n\n  return undefined\n}\n\n/**\n * Creates an Error class with a stable `_tag`, typed template props, cause support, and JSON output.\n *\n * Prefer tagged errors for domain failures that travel through Resultar error channels.\n *\n * @example\n * ```ts\n * class UserNotFoundError extends createTaggedError({\n *   name: \"UserNotFoundError\",\n *   message: \"User $id was not found\",\n * }) {}\n * ```\n */\nexport function createTaggedError<\n  const Tag extends string,\n  const MessageTemplate extends string = typeof defaultMessageTemplate,\n  Base extends Error = Error,\n>(\n  options: Omit<TaggedErrorOptions<Tag, MessageTemplate, Base>, 'message'> & {\n    readonly message?: RejectReservedTemplateVariables<MessageTemplate>\n  },\n): TaggedErrorClass<Tag, MessageTemplate, Base> {\n  const BaseError = options.extends ?? defaultBaseError\n  const messageTemplate = options.message ?? (defaultMessageTemplate as MessageTemplate)\n  assertNoReservedTemplateVariables(options.name, messageTemplate)\n  const interpolate = compileMessageInterpolator(messageTemplate)\n\n  class GeneratedTaggedError extends BaseError {\n    public static readonly tag = options.name\n    public readonly _tag = options.name\n    public readonly fingerprint = [options.name, messageTemplate] as const\n    public readonly messageTemplate = messageTemplate\n\n    public constructor(props?: ConstructorProps<MessageTemplate>) {\n      const message = interpolate(props)\n      super(message, getErrorOptions(props?.cause))\n      // eslint-disable-next-line nicorn/custom-error-definition\n      this.name = options.name\n\n      if (props) {\n        for (const [key, value] of Object.entries(props)) {\n          if (!reservedTemplateVariables.has(key as ReservedTemplateVariable)) {\n            assignReadonly(this, key, value)\n          }\n        }\n      }\n    }\n\n    /**\n     * Narrows a value to this tagged error class.\n     */\n    public static is(value: unknown): value is TaggedErrorInstance<Tag, MessageTemplate, Base> {\n      return value instanceof this\n    }\n\n    /**\n     * Creates an Err containing this tagged error.\n     */\n    public static err<\n      This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error,\n    >(\n      this: This,\n      ...args: TaggedErrorConstructorArgs<MessageTemplate>\n    ): ErrResult<never, InstanceType<This>> {\n      const error = new this(...args) as InstanceType<This>\n      return resultErr<never, InstanceType<This>>(error)\n    }\n\n    /**\n     * Finds a matching cause in this error's cause chain.\n     */\n    public findCause<T extends Error>(ErrorClass: ErrorClass<T>): T | undefined {\n      return findCause(this, ErrorClass)\n    }\n\n    /**\n     * Serializes the tagged error, metadata, and cause chain.\n     */\n    public toJSON(): object {\n      const json: Record<string, unknown> = {\n        _tag: this._tag,\n        fingerprint: this.fingerprint,\n        message: this.message,\n        messageTemplate: this.messageTemplate,\n        name: this.name,\n      }\n\n      if (this.cause !== undefined) {\n        json['cause'] = serializeCause(this.cause)\n      }\n\n      for (const [key, value] of Object.entries(this)) {\n        if (!(key in json) && key !== 'cause' && key !== 'stack') {\n          json[key] = serializeTaggedValue(value)\n        }\n      }\n\n      return json\n    }\n  }\n\n  return GeneratedTaggedError as TaggedErrorClass<Tag, MessageTemplate, Base>\n}\n\n/**\n * Creates a small tagged-union factory with member constructors, `$is`, and `$match`.\n */\nexport const taggedEnum = <\n  Members extends Record<string, object>,\n>(): TaggedEnumFactory<Members> => {\n  const target = {\n    $is<Tag extends keyof Members>(\n      tag: Tag,\n      value: unknown,\n    ): value is TaggedEnumMember<Members, Tag> {\n      return (\n        typeof value === 'object' &&\n        value !== null &&\n        '_tag' in value &&\n        (value as { readonly _tag?: unknown })._tag === tag\n      )\n    },\n    $match<ReturnType>(\n      value: TaggedEnum<Members>,\n      handlers: {\n        readonly [Tag in keyof Members]: (value: TaggedEnumMember<Members, Tag>) => ReturnType\n      },\n    ): ReturnType {\n      const handler = handlers[value._tag] as\n        | ((value: TaggedEnum<Members>) => ReturnType)\n        | undefined\n\n      if (handler === undefined) {\n        throw new Error(`No tagged enum handler for ${String(value._tag)}`)\n      }\n\n      return handler(value)\n    },\n  }\n\n  return new Proxy(target, {\n    get(base, property, receiver) {\n      if (property in base) {\n        return Reflect.get(base, property, receiver) as unknown\n      }\n\n      if (typeof property !== 'string') {\n        return undefined\n      }\n\n      return (props?: object): object => {\n        const value: Record<string, unknown> = { _tag: property }\n\n        if (props !== undefined) {\n          for (const [key, propValue] of Object.entries(props)) {\n            if (key !== '_tag') {\n              value[key] = propValue\n            }\n          }\n        }\n\n        return Object.freeze(value)\n      }\n    },\n  }) as TaggedEnumFactory<Members>\n}\n\n/**\n * Matches an Error by tagged `_tag`, with optional native `Error` fallback.\n *\n * Throws the original error when no handler matches.\n */\nexport const matchError = <ErrorType extends Error, ReturnType>(\n  error: ErrorType,\n  handlers: MatchHandlers<ErrorType, ReturnType>,\n): ReturnType => {\n  if ('_tag' in error && typeof error._tag === 'string' && error._tag in handlers) {\n    const handler = handlers[error._tag as keyof typeof handlers] as (\n      error: ErrorType,\n    ) => ReturnType\n    return handler(error)\n  }\n\n  if (handlers.Error) {\n    return (handlers.Error as (error: ErrorType) => ReturnType)(error)\n  }\n\n  throw error\n}\n\n/**\n * Matches an Error by tagged `_tag`, then native `Error`, then the provided fallback.\n */\nexport const matchErrorPartial = <ErrorType extends Error, ReturnType>(\n  error: ErrorType,\n  handlers: PartialMatchHandlers<ErrorType, ReturnType>,\n  fallback: (error: ErrorType) => ReturnType,\n): ReturnType => {\n  if ('_tag' in error && typeof error._tag === 'string' && error._tag in handlers) {\n    const handler = handlers[error._tag as keyof typeof handlers]\n    if (handler) {\n      return (handler as (error: ErrorType) => ReturnType)(error)\n    }\n  }\n\n  if (handlers.Error) {\n    return (handlers.Error as (error: ErrorType) => ReturnType)(error)\n  }\n\n  return fallback(error)\n}\n"],"mappings":";;;;AAGA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC,YAAmB,UAAU,qBAAqB,SAAwB;EACxE,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO;CACd;AACF;AAEA,MAAM,gBAAgB,UACpB,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAAsC,SAAS;AAElD,MAAM,gBAAgB,UACpB,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAAsC,SAAS;;;;AAKlD,MAAa,gBAAgB,UAC3B,iBAAiB,cAAc,aAAa,KAAK,KAAK,aAAa,KAAK;;;AC3B1E,MAAM,WAAiB,MAAY,QAAoD;CACrF,MAAM,QAAQ,IAAI;CAElB,IAAI,CAAC,OACH,OAAO;CAGT,IAAI,QAAQ,MAAM,IAAa;CAE/B,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,GAC1B,QAAS,GAAgC,KAAK;CAGhD,OAAO;AACT;AAEA,IAAsB,WAAtB,MAA+B;CAU7B,KAAY,GAAG,KAAiD;EAC9D,OAAO,QAAQ,MAAM,GAAG;CAC1B;AACF;;;AC7BA,IAAI,qBAAqD,KAAA;AAEzD,MAAa,8BAA8B,YAAsC;CAC/E,qBAAqB;AACvB;AAEA,MAAa,qBAAwB,YAAiC;CACpE,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MAAM,+BAA+B;CAGjD,OAAO,mBAAmB,OAAO;AACnC;;;ACRA,MAAM,qBAAkC,EAAE,gBAAgB,MAAM;AAMhE,MAAa,uBACX,SACA,QACA,SAAsB,uBACE;CACxB,MAAM,OAAO,OAAO,KAAK,IACrB;EAAE,MAAM;EAAM,OAAO,OAAO;CAAM,IAClC;EAAE,MAAM;EAAO,OAAO,OAAO;CAAM;CAEvC,MAAM,aAAa,OAAO,kCAAiB,IAAI,MAAM,EAAA,CAAE,QAAQ,KAAA;CAE/D,MAAM,QAAQ;EAAE,MAAM;EAAiB;EAAM;CAAQ;CAErD,OAAO,eAAe,KAAA,IAAY,QAAQ,OAAO,OAAO,OAAO,EAAE,OAAO,WAAW,CAAC;AACtF;;;ACxBA,MAAM,uBAAuB,OAAO,sBAAsB;AAI1D,MAAa,wBACX,SACkC,SAAS;AAE7C,MAAM,iBAAiB,UACrB,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU;AAE3D,MAAa,UACX,OACA,QACoC,cAAc,KAAK,KAAK,MAAM,SAAS;AAE7E,MAAa,qBAAwB,OAAgB,aAA2C;CAC9F,IAAI,CAAC,cAAc,KAAK,GACtB,OAAO;CAGT,MAAM,UAAW,SAAqC,MAAM;CAE5D,IAAI,YAAY,KAAA,GACd,OAAO;CAGT,OAAO,EAAE,OAAQ,QAAkC,KAAK,EAAE;AAC5D;AAEA,MAAM,oBACJ,OACA,aACyB;CACzB,MAAM,UAAU,SAAS;CAEzB,IAAI,YAAY,KAAA,GACd,OAAO;CAGT,OAAO,EAAE,OAAO,QAAQ,KAAK,EAAE;AACjC;AAEA,MAAM,4BAAkC,OAAU,aAA2C;CAC3F,MAAM,SAAS,kBAAqB,OAAO,QAAQ;CAEnD,IAAI,qBAAqB,MAAM,GAC7B,OAAO;CAGT,OAAO,iBAAiB,OAAO,QAAgD;AACjF;AAEA,MAAa,iBACX,OACA,UACA,aACU;CACV,MAAM,UAAU,yBAA+B,OAAO,QAAQ;CAE9D,OAAO,qBAAqB,OAAO,IAAI,QAAQ,QAAQ,SAAS,KAAK;AACvE;;;AC2aA,MAAM,qBAA2B,eAAiE;CAChG,MAAM,SAAc,CAAC;CAErB,KAAK,MAAM,UAAU,YAAY;EAC/B,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAK;EAGzB,OAAO,KAAK,OAAO,KAAK;CAC1B;CAEA,OAAO,GAAG,MAAM;AAClB;AAEA,MAAM,uBAA+C,iBAA6C;CAChG,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,YAAY,GAAG;EACxD,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAK;EAGzB,OAAO,OAAO,OAAO;CACvB;CAEA,OAAO,GAAG,MAAM;AAClB;AAEA,MAAM,kCACJ,eAC8B;CAC9B,IAAI,MAAM,GAAG,CAAC,CAAC;CAEf,KAAK,MAAM,UAAU,YACnB,IAAI,OAAO,MAAM,KAAK,IAAI,MAAM,GAC9B,IAAI,MAAM,KAAK,OAAO,KAAK;MACtB,IAAI,OAAO,MAAM,KAAK,IAAI,KAAK,GACpC,MAAM,IAAI,CAAC,OAAO,KAAK,CAAC;MACnB,IAAI,OAAO,KAAK,KAAK,IAAI,KAAK,GACnC,IAAI,MAAM,KAAK,OAAO,KAAK;CAI/B,OAAO;AACT;AAEA,MAAM,oCACJ,iBACyC;CACzC,MAAM,SAAoB,CAAC;CAC3B,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,YAAY,GACrD,IAAI,OAAO,MAAM,GACf,OAAO,KAAK,OAAO,KAAK;MAExB,OAAO,OAAO,OAAO;CAIzB,IAAI,OAAO,SAAS,GAClB,OAAO,IAAI,MAAM;CAGnB,OAAO,GAAG,MAAM;AAClB;AAEA,MAAMA,gBAAc,UAElB,UAAU,SAET,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,OAAQ,MAAmD,OAAO,cAAc;AAElF,MAAa,0CAAiD;CAC5D,MAAM,wBAAQ,IAAI,MAAM,yCAAyC;CACjE,MAAM,OAAO;CAEb,OAAO;AACT;AAEA,MAAMC,eAAa,UAA6B,MAAwC;AAExF,MAAM,cACJ,SACA,YACoD;CACpD,IAAI,QAAQ;CAEZ,IAAI,QAAQ,YAAY,MAAM;EAC5B,OAAO,QAAQ,MAAM,KAAK,GAAG;GAC3B,MAAM,SAAS,QAAQ,KAAK,KAAK;GAEjC,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAyB;GAK7C,QAAQ,QAAQ,KAAK,KAAK;EAC5B;EAEA,OAAO,GAA2B,KAAA,CAAS;CAC7C;CAEA,MAAM,SAA4B,CAAC;CAEnC,OAAO,QAAQ,MAAM,KAAK,GAAG;EAC3B,MAAM,SAAS,QAAQ,KAAK,KAAK;EAEjC,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAyB;EAK7C,OAAO,KAAK,OAAO,KAAwB;EAC3C,QAAQ,QAAQ,KAAK,KAAK;CAC5B;CAEA,OAAO,GAAiD,MAAM;AAChE;AAEA,MAAM,iBACJ,SACA,YAC6B;CAC7B,IAAI,QAAQ;CAEZ,OAAO,QAAQ,MAAM,KAAK,GAAG;EAC3B,MAAM,SAAS,QAAQ,KAAK,KAAK;EAEjC,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAyB;EAG7C,QAAQ,OAAO;CACjB;CAEA,OAAO,GAA4B,KAAK;AAC1C;AAEA,MAAM,iBACJ,OACA,GACA,YAC0D;CAC1D,IAAI,SAAS,YAAY,MAAM;EAC7B,IAAI,QAAQ;EAEZ,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,SAAS,EAAE,MAAM,KAAK;GAE5B,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAyB;GAK7C,SAAS;EACX;EAEA,OAAO,GAA2B,KAAA,CAAS;CAC7C;CAEA,MAAM,SAA4B,CAAC;CACnC,IAAI,QAAQ;CAEZ,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,SAAS,EAAE,MAAM,KAAK;EAE5B,IAAI,OAAO,MAAM,GACf,OAAO,IAAI,OAAO,KAAyB;EAK7C,OAAO,KAAK,OAAO,KAAwB;EAC3C,SAAS;CACX;CAEA,OAAO,GAAiD,MAAM;AAChE;AAEA,MAAM,sBAAsB,WAA6B;CACvD,IAAI;EACF,OAAO;CACT,QAAQ,CAER;AACF;AAEA,MAAa,wBACX,OACA,UAC4B;CAC5B,IAAI,OAAO,UAAU,YACnB,OAAO,MAAM;CAGf,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,UAAU,wCAAwC;CAG9D,OAAO;AACT;;;;AAyOA,IAAM,kBAAN,MAAsB;CACpB,QAAe,OAAO,aAAa,OAAyB;EAC1D,OAAO,iBAAiB,MAAM,iBAAiB;CACjD;;;;;;;;;;;;CAaA,OAAc,SAEZ,IACA,SACc;EACd,IAAI;GACF,OAAO,GAAG,GAAG,CAAC;EAChB,SAAS,OAAO;GACd,IAAI,SACF,OAAO,IAAI,QAAQ,KAAK,CAAC;GAE3B,OAAO,IAAI,KAAU;EACvB;CACF;;;;;;;;CASA,OAAc,cAEZ,IACA,SACwD;EACxD,QAAQ,GAAG,SAAS;GAClB,IAAI;IAEF,OAAO,GADQ,GAAG,GAAG,IACN,CAAmB;GACpC,SAAS,OAAO;IACd,IAAI,SACF,OAAO,IAAI,QAAQ,KAAK,CAAC;IAG3B,OAAO,IAAI,KAAU;GACvB;EACF;CACF;CAWA,OAAc,GAA6B,OAA0B;EACnE,OAAO,GAAS,KAAK;CACvB;;;;;;CAOA,OAAc,OAAkD;EAC9D,OAAO,KAAQ;CACjB;CAKA,OAAc,IAAwC,OAA2B;EAC/E,OAAO,IAAU,KAAK;CACxB;CAiBA,OAAc,QAOZ,OAImD;EAEnD,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,kBAAkB,KAAK;EAGhC,IAAID,aAAW,KAAK,GAClB,OAAO,kBAAkB,CAAC,GAAG,KAAK,CAAwC;EAK5E,OAAO,oBAAoB,KAAK;CAClC;CAiBA,OAAc,qBAOZ,OAIgE;EAEhE,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,+BAA+B,KAAK;EAK7C,IAAIA,aAAW,KAAK,GAClB,OAAO,+BAA+B,CAAC,GAAG,KAAK,CAAwC;EAKzF,OAAO,iCAAiC,KAAK;CAC/C;CAcA,OAAc,YAMZ,mBACA,GAC6D;EAE7D,IAAI,MAAM,KAAA,GACR,OAAO,+BACL,iBACF;EAKF,OAAO,+BAFY,MAAM,KAAK,mBAAqC,CAEpB,CAAC;CAClD;CAEA,OAAc,IAEZ,MACA,OAC2B;EAC3B,OAAO,kBAAkB,CAAC,MAAM,KAAK,CAAC;CACxC;CAEA,OAAc,eAEZ,YAC4B;EAC5B,IAAI,cAAoD,KAAA;EAExD,KAAK,MAAM,aAAa,YAAY;GAClC,MAAM,SAAS,UAAU;GAEzB,IAAI,OAAO,KAAK,GACd,OAAO;GAGT,cAAc;EAChB;EAEA,IAAI,gBAAgB,KAAA,GAClB,MAAM,kCAAkC;EAG1C,OAAO;CACT;CAmBA,OAAc,GAMZ,WACA,SACwF;EACxF,IAAI,OAAO,cAAc,aAAa,OAAO,cAAc,YACzD,QACG,OAAO,cAAc,aAAa,UAAU,IAAI,aAC7C,QAAQ,OAAO,IACf,QAAQ,QAAQ;EAIxB,IAAI,UAAU,MAAM,GAClB,OAAO,IAAI,UAAU,KAAiC;EAOxD,OAAQ,UAAU,QAAQ,QAAQ,OAAO,IAAI,QAAQ,QAAQ;CAK/D;CAEA,OAAc,KAEZ,WACA,MACe;EACf,IAAI,OAAO,cAAc,aAAa,UAAU,IAAI,WAClD,OAAO,KAAK;EAGd,OAAO,GAAkD,KAAA,CAAS;CACpE;CAEA,OAAc,WAGA,WAAsB,MAAsD;EACxF,IAAI,UAAU,MAAM,GAClB,OAAO,IAAI,UAAU,KAAiC;EAMxD,IAAI,UAAU,OACZ,OAAO,KAAK;EAGd,OAAO,GAAkD,KAAA,CAAS;CAIpE;CAEA,OAAc,OAEZ,WACA,MACe;EACf,IAAI,OAAO,cAAc,aAAa,CAAC,UAAU,IAAI,CAAC,WACpD,OAAO,KAAK;EAGd,OAAO,GAAkD,KAAA,CAAS;CACpE;CAEA,OAAc,aAGA,WAAsB,MAAsD;EACxF,IAAI,UAAU,MAAM,GAClB,OAAO,IAAI,UAAU,KAAiC;EAMxD,IAAI,CAAC,UAAU,OACb,OAAO,KAAK;EAGd,OAAO,GAAkD,KAAA,CAAS;CAIpE;CAsBA,OAAc,KAEZ,SACA,SAKiD;EACjD,OAAO,WAAW,SAAS,OAA6C;CAC1E;CAgBA,OAAc,QAEZ,SACA,SAGwC;EACxC,OAAO,cACL,SACA,OACF;CACF;CAcA,OAAc,QAEZ,OACA,GACA,SACuD;EACvD,OAAO,cAAc,OAAO,GAAG,OAAO;CACxC;AACF;AAEA,MAAa,SAAuB;AAEpC,IAAe,gBAAf,cAA2C,SAAS;CASlD,aACE,WACA,SACkB;EAClB,OAAO,KAAK,mBAAmB,WAAW,OAAO;CACnD;CAEA,GAAU,YAIR;EACA,OAAO,EACL,OAAe,WAAqC,EAClD,QAAgB,WACd,KAAK,aAAa,YAAY,OAAO,MAAM,EAC/C,GACF;CACF;CAMA,OAAoB,GAA6C;EAC/D,OAAO,KAAK,aAAa,CAAC;CAC5B;AAcF;AAEA,IAAM,KAAN,cAAuB,cAAoB;CACzC;CAEA,YAAmB,OAAU;EAC3B,MAAM;EACN,KAAK,QAAQ;CACf;CAEA,OAAsC;EAEpC,OAAO;CACT;CAEA,QAAwC;EAEtC,OAAO;CACT;CAEA,IAAc,GAA8B;EAC1C,OAAO,GAAS,EAAE,KAAK,KAAK,CAAC;CAC/B;CAEA,GAAa,OAAwB;EAEnC,OAAO,GAAS,KAAK;CACvB;CAEA,mBACE,WACA,SACkB;EAClB,IAAI,UAAU,KAAK,KAAK,GACtB,OAAO,GAAa,KAAK,KAAK;EAGhC,OAAO,IAAc,QAAQ,KAAK,KAAK,CAAC;CAC1C;CAEA,OAAiB,KAAgC;EAC/C,OAAO,GAAS,KAAK,KAAK;CAC5B;CAEA,QAAqB,GAA6C;EAChE,OAAO,EAAE,KAAK,KAAK;CACrB;CAEA,aAA6B,IAA8C;EACzE,OAAO,GAAa,KAAK,KAAiC;CAC5D;CAEA,SACE,MACA,IACoE;EACpE,OAAO,GAAG,KAAK,KAAK;CACtB;CAEA,UACE,WAIA;EACA,OAAO,GAAG,KAAK,KAAK;CACtB;CAEA,YAKE,WACA,YACA,IAC0F;EAC1F,OAAO,GAAG,KAAK,KAAK;CACtB;CAEA,aACE,WACA,WAKA;EACA,OAAO,GAAG,KAAK,KAAK;CACtB;CAEA,aACE,WAC6D;EAC7D,OAAO,GAAG,KAAK,KAAK;CACtB;CAEA,aACE,YACA,OACA,QAC8B;EAC9B,OAAO,WAAW,KAAK,KAAK,IAAI,MAAM,KAAK,KAAK,IAAI,OAAO,KAAK,KAAK;CACvE;CAGA,aAA0B,GAAuD;EAC/E,OAAO,EAAE,KAAK,KAAK;CACrB;CAEA,SAAmB,GAA4C;EAC7D,OAAO,kBACL,QAAQ,QAAQ,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,UAAU,GAAS,KAAK,CAAC,CAChE;CACF;CAEA,SAAmB,eAAyB;EAC1C,OAAO,KAAK;CACd;CAIA,MACE,OACA,QACO;EAGP,QAFa,OAAO,UAAU,aAAa,QAAQ,MAAM,GAAA,CAE7C,KAAK,KAAK;CACxB;CAEA,UACE,MACA,WACqC;EACrC,OAAO,KAAK,KAAK,KAAK;CACxB;CAEA,iBACE,MACA,WACA,WACyC;EACzC,OAAO,KAAK,KAAK,KAAK;CACxB;CAEA,IAAW,IAAkC;EAC3C,yBAAyB;GACvB,GAAG,KAAK,OAAO,KAAA,CAAS;EAC1B,CAAC;EACD,OAAO;CACT;CAEA,IAAW,IAA0B;EACnC,yBAAyB;GACvB,GAAG,KAAK,KAAK;EACf,CAAC;EACD,OAAO;CACT;CAEA,SAAgB,KAA2B;EACzC,OAAO;CACT;CAEA,aAAoB,GAAkD;EACpE,OAAO,IAAI,iBAAiB,MAAM,CAAC;CACrC;CAEA,gBAA0B;EACxB,OAAO,KAAK;CACd;CAEA,cAAqB,SAA0B;EAC7C,OAAO,KAAK;CACd;CAEA,iBAAwB,QAAyB;EAC/C,MAAM,oBAAoB,sCAAsC,MAAM,MAAM;CAC9E;CAGA,EAAS,OAAO,YAA4C;EAC1D,OAAO,KAAK;CACd;CAEA,aAAoD;EAClD,MAAM,EAAE,UAAU;EAElB,QAAQ,aAAa;GACnB,OAAO;EACT,EAAA,CAAG;CACL;AACF;AAEA,IAAM,MAAN,cAAwB,cAAoB;CAC1C;CAEA,YAAmB,OAAU;EAC3B,MAAM;EACN,KAAK,QAAQ;CACf;CAEA,OAAsC;EAEpC,OAAO;CACT;CAEA,QAAwC;EAEtC,OAAO;CACT;CAEA,IAAc,IAA+B;EAC3C,OAAO,IAAU,KAAK,KAAK;CAC7B;CAEA,GAAa,QAAyB;EACpC,OAAO,IAAU,KAAK,KAAK;CAC7B;CAEA,mBACE,YACA,UACkB;EAClB,OAAO,IAAc,KAAK,KAAK;CACjC;CAEA,OAAiB,IAA+B;EAC9C,OAAO,IAAU,GAAG,KAAK,KAAK,CAAC;CACjC;CAEA,QAAqB,IAA8C;EACjE,OAAO,IAAc,KAAK,KAAK;CACjC;CAEA,aAA6B,GAA6C;EACxE,OAAO,EAAE,KAAK,KAAK;CACrB;CAEA,aACE,aACA,QACA,SAC8B;EAC9B,OAAO,IAA0B,KAAK,KAAK;CAC7C;CAEA,SACE,KACA,GACoE;EACpE,IAAI,OAAO,KAAK,OAAO,GAAG,GACxB,OAAO,EAAE,KAAK,KAA4B;EAM5C,OAAO,IAAI,KAAK,KAA2B;CAC7C;CAEA,UACE,UAIA;EACA,MAAM,QAAQ,KAAK;EACnB,MAAM,UAAU,kBAAmD,OAAO,QAAQ;EAElF,IAAI,qBAAqB,OAAO,GAC9B,OAAO,QAAQ;EAMjB,OAAO,IAAI,KAA+C;CAC5D;CAEA,YAKE,UACA,WACA,GAC0F;EAC1F,IAAI,OAAO,KAAK,OAAO,QAAQ,GAAG;GAChC,MAAM,SAASC,YAAU,KAAK,KAAK;GAEnC,IAAI,OAAO,QAAQ,SAAS,GAC1B,OAAO,EACL,QACA,KAAK,KACP;EAKJ;EAEA,OAAO,IAAI,KAAK,KAAiD;CACnE;CAEA,aACE,UACA,UAKA;EACA,IAAI,OAAO,KAAK,OAAO,QAAQ,GAAG;GAChC,MAAM,SAASA,YAAU,KAAK,KAAK;GAEnC,IAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,UAAU,QAAQ;IACrE,MAAM,UAAW,SACd,OAAqC;IAGxC,IAAI,YAAY,KAAA,GACd,OAAQ,QACN,QACA,KAAK,KACP;GAMJ;EACF;EAEA,OAAO,IAAI,KAAK,KAA+D;CACjF;CAEA,aACE,UAC6D;EAC7D,IAAI,OAAO,KAAK,OAAO,QAAQ,GAC7B,OAAO,IAAIA,YAAU,KAAK,KAAK,CAA2B;EAG5D,OAAO,IAAI,KAAK,KAAgC;CAClD;CAGA,aAA0B,IAAwD;EAChF,OAAO,kBAAyC,QAAQ,QAAQ,IAAc,KAAK,KAAK,CAAC,CAAC;CAC5F;CAEA,SAAmB,IAA6C;EAC9D,OAAO,kBAAqC,QAAQ,QAAQ,IAAU,KAAK,KAAK,CAAC,CAAC;CACpF;CAEA,SAAmB,cAAwB;EAEzC,OAAO;CACT;CAIA,MACE,OACA,OACO;EAGP,OAFqB,qBAAqB,OAAO,KAE/B,CAAC,CAAC,KAAK,KAAK;CAChC;CAEA,UACE,OACA,UACqC;EACrC,OAAO,cACL,KAAK,OACL,WACC,UAAU;GAET,MAAM;EACR,CACF;CACF;CAEA,iBACE,OACA,UACA,UACyC;EACzC,OAAO,cAAqD,KAAK,OAAO,UAAU,QAAQ;CAC5F;CAEA,IAAW,IAAkC;EAC3C,yBAAyB;GACvB,GAAG,KAAA,GAAW,KAAK,KAAK;EAC1B,CAAC;EACD,OAAO;CACT;CAEA,IAAW,KAA2B;EACpC,OAAO;CACT;CAEA,SAAgB,IAA0B;EACxC,yBAAyB;GACvB,GAAG,KAAK,KAAK;EACf,CAAC;EACD,OAAO;CACT;CAEA,aAAoB,GAAkD;EACpE,OAAO,IAAI,iBAAiB,MAAM,CAAC;CACrC;CAEA,gBAA0B;EAExB,MAAM,KAAK;CACb;CAEA,cAAqB,QAAyB;EAC5C,MAAM,oBAAoB,oCAAoC,MAAM,MAAM;CAC5E;CAEA,iBAAwB,SAA0B;EAChD,OAAO,KAAK;CACd;CAEA,EAAS,OAAO,YAA4C;EAC1D,MAAM;EACN,OAAO;CACT;CAEA,aAAoD;EAClD,MAAM,EAAE,UAAU;EAClB,QAAQ,aAAa;GACnB,MAAM,IAAI,KAAK;GAEf,MAAM,IAAI,MAAM,4CAA4C;EAC9D,EAAA,CAAG;CACL;AACF;;;;;AAMA,IAAa,mBAAb,MAA4E;CAC1E,WAAmB;CACnB;;;;CAIA;;;;CAKA,YAAmB,QAAsB,WAAkC;EACzE,KAAK,SAAS;EACd,KAAK,YAAY;CACnB;;;;CAKA,IAAW,QAAW;EACpB,OAAO,KAAK,OAAO,KAAK,IAAI,KAAK,OAAO,QAAS,KAAA;CACnD;;;;CAKA,IAAW,QAAW;EACpB,OAAO,KAAK,OAAO,MAAM,IAAI,KAAK,OAAO,QAAS,KAAA;CACpD;;;;CAKA,cAAqB,QAAyB;EAC5C,OAAO,KAAK,OAAO,cAAc,MAAM;CACzC;;;;CAKA,iBAAwB,QAAyB;EAC/C,OAAO,KAAK,OAAO,iBAAiB,MAAM;CAC5C;;;;CAKA,OAAuB;EACrB,OAAO,KAAK,OAAO,KAAK;CAC1B;;;;CAKA,QAAwB;EACtB,OAAO,KAAK,OAAO,MAAM;CAC3B;;;;CAKA,SAAmB,cAAwB;EACzC,OAAO,KAAK,OAAO,SAAS,YAAY;CAC1C;;;;;;CAOA,CAAQ,OAAO,WAAiB;EAC9B,IAAI,KAAK,UACP;EAGF,KAAK,WAAW;EAChB,IAAI;GACF,KAAK,UACH,KAAK,OAAO,KAAK,IAAI,KAAK,OAAO,QAAQ,KAAA,GACzC,KAAK,OAAO,MAAM,IAAI,KAAK,OAAO,QAAQ,KAAA,CAC5C;EACF,QAAQ,CAER;CACF;AACF;AAmFA,SAAgB,QACd,OAKwD;CACxD,MAAM,OAAO,OAAO,UAAU,aAAa,QAAQ,MAAM;CACzD,MAAM,UAAU,OAAO,UAAU,aAAa,KAAA,IAAY,MAAM;CAChE,IAAI,IAE0D,KAAA;CAE9D,IAAI;EACF,IAAI,KAAK,CAAC,CAAC,KAAK;CAClB,SAAS,OAAO;EACd,IAAI,SACF,OAAO,IAAqB,QAAQ,KAAK,CAAC;EAG5C,MAAM;CACR;CAEA,IAAI,aAAa,SACf,OAAO,kBACL,EACG,MAAM,MAAM,EAAE,KAAK,CAAC,CACpB,OAAO,UAAmB;EACzB,IAAI,SACF,OAAO,IAAqB,QAAQ,KAAK,CAAC;EAG5C,MAAM;CACR,CAAC,CACL;CAGF,OAAO,EAAE;AACX;AAOA,SAAgB,GAAiB,OAA0B;CACzD,OAAO,IAAI,GAAS,KAAK;AAC3B;AAQA,SAAgB,IAA4B,OAA2B;CACrE,OAAO,IAAI,IAAU,KAAK;AAC5B;;;;;;AAOA,MAAa,gBAA6C,OAAO;AAuCjE,SAAgB,UACd,OACA,SACc;CACd,MAAM,KAAK,OAAO,UAAU,aAAa,QAAQ,MAAM;CACvD,MAAM,UAAU,OAAO,UAAU,aAAa,UAAU,MAAM;CAE9D,IAAI;EACF,OAAO,GAAS,GAAG,CAAM;CAC3B,SAAS,OAAO;EACd,IAAI,SACF,OAAO,IAAU,QAAQ,KAAK,CAAC;EAGjC,OAAO,IAAU,KAAU;CAC7B;AACF;;;;AAKA,SAAgB,OAA0C;CACxD,OAAO,GAAiB,KAAA,CAAS;AACnC;;;;;;;AAQA,MAAa,WAAiB,WAA4B,OAAO,cAAc;;AAG/E,MAAa,WAA6B;;;ACrrD1C,SAAS,wBACP,OACsC;CAEtC,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,SAAS;AACjE;AAEA,MAAM,0BACJ,oBAEA,YAAY,gBAAgB,QAAQ,IAAI,eAAe,CAAC,CAAC,CAAC,SAAS,eACjE,OAAO,QAAQ,UAAU,CAC3B;AAEF,MAAM,2BAA2B,OAC/B,sBACsD;CACtD,MAAM,UAAU,OAAO,QAAQ,iBAAiB;CAChD,MAAM,aAAa,MAAM,QAAQ,IAAI,QAAQ,KAAK,UAAU,MAAM,EAAE,CAAC;CACrE,MAAM,eAAyD,CAAC;CAEhE,KAAK,MAAM,CAAC,OAAO,CAAC,SAAS,QAAQ,QAAQ,GAAG;EAC9C,MAAM,SAAS,WAAW;EAG1B,IAAI,WAAW,KAAA,GACb,aAAa,OAAO;CAExB;CAEA,OAAO;AACT;AAEA,MAAM,4BACJ,sBACiC;CAIjC,OAAO,IAAI,YAHK,yBAAyB,iBAAiB,CAAC,CAAC,MAAM,iBAChE,OAAO,QAAQ,YAAY,CAEA,CAAC;AAChC;AAEA,MAAM,uCACJ,oBAEA,YAAY,gBAAgB,QAAQ,IAAI,eAAe,CAAC,CAAC,CAAC,SAAS,eACjE,OAAO,qBAAqB,UAAU,CACxC;AAEF,MAAM,yCACJ,sBAC8C;CAI9C,OAAO,IAAI,YAHK,yBAAyB,iBAAiB,CAAC,CAAC,MAAM,iBAChE,OAAO,qBAAqB,YAAY,CAEb,CAAC;AAChC;AAEA,MAAM,cAAc,UAElB,UAAU,SAET,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,OAAQ,MAAmD,OAAO,cAAc;AAOlF,MAAM,kCAAkC,YAA2B;CACjE,MAAM,QAAQ,IAAI,MAAM,OAAO;CAC/B,MAAM,OAAO;CAEb,OAAO;AACT;AAEA,MAAM,iDACJ,+BACE,qEACF;AAEF,MAAM,mCAAmC,gBAAiD;CACxF,IAAI,gBAAgB,KAAA,GAClB,OAAO;CAGT,IAAI,gBAAgB,aAClB,OAAO,OAAO;CAGhB,IAAI,OAAO,UAAU,WAAW,KAAK,cAAc,GACjD,OAAO;CAGT,MAAM,yCAAyC;AACjD;AAEA,MAAM,+BAA+B,UACnC,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAE1D,MAAM,gCACJ,WACiC,CAAC,GAAG,MAAM,CAAC,CAAC,UAAU,MAAM,UAAU,KAAK,QAAQ,MAAM,KAAK;AAuBjG,MAAM,yCAAgF;CACpF,aAAa;CACb,QAAQ,CAAC;CACT,cAAc;CACd,WAAW;CACX,gBAAgB;CAChB,QAAQ,CAAC;AACX;AAEA,MAAM,iCACJ,YAEA,QAAQ,IAAI,YAAY;CACtB,MAAM,cAAc,gCAAgC,QAAQ,WAAW;CACvE,MAAM,WAAW,QAAQ,MAAM,OAAO,SAAS,CAAC;CAChD,MAAM,QAAQ,gCAAsC;CAEpD,OAAO,IAAI,SAAkC,SAAS,WAAW;EAC/D,IAAI,UAAU;EAEd,MAAM,cAAc,UAAyB;GAE3C,IAAI,CAAC,SAAS;IAEZ,UAAU;IACV,OAAO,4BAA4B,KAAK,CAAC;GAC3C;EACF;EAEA,MAAM,eAAe,WAA0C;GAE7D,IAAI,CAAC,SAAS;IAEZ,UAAU;IACV,QAAQ,MAAM;GAChB;EACF;EAEA,MAAM,qBAA2B;GAC/B,MAAM,SAAS,QAAQ,OAAO,KAAK;GAEnC,IAAI,WAAW,KAAA,GACb,YAAY,MAAM;EAEtB;EAEA,MAAM,iBAAmD;GACvD,IAAI;IACF,OAAO,SAAS,KAAK;GACvB,SAAS,OAAO;IACd,WAAW,KAAK;IAChB;GACF;EACF;EAEA,MAAM,iBAAuB;GAE3B,IAAI,SACF;GAGF,IAAI,MAAM,gBAAgB;IACxB,aAAa;IACb;GACF;GAEA,OAAO,CAAC,MAAM,gBAAgB,MAAM,cAAc,aAAa;IAC7D,MAAM,OAAO,SAAS;IAGtB,IAAI,SAAS,KAAA,GACX;IAGF,IAAI,KAAK,SAAS,MAAM;KACtB,MAAM,eAAe;KACrB;IACF;IAEA,MAAM,eAAe,MAAM;IAC3B,MAAM,aAAa;IACnB,UAAU,KAAK,OAAO,YAAY;GACpC;GAEA,aAAa;EACf;EAEA,MAAM,aAAa,MAAY,iBAA+B;GAC5D,MAAM,eAAe;GAErB,IAAI;IACF,MAAM,cAAc,QAAQ,IAAI,MAAM,YAAY;IAElD,QAAa,QAAQ,WAAW,CAAC,CAC9B,MAAM,WAAW;KAChB,QAAQ,SAAS,QAAQ,cAAc,KAAK;IAC9C,GAAG,UAAU,CAAC,CACb,cAAc;KAEb,IAAI,SACF;KAGF,MAAM,eAAe;KACrB,SAAS;KACT,aAAa;IACf,CAAC;GACL,SAAS,OAAO;IACd,WAAW,KAAK;GAClB;EACF;EAEA,SAAS;CACX,CAAC;AACH,CAAC;AAEH,MAAM,oCAAoC,WACxC,OAAO,WAAW,KAAA,IACd,IAAI,WAAW,2BAA2B,IAC1C,IAAI,WAAW,6BAA6B,EAAE,OAAO,OAAO,OAAO,CAAC;AAE1E,MAAM,uCAAuC,WAC3C,OAAO,WAAW,KAAA,IACd,IAAI,WAAW,oCAAoC,IACnD,IAAI,WAAW,sCAAsC,EAAE,OAAO,OAAO,OAAO,CAAC;AAEnF,MAAM,iCAAiC,UAAwB;CAC7D,IAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,GACtC,MAAM,+BAA+B,wDAAwD;AAEjG;AAEA,MAAM,sCAAsC,YAA0B;CACpE,IAAI,CAAC,OAAO,SAAS,OAAO,KAAK,UAAU,GACzC,MAAM,+BACJ,gEACF;AAEJ;AAEA,MAAM,oCAAoC,aAA2B;CACnE,IAAI,CAAC,OAAO,SAAS,QAAQ,KAAK,WAAW,GAC3C,MAAM,+BACJ,iEACF;AAEJ;AAEA,MAAM,6CAA6C,UAAwB;CACzE,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,QAAQ,KAAK,QAAQ,GAClD,MAAM,+BACJ,+EACF;AAEJ;AAEA,MAAM,0CAA0C,aAAuC;CACrF,IAAI,aAAa,KAAA,GACf,iCAAiC,QAAQ;AAE7C;AAEA,MAAM,uCAAuC,UAAmD;CAC9F,IAAI,OAAO,UAAU,UACnB,mCAAmC,KAAK;AAE5C;AAEA,MAAM,4BAA4B,OAChC,SACA,WACsC;CACtC,IAAI,OAAO,SACT,OAAO,OAAO,IAAI,iCAAiC,MAAM,CAAC;CAG5D,IAAI,YAAY,GACd,OAAO,OAAO,GAAG,KAAA,CAAS;CAG5B,OAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,UAAU,iBAAiB;GAC/B,OAAO,oBAAoB,SAAS,KAAK;GACzC,QAAQ,OAAO,GAAG,KAAA,CAAS,CAAC;EAC9B,GAAG,OAAO;EACV,MAAM,cAAoB;GACxB,aAAa,OAAO;GACpB,QAAQ,OAAO,IAAI,iCAAiC,MAAM,CAAC,CAAC;EAC9D;EAEA,OAAO,iBAAiB,SAAS,OAAO,EAAE,MAAM,KAAK,CAAC;CACxD,CAAC;AACH;AAIA,MAAM,8BAA8B,OAClC,MACA,SACA,YAC2C;CAC3C,8BAA8B,QAAQ,KAAK;CAC3C,oCAAoC,QAAQ,OAAO;CACnD,uCAAuC,QAAQ,QAAQ;CAEvD,MAAM,SAAiC,QAAQ,UAAU,IAAI,gBAAgB,CAAC,CAAC;CAC/E,IAAI,UAAU;CAEd,OAAO,MAAM;EACX,IAAI,OAAO,SACT,OAAO,OAAO,IAAI,iCAAiC,MAAM,CAAC;EAI5D,MAAM,SAAS,MAAM,KAAK,SAAS,MAAM;EAEzC,IAAI,OAAO,KAAK,GACd,OAAO,OAAO,GAAG,OAAO,KAAK;EAG/B,MAAM,UAAmC;GACvC;GACA,aAAa,UAAU;GACvB,kBAAkB,KAAK,IAAI,GAAG,QAAQ,QAAQ,OAAO;EACvD;EAEA,MAAM,cAAc,QAAQ;EAO5B,IAAI,EALF,gBAAgB,KAAA,IACZ,OAEA,MAAM,YAAY,OAAO,OAAO,OAAO,MAEvB,WAAW,QAAQ,OAAO;GAC9C,MAAM,YAAY,QAAQ,OAAO,OAAO,OAAO;GAC/C,OAAO,qBAAqB,cAAc,YAAY;EACxD;EAEA,MAAM,UAAU,QAAQ;EAGxB,IAAI,YAAY,KAAA,GACd,IAAI;GAEF,MAAM,QAAQ,OAAO,OAAO,OAAO;EACrC,QAAQ,CAER;EAGF,IAAI,UACF,OAAO,QAAQ,YAAY,aAAa,QAAQ,QAAQ,OAAO,IAAK,QAAQ,WAAW;EACzF,mCAAmC,OAAO;EAE1C,MAAM,WAAW,QAAQ;EAEzB,IAAI,aAAa,KAAA,KAAa,aAAa,KAAK,YAAY,GAAG;GAC7D,MAAM,SAAS,KAAK,OAAO;GAC3B,0CAA0C,MAAM;GAEhD,MAAM,QAAQ,UAAU;GACxB,MAAM,MAAM,KAAK,IAAI,GAAG,UAAU,KAAK;GAEvC,UAAU,OADE,UAAU,QACC,OAAO;EAChC;EAGA,MAAM,cAAc,MAAM,0BAA0B,SAAS,MAAM;EAEnE,IAAI,YAAY,MAAM,GACpB,OAAO,OAAO,IAAI,YAAY,KAAK;EAGrC,WAAW;CACb;AACF;AAEA,MAAM,wBACJ,MACA,YAEA,IAAI,YACF,4BAA4C,MAAM,UAAU,UAAU,OAAO,IAAI,KAAK,CAAC,CACzF;AAEF,MAAM,8BACJ,MACA,YAEA,IAAI,YACF,4BAAwC,MAAM,UAAU,OAAO,YAC7D,QAAQ,OAAO,OAAO,OAAO,CAC/B,CACF;AAEF,MAAM,iCAAiC,OACrC,SACA,UACA,YACkB;CAClB,IAAI;EACF,MAAM,QAAQ,UAAU,OAAO;CACjC,QAAQ,CAER;AACF;AAEA,MAAM,6BAA6B,OACjC,YAC6D;CAC7D,MAAM,SAAiC,QAAQ,UAAU,IAAI,gBAAgB,CAAC,CAAC;CAE/E,IAAI,OAAO,SACT,OAAO,OAAO,IAAI,oCAAoC,MAAM,CAAC;CAG/D,MAAM,WAAW,MAAM,QAAQ,QAAQ,MAAM;CAE7C,IAAI,SAAS,MAAM,GACjB,OAAO,OAAO,IAAI,SAAS,KAAK;CAGlC,IAAI,SAAuD,KAAA;CAE3D,IAAI;EACF,IAAI,OAAO,SAAS;GAClB,SAAS,OAAO,IAAI,oCAAoC,MAAM,CAAC;GAC/D,OAAO;EACT;EAEA,SAAS,MAAM,cAAc,QAAQ,IAAI,SAAS,OAAO,MAAM,CAAC;EAEhE,OAAO;CACT,UAAU;EACR,MAAM,+BAA+B,QAAQ,SAAS,SAAS,OAAO;GAAE;GAAQ;EAAO,CAAC;CAC1F;AACF;AAEA,MAAM,2BACJ,YAEA,IAAI,YAAY,2BAA2B,OAAO,CAAC;AAErD,MAAM,+BACJ,OACA,GACA,YAC+B;CAgC/B,OAAO,IAAI,YA9BT,8BAA8B;EAC5B,aAAa,SAAS;EACtB,SAAS,UAAU;GACjB,IAAI,CAAC,MAAM,gBAAgB,MAAM,cAAc,GAC7C;GAGF,IAAI,MAAM,OAAO,SAAS,GACxB,OAAO,OAAO,IACZ,6BAA6B,MAAM,MAAM,CAAC,CAAC,KAAK,UAAU,MAAM,KAAK,CACvE;GAGF,OAAO,OAAO,GAA6D,MAAM,MAAM;EACzF;EACA;EACA,WAAW,QAAQ,cAAc,UAAU;GACzC,IAAI,OAAO,MAAM,GAAG;IAClB,MAAM,OAAO,KAAK;KAAE,OAAO,OAAO;KAAO,OAAO;IAAa,CAAC;IAC9D;GACF;GAEA,MAAM,OAAO,gBAAgB,OAAO;EACtC;EACA,KAAK;CAIP,CAE2B,CAAC;AAChC;AAEA,MAAM,iCACJ,eACoC;CAsBpC,OAAO,IAAI,YArBK,QAAQ,IAAI,YAAY;EACtC,IAAI,cAAoD,KAAA;EAExD,KAAK,MAAM,aAAa,YAAY;GAElC,MAAM,SAAS,MAAM,UAAU;GAE/B,IAAI,OAAO,KAAK,GACd,OAAO;GAGT,cAAc;EAChB;EAEA,IAAI,gBAAgB,KAAA,GAClB,MAAM,kCAAkC;EAG1C,OAAO;CACT,CAE6B,CAAC;AAChC;AAEA,MAAM,aAAa,UAA6B,MAAwC;AAQxF,MAAM,8BAA0C,IAAI,WAAW,oCAAoC;AAEnG,MAAM,iBACJ,MACA,UAC0B;CAC1B,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,SAAS,KAAK,WAAW,MAAM;CAGrC,OAAO;EAAE;EAAY;EAAQ,SAFb,QAAQ,QAAQ,MAAM,CAAC,CAAC,MAAM,gBAAgB;GAAE;GAAO,QAAQ;EAAW,EAEvD;CAAE;AACvC;AAEA,MAAM,oBAA0B,UAA8D;CAC5F,IAAI,SAAS;EACX,OAAO,KAAK,WAAW;CACzB;CACA,MAAM,SAAS,sBAAsB,GAAG;EACtC,KAAK,WAAW,MAAM,MAAM;CAC9B;CACA,OAAO;EACL,OAAO,KAAK;CACd;AACF;AAkCA,MAAM,wBACJ,MACA,YACS;CACT,KAAU,QAAQ,MAAM,EAAE,OAAO,aAAa;EAC5C,IAAI,QAAQ,MAAM,SAChB;EAGF,QAAQ,MAAM,UAAU;EACxB,MAAM,eAAe,QAAQ;EAG7B,KAAK,IAAI,aAAa,GAAG,aAAa,aAAa,QAAQ,cAAc,GAAG;GAC1E,MAAM,QAAQ,aAAa;GAG3B,IAAI,UAAU,KAAA,GAAW,CAEzB,OAAO,IAAI,eAAe,OACxB,MAAM,WAAW,MAAM,sBAAsB,CAAC;EAElD;EAEA,QAAQ,QAAQ,MAA+E;CACjG,CAAC;AACH;AAEA,MAAM,0BACJ,MACA,YACS;CACT,KAAU,QAAQ,MAAM,EAAE,OAAO,aAAa;EAE5C,IAAI,QAAQ,MAAM,SAChB;EAGF,QAAQ,MAAM,iBAAiB,IAAI,KAAK;EAExC,IAAI,OAAO,KAAK,GAAG;GAEjB,QAAQ,MAAM,UAAU;GACxB,MAAM,eAAe,QAAQ;GAG7B,KAAK,IAAI,aAAa,GAAG,aAAa,aAAa,QAAQ,cAAc,GAAG;IAC1E,MAAM,QAAQ,aAAa;IAG3B,IAAI,UAAU,KAAA,GAAW,CAEzB,OAAO,IAAI,CAAC,QAAQ,MAAM,iBAAiB,IAAI,UAAU,GACvD,MAAM,WAAW,MAAM,sBAAsB,CAAC;GAElD;GAEA,QAAQ,QACN,MACF;GACA;EACF;EAEA,QAAQ,MAAM,kBAAkB;EAChC,QAAQ,MAAM,cAAc;EAE5B,IAAI,QAAQ,MAAM,mBAAmB,QAAQ,aAAa,QAAQ;GAEhE,QAAQ,MAAM,UAAU;GACxB,QAAQ,QACN,QAAQ,MAAM,WAIhB;EACF;CACF,CAAC;AACH;AAEA,MAAM,+BAIJ,OACA,eAIA,gBAC+E;CAC/E,MAAM,WAAW,CAAC,GAAG,KAAK;CAE1B,IAAI,SAAS,WAAW,GACtB,OAAO,IAAI,YACT,QAAQ,QAAQ,OAAO,IAAI,kCAAkC,CAAC,CAAC,CACjE;CAcF,OAAO,IAAI,YAAY,IAXH,SAEjB,YAAY;EACb,MAAM,eAAe,SAAS,KAAK,MAAM,UAAU,cAAc,MAAM,KAAK,CAAC;EAC7E,MAAM,UAAU,cAAc,SAAS,YAAY;EAEnD,KAAK,MAAM,QAAQ,cACjB,YAAY,MAAM,OAAO;CAE7B,CAE6B,CAAC;AAChC;AAEA,MAAM,wBACJ,UAEA,4BACE,QACC,SAAS,kBAAkB;CAC1B;CACA;CACA,OAAO;EACL,gBAAgB;EAChB,kCAAkB,IAAI,IAAY;EAClC,aAAa,KAAA;EAEb,SAAS;CACX;AACF,IACA,sBACF;AAEF,MAAM,mBACJ,SACA,YAC8D;CAqC9D,OAAO,IAAI,YAnCT,QAAQ,IAAI,YAAY;EACtB,IAAI,QAAQ;EAEZ,IAAI,QAAQ,YAAY,MAAM;GAC5B,OAAO,QAAQ,MAAM,KAAK,GAAG;IAE3B,MAAM,SAAS,MAAM,QAAQ,KAAK,KAAK;IAEvC,IAAI,OAAO,MAAM,GACf,OAAO,OAAO,IAAI,OAAO,KAA8B;IAGzD,QAAQ,QAAQ,KAAK,KAAK;GAC5B;GAEA,OAAO,OAAO,GAAgC,KAAA,CAAS;EACzD;EAEA,MAAM,SAAiC,CAAC;EAExC,OAAO,QAAQ,MAAM,KAAK,GAAG;GAE3B,MAAM,SAAS,MAAM,QAAQ,KAAK,KAAK;GAEvC,IAAI,OAAO,MAAM,GACf,OAAO,OAAO,IAAI,OAAO,KAA8B;GAGzD,OAAO,KAAK,OAAO,KAA6B;GAChD,QAAQ,QAAQ,KAAK,KAAK;EAC5B;EAEA,OAAO,OAAO,GAA2D,MAAM;CACjF,CAE2B,CAAC;AAChC;AAEA,MAAM,sBACJ,SACA,YACkC;CAkBlC,OAAO,IAAI,YAjBK,QAAQ,IAAI,YAAY;EACtC,IAAI,QAAQ;EAEZ,OAAO,QAAQ,MAAM,KAAK,GAAG;GAE3B,MAAM,SAAS,MAAM,QAAQ,KAAK,KAAK;GAEvC,IAAI,OAAO,MAAM,GACf,OAAO,OAAO,IAAI,OAAO,KAA8B;GAGzD,QAAQ,OAAO;EACjB;EAEA,OAAO,OAAO,GAAiC,KAAK;CACtD,CAE6B,CAAC;AAChC;AAEA,MAAM,sBACJ,OACA,GACA,YACoE;CACpE,IAAI,SAAS,YAAY,MA6BvB,OAAO,IAAI,YA5BmD,8BAA8B;EAC1F,aAAa,QAAQ;EACrB,SAAS,UAAU;GACjB,IAAI,MAAM,cAAc,GACtB;GAGF,MAAM,aAAa,6BAA6B,MAAM,MAAM,CAAC,CAAC;GAE9D,IAAI,eAAe,KAAA,GACjB,OAAO,OAAO,IAAiC,WAAW,KAAK;GAGjE,OAAO,OAAO,GAAgC,KAAA,CAAS;EACzD;EACA;EACA,WAAW,QAAQ,cAAc,UAAU;GACzC,IAAI,OAAO,MAAM,GAAG;IAClB,MAAM,OAAO,KAAK;KAAE,OAAO,OAAO;KAAO,OAAO;IAAa,CAAC;IAC9D,MAAM,iBAAiB;GACzB;EACF;EACA,KAAK;CAIP,CAE6B,CAAC;CAqChC,OAAO,IAAI,YAjCT,8BAA8B;EAC5B,aAAa,SAAS;EACtB,SAAS,UAAU;GACjB,IAAI,MAAM,cAAc,GACtB;GAGF,MAAM,aAAa,6BAA6B,MAAM,MAAM,CAAC,CAAC;GAE9D,IAAI,eAAe,KAAA,GACjB,OAAO,OAAO,IACZ,WAAW,KACb;GAGF,OAAO,OAAO,GAA2D,MAAM,MAAM;EACvF;EACA;EACA,WAAW,QAAQ,cAAc,UAAU;GACzC,IAAI,OAAO,MAAM,GAAG;IAClB,MAAM,OAAO,KAAK;KAAE,OAAO,OAAO;KAAO,OAAO;IAAa,CAAC;IAC9D,MAAM,iBAAiB;IACvB;GACF;GAEA,MAAM,OAAO,gBAAgB,OAAO;EACtC;EACA,KAAK;CAIP,CAE2B,CAAC;AAChC;AAEA,MAAM,sCAAsC,cAC1C,OAAO,cAAc,aAAa,UAAU,IAAI;AAElD,MAAM,iBACJ,WAC6C;CAE7C,IAAI,kBAAkB,aACpB,OAAO;CAGT,OAAO,IAAI,YAAY,QAAQ,QAAQ,MAA6C,CAAC;AACvF;AAEA,MAAM,iBAIJ,WACA,YAC0C;CAc1C,OAAO,IAAI,YAXP,QAAQ,IAAI,YAAY;EAK1B,OAAQ,MAAM,cAJC,mCAAmC,SAAS,IACvD,QAAQ,OAAO,IACf,QAAQ,QAAQ,CAEc;CAIpC,CAE6B,CAAC;AAChC;AAEA,MAAM,8BAKJ,WACA,YAC0D;CAqB1D,OAAO,IAAI,YAfP,QAAQ,IAAI,YAAY;EAC1B,MAAM,kBAAkB,MAAM,cAAc,SAAS;EAErD,IAAI,gBAAgB,MAAM,GACxB,OAAO,OAAO,IAAI,gBAAgB,KAAK;EAKzC,OAAQ,MAAM,cAFC,gBAAgB,QAAQ,QAAQ,OAAO,IAAI,QAAQ,QAAQ,CAExC;CAIpC,CAE6B,CAAC;AAChC;AAEA,MAAM,mBACJ,WACA,SACuB;CAWvB,OAAO,IAAI,YAV+D,QAAQ,IAChF,YAAY;EACV,IAAI,CAAC,mCAAmC,SAAS,GAC/C,OAAO,OAAO,GAA4C,KAAA,CAAS;EAGrE,OAAQ,MAAM,cAAc,KAAK,CAAC;CACpC,CAG2B,CAAC;AAChC;AAEA,MAAM,2CAIJ,WACA,MACA,cAC+C;CAmB/C,OAAO,IAAI,YAjBT,QAAQ,IAAI,YAAY;EACtB,MAAM,kBAAkB,MAAM,cAAc,SAAS;EAErD,IAAI,gBAAgB,MAAM,GACxB,OAAO,OAAO,IAAI,gBAAgB,KAAK;EAGzC,IAAI,CAAC,UAAU,gBAAgB,KAAK,GAClC,OAAO,OAAO,GAAoE,KAAA,CAAS;EAG7F,OAAQ,MAAM,cAAc,KAAK,CAAC;CAIpC,CAE2B,CAAC;AAChC;AAEA,MAAM,gCAIJ,WACA,SAEA,wCAAwC,WAAW,OAAO,UAAU,KAAK;AAE3E,MAAM,qBACJ,WACA,SACuB,sBAAsB,CAAC,mCAAmC,SAAS,GAAG,IAAI;AAEnG,MAAM,kCAIJ,WACA,SAEA,wCAAwC,WAAW,OAAO,UAAU,CAAC,KAAK;AAS5E,MAAM,2BAA0C,EAC9C,UACA,UACA,IACA,aAC2D;CAC3D,IAAI,OAAO,KAAK,GACd,OAAO,GAAG,OAAO,KAAK;CAGxB,OAAO,cAAuB,OAAO,OAAO,UAAU,QAAQ;AAChE;AAEA,MAAM,sBAAsB,OAAO,WAAsD;CACvF,IAAI;EACF,MAAM,OAAO;CACf,QAAQ,CAER;AACF;AAEA,IAAa,wBAAb,MAA+F;CAC7F;CACA;CACA,WAAmB;;;;CAKnB,YAAmB,KAA4B,WAAuC;EACpF,KAAK,eAAe;EACpB,KAAK,YAAY;CACnB;;;;CAKA,KACE,iBACA,iBACoB;EACpB,OAAO,KAAK,aAAa,KAAK,iBAAiB,eAAe;CAChE;;;;;;CAOA,OAAc,OAAO,gBAA+B;EAClD,IAAI,KAAK,UACP;EAGF,KAAK,WAAW;EAChB,MAAM,SAAS,MAAM,KAAK;EAE1B,IAAI;GACF,MAAM,KAAK,UACT,OAAO,KAAK,IAAI,OAAO,QAAQ,KAAA,GAC/B,OAAO,MAAM,IAAI,OAAO,QAAQ,KAAA,CAClC;EACF,QAAQ,CAER;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,cAAb,MAAa,oBAA0B,SAA8C;CASnF,OAAc,QAAkC,OAA6B;EAC3E,OAAO,IAAI,YAAkB,QAAQ,QAAQC,GAAe,KAAK,CAAC,CAAC;CACrE;;;;;;CAOA,OAAc,YAA4D;EACxE,OAAO,IAAI,YAA0B,QAAQ,QAAQ,OAAO,KAAK,CAAC,CAAC;CACrE;CAUA,OAAc,SAA6C,OAA6B;EACtF,OAAO,IAAI,YAAkB,QAAQ,QAAQ,IAAU,KAAK,CAAC,CAAC;CAChE;CAwBA,OAAc,SAEZ,IACA,SACyB;EAUzB,OAAO,IAAI,aATc,OAAO,OAAO,aAAa,QAAQ,IAAI,EAAE,IAAI,GAAA,CAEnE,MAAM,UAAaA,GAAqB,KAAK,CAAC,CAAC,CAC/C,OAAO,UAAmB;GACzB,IAAI,SACF,OAAO,IAAgB,QAAQ,KAAK,CAAC;GAEvC,OAAO,IAAgB,KAAK;EAC9B,CAC0C,CAAC;CAC/C;CAaA,OAAc,gBAA0C,SAAwC;EAG9F,OAAO,IAAI,YAFQ,QAAQ,MAAM,UAAaA,GAAe,KAAK,CAE5B,CAAC;CACzC;CAeA,OAAc,YAEZ,SACA,SACmB;EAKnB,OAAO,IAAI,YAJQ,QAChB,MAAM,UAAaA,GAAe,KAAK,CAAC,CAAC,CACzC,OAAO,UAAmB,IAAU,QAAQ,KAAK,CAAC,CAEf,CAAC;CACzC;CAuBA,OAAc,QAOZ,OAI6D;EAE7D,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,uBAAuB,KAAK;EAKrC,IAAI,WAAW,KAAK,GAClB,OAAO,uBAAuB,CAAC,GAAG,KAAK,CAA6C;EAKtF,OAAO,yBAAyB,KAAK;CACvC;CAoBA,OAAc,qBAOZ,OAI0E;EAE1E,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,oCAAoC,KAAK;EAKlD,IAAI,WAAW,KAAK,GAClB,OAAO,oCAAoC,CAAC,GAAG,KAAK,CAGjD;EAKL,OAAO,sCAAsC,KAAK;CACpD;CAqBA,OAAc,YAMZ,wBACA,GACA,SACuE;EACvE,IAAI,MAAM,KAAA,GACR,OAAO,oCACL,sBACF;EAGF,OAAO,4BAA4B,wBAA0C,GAAG,OAAO;CACzF;;;;CAKA,OAAc,IAGA,MAAY,OAA8C;EACtE,OAAO,uBAAuB,CAAC,MAAM,KAAK,CAAC;CAC7C;;;;;;CAOA,OAAc,MAEZ,MACA,SACuF;EACvF,OAAO,qBACL,MACA,OACF;CACF;;;;CAKA,OAAc,YAEZ,MACA,SAC+D;EAC/D,OAAO,2BACL,MACA,OACF;CACF;;;;;;;CAQA,OAAc,aAEZ,SACsD;EACtD,OAAO,wBAAwB,OAAO;CACxC;;;;CAKA,OAAc,KAKZ,MACA,OAIA;EACA,OAAO,qBAAqB,CAAC,MAAM,KAAK,CAAU;CACpD;;;;CAKA,OAAc,QAOZ,OAC4E;EAC5E,OAAO,qBAAqB,KAAK;CACnC;;;;;;CAOA,OAAc,UAKZ,MACA,OAIA;EACA,OAAO,4BAIL,CAAC,MAAM,KAAK,IAEX,SAAS,kBAAkB;GAAE;GAAS;GAAc,OAAO,EAAE,SAAS,MAAM;EAAE,IAC/E,oBACF;CACF;;;;;;;CAQA,OAAc,SAOZ,MACA,OACA,UAaA;EA8DA,OAAO,IAAI,YAAY,IA7DH,SAKjB,YAAY;GACb,MAAM,WAAW,cAAc,MAAM,CAAC;GACtC,MAAM,YAAY,cAAc,OAAO,CAAC;GACxC,MAAM,aAAa,iBAAiB,QAAQ;GAI5C,MAAM,cAAc,iBAAiB,SAAS;GAI9C,IAAI,UAAU;GAEd,SAAc,QAAQ,MAAM,EAAE,aAAa;IACzC,IAAI,SACF;IAGF,UAAU;IACV,MAAM,UAAU,SAAS,WACvB,QACA,WACF;IAEA,QAAa,QAAQ,cAAc,OAAO,CAAC,CAAC,CAAC,MAAM,kBAAkB;KACnE,QACE,aAIF;IACF,CAAC;GACH,CAAC;GAED,UAAe,QAAQ,MAAM,EAAE,aAAa;IAC1C,IAAI,SACF;IAGF,UAAU;IACV,MAAM,UAAU,SAAS,YACvB,QACA,UACF;IAEA,QAAa,QAAQ,cAAc,OAAO,CAAC,CAAC,CAAC,MAAM,kBAAkB;KACnE,QACE,aAIF;IACF,CAAC;GACH,CAAC;EACH,CAE6B,CAAC;CAChC;;;;CAKA,OAAc,QAEZ,MACA,SACuF;EACvF,MAAM,eAAe,WAAqE;GAWxF,OAAO,IAAI,YAAY,IAVH,SAAsC,YAAY;IACpE,MAAM,UAAU,iBAAiB;KAC/B,QAAQ,OAAO,IAAI,QAAQ,UAAU,CAAC,CAAC;IACzC,GAAG,QAAQ,SAAS;IAEpB,OAAO,iBAAiB,eAAe;KACrC,aAAa,OAAO;IACtB,CAAC;GACH,CAE6B,CAAC;EAChC;EAEA,OAAO,YAAY,SAAS,MAAM,aAAa;GAC7C,aAAa,QAAQ,kBAAkB;IACrC,cAAc,MAAM,sBAAsB,CAAC;IAC3C,OAAO;GACT;GACA,cAAc,QAAQ,eAAe;IAEnC,IAAI,OAAO,MAAM,GACf,WAAW,MAAM,OAAO,KAAK;IAG/B,OAAO;GACT;EACF,CAAC;CACH;;;;CAKA,OAAc,eAEZ,YACiC;EACjC,OAAO,8BAA8B,UAAU;CACjD;CAmBA,OAAc,GAMZ,WACA,SAC+F;EAC/F,IAAI,OAAO,cAAc,aAAa,OAAO,cAAc,YACzD,OAAO,cAAc,WAAW,OAAO;EAGzC,OAAO,2BAA2B,WAAW,OAAO;CACtD;;;;CAKA,OAAc,KAEZ,WACA,MACoB;EACpB,OAAO,gBAAgB,WAAW,IAAI;CACxC;;;;CAKA,OAAc,WAGA,WAAsB,MAA2D;EAC7F,OAAO,6BAA6B,WAAW,IAAI;CACrD;;;;CAKA,OAAc,OAEZ,WACA,MACoB;EACpB,OAAO,kBAAkB,WAAW,IAAI;CAC1C;;;;CAKA,OAAc,aAGA,WAAsB,MAA2D;EAC7F,OAAO,+BAA+B,WAAW,IAAI;CACvD;CA2BA,OAAc,KAEZ,SACA,SAK2D;EAC3D,OAAO,gBAAgB,SAAS,OAAkD;CACpF;CAmBA,OAAc,QAEZ,SACA,SAG6C;EAC7C,OAAO,mBACL,SACA,OACF;CACF;CAoBA,OAAc,QAEZ,OACA,GACA,SACiE;EACjE,OAAO,mBAAmB,OAAO,GAAG,OAAO;CAC7C;;;;;;CAOA,OAAc,cAEZ,IACA,SACmC;EACnC,QAAQ,GAAG,SACT,IAAI,aACD,YAAY;GACX,IAAI;IAEF,OAAOA,GAAe,MADN,GAAG,GAAG,IAAI,CACH;GACzB,SAAS,OAAO;IAEd,OAAO,IADG,UAAU,QAAQ,KAAK,IAAI,KACd;GACzB;EACF,EAAA,CAAG,CACL;CACJ;CAEA;;;;;;CAOA,YAAmB,KAA4B;EAC7C,MAAM;EACN,KAAK,eAAe;CACtB;;;;;;;CAQA,KACE,iBACA,iBACoB;EACpB,OAAO,KAAK,aAAa,KAAK,iBAAiB,eAAe;CAChE;;;;CAKA,OAAiB,GAAgD;EAC/D,OAAO,IAAI,YACT,KAAK,aAAa,KAAK,OAAO,QAAQ;GACpC,IAAI,IAAI,KAAK,GACX,OAAOA,GAAe,IAAI,KAAK;GAGjC,OAAO,IAAU,MAAM,EAAE,IAAI,KAAK,CAAC;EACrC,CAAC,CACH;CACF;;;;CAKA,IAAc,GAAgD;EAC5D,OAAO,IAAI,YACT,KAAK,aAAa,KAAK,OAAO,QAAsB;GAClD,IAAI,IAAI,MAAM,GACZ,OAAO,IAAU,IAAI,KAAK;GAG5B,OAAOA,GAAe,MAAM,EAAE,IAAI,KAAK,CAAC;EAC1C,CAAC,CACH;CACF;;;;CAKA,GAAa,OAA6B;EACxC,OAAO,IAAI,YACT,KAAK,aAAa,MAAM,QAAsB;GAC5C,IAAI,IAAI,MAAM,GACZ,OAAO,IAAU,IAAI,KAAK;GAG5B,OAAOA,GAAe,KAAK;EAC7B,CAAC,CACH;CACF;CAaA,aACE,WACA,SACuB;EACvB,OAAO,IAAI,YACT,KAAK,aAAa,KAAK,OAAO,QAAQ;GACpC,IAAI,IAAI,MAAM,GACZ,OAAO,IAAc,IAAI,KAAK;GAGhC,IAAI,MAAM,UAAU,IAAI,KAAK,GAC3B,OAAOA,GAAmB,IAAI,KAAK;GAGrC,OAAO,IAAc,MAAM,QAAQ,IAAI,KAAK,CAAC;EAC/C,CAAC,CACH;CACF;CAcA,QAAqB,GAAsE;EACzF,OAAO,IAAI,YACT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,MAAM,GACZ,OAAO,IAAc,IAAI,KAAK;GAGhC,MAAM,OAAO,EAAE,IAAI,KAAK;GACxB,OAAO,gBAAgB,cAAc,KAAK,eAAe;EAC3D,CAAC,CACH;CACF;;;;CAKA,GAAU,YAMR;EACA,OAAO,EACL,OAAe,WAA0C,EACvD,QAAgB,WACd,IAAI,YACF,KAAK,aAAa,KAAK,OAAO,QAAQ;GACpC,IAAI,IAAI,KAAK,GAEX,OADkB,WAAW,IAAI,KAClB,IAAI,MAAM,IAAI,KAAK,IAAI,OAAO,IAAI,KAAK;GAGxD,OAAO,SAAS,IAAI,KAAK;EAC3B,CAAC,CACH,EACJ,GACF;CACF;CAYA,OAAoB,GAAsE;EACxF,OAAO,IAAI,YACT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,MAAM,GAAG;IACf,MAAM,OAAO,EAAE,IAAI,KAAK;IACxB,OAAO,gBAAgB,cAAc,KAAK,eAAe;GAC3D;GAEA,OAAOA,GAAmB,IAAI,KAAK;EACrC,CAAC,CACH;CACF;CAiBA,SACE,KACA,GAC4C;EAC5C,OAAO,IAAI,YACT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,KAAK,GACX,OAAO,OAAO,GAAG,IAAI,KAAK;GAG5B,IAAI,OAAO,IAAI,OAAO,GAAG,GAAG;IAC1B,MAAM,OAAO,EAAE,IAAI,KAA4B;IAC/C,OAAO,gBAAgB,cAAc,KAAK,eAAe;GAC3D;GAEA,OAAO,OAAO,IAAI,IAAI,KAA2B;EACnD,CAAC,CACH;CACF;;;;CAKA,UACE,UAIA;EACA,OAAO,IAAI,YAIT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,KAAK,GACX,OAAO,OAAO,GAAG,IAAI,KAAK;GAG5B,MAAM,QAAQ,IAAI;GAClB,MAAM,UAAU,kBAAmD,OAAO,QAAQ;GAElF,IAAI,qBAAqB,OAAO,GAAG;IACjC,MAAM,OAAO,QAAQ;IACrB,OAAO,gBAAgB,cAAc,KAAK,eAAe;GAC3D;GAEA,OAAO,OAAO,IAAI,KAA+C;EACnE,CAAC,CAMH;CACF;CAuCA,YAKE,UACA,WACA,GACyF;EACzF,OAAO,IAAI,YAIT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,KAAK,GACX,OAAO,OAAO,GAAG,IAAI,KAAK;GAG5B,IAAI,OAAO,IAAI,OAAO,QAAQ,GAAG;IAC/B,MAAM,SAAS,UAAU,IAAI,KAAK;IAElC,IAAI,OAAO,QAAQ,SAAS,GAAG;KAC7B,MAAM,OAAO,EACX,QACA,IAAI,KACN;KACA,OAAO,gBAAgB,cAAc,KAAK,eAAe;IAC3D;GACF;GAEA,OAAO,OAAO,IAAI,IAAI,KAAiD;EACzE,CAAC,CAGH;CACF;;;;CAKA,aACE,UACA,UAKA;EACA,OAAO,IAAI,YAKT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,KAAK,GACX,OAAO,OAAO,GAAG,IAAI,KAAK;GAG5B,IAAI,OAAO,IAAI,OAAO,QAAQ,GAAG;IAC/B,MAAM,SAAS,UAAU,IAAI,KAAK;IAElC,IAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,UAAU,QAAQ;KACrE,MAAM,UAAW,SACd,OAAqC;KAGxC,IAAI,YAAY,KAAA,GAAW;MACzB,MAAM,OACJ,QAIA,QAAQ,IAAI,KAAK;MACnB,OAAO,gBAAgB,cAAc,KAAK,eAAe;KAC3D;IACF;GACF;GAEA,OAAO,OAAO,IAAI,IAAI,KAA+D;EACvF,CAAC,CAOH;CACF;;;;CAKA,aACE,UACkE;EAClE,OAAO,IAAI,YACT,KAAK,aAAa,MAAM,QAAQ;GAC9B,IAAI,IAAI,KAAK,GACX,OAAO,OAAO,GAAG,IAAI,KAAK;GAG5B,IAAI,OAAO,IAAI,OAAO,QAAQ,GAC5B,OAAO,OAAO,IAAI,UAAU,IAAI,KAAK,CAA2B;GAGlE,OAAO,OAAO,IAAI,IAAI,KAAgC;EACxD,CAAC,CACH;CACF;CAOA,MAAa,MACX,OACA,OACgB;EAChB,OAAO,KAAK,aAAa,MAAM,QAE7B,OAAO,UAAU,aACb,IAAI,MAAM,OAAO,qBAAqB,OAAO,KAAK,CAAC,IACnD,IAAI,MAAM,KAAK,CACrB;CACF;;;;CAKA,MAAa,UACX,IACA,UAC8C;EAC9C,OAAO,KAAK,aAAa,MAAM,QAC7B,wBAAyE;GACvE,QAAQ;GACR;GACA;GACA,WAAW,UAAU;IAEnB,MAAM;GACR;EACF,CAAC,CACH;CACF;;;;;CAMA,MAAa,iBACX,IACA,UACA,UACkD;EAClD,OAAO,KAAK,aAAa,MAAM,QAC7B,wBAAqE;GACnE,QAAQ;GACR;GACA;GACA;EACF,CAAC,CACH;CACF;;;;CAKA,MAAa,SAAY,GAAsB;EAC7C,OAAO,KAAK,aAAa,MAAM,QAAQ,IAAI,SAAS,CAAC,CAAC;CACxD;;;;;;CAOA,MAAa,gBAA4B;EACvC,OAAO,KAAK,aAAa,MAAM,QAAQ,IAAI,cAAc,CAAC;CAC5D;;;;;;;;;;;CAYA,IAAW,GAA8D;EACvE,OAAO,IAAI,YACT,KAAK,aAAa,KAAK,OAAO,QAAQ;GACpC,IAAI,IAAI,KAAK,GAAG;IACd,MAAM,0BAA0B,EAAE,IAAI,KAAK,CAAC;IAE5C,OAAO,QAAQ,IAAI,KAAK;GAC1B;GAEA,MAAM,0BAA0B,EAAE,KAAA,GAAW,IAAI,KAAK,CAAC;GAEvD,OAAO,SAAS,IAAI,KAAK;EAC3B,CAAC,CACH;CACF;;;;;;;CAQA,IAAW,GAAsD;EAC/D,OAAO,IAAI,YACT,KAAK,aAAa,KAAK,OAAO,QAAQ;GACpC,IAAI,IAAI,MAAM,GACZ,OAAO,SAAS,IAAI,KAAK;GAG3B,MAAM,0BAA0B,EAAE,IAAI,KAAK,CAAC;GAE5C,OAAO,QAAQ,IAAI,KAAK;EAC1B,CAAC,CACH;CACF;;;;;;;CAQA,SAAgB,GAAsD;EACpE,OAAO,IAAI,YACT,KAAK,aAAa,KAAK,OAAO,QAAQ;GACpC,IAAI,IAAI,MAAM,GAAG;IACf,MAAM,0BAA0B,EAAE,IAAI,KAAK,CAAC;IAE5C,OAAO,SAAS,IAAI,KAAK;GAC3B;GAEA,OAAO,QAAQ,IAAI,KAAK;EAC1B,CAAC,CACH;CACF;;;;CAKA,kBAAyB,GAA4D;EACnF,OAAO,IAAI,sBAAsB,KAAK,cAAc,CAAC;CACvD;;;;CAKA,QAAe,OAAO,iBAAsD;EAC1E,MAAM,SAAS,MAAM,KAAK;EAE1B,IAAI,OAAO,KAAK,GACd,OAAO,OAAO;EAGhB,MAAM,IAAI,OAAO,KAAK;EAEtB,OAAO,KAAA;CACT;AACF;AAEA,4BACG,YAAY,IAAI,YAAY,OAA4C,CAC3E;;;;AAOA,MAAa,UAAsC,YAAY;;;;AAI/D,MAAa,WAAwC,YAAY;;;;AAIjE,MAAa,cAA8C,YAAY;;;;;;AAMvE,MAAa,kBAAsD,YAAY;;;;AAI/E,MAAa,YAA0C,YAAY;;;;AAInE,MAAa,qBAAuD,YAAY;AAiDhF,SAAgB,eACd,OACA,SACmB;CACnB,MAAM,cAAc,wBAAwB,KAAK,IAAI,MAAM,MAAM;CACjE,MAAM,UAAU,wBAAwB,KAAK,IAAI,MAAM,QAAQ;CAa/D,OAAO,IAAI,aAXT,OAAO,gBAAgB,aAAa,QAAQ,IAAI,WAAW,IAAI,YAAA,CAE9D,MAAM,UAAa,OAAO,GAAS,KAAK,CAAC,CAAC,CAC1C,OAAO,UAAmB;EACzB,IAAI,SACF,OAAO,OAAO,IAAU,QAAQ,KAAK,CAAC;EAGxC,OAAO,OAAO,IAAU,KAAU;CACpC,CAEoC,CAAC;AACzC;;;;;;;AAQA,MAAa,cAAoB,WAA0C,OAAO,cAAc;;AAGhG,MAAa,gBAAuC;;;AC11FpD,MAAM,iCAAiB,IAAI,QAAyB;AAEpD,MAAM,kBAAkB,UACtB,UAAU,KAAA,IAAY,eAAe,aAAa,MAAM;AAE1D,IAAM,gBAAN,MAAuB;CACrB,qBAAqC;CACrC;;;;CAKA,YAAmB,OAAU,OAA2B;EACtD,KAAK,QAAQ;EACb,eAAe,IAAI,MAAM,KAAK;CAChC;;;;CAKA,SAAwB;EACtB,OAAO,KAAK,SAAS;CACvB;;;;CAKA,WAA0B;EACxB,OAAO,eAAe,KAAK,KAAK;CAClC;AACF;;;;AAKA,MAAa,UAAa,OAAU,UAClC,IAAI,cAAc,OAAO,KAAK;;;;AAKhC,MAAa,cAAc,UAEzB,OAAO,UAAU,YAAY,UAAU,QAAQ,eAAe,IAAI,KAAK;;;;AAKzE,MAAa,kBAAqB,UAChC,eAAe,IAAI,KAA0B;;;;AAK/C,MAAa,qBAAqB,UAAqC,MAAM,SAAS;;;ACiLtF,MAAM,mBAAyC;AAC/C,MAAM,yBAAyB;AAE/B,MAAM,cAAc;AACpB,MAAM,0BAA0B;AAChC,MAAM,4BAA4B,IAAI,IAA8B;CAClE;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AASD,SAAgB,QAAQ,OAAgC;CACtD,OAAO,YAAY,UAAU,KAAK,KAAK,iBAAiB;AAC1D;AAEA,MAAM,+BAAyD;AAE/D,MAAM,gCAAgC,UAA2B;CAC/D,MAAM,SAAS;CAEf,OAAO,OAAO,eAAe,OAAO,SAAS;AAC/C;AAEA,MAAM,kCAAkC,UACrC,MAAoC;AAEvC,MAAM,gCAAgC,UACpC,KAAK,UAAU,KAAK,KAAK,OAAO,UAAU,SAAS,KAAK,KAAK;AAW/D,MAAM,4BACJ;CACE,QAAQ;CACR,SAAS;CACT,UAAU;CACV,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;AACV;AAEF,MAAM,0BAA0B,UAC9B,WAAW,KAAK,IACZ,kBAAkB,KAAK,IACvB,0BAA0B,OAAO,MAAwC,CAAC,KAAK;AAErF,MAAM,8BACH,cACA,WACC,SAAS,WAAW,0BAA0B,UAAU,QAAgB;CACtE,MAAM,QAAQ,SAAS;CACvB,OAAO,UAAU,KAAA,IAAY,WAAW,uBAAuB,KAAK;AACtE,CAAC;AAEL,MAAM,4BAA4B,aAAwC;CACxE,wBAAwB,YAAY;CACpC,OAAO,CAAC,GAAG,SAAS,SAAS,uBAAuB,CAAC,CAAC,CAAC,KAAK,UAC1D,OAAO,MAAM,SAAS,OAAO,CAC/B;AACF;AAEA,MAAM,qCAAqC,KAAa,aAA2B;CACjF,IAAI,aAAa,wBACf;CAGF,MAAM,oBAAoB,yBAAyB,QAAQ,CAAC,CAAC,QAC1D,aACC,0BAA0B,IAAI,QAAoC,CACtE;CAEA,IAAI,kBAAkB,SAAS,GAC7B,MAAM,IAAI,MACR,qBAAqB,IAAI,iCAAiC,kBAAkB,GAAG,gBACjF;AAEJ;AAEA,MAAM,mBAAmB,UACvB,UAAU,KAAA,IAAY,CAAC,IAAI,EAAE,MAAM;AAErC,MAAM,kBAAkB,QAAgB,KAAkB,UAAyB;CACjF,OAAO,eAAe,QAAQ,KAAK;EACjC,cAAc;EACd,YAAY;EACZ;EACA,UAAU;CACZ,CAAC;AACH;AAEA,MAAM,wBAAwB,UAC5B,WAAW,KAAK,IAAI,kBAAkB,KAAK,IAAI;AAEjD,MAAM,kBAAkB,OAAgB,uBAAO,IAAI,IAAW,MAAe;CAC3E,IAAI,CAAC,QAAQ,KAAK,GAChB,OAAO,qBAAqB,KAAK;CAGnC,IAAI,KAAK,IAAI,KAAK,GAChB,OAAO;EAAE,OAAO;EAAc,SAAS,MAAM;EAAS,MAAM,MAAM;EAAM,OAAO,MAAM;CAAM;CAG7F,KAAK,IAAI,KAAK;CAEd,MAAM,OAAgC;EACpC,SAAS,MAAM;EACf,MAAM,MAAM;EACZ,OAAO,MAAM;CACf;CAEA,IAAI,MAAM,UAAU,KAAA,GAClB,KAAK,WAAW,eAAe,MAAM,OAAO,IAAI;CAGlD,OAAO;AACT;;;;AAKA,MAAa,aACX,OACA,eACkB;CAClB,MAAM,uBAAO,IAAI,IAAW;CAC5B,IAAI,UAAmB;CAEvB,OAAO,QAAQ,OAAO,GAAG;EACvB,IAAI,KAAK,IAAI,OAAO,GAClB;EAGF,KAAK,IAAI,OAAO;EAEhB,IAAI,mBAAmB,YACrB,OAAO;EAGT,UAAU,QAAQ;CACpB;AAGF;;;;;;;;;;;;;;AAeA,SAAgB,kBAKd,SAG8C;CAC9C,MAAM,YAAY,QAAQ,WAAW;CACrC,MAAM,kBAAkB,QAAQ,WAAY;CAC5C,kCAAkC,QAAQ,MAAM,eAAe;CAC/D,MAAM,cAAc,2BAA2B,eAAe;CAE9D,MAAM,6BAA6B,UAAU;EAC3C,OAAuB,MAAM,QAAQ;EACrC,OAAuB,QAAQ;EAC/B,cAA8B,CAAC,QAAQ,MAAM,eAAe;EAC5D,kBAAkC;EAElC,YAAmB,OAA2C;GAC5D,MAAM,UAAU,YAAY,KAAK;GACjC,MAAM,SAAS,gBAAgB,OAAO,KAAK,CAAC;GAE5C,KAAK,OAAO,QAAQ;GAEpB,IAAI;SACG,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAC7C,IAAI,CAAC,0BAA0B,IAAI,GAA+B,GAChE,eAAe,MAAM,KAAK,KAAK;GAAA;EAIvC;;;;EAKA,OAAc,GAAG,OAA0E;GACzF,OAAO,iBAAiB;EAC1B;;;;EAKA,OAAc,IAIZ,GAAG,MACmC;GAEtC,OAAOC,IAAqC,IAD1B,KAAK,GAAG,IACsB,CAAC;EACnD;;;;EAKA,UAAkC,YAA0C;GAC1E,OAAO,UAAU,MAAM,UAAU;EACnC;;;;EAKA,SAAwB;GACtB,MAAM,OAAgC;IACpC,MAAM,KAAK;IACX,aAAa,KAAK;IAClB,SAAS,KAAK;IACd,iBAAiB,KAAK;IACtB,MAAM,KAAK;GACb;GAEA,IAAI,KAAK,UAAU,KAAA,GACjB,KAAK,WAAW,eAAe,KAAK,KAAK;GAG3C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,GAC5C,IAAI,EAAE,OAAO,SAAS,QAAQ,WAAW,QAAQ,SAC/C,KAAK,OAAO,qBAAqB,KAAK;GAI1C,OAAO;EACT;CACF;CAEA,OAAO;AACT;;;;AAKA,MAAa,mBAEsB;CA+BjC,OAAO,IAAI,MAAM;EA7Bf,IACE,KACA,OACyC;GACzC,OACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAAsC,SAAS;EAEpD;EACA,OACE,OACA,UAGY;GACZ,MAAM,UAAU,SAAS,MAAM;GAI/B,IAAI,YAAY,KAAA,GACd,MAAM,IAAI,MAAM,8BAA8B,OAAO,MAAM,IAAI,GAAG;GAGpE,OAAO,QAAQ,KAAK;EACtB;CAGoB,GAAG,EACvB,IAAI,MAAM,UAAU,UAAU;EAC5B,IAAI,YAAY,MACd,OAAO,QAAQ,IAAI,MAAM,UAAU,QAAQ;EAG7C,IAAI,OAAO,aAAa,UACtB;EAGF,QAAQ,UAA2B;GACjC,MAAM,QAAiC,EAAE,MAAM,SAAS;GAExD,IAAI,UAAU,KAAA;SACP,MAAM,CAAC,KAAK,cAAc,OAAO,QAAQ,KAAK,GACjD,IAAI,QAAQ,QACV,MAAM,OAAO;GAAA;GAKnB,OAAO,OAAO,OAAO,KAAK;EAC5B;CACF,EACF,CAAC;AACH;;;;;;AAOA,MAAa,cACX,OACA,aACe;CACf,IAAI,UAAU,SAAS,OAAO,MAAM,SAAS,YAAY,MAAM,QAAQ,UAAU;EAC/E,MAAM,UAAU,SAAS,MAAM;EAG/B,OAAO,QAAQ,KAAK;CACtB;CAEA,IAAI,SAAS,OACX,OAAQ,SAAS,MAA2C,KAAK;CAGnE,MAAM;AACR;;;;AAKA,MAAa,qBACX,OACA,UACA,aACe;CACf,IAAI,UAAU,SAAS,OAAO,MAAM,SAAS,YAAY,MAAM,QAAQ,UAAU;EAC/E,MAAM,UAAU,SAAS,MAAM;EAC/B,IAAI,SACF,OAAQ,QAA6C,KAAK;CAE9D;CAEA,IAAI,SAAS,OACX,OAAQ,SAAS,MAA2C,KAAK;CAGnE,OAAO,SAAS,KAAK;AACvB"}