npm - unthrown - Versions diffs - 0.3.0 → 1.1.0 - Mend

unthrown 0.3.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/index.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.mjs","names":[],"sources":["../src/core.ts","../src/constructors.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"sourcesContent":["// unthrown — the runtime engine.\n//\n// `Result` is the PUBLIC discriminated union (tag/value/error/cause + methods).\n// `Res` is a method holder only: its prototype carries the implementations, and\n// instances are built by `okRes`/`errRes`/`defectRes` with `Object.create` +\n// the variant type — so a builder returns a value that already is a union\n// member (no `as unknown as`). `Res` is never exported from `index.ts`.\n// `AsyncRes` wraps a `Promise<Result>` constructed never to reject and operates\n// purely on the public union (via `r.tag`). See CLAUDE.md → \"Internal design\".\n//\n// The only casts left are the inherent type-changing pass-throughs (e.g. `map`\n// reusing an `Err` as a differently-typed `Result`) — the same `as unknown as`\n// boxed uses, sound because the passed-through variant carries no value of the\n// changed type.\n\nimport type { AsyncResult, DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/*\n Thrown by a {@link Result}'s `unwrap` / `unwrapErr` when the assertion is\n * wrong on a modeled result — `unwrap()` on an `Err`, or `unwrapErr()` on an\n * `Ok`.\n \n @remarks\n * A `Defect` is never wrapped in an `UnwrapError`: its original cause is\n * re-thrown (with its original stack) instead.\n \n @typeParam E - the type of the {@link UnwrapError.error} it carries.\n /\nexport class UnwrapError<E = unknown> extends Error {\n /\n The offending value: the `Err` error for `unwrap()`, or the `Ok` value for\n * `unwrapErr()`.\n /\n readonly error: E;\n constructor(error: E) {\n super(\"unthrown: called unwrap on a non-matching Result\");\n this.name = \"UnwrapError\";\n this.error = error;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n\n/\n Method holder for {@link Result}. Never instantiated with `new` and never\n * exported; the builders below attach its prototype to plain objects. Every\n * method types `this` as the public `Result` union, so it narrows on `tag`.\n \n @internal\n /\nclass Res<T, E> {\n map<U>(this: Result<T, E>, f: (value: T) => U): Result<U, E> {\n if (this.tag !== \"Ok\") return this as unknown as Result<U, E>;\n try {\n return okRes(f(this.value));\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n flatMap<U, E2>(this: Result<T, E>, f: (value: T) => Result<U, E2>): Result<U, E \| E2> {\n if (this.tag !== \"Ok\") return this as unknown as Result<U, E \| E2>;\n try {\n return f(this.value) as Result<U, E \| E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n tap(this: Result<T, E>, f: (value: T) => void): Result<T, E> {\n if (this.tag !== \"Ok\") return this;\n try {\n f(this.value);\n return this;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n flatTap<E2>(this: Result<T, E>, f: (value: T) => Result<unknown, E2>): Result<T, E \| E2> {\n if (this.tag !== \"Ok\") return this as unknown as Result<T, E \| E2>;\n try {\n const r = f(this.value);\n // Keep the original value on success; an Err/Defect from `f` short-circuits.\n return (r.tag === \"Ok\" ? this : r) as unknown as Result<T, E \| E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n as<U>(this: Result<T, E>, value: U): Result<U, E> {\n if (this.tag !== \"Ok\") return this as unknown as Result<U, E>;\n return okRes(value);\n }\n\n mapErr<E2>(this: Result<T, E>, f: (error: E) => E2): Result<T, E2> {\n if (this.tag !== \"Err\") return this as unknown as Result<T, E2>;\n try {\n return errRes(f(this.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n orElse<U, E2>(this: Result<T, E>, f: (error: E) => Result<U, E2>): Result<T \| U, E2> {\n if (this.tag !== \"Err\") return this as unknown as Result<T \| U, E2>;\n try {\n return f(this.error) as Result<T \| U, E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n recover<U>(this: Result<T, E>, f: (error: E) => U): Result<T \| U, never> {\n if (this.tag !== \"Err\") return this as unknown as Result<T \| U, never>;\n try {\n return okRes(f(this.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n tapErr(this: Result<T, E>, f: (error: E) => void): Result<T, E> {\n if (this.tag !== \"Err\") return this;\n try {\n f(this.error);\n return this;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n recoverDefect<U, E2>(\n this: Result<T, E>,\n f: (cause: unknown) => Result<U, E2>,\n ): Result<T \| U, E \| E2> {\n if (this.tag !== \"Defect\") return this as unknown as Result<T \| U, E \| E2>;\n try {\n return f(this.cause) as Result<T \| U, E \| E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n tapDefect(this: Result<T, E>, f: (cause: unknown) => void): Result<T, E> {\n if (this.tag !== \"Defect\") return this;\n try {\n f(this.cause);\n return this;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n match<R>(\n this: Result<T, E>,\n cases: { ok: (value: T) => R; err: (error: E) => R; defect: (cause: unknown) => R },\n ): R {\n switch (this.tag) {\n case \"Ok\":\n return cases.ok(this.value);\n case \"Err\":\n return cases.err(this.error);\n case \"Defect\":\n return cases.defect(this.cause);\n }\n }\n\n unwrap(this: Result<T, E>): T {\n switch (this.tag) {\n case \"Ok\":\n return this.value;\n case \"Err\":\n throw new UnwrapError(this.error);\n case \"Defect\":\n throw this.cause; // rethrow original cause, original stack\n }\n }\n\n unwrapErr(this: Result<T, E>): E {\n switch (this.tag) {\n case \"Err\":\n return this.error;\n case \"Ok\":\n throw new UnwrapError(this.value);\n case \"Defect\":\n throw this.cause;\n }\n }\n\n unwrapOr(this: Result<T, E>, fallback: T): T {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return fallback;\n }\n\n unwrapOrElse(this: Result<T, E>, f: (error: E) => T): T {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return f(this.error);\n }\n\n getOrNull(this: Result<T, E>): T \| null {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return null;\n }\n\n getOrUndefined(this: Result<T, E>): T \| undefined {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return undefined;\n }\n\n isOk(this: Result<T, E>): this is OkView<T, E> {\n return this.tag === \"Ok\";\n }\n isErr(this: Result<T, E>): this is ErrView<E, T> {\n return this.tag === \"Err\";\n }\n isDefect(this: Result<T, E>): this is DefectView<T, E> {\n return this.tag === \"Defect\";\n }\n\n toAsync(this: Result<T, E>): AsyncResult<T, E> {\n return new AsyncRes<T, E>(Promise.resolve(this));\n }\n}\n\nconst RESULT_PROTO = Res.prototype;\n\n/\n Construct an `Ok` result — a plain object on the {@link Res} prototype.\n \n @internal\n /\nexport function okRes<T, E>(value: T): Result<T, E> {\n return Object.assign(Object.create(RESULT_PROTO), { tag: \"Ok\" as const, value }) as OkView<T, E>;\n}\n\n/\n Construct an `Err` result.\n \n @internal\n /\nexport function errRes<T, E>(error: E): Result<T, E> {\n return Object.assign(Object.create(RESULT_PROTO), { tag: \"Err\" as const, error }) as ErrView<\n E,\n T\n >;\n}\n\n/\n Construct a `Defect` result.\n \n @internal\n /\nexport function defectRes<T, E>(cause: unknown): Result<T, E> {\n return Object.assign(Object.create(RESULT_PROTO), {\n tag: \"Defect\" as const,\n cause,\n }) as DefectView<T, E>;\n}\n\n/\n The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n \n @internal\n /\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n // oxlint-disable-next-line no-thenable -- AsyncResult is an intentional (success-only) thenable so `await` collapses it to a Result; see the Awaitable type. onrejected is still forwarded so a hypothetical internal rejection settles the await instead of hanging — though the internal promise never rejects.\n then<R1 = Result<T, E>, R2 = never>(\n onfulfilled?: ((value: Result<T, E>) => R1 \| PromiseLike<R1>) \| null,\n onrejected?: ((reason: unknown) => R2 \| PromiseLike<R2>) \| null,\n ): PromiseLike<R1 \| R2> {\n return this.promise.then(onfulfilled, onrejected);\n }\n\n map<U>(f: (value: T) => U): AsyncResult<U, E> {\n return new AsyncRes<U, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Ok\") return r as unknown as Result<U, E>;\n try {\n return okRes(f(r.value));\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n flatMap<U, E2>(f: (value: T) => Result<U, E2> \| AsyncResult<U, E2>): AsyncResult<U, E \| E2> {\n return new AsyncRes<U, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Ok\") return r as unknown as Result<U, E \| E2>;\n try {\n return (await f(r.value)) as Result<U, E \| E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n tap(f: (value: T) => void): AsyncResult<T, E> {\n return new AsyncRes<T, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Ok\") return r;\n try {\n f(r.value);\n return r;\n } catch (cause) {\n return defectRes<T, E>(cause);\n }\n }),\n );\n }\n\n flatTap<E2>(\n f: (value: T) => Result<unknown, E2> \| AsyncResult<unknown, E2>,\n ): AsyncResult<T, E \| E2> {\n return new AsyncRes<T, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Ok\") return r as unknown as Result<T, E \| E2>;\n try {\n const inner = (await f(r.value)) as Result<unknown, E2>;\n // Keep the original value on success; an Err/Defect from `f` wins.\n return (inner.tag === \"Ok\" ? r : inner) as unknown as Result<T, E \| E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n as<U>(value: U): AsyncResult<U, E> {\n return new AsyncRes<U, E>(\n this.promise.then((r) =>\n r.tag === \"Ok\" ? okRes<U, E>(value) : (r as unknown as Result<U, E>),\n ),\n );\n }\n\n mapErr<E2>(f: (error: E) => E2): AsyncResult<T, E2> {\n return new AsyncRes<T, E2>(\n this.promise.then((r) => {\n if (r.tag !== \"Err\") return r as unknown as Result<T, E2>;\n try {\n return errRes(f(r.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n orElse<U, E2>(f: (error: E) => Result<U, E2> \| AsyncResult<U, E2>): AsyncResult<T \| U, E2> {\n return new AsyncRes<T \| U, E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Err\") return r as unknown as Result<T \| U, E2>;\n try {\n return (await f(r.error)) as Result<T \| U, E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n recover<U>(f: (error: E) => U): AsyncResult<T \| U, never> {\n return new AsyncRes<T \| U, never>(\n this.promise.then((r) => {\n if (r.tag !== \"Err\") return r as unknown as Result<T \| U, never>;\n try {\n return okRes<T \| U, never>(f(r.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n tapErr(f: (error: E) => void): AsyncResult<T, E> {\n return new AsyncRes<T, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Err\") return r;\n try {\n f(r.error);\n return r;\n } catch (cause) {\n return defectRes<T, E>(cause);\n }\n }),\n );\n }\n\n recoverDefect<U, E2>(\n f: (cause: unknown) => Result<U, E2> \| AsyncResult<U, E2>,\n ): AsyncResult<T \| U, E \| E2> {\n return new AsyncRes<T \| U, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Defect\") return r as unknown as Result<T \| U, E \| E2>;\n try {\n return (await f(r.cause)) as Result<T \| U, E \| E2>;\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n tapDefect(f: (cause: unknown) => void): AsyncResult<T, E> {\n return new AsyncRes<T, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Defect\") return r;\n try {\n f(r.cause);\n return r;\n } catch (cause) {\n return defectRes<T, E>(cause);\n }\n }),\n );\n }\n\n match<R>(cases: {\n ok: (value: T) => R;\n err: (error: E) => R;\n defect: (cause: unknown) => R;\n }): Promise<R> {\n return this.promise.then((r) => r.match(cases));\n }\n\n unwrap(): Promise<T> {\n return this.promise.then((r) => r.unwrap());\n }\n unwrapErr(): Promise<E> {\n return this.promise.then((r) => r.unwrapErr());\n }\n unwrapOr(fallback: T): Promise<T> {\n return this.promise.then((r) => r.unwrapOr(fallback));\n }\n unwrapOrElse(f: (error: E) => T): Promise<T> {\n return this.promise.then((r) => {\n if (r.tag === \"Ok\") return r.value;\n if (r.tag === \"Defect\") throw r.cause;\n return f(r.error);\n });\n }\n getOrNull(): Promise<T \| null> {\n return this.promise.then((r) => r.getOrNull());\n }\n getOrUndefined(): Promise<T \| undefined> {\n return this.promise.then((r) => r.getOrUndefined());\n }\n}\n","// Result constructors and the standalone narrowing guards.\n\nimport { errRes, okRes } from \"./core.js\";\nimport type { DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/\n Construct a successful {@link Result}.\n \n @typeParam T - the success value type.\n * @param value - the success value to wrap.\n \n @example\n * ```ts\n * import { ok } from \"unthrown\";\n * ok(42).unwrap(); // 42\n * ```\n /\nexport function ok<T>(value: T): Result<T, never> {\n return okRes(value);\n}\n\n/\n Construct a failed {@link Result} carrying a modeled error.\n \n @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n \n @example\n * ```ts\n * import { err } from \"unthrown\";\n * err(\"not_found\").unwrapErr(); // \"not_found\"\n * ```\n /\nexport function err<E>(error: E): Result<never, E> {\n return errRes(error);\n}\n\n/\n Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.\n \n @returns `true` when `r` is `Ok`.\n \n @example\n * ```ts\n * import { isOk, type Result } from \"unthrown\";\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\n /\nexport function isOk<T, E>(r: Result<T, E>): r is OkView<T, E> {\n return r.tag === \"Ok\";\n}\n/\n Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.\n \n @returns `true` when `r` is `Err`.\n /\nexport function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T> {\n return r.tag === \"Err\";\n}\n/\n Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.\n \n @returns `true` when `r` is a `Defect`.\n /\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n return r.tag === \"Defect\";\n}\n","// Defect marker plumbing.\n\nconst DEFECT: unique symbol = Symbol(\"unthrown/defect\");\n\n/\n The marker a `qualify` function returns to triage a cause as unexpected.\n \n @remarks\n * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns\n * `E \| Defect`: either a modeled domain error, or a `Defect` produced by\n * {@link defect} to say \"this failure is not modeled\". A `Defect` is opaque —\n * it carries the original cause for the boundary to convert into the third\n * runtime state of a `Result`.\n /\nexport type Defect = {\n readonly [DEFECT]: true;\n readonly cause: unknown;\n};\n\n/\n Wrap a cause as a {@link Defect} — the value you return from a `qualify`\n * function when a failure is not a modeled domain error.\n \n @param cause - the original thrown/rejected value.\n * @returns an opaque defect marker carrying `cause`.\n \n @example\n * ```ts\n * import { fromPromise, defect } from \"unthrown\";\n \n const user = fromPromise(fetchUser(id), (cause) =>\n * cause instanceof NotFoundError ? cause : defect(cause),\n * );\n * ```\n /\nexport function defect(cause: unknown): Defect {\n return { [DEFECT]: true, cause };\n}\n\n/\n Internal guard for the qualify-time marker. Distinct from the public\n * {@link isDefect} state guard — this one narrows the `E \| Defect` union a\n * `qualify` function returns, not a `Result`.\n \n @internal\n /\nexport function isDefectMarker(x: unknown): x is Defect {\n return (\n typeof x === \"object\" && x !== null && (x as Record<PropertyKey, unknown>)[DEFECT] === true\n );\n}\n","// Boundary interop and aggregation. Every throwing/rejecting boundary is forced\n// through `qualify`, which triages each cause into a modeled `E` or a `Defect`;\n// there is no path that yields `unknown` in `E`.\n\nimport { AsyncRes, defectRes, errRes, okRes } from \"./core.js\";\nimport { type Defect, isDefectMarker } from \"./defect.js\";\nimport { err, ok } from \"./constructors.js\";\nimport type { AsyncErrOf, AsyncOkOf, AsyncResult, ErrOf, OkOf, Result } from \"./types.js\";\n\n/\n Bridge a nullable value into a {@link Result}: absence becomes a modeled\n * `Err`. The sanctioned alternative to an `Option` type.\n \n @remarks\n * `null` and `undefined` map to `err(onAbsent())`; any other value (including\n * falsy ones like `0`, `\"\"`, `false`) maps to `Ok`.\n \n @typeParam T - the (nullable) value type.\n * @typeParam E - the error produced when the value is absent.\n * @param value - the possibly-absent value.\n * @param onAbsent - lazily produces the error for the absent case.\n \n @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n * fromNullable(map.get(key), () => \"missing\").unwrap();\n * ```\n /\nexport function fromNullable<T, E>(\n value: T \| null \| undefined,\n onAbsent: () => E,\n): Result<NonNullable<T>, E> {\n return value === null \|\| value === undefined ? err(onAbsent()) : ok(value as NonNullable<T>);\n}\n\n/\n Wrap a throwing synchronous function so it returns a {@link Result} instead of\n * throwing.\n \n @remarks\n * `qualify` must triage every thrown cause into a modeled error `E` or a\n * {@link Defect} (via {@link defect}) — there is no path that leaves `unknown`\n * in `E`. A throw inside `qualify` itself is treated as a `Defect`.\n \n The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is subtracted from `E`, never inferred into it. So a\n * `qualify` that returns only `defect(cause)` yields `E = never` (a defect is\n * out-of-band and must not pollute the error channel); reach for\n * {@link fromSafePromise} when every failure is a defect.\n \n @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param fn - the throwing function to wrap.\n * @param qualify - triages a thrown cause into `E` or a `Defect`.\n * @returns a function with the same arguments returning `Result<T, E>`.\n \n @example\n * ```ts\n * import { fromThrowable, defect } from \"unthrown\";\n * const parse = fromThrowable(JSON.parse, (cause) => defect(cause));\n * parse(\"{}\").unwrap();\n * ```\n /\nexport function fromThrowable<A extends unknown[], T, R>(\n fn: (...args: A) => T,\n qualify: (cause: unknown) => R,\n): (...args: A) => Result<T, Exclude<R, Defect>> {\n type E = Exclude<R, Defect>;\n const triage = qualify as (cause: unknown) => E \| Defect;\n return (...args: A): Result<T, E> => {\n try {\n return ok(fn(...args)) as Result<T, E>;\n } catch (cause) {\n return qualifyToResult<T, E>(cause, triage);\n }\n };\n}\n\n/\n Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing\n * every rejection to be triaged.\n \n @remarks\n * `qualify` must map each rejection cause into a modeled error `E` or a\n * {@link Defect}. The returned `AsyncResult`'s internal promise never rejects;\n * `await`-ing it always yields a `Result`. A throw inside `qualify` is itself a\n * `Defect`.\n \n The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is subtracted from `E`, never inferred into it. So a\n * `qualify` that returns only `defect(cause)` yields `E = never`; when every\n * rejection is a defect, prefer {@link fromSafePromise}.\n \n @typeParam T - the resolved value type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param promise - the promise, or a thunk returning one.\n * @param qualify - triages a rejection cause into `E` or a `Defect`.\n \n @example\n * ```ts\n * import { fromPromise, defect } from \"unthrown\";\n * const user = await fromPromise(fetchUser(id), (cause) =>\n * cause instanceof NotFoundError ? (\"not_found\" as const) : defect(cause),\n * );\n * ```\n /\nexport function fromPromise<T, R>(\n promise: Promise<T> \| (() => Promise<T>),\n qualify: (cause: unknown) => R,\n): AsyncResult<T, Exclude<R, Defect>> {\n type E = Exclude<R, Defect>;\n const triage = qualify as (cause: unknown) => E \| Defect;\n const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : promise;\n const settled: Promise<Result<T, E>> = p.then(\n (value) => okRes<T, E>(value),\n (cause) => qualifyToResult<T, E>(cause, triage),\n );\n return new AsyncRes<T, E>(settled);\n}\n\n/\n Wrap a `Promise` asserted not to fail in any modeled way: any rejection\n * becomes a `Defect`.\n \n @remarks\n * Use this only when a rejection genuinely indicates a bug rather than an\n * anticipated outcome — the error channel is `never`, so there is nothing to\n * triage. (`await`-ing still yields a `Result`; it never throws.)\n \n @typeParam T - the resolved value type.\n * @param promise - the promise, or a thunk returning one.\n /\nexport function fromSafePromise<T>(\n promise: Promise<T> \| (() => Promise<T>),\n): AsyncResult<T, never> {\n const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : promise;\n const settled: Promise<Result<T, never>> = p.then(\n (value) => okRes<T, never>(value),\n (cause) => defectRes<T, never>(cause),\n );\n return new AsyncRes<T, never>(settled);\n}\n\nfunction qualifyToResult<T, E>(\n cause: unknown,\n qualify: (cause: unknown) => E \| Defect,\n): Result<T, E> {\n try {\n const q = qualify(cause);\n return isDefectMarker(q) ? defectRes<T, E>(q.cause) : errRes<T, E>(q);\n } catch (qErr) {\n // a throw inside qualify is itself a defect\n return defectRes<T, E>(qErr);\n }\n}\n\n/\n The success channel of {@link all} / {@link allAsync}: a positional tuple\n * for a fixed-length input (including the empty tuple), or a homogeneous\n * array for a dynamic one.\n \n @remarks\n * The split keys off the input's `length`: a fixed tuple has a literal length\n * (`number extends Rs[\"length\"]` is false → keep the positional `Ts`), while a\n * general array has `length: number` (→ collapse to `Ts[number][]`). Checking\n * length rather than `Rs extends [unknown, ...unknown[]]` keeps `all([])` typed\n * as `Result<[], …>` instead of `Result<never[], …>`.\n \n @typeParam Rs - the tuple/array of input `Result` types.\n * @typeParam Ts - per-element extracted success types (`OkOf` for `all`,\n * `AsyncOkOf` for `allAsync`).\n * @internal\n /\ntype AllOk<\n Rs extends readonly unknown[],\n Ts extends readonly unknown[],\n> = number extends Rs[\"length\"] ? Ts[number][] : Ts;\n\n/* A record of `Result`s — the input to {@link allFromDict}. /\ntype ResultRecord = Record<string, Result<unknown, unknown>>;\n/* A record of `AsyncResult`s — the input to {@link allFromDictAsync}. /\ntype AsyncResultRecord = Record<string, AsyncResult<unknown, unknown>>;\n\n/\n Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,\n * else `Ok` of the values array.\n \n @internal\n /\nfunction foldArray(results: readonly Result<unknown, unknown>[]): Result<unknown, unknown> {\n let firstErr: Result<unknown, unknown> \| undefined;\n let firstDefect: Result<unknown, unknown> \| undefined;\n const values: unknown[] = [];\n for (const r of results) {\n if (r.tag === \"Defect\") firstDefect ??= r;\n else if (r.tag === \"Err\") firstErr ??= r;\n else values.push(r.value);\n }\n return firstDefect ?? firstErr ?? ok(values);\n}\n\n/\n Fold a record of settled `Result`s with the same rules, else `Ok` of the\n * record of values. Keys are written with `Object.defineProperty` so a\n * caller-supplied `\"__proto__\"` key cannot pollute the prototype.\n \n @internal\n /\nfunction foldRecord(results: ResultRecord): Result<unknown, unknown> {\n let firstErr: Result<unknown, unknown> \| undefined;\n let firstDefect: Result<unknown, unknown> \| undefined;\n const values: Record<string, unknown> = {};\n for (const [key, r] of Object.entries(results)) {\n if (r.tag === \"Defect\") firstDefect ??= r;\n else if (r.tag === \"Err\") firstErr ??= r;\n else\n Object.defineProperty(values, key, {\n value: r.value,\n enumerable: true,\n writable: true,\n configurable: true,\n });\n }\n return firstDefect ?? firstErr ?? ok(values);\n}\n\n/\n Collect a tuple/array of {@link Result}s into a single `Result` of all their\n * success values.\n \n @remarks\n * Short-circuits on the first `Err` (later entries are not inspected for\n * their error); any `Defect` present dominates, winning even over an earlier\n * `Err`. A fixed tuple keeps its positional types — `all([ok(1), ok(\"a\")])`\n * is `Result<[number, string], …>` — while a dynamic array `Result<T, E>[]`\n * collapses to `Result<T[], E>` with no cast. For a record keyed by name,\n * use {@link allFromDict}.\n \n @example\n * ```ts\n * import { all, ok } from \"unthrown\";\n * all([ok(1), ok(\"a\"), ok(true)]).unwrap(); // [1, \"a\", true] (typed [number, string, boolean])\n * all([ok(1), ok(2)] as Result<number, never>[]).unwrap(); // number[]\n * ```\n /\nexport function all<Rs extends readonly Result<unknown, unknown>[]>(\n results: readonly [...Rs],\n): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>> {\n return foldArray(results) as Result<\n AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>,\n ErrOf<Rs[number]>\n >;\n}\n\n/\n Collect a record of {@link Result}s into a single `Result` of a record of\n * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is\n * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for\n * parallel work you'd rather not tuple.\n \n @remarks\n * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`\n * dominates. This is not error accumulation.\n \n @example\n * ```ts\n * import { allFromDict, ok } from \"unthrown\";\n * allFromDict({ id: ok(1), name: ok(\"ada\") }).unwrap(); // { id: 1, name: \"ada\" }\n * ```\n /\nexport function allFromDict<R extends ResultRecord>(\n results: R,\n): Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>> {\n return foldRecord(results) as Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>>;\n}\n\n/\n The asynchronous counterpart of {@link all}: combine a tuple/array of\n * {@link AsyncResult}s into one `AsyncResult` of all their success values.\n \n @remarks\n * The inputs are resolved concurrently (order preserved); the resolved\n * `Result`s are then folded with the same rules as {@link all} — first `Err`\n * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s\n * internal promise never rejects. For a record, use {@link allFromDictAsync}.\n \n @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n * await allAsync([fromSafePromise(a()), fromSafePromise(b())]);\n * ```\n /\nexport function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(\n results: readonly [...Rs],\n): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>> {\n // Each AsyncResult is a (never-rejecting) thenable, so Promise.all adopts them;\n // `foldArray` then applies the all() rules. The internal promise never rejects.\n const settled = Promise.all(results).then((resolved) =>\n foldArray(resolved as readonly Result<unknown, unknown>[]),\n );\n return new AsyncRes(settled) as AsyncResult<\n AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>,\n AsyncErrOf<Rs[number]>\n >;\n}\n\n/\n The asynchronous counterpart of {@link allFromDict}: combine a record of\n * {@link AsyncResult}s into one `AsyncResult` of a record of their values.\n \n @remarks\n * Resolved concurrently (order preserved), folded with the {@link all} rules,\n * and the internal promise never rejects.\n \n @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n * await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });\n * ```\n /\nexport function allFromDictAsync<R extends AsyncResultRecord>(\n results: R,\n): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>> {\n const entries = Object.entries(results);\n const settled = Promise.all(entries.map(([, ar]) => ar)).then((resolved) => {\n // Null-proto accumulator: pairing resolved values back to keys can't pollute.\n const byKey: ResultRecord = Object.create(null) as ResultRecord;\n entries.forEach(([key], i) => {\n byKey[key] = resolved[i] as Result<unknown, unknown>;\n });\n return foldRecord(byKey);\n });\n return new AsyncRes(settled) as AsyncResult<\n { [K in keyof R]: AsyncOkOf<R[K]> },\n AsyncErrOf<R[keyof R]>\n >;\n}\n","// Result facade — a discoverable namespace alias for the standalone entry\n// points. The free functions remain the primary, tree-shakeable API; this\n// object is a separate export, so `import { ok }` never pulls it in. The value\n// `Result` and the type `Result<T, E>` (types.ts) share a name — the\n// companion-object pattern. See CLAUDE.md → \"Internal design\".\n\nimport { err, isDefect, isErr, isOk, ok } from \"./constructors.js\";\nimport { defect } from \"./defect.js\";\nimport {\n all,\n allAsync,\n allFromDict,\n allFromDictAsync,\n fromNullable,\n fromPromise,\n fromSafePromise,\n fromThrowable,\n} from \"./interop.js\";\nimport type { Result as ResultType } from \"./types.js\";\n\n/\n Companion object grouping the standalone entry points under a single,\n * discoverable namespace: {@link Result.ok}, {@link Result.err},\n * {@link Result.defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},\n * {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},\n * {@link Result.allAsync}, {@link Result.allFromDict},\n * {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},\n * {@link Result.isDefect}.\n \n @remarks\n * Purely additive sugar — each member is the corresponding free function.\n * The free functions remain the primary, tree-shakeable API; importing only\n * `{ ok }` never pulls this object in. The value `Result` and the type\n * {@link Result} share one name (the companion-object pattern).\n \n @example\n * ```ts\n * import { Result } from \"unthrown\";\n * Result.ok(1).flatMap((n) => Result.ok(n + 1)).unwrap(); // 2\n * ```\n /\nexport const Result = {\n ok,\n err,\n defect,\n fromNullable,\n fromThrowable,\n fromPromise,\n fromSafePromise,\n all,\n allAsync,\n allFromDict,\n allFromDictAsync,\n isOk,\n isErr,\n isDefect,\n} as const;\n\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and an\n// exhaustive, zero-dependency fold over a tagged error union.\n\nimport type { AsyncResult, Result } from \"./types.js\";\n\ntype Props = Record<string, unknown>;\n\n/\n The instance shape produced by a {@link TaggedError} class: an `Error` plus a\n * `_tag` discriminant and the (readonly) payload fields.\n \n @typeParam Tag - the string literal discriminant.\n * @typeParam A - the payload object type.\n /\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n Readonly<A> & { readonly _tag: Tag };\n\n/\n The class constructor returned by {@link TaggedError}. Generic in its payload:\n * apply it with an instantiation expression at the `extends` site.\n \n @remarks\n * When the payload is empty, the constructor takes no arguments (the\n * `keyof A extends never ? void : A` trick); otherwise it takes the payload.\n \n @typeParam Tag - the string literal discriminant.\n /\nexport type TaggedErrorConstructor<Tag extends string> = {\n new <A extends Props = {}>(args: keyof A extends never ? void : A): TaggedErrorInstance<Tag, A>;\n};\n\n/\n Build a base class for a tagged error — a class extending `Error` with a\n * `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.\n \n @remarks\n * Extend the returned class to declare a concrete error. Supply the payload with\n * an instantiation expression; omit it for a payload-less error. A `message`\n * field in the payload is forwarded to `Error`. The `_tag` always reflects\n * `tag` and cannot be overridden by the payload.\n \n `_tag` is the discriminant used by {@link matchTags}; `Error.name` is the\n * human-facing label in stack traces and logs. By default they coincide, but\n * they can be decoupled with `options.name` — so a tag can be namespaced for\n * collision-safety (`\"@my-lib/RetryableError\"`) without that slash-prefixed\n * string leaking into `Error.name`:\n \n ```ts\n * class RetryableError extends TaggedError(\"@my-lib/RetryableError\", {\n * name: \"RetryableError\",\n * })<{ message: string }> {}\n \n const e = new RetryableError({ message: \"boom\" });\n * e._tag; // \"@my-lib/RetryableError\" — namespaced discriminant\n * e.name; // \"RetryableError\" — clean display name\n * ```\n \n @typeParam Tag - the string literal discriminant.\n * @param tag - the discriminant value; also the default error `name`.\n * @param options - optional overrides. `options.name` sets `Error.name`\n * independently of `tag` (defaults to `tag`).\n \n @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class HttpError extends TaggedError(\"HttpError\")<{ status: number }> {}\n \n new NotFound()._tag; // \"NotFound\"\n * new HttpError({ status: 500 }).status; // 500\n * ```\n /\nexport function TaggedError<Tag extends string>(\n tag: Tag,\n options?: { readonly name?: string },\n): TaggedErrorConstructor<Tag> {\n const displayName = options?.name ?? tag;\n class TaggedErrorBase extends Error {\n readonly _tag!: Tag;\n\n constructor(props?: Props) {\n super(typeof props?.[\"message\"] === \"string\" ? (props[\"message\"] as string) : undefined);\n if (props) Object.assign(this, props);\n // The tag is authoritative — assign it after the payload so it can't be\n // clobbered. `name` is the display label, independent of the discriminant.\n (this as { _tag: Tag })._tag = tag;\n this.name = displayName;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n }\n\n return TaggedErrorBase as unknown as TaggedErrorConstructor<Tag>;\n}\n\n/\n The handler object {@link matchTags} requires: a branch per error tag, plus\n * `Ok` and `Defect`. Miss a tag and it will not compile — the exhaustiveness is\n * enforced by the type, with no `.exhaustive()` to forget.\n \n @typeParam T - the success value type.\n * @typeParam E - the tagged error union.\n * @typeParam R - the folded result type.\n /\nexport type TagHandlers<T, E extends { _tag: string }, R> = {\n Ok: (value: T) => R;\n Defect: (cause: unknown) => R;\n} & { [K in E[\"_tag\"]]: (error: Extract<E, { _tag: K }>) => R };\n\n/\n Exhaustively fold a {@link Result} (or {@link AsyncResult}) whose error type is\n * a tagged union, dispatching each error to the handler matching its `_tag`.\n \n @remarks\n * The `handlers` object must provide `Ok`, `Defect`, and exactly one function\n * per error tag; each tag's handler receives the narrowed error variant. A\n * missing tag is a compile error. For an `AsyncResult`, the fold resolves to a\n * `Promise<R>`.\n \n @typeParam T - the success value type.\n * @typeParam E - the tagged error union (`E extends { _tag: string }`).\n * @typeParam R - the folded result type.\n * @param result - the result to fold.\n * @param handlers - one branch per channel/tag.\n \n @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class Forbidden extends TaggedError(\"Forbidden\")<{ user: string }> {}\n \n declare const r: Result<number, NotFound \| Forbidden>;\n * matchTags(r, {\n * Ok: (n) => `got ${n}`,\n * Defect: (cause) => `bug: ${String(cause)}`,\n * NotFound: () => \"404\",\n * Forbidden: (e) => `403 for ${e.user}`,\n * });\n * ```\n */\nexport function matchTags<T, E extends { _tag: string }, R>(\n result: Result<T, E>,\n handlers: TagHandlers<T, E, R>,\n): R;\nexport function matchTags<T, E extends { _tag: string }, R>(\n result: AsyncResult<T, E>,\n handlers: TagHandlers<T, E, R>,\n): Promise<R>;\nexport function matchTags<T, E extends { _tag: string }, R>(\n result: Result<T, E> \| AsyncResult<T, E>,\n handlers: TagHandlers<T, E, R>,\n): R \| Promise<R> {\n const onErr = (error: E): R => {\n const handler = handlers[error._tag as E[\"_tag\"]] as unknown as (e: E) => R;\n return handler(error);\n };\n // Both Result and AsyncResult share `match`; the cast picks one signature for\n // the call while the public overloads keep the return type correct.\n return (result as Result<T, E>).match({ ok: handlers.Ok, err: onErr, defect: handlers.Defect });\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"index.mjs","names":[],"sources":["../src/core.ts","../src/constructors.ts","../src/defect.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"sourcesContent":["// unthrown — the runtime engine.\n//\n// `Result` is the PUBLIC discriminated union (tag/value/error/cause + methods).\n// `Res` is a method holder only: its prototype carries the implementations, and\n// instances are built by `okRes`/`errRes`/`defectRes` with `Object.create` +\n// the variant type — so a builder returns a value that already is a union\n// member (no `as unknown as`). `Res` is never exported from `index.ts`.\n// `AsyncRes` wraps a `Promise<Result>` constructed never to reject and operates\n// purely on the public union (via `r.tag`). See CLAUDE.md → \"Internal design\".\n//\n// Type-changing pass-throughs (e.g. `map` reusing an `Err` as a differently-typed\n// `Result`) all funnel through the single `passThrough` helper — one sound\n// `as unknown as` in one place, rather than boxed's inline cast at every branch.\n// The only other casts are the builders' construction (`as OkView`/…) and the\n// `bind`/`let` scope merge (a computed key can't be spelled at the type level).\n\nimport type { AsyncResult, Bound, DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/*\n Thrown by a {@link Result}'s `unwrap` / `unwrapErr` when the assertion is\n * wrong on a modeled result — `unwrap()` on an `Err`, or `unwrapErr()` on an\n * `Ok`.\n \n @remarks\n * A `Defect` is never wrapped in an `UnwrapError`: its original cause is\n * re-thrown (with its original stack) instead.\n \n @typeParam E - the type of the {@link UnwrapError.error} it carries.\n /\nexport class UnwrapError<E = unknown> extends Error {\n /\n The offending value: the `Err` error for `unwrap()`, or the `Ok` value for\n * `unwrapErr()`.\n /\n readonly error: E;\n constructor(error: E) {\n super(\"unthrown: called unwrap on a non-matching Result\");\n this.name = \"UnwrapError\";\n this.error = error;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n\n/\n Method holder for {@link Result}. Never instantiated with `new` and never\n * exported; the builders below attach its prototype to plain objects. Every\n * method types `this` as the public `Result` union, so it narrows on `tag`.\n \n @internal\n /\nclass Res<T, E> {\n map<U>(this: Result<T, E>, f: (value: T) => U): Result<U, E> {\n if (this.tag !== \"Ok\") return passThrough(this);\n try {\n return okRes(f(this.value));\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n flatMap<U, E2>(this: Result<T, E>, f: (value: T) => Result<U, E2>): Result<U, E \| E2> {\n if (this.tag !== \"Ok\") return passThrough(this);\n try {\n return f(this.value);\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n tap(this: Result<T, E>, f: (value: T) => void): Result<T, E> {\n if (this.tag !== \"Ok\") return this;\n try {\n f(this.value);\n return this;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n flatTap<E2>(this: Result<T, E>, f: (value: T) => Result<unknown, E2>): Result<T, E \| E2> {\n if (this.tag !== \"Ok\") return this;\n try {\n const r = f(this.value);\n // Keep the original value on success; an Err/Defect from `f` short-circuits.\n return r.tag === \"Ok\" ? this : passThrough(r);\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n bind<K extends string, U, E2>(\n this: Result<T, E>,\n name: K,\n f: (scope: T) => Result<U, E2>,\n ): Result<Bound<T, K, U>, E \| E2> {\n if (this.tag !== \"Ok\") return passThrough(this);\n try {\n const r = f(this.value);\n if (r.tag !== \"Ok\") return passThrough(r);\n // The merged scope can't be spelled at the type level (a computed key\n // widens to an index signature), so the constructed Ok is cast to `Bound`.\n return okRes({ ...scopeOf(this.value), [name]: r.value }) as unknown as Result<\n Bound<T, K, U>,\n E \| E2\n >;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n let<K extends string, U>(\n this: Result<T, E>,\n name: K,\n f: (scope: T) => U,\n ): Result<Bound<T, K, U>, E> {\n if (this.tag !== \"Ok\") return passThrough(this);\n try {\n return okRes({ ...scopeOf(this.value), [name]: f(this.value) }) as unknown as Result<\n Bound<T, K, U>,\n E\n >;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n as<U>(this: Result<T, E>, value: U): Result<U, E> {\n if (this.tag !== \"Ok\") return passThrough(this);\n return okRes(value);\n }\n\n mapErr<E2>(this: Result<T, E>, f: (error: E) => E2): Result<T, E2> {\n if (this.tag !== \"Err\") return passThrough(this);\n try {\n return errRes(f(this.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n orElse<U, E2>(this: Result<T, E>, f: (error: E) => Result<U, E2>): Result<T \| U, E2> {\n if (this.tag !== \"Err\") return passThrough(this);\n try {\n return f(this.error);\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n recover<U>(this: Result<T, E>, f: (error: E) => U): Result<T \| U, never> {\n if (this.tag !== \"Err\") return passThrough(this);\n try {\n return okRes(f(this.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n tapErr(this: Result<T, E>, f: (error: E) => void): Result<T, E> {\n if (this.tag !== \"Err\") return this;\n try {\n f(this.error);\n return this;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n flatTapErr<E2>(this: Result<T, E>, f: (error: E) => Result<unknown, E2>): Result<T, E \| E2> {\n if (this.tag !== \"Err\") return this;\n try {\n const r = f(this.error);\n // Keep the original error on the effect's success; an Err/Defect threads through.\n return r.tag === \"Ok\" ? this : passThrough(r);\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n recoverDefect<U, E2>(\n this: Result<T, E>,\n f: (cause: unknown) => Result<U, E2>,\n ): Result<T \| U, E \| E2> {\n if (this.tag !== \"Defect\") return this;\n try {\n return f(this.cause);\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n tapDefect(this: Result<T, E>, f: (cause: unknown) => void): Result<T, E> {\n if (this.tag !== \"Defect\") return this;\n try {\n f(this.cause);\n return this;\n } catch (cause) {\n return defectRes(cause);\n }\n }\n\n match<R>(\n this: Result<T, E>,\n cases: {\n ok: (value: T) => R;\n err: (error: E) => R;\n defect: (cause: unknown) => R;\n },\n ): R {\n switch (this.tag) {\n case \"Ok\":\n return cases.ok(this.value);\n case \"Err\":\n return cases.err(this.error);\n case \"Defect\":\n return cases.defect(this.cause);\n }\n }\n\n unwrap(this: Result<T, E>): T {\n switch (this.tag) {\n case \"Ok\":\n return this.value;\n case \"Err\":\n throw new UnwrapError(this.error);\n case \"Defect\":\n throw this.cause; // rethrow original cause, original stack\n }\n }\n\n unwrapErr(this: Result<T, E>): E {\n switch (this.tag) {\n case \"Err\":\n return this.error;\n case \"Ok\":\n throw new UnwrapError(this.value);\n case \"Defect\":\n throw this.cause;\n }\n }\n\n unwrapOr(this: Result<T, E>, fallback: T): T {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return fallback;\n }\n\n unwrapOrElse(this: Result<T, E>, f: (error: E) => T): T {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return f(this.error);\n }\n\n getOrNull(this: Result<T, E>): T \| null {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return null;\n }\n\n getOrUndefined(this: Result<T, E>): T \| undefined {\n if (this.tag === \"Ok\") return this.value;\n if (this.tag === \"Defect\") throw this.cause;\n return undefined;\n }\n\n isOk(this: Result<T, E>): this is OkView<T, E> {\n return this.tag === \"Ok\";\n }\n\n isErr(this: Result<T, E>): this is ErrView<E, T> {\n return this.tag === \"Err\";\n }\n\n isDefect(this: Result<T, E>): this is DefectView<T, E> {\n return this.tag === \"Defect\";\n }\n\n toAsync(this: Result<T, E>): AsyncResult<T, E> {\n return new AsyncRes<T, E>(Promise.resolve(this));\n }\n}\n\nconst RESULT_PROTO = Res.prototype;\n\n/\n Construct an `Ok` result — a plain object on the {@link Res} prototype.\n \n @internal\n /\nexport function okRes<T, E>(value: T): Result<T, E> {\n return Object.assign(Object.create(RESULT_PROTO), {\n tag: \"Ok\" as const,\n value,\n }) as OkView<T, E>;\n}\n\n/\n Construct an `Err` result.\n \n @internal\n /\nexport function errRes<T, E>(error: E): Result<T, E> {\n return Object.assign(Object.create(RESULT_PROTO), {\n tag: \"Err\" as const,\n error,\n }) as ErrView<E, T>;\n}\n\n/\n Construct a `Defect` result.\n \n @internal\n /\nexport function defectRes<T, E>(cause: unknown): Result<T, E> {\n return Object.assign(Object.create(RESULT_PROTO), {\n tag: \"Defect\" as const,\n cause,\n }) as DefectView<T, E>;\n}\n\n/\n Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?\n \n @remarks\n * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value\n * already known to be a `Result`, this narrows from `unknown` — useful at an\n * untyped boundary. It checks the value carries the `Result` prototype, so a\n * look-alike plain object (`{ tag: \"Ok\" }`) is not matched. An `AsyncResult`\n * is not a `Result` and returns `false`.\n \n @returns `true` when `x` is a `Result` produced by this library.\n /\nexport function isResult(x: unknown): x is Result<unknown, unknown> {\n return x instanceof Res;\n}\n\n/\n Reuse a non-matching variant (an `Err` or `Defect`) as a differently-typed\n * `Result`, with no runtime work. Sound because the passed-through variant\n * carries no value of the changed success type, so retyping it is a no-op — only\n * the phantom type parameter moves. This is the single sanctioned home for that\n * assertion (the same one boxed applies inline at every pass-through); every\n * combinator's short-circuit branch funnels through here instead of casting.\n \n @internal\n /\nfunction passThrough<T, E>(self: Result<unknown, unknown>): Result<T, E> {\n return self as unknown as Result<T, E>;\n}\n\n/\n Validate that a `bind`/`let` scope is a real (non-null) object before merging a\n * key into it.\n \n @remarks\n * Do-notation accumulates an object scope: a chain starts at `Do()` (an\n * empty object) and every `bind`/`let` returns an object, so in typed code the\n * scope is always an object. The method lives on the general `Result` surface,\n * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was\n * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`\n * silently collapse to `{}` and drop the prior scope, we throw here — the\n * surrounding `try` turns it into a {@link Defect}, surfacing the misuse as the\n * bug it is (a defect is a bug, not an absent value). A `this: object` constraint\n * was rejected: TypeScript does not hard-enforce a constraint inferred solely\n * from `this`, and it breaks `AsyncRes implements AsyncResult`.\n \n @internal\n /\nfunction scopeOf(value: unknown): object {\n if (typeof value !== \"object\" \|\| value === null) {\n throw new TypeError(\"bind/let requires an object scope — start a do-chain with Do()\");\n }\n return value;\n}\n\n/\n The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n \n @internal\n /\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n // oxlint-disable-next-line no-thenable -- AsyncResult is an intentional (success-only) thenable so `await` collapses it to a Result; see the Awaitable type. onrejected is still forwarded so a hypothetical internal rejection settles the await instead of hanging — though the internal promise never rejects.\n then<R1 = Result<T, E>, R2 = never>(\n onfulfilled?: ((value: Result<T, E>) => R1 \| PromiseLike<R1>) \| null,\n onrejected?: ((reason: unknown) => R2 \| PromiseLike<R2>) \| null,\n ): PromiseLike<R1 \| R2> {\n return this.promise.then(onfulfilled, onrejected);\n }\n\n map<U>(f: (value: T) => U): AsyncResult<U, E> {\n return new AsyncRes<U, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Ok\") return passThrough(r);\n try {\n return okRes(f(r.value));\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n flatMap<U, E2>(f: (value: T) => Result<U, E2> \| AsyncResult<U, E2>): AsyncResult<U, E \| E2> {\n return new AsyncRes<U, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Ok\") return passThrough(r);\n try {\n return await f(r.value);\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n tap(f: (value: T) => void): AsyncResult<T, E> {\n return new AsyncRes<T, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Ok\") return r;\n try {\n f(r.value);\n return r;\n } catch (cause) {\n return defectRes<T, E>(cause);\n }\n }),\n );\n }\n\n flatTap<E2>(\n f: (value: T) => Result<unknown, E2> \| AsyncResult<unknown, E2>,\n ): AsyncResult<T, E \| E2> {\n return new AsyncRes<T, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Ok\") return passThrough(r);\n try {\n const inner = await f(r.value);\n // Keep the original value on success; an Err/Defect from `f` wins.\n return inner.tag === \"Ok\" ? r : passThrough(inner);\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n bind<K extends string, U, E2>(\n name: K,\n f: (scope: T) => Result<U, E2> \| AsyncResult<U, E2>,\n ): AsyncResult<Bound<T, K, U>, E \| E2> {\n return new AsyncRes<Bound<T, K, U>, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Ok\") return passThrough(r);\n try {\n const inner = await f(r.value);\n if (inner.tag !== \"Ok\") return passThrough(inner);\n return okRes({ ...scopeOf(r.value), [name]: inner.value }) as unknown as Result<\n Bound<T, K, U>,\n E \| E2\n >;\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n let<K extends string, U>(name: K, f: (scope: T) => U): AsyncResult<Bound<T, K, U>, E> {\n return new AsyncRes<Bound<T, K, U>, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Ok\") return passThrough(r);\n try {\n return okRes({ ...scopeOf(r.value), [name]: f(r.value) }) as unknown as Result<\n Bound<T, K, U>,\n E\n >;\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n as<U>(value: U): AsyncResult<U, E> {\n return new AsyncRes<U, E>(\n this.promise.then((r) => (r.tag === \"Ok\" ? okRes<U, E>(value) : passThrough(r))),\n );\n }\n\n mapErr<E2>(f: (error: E) => E2): AsyncResult<T, E2> {\n return new AsyncRes<T, E2>(\n this.promise.then((r) => {\n if (r.tag !== \"Err\") return passThrough(r);\n try {\n return errRes(f(r.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n orElse<U, E2>(f: (error: E) => Result<U, E2> \| AsyncResult<U, E2>): AsyncResult<T \| U, E2> {\n return new AsyncRes<T \| U, E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Err\") return passThrough(r);\n try {\n return await f(r.error);\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n recover<U>(f: (error: E) => U): AsyncResult<T \| U, never> {\n return new AsyncRes<T \| U, never>(\n this.promise.then((r) => {\n if (r.tag !== \"Err\") return passThrough(r);\n try {\n return okRes<T \| U, never>(f(r.error));\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n tapErr(f: (error: E) => void): AsyncResult<T, E> {\n return new AsyncRes<T, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Err\") return r;\n try {\n f(r.error);\n return r;\n } catch (cause) {\n return defectRes<T, E>(cause);\n }\n }),\n );\n }\n\n flatTapErr<E2>(\n f: (error: E) => Result<unknown, E2> \| AsyncResult<unknown, E2>,\n ): AsyncResult<T, E \| E2> {\n return new AsyncRes<T, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Err\") return passThrough(r);\n try {\n const inner = await f(r.error);\n // Keep the original error on success; an Err/Defect from `f` wins.\n return inner.tag === \"Ok\" ? passThrough(r) : passThrough(inner);\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n recoverDefect<U, E2>(\n f: (cause: unknown) => Result<U, E2> \| AsyncResult<U, E2>,\n ): AsyncResult<T \| U, E \| E2> {\n return new AsyncRes<T \| U, E \| E2>(\n this.promise.then(async (r) => {\n if (r.tag !== \"Defect\") return r;\n try {\n return await f(r.cause);\n } catch (cause) {\n return defectRes(cause);\n }\n }),\n );\n }\n\n tapDefect(f: (cause: unknown) => void): AsyncResult<T, E> {\n return new AsyncRes<T, E>(\n this.promise.then((r) => {\n if (r.tag !== \"Defect\") return r;\n try {\n f(r.cause);\n return r;\n } catch (cause) {\n return defectRes<T, E>(cause);\n }\n }),\n );\n }\n\n match<R>(cases: {\n ok: (value: T) => R;\n err: (error: E) => R;\n defect: (cause: unknown) => R;\n }): Promise<R> {\n return this.promise.then((r) => r.match(cases));\n }\n\n unwrap(): Promise<T> {\n return this.promise.then((r) => r.unwrap());\n }\n unwrapErr(): Promise<E> {\n return this.promise.then((r) => r.unwrapErr());\n }\n unwrapOr(fallback: T): Promise<T> {\n return this.promise.then((r) => r.unwrapOr(fallback));\n }\n unwrapOrElse(f: (error: E) => T): Promise<T> {\n return this.promise.then((r) => {\n if (r.tag === \"Ok\") return r.value;\n if (r.tag === \"Defect\") throw r.cause;\n return f(r.error);\n });\n }\n getOrNull(): Promise<T \| null> {\n return this.promise.then((r) => r.getOrNull());\n }\n getOrUndefined(): Promise<T \| undefined> {\n return this.promise.then((r) => r.getOrUndefined());\n }\n}\n","// Result constructors and the standalone narrowing guards.\n\nimport { errRes, okRes } from \"./core.js\";\nimport type { DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/\n Construct a successful {@link Result}.\n \n @typeParam T - the success value type.\n * @param value - the success value to wrap.\n \n @example\n * ```ts\n * import { Ok } from \"unthrown\";\n * Ok(42).unwrap(); // 42\n * ```\n /\nexport function Ok<T>(value: T): Result<T, never> {\n return okRes(value);\n}\n\n/\n Construct a failed {@link Result} carrying a modeled error.\n \n @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n \n @example\n * ```ts\n * import { Err } from \"unthrown\";\n * Err(\"not_found\").unwrapErr(); // \"not_found\"\n * ```\n /\nexport function Err<E>(error: E): Result<never, E> {\n return errRes(error);\n}\n\n/\n Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.\n \n @returns `true` when `r` is `Ok`.\n \n @example\n * ```ts\n * import { isOk, type Result } from \"unthrown\";\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\n /\nexport function isOk<T, E>(r: Result<T, E>): r is OkView<T, E> {\n return r.tag === \"Ok\";\n}\n/\n Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.\n \n @returns `true` when `r` is `Err`.\n /\nexport function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T> {\n return r.tag === \"Err\";\n}\n/\n Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.\n \n @returns `true` when `r` is a `Defect`.\n /\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n return r.tag === \"Defect\";\n}\n","// Defect marker plumbing.\n\nconst DEFECT: unique symbol = Symbol(\"unthrown/Defect\");\n\n/\n The marker a `qualify` function returns to triage a cause as unexpected.\n \n @remarks\n * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns\n * `E \| Defect`: either a modeled domain error, or a `Defect` produced by\n * {@link Defect} to say \"this failure is not modeled\". A `Defect` is opaque —\n * it carries the original cause for the boundary to convert into the third\n * runtime state of a `Result`.\n /\nexport type Defect = {\n readonly [DEFECT]: true;\n readonly cause: unknown;\n};\n\n/\n Wrap a cause as a {@link Defect} — the value you return from a `qualify`\n * function when a failure is not a modeled domain error.\n \n @param cause - the original thrown/rejected value.\n * @returns an opaque Defect marker carrying `cause`.\n \n @example\n * ```ts\n * import { fromPromise, Defect } from \"unthrown\";\n \n const user = fromPromise(fetchUser(id), (cause) =>\n * cause instanceof NotFoundError ? cause : Defect(cause),\n * );\n * ```\n /\nexport function Defect(cause: unknown): Defect {\n return { [DEFECT]: true, cause };\n}\n\n/\n Internal guard for the qualify-time marker. Distinct from the public\n * {@link isDefect} state guard — this one narrows the `E \| Defect` union a\n * `qualify` function returns, not a `Result`.\n \n @internal\n /\nexport function isDefectMarker(x: unknown): x is Defect {\n return (\n typeof x === \"object\" && x !== null && (x as Record<PropertyKey, unknown>)[DEFECT] === true\n );\n}\n","// Do-notation entry point. The `bind` / `let` steps live on the `Result` /\n// `AsyncResult` method surface (core.ts); `Do()` just seeds an empty object\n// scope to grow.\n\nimport { Ok } from \"./constructors.js\";\nimport type { Result } from \"./types.js\";\n\n/\n Start a do-notation chain with an empty object scope, grown step by step with\n * `bind` (for `Result`-returning steps) and `let` (for pure values).\n \n @remarks\n * Capitalised because `do` is a reserved word. Each step receives the scope\n * accumulated so far; the error types union across `bind`s, and a throw in any\n * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`\n * (then a `bind` may return an `AsyncResult`).\n \n @example\n * ```ts\n * import { Do, Ok } from \"unthrown\";\n \n const result = Do()\n * .bind(\"user\", () => findUser(id)) // Result<User, NotFound>\n * .bind(\"org\", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>\n * .let(\"label\", ({ user, org }) => `${user.name} @ ${org.name}`)\n * .map(({ user, org, label }) => render(user, org, label));\n * // Result<View, NotFound>\n * ```\n /\nexport function Do(): Result<{}, never> {\n return Ok({});\n}\n","// Boundary interop and aggregation. Every throwing/rejecting boundary is forced\n// through `qualify`, which triages each cause into a modeled `E` or a `Defect`;\n// there is no path that yields `unknown` in `E`.\n\nimport { AsyncRes, defectRes, errRes, okRes } from \"./core.js\";\nimport { type Defect, isDefectMarker } from \"./defect.js\";\nimport { Err, Ok } from \"./constructors.js\";\nimport type { AsyncErrOf, AsyncOkOf, AsyncResult, ErrOf, OkOf, Result } from \"./types.js\";\n\n/\n Bridge a nullable value into a {@link Result}: absence becomes a modeled\n * `Err`. The sanctioned alternative to an `Option` type.\n \n @remarks\n * `null` and `undefined` map to `Err(onAbsent())`; any other value (including\n * falsy ones like `0`, `\"\"`, `false`) maps to `Ok`.\n \n @typeParam T - the (nullable) value type.\n * @typeParam E - the error produced when the value is absent.\n * @param value - the possibly-absent value.\n * @param onAbsent - lazily produces the error for the absent case.\n \n @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n * fromNullable(map.get(key), () => \"missing\").unwrap();\n * ```\n /\nexport function fromNullable<T, E>(\n value: T \| null \| undefined,\n onAbsent: () => E,\n): Result<NonNullable<T>, E> {\n return value === null \|\| value === undefined ? Err(onAbsent()) : Ok(value as NonNullable<T>);\n}\n\n/\n Wrap a throwing synchronous function so it returns a {@link Result} instead of\n * throwing.\n \n @remarks\n * `qualify` must triage every thrown cause into a modeled error `E` or a\n * {@link Defect} (via {@link Defect}) — there is no path that leaves `unknown`\n * in `E`. A throw inside `qualify` itself is treated as a `Defect`.\n \n The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is subtracted from `E`, never inferred into it. So a\n * `qualify` that returns only `Defect(cause)` yields `E = never` (a Defect is\n * out-of-band and must not pollute the error channel); reach for\n * {@link fromSafePromise} when every failure is a Defect.\n \n @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param fn - the throwing function to wrap.\n * @param qualify - triages a thrown cause into `E` or a `Defect`.\n * @returns a function with the same arguments returning `Result<T, E>`.\n \n @example\n * ```ts\n * import { fromThrowable, Defect } from \"unthrown\";\n * const parse = fromThrowable(JSON.parse, (cause) => Defect(cause));\n * parse(\"{}\").unwrap();\n * ```\n /\nexport function fromThrowable<A extends unknown[], T, R>(\n fn: (...args: A) => T,\n qualify: (cause: unknown) => R,\n): (...args: A) => Result<T, Exclude<R, Defect>> {\n type E = Exclude<R, Defect>;\n const triage = qualify as (cause: unknown) => E \| Defect;\n return (...args: A): Result<T, E> => {\n try {\n return Ok(fn(...args)) as Result<T, E>;\n } catch (cause) {\n return qualifyToResult<T, E>(cause, triage);\n }\n };\n}\n\n/\n Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing\n * every rejection to be triaged.\n \n @remarks\n * `qualify` must map each rejection cause into a modeled error `E` or a\n * {@link Defect}. The returned `AsyncResult`'s internal promise never rejects;\n * `await`-ing it always yields a `Result`. A throw inside `qualify` is itself a\n * `Defect`.\n \n The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is subtracted from `E`, never inferred into it. So a\n * `qualify` that returns only `Defect(cause)` yields `E = never`; when every\n * rejection is a Defect, prefer {@link fromSafePromise}.\n \n @typeParam T - the resolved value type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param promise - the promise, or a thunk returning one.\n * @param qualify - triages a rejection cause into `E` or a `Defect`.\n \n @example\n * ```ts\n * import { fromPromise, Defect } from \"unthrown\";\n * const user = await fromPromise(fetchUser(id), (cause) =>\n * cause instanceof NotFoundError ? (\"not_found\" as const) : Defect(cause),\n * );\n * ```\n /\nexport function fromPromise<T, R>(\n promise: Promise<T> \| (() => Promise<T>),\n qualify: (cause: unknown) => R,\n): AsyncResult<T, Exclude<R, Defect>> {\n type E = Exclude<R, Defect>;\n const triage = qualify as (cause: unknown) => E \| Defect;\n const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : promise;\n const settled: Promise<Result<T, E>> = p.then(\n (value) => okRes<T, E>(value),\n (cause) => qualifyToResult<T, E>(cause, triage),\n );\n return new AsyncRes<T, E>(settled);\n}\n\n/\n Wrap a `Promise` asserted not to fail in any modeled way: any rejection\n * becomes a `Defect`.\n \n @remarks\n * Use this only when a rejection genuinely indicates a bug rather than an\n * anticipated outcome — the error channel is `never`, so there is nothing to\n * triage. (`await`-ing still yields a `Result`; it never throws.)\n \n @typeParam T - the resolved value type.\n * @param promise - the promise, or a thunk returning one.\n /\nexport function fromSafePromise<T>(\n promise: Promise<T> \| (() => Promise<T>),\n): AsyncResult<T, never> {\n const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : promise;\n const settled: Promise<Result<T, never>> = p.then(\n (value) => okRes<T, never>(value),\n (cause) => defectRes<T, never>(cause),\n );\n return new AsyncRes<T, never>(settled);\n}\n\nfunction qualifyToResult<T, E>(\n cause: unknown,\n qualify: (cause: unknown) => E \| Defect,\n): Result<T, E> {\n try {\n const q = qualify(cause);\n return isDefectMarker(q) ? defectRes<T, E>(q.cause) : errRes<T, E>(q);\n } catch (qErr) {\n // a throw inside qualify is itself a Defect\n return defectRes<T, E>(qErr);\n }\n}\n\n/\n The success channel of {@link all} / {@link allAsync}: a positional tuple\n * for a fixed-length input (including the empty tuple), or a homogeneous\n * array for a dynamic one.\n \n @remarks\n * The split keys off the input's `length`: a fixed tuple has a literal length\n * (`number extends Rs[\"length\"]` is false → keep the positional `Ts`), while a\n * general array has `length: number` (→ collapse to `Ts[number][]`). Checking\n * length rather than `Rs extends [unknown, ...unknown[]]` keeps `all([])` typed\n * as `Result<[], …>` instead of `Result<never[], …>`.\n \n @typeParam Rs - the tuple/array of input `Result` types.\n * @typeParam Ts - per-element extracted success types (`OkOf` for `all`,\n * `AsyncOkOf` for `allAsync`).\n * @internal\n /\ntype AllOk<\n Rs extends readonly unknown[],\n Ts extends readonly unknown[],\n> = number extends Rs[\"length\"] ? Ts[number][] : Ts;\n\n/* A record of `Result`s — the input to {@link allFromDict}. /\ntype ResultRecord = Record<string, Result<unknown, unknown>>;\n/* A record of `AsyncResult`s — the input to {@link allFromDictAsync}. /\ntype AsyncResultRecord = Record<string, AsyncResult<unknown, unknown>>;\n\n/\n Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,\n * else `Ok` of the values array.\n \n @internal\n /\nfunction foldArray(results: readonly Result<unknown, unknown>[]): Result<unknown, unknown> {\n let firstErr: Result<unknown, unknown> \| undefined;\n let firstDefect: Result<unknown, unknown> \| undefined;\n const values: unknown[] = [];\n for (const r of results) {\n if (r.tag === \"Defect\") firstDefect ??= r;\n else if (r.tag === \"Err\") firstErr ??= r;\n else values.push(r.value);\n }\n return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/\n Fold a record of settled `Result`s with the same rules, else `Ok` of the\n * record of values. Keys are written with `Object.defineProperty` so a\n * caller-supplied `\"__proto__\"` key cannot pollute the prototype.\n \n @internal\n /\nfunction foldRecord(results: ResultRecord): Result<unknown, unknown> {\n let firstErr: Result<unknown, unknown> \| undefined;\n let firstDefect: Result<unknown, unknown> \| undefined;\n const values: Record<string, unknown> = {};\n for (const [key, r] of Object.entries(results)) {\n if (r.tag === \"Defect\") firstDefect ??= r;\n else if (r.tag === \"Err\") firstErr ??= r;\n else\n Object.defineProperty(values, key, {\n value: r.value,\n enumerable: true,\n writable: true,\n configurable: true,\n });\n }\n return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/\n Collect a tuple/array of {@link Result}s into a single `Result` of all their\n * success values.\n \n @remarks\n * Short-circuits on the first `Err` (later entries are not inspected for\n * their error); any `Defect` present dominates, winning even over an earlier\n * `Err`. A fixed tuple keeps its positional types — `all([Ok(1), Ok(\"a\")])`\n * is `Result<[number, string], …>` — while a dynamic array `Result<T, E>[]`\n * collapses to `Result<T[], E>` with no cast. For a record keyed by name,\n * use {@link allFromDict}.\n \n @example\n * ```ts\n * import { all, Ok } from \"unthrown\";\n * all([Ok(1), Ok(\"a\"), Ok(true)]).unwrap(); // [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Ok(2)] as Result<number, never>[]).unwrap(); // number[]\n * ```\n /\nexport function all<Rs extends readonly Result<unknown, unknown>[]>(\n results: readonly [...Rs],\n): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>> {\n return foldArray(results) as unknown as Result<\n AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>,\n ErrOf<Rs[number]>\n >;\n}\n\n/\n Collect a record of {@link Result}s into a single `Result` of a record of\n * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is\n * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for\n * parallel work you'd rather not tuple.\n \n @remarks\n * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`\n * dominates. This is not error accumulation.\n \n @example\n * ```ts\n * import { allFromDict, Ok } from \"unthrown\";\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).unwrap(); // { id: 1, name: \"ada\" }\n * ```\n /\nexport function allFromDict<R extends ResultRecord>(\n results: R,\n): Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>> {\n return foldRecord(results) as unknown as Result<\n { [K in keyof R]: OkOf<R[K]> },\n ErrOf<R[keyof R]>\n >;\n}\n\n/\n The asynchronous counterpart of {@link all}: combine a tuple/array of\n * {@link AsyncResult}s into one `AsyncResult` of all their success values.\n \n @remarks\n * The inputs are resolved concurrently (order preserved); the resolved\n * `Result`s are then folded with the same rules as {@link all} — first `Err`\n * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s\n * internal promise never rejects. For a record, use {@link allFromDictAsync}.\n \n @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n * await allAsync([fromSafePromise(a()), fromSafePromise(b())]);\n * ```\n /\nexport function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(\n results: readonly [...Rs],\n): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>> {\n // Each AsyncResult is a (never-rejecting) thenable, so Promise.all adopts them;\n // `foldArray` then applies the all() rules. The internal promise never rejects.\n const settled = Promise.all(results).then((resolved) =>\n foldArray(resolved as readonly Result<unknown, unknown>[]),\n );\n return new AsyncRes(settled) as unknown as AsyncResult<\n AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>,\n AsyncErrOf<Rs[number]>\n >;\n}\n\n/\n The asynchronous counterpart of {@link allFromDict}: combine a record of\n * {@link AsyncResult}s into one `AsyncResult` of a record of their values.\n \n @remarks\n * Resolved concurrently (order preserved), folded with the {@link all} rules,\n * and the internal promise never rejects.\n \n @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n * await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });\n * ```\n /\nexport function allFromDictAsync<R extends AsyncResultRecord>(\n results: R,\n): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>> {\n const entries = Object.entries(results);\n const settled = Promise.all(entries.map(([, ar]) => ar)).then((resolved) => {\n // Null-proto accumulator: pairing resolved values back to keys can't pollute.\n const byKey: ResultRecord = Object.create(null) as ResultRecord;\n entries.forEach(([key], i) => {\n byKey[key] = resolved[i] as Result<unknown, unknown>;\n });\n return foldRecord(byKey);\n });\n return new AsyncRes(settled) as unknown as AsyncResult<\n { [K in keyof R]: AsyncOkOf<R[K]> },\n AsyncErrOf<R[keyof R]>\n >;\n}\n","// Result facade — a discoverable namespace alias for the standalone entry\n// points. The free functions remain the primary, tree-shakeable API; this\n// object is a separate export, so `import { Ok }` never pulls it in. The value\n// `Result` and the type `Result<T, E>` (types.ts) share a name — the\n// companion-object pattern. See CLAUDE.md → \"Internal design\".\n\nimport { Err, isDefect, isErr, isOk, Ok } from \"./constructors.js\";\nimport { isResult } from \"./core.js\";\nimport { Defect } from \"./defect.js\";\nimport { Do } from \"./do.js\";\nimport {\n all,\n allAsync,\n allFromDict,\n allFromDictAsync,\n fromNullable,\n fromPromise,\n fromSafePromise,\n fromThrowable,\n} from \"./interop.js\";\nimport type { Result as ResultType } from \"./types.js\";\n\n/\n Companion object grouping the standalone entry points under a single,\n * discoverable namespace: {@link Result.Ok}, {@link Result.Err},\n * {@link Result.Defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},\n * {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},\n * {@link Result.allAsync}, {@link Result.allFromDict},\n * {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},\n * {@link Result.isDefect}, {@link Result.isResult}.\n \n @remarks\n * Purely additive sugar — each member is the corresponding free function.\n * The free functions remain the primary, tree-shakeable API; importing only\n * `{ Ok }` never pulls this object in. The value `Result` and the type\n * {@link Result} share one name (the companion-object pattern).\n \n @example\n * ```ts\n * import { Result } from \"unthrown\";\n * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // 2\n * ```\n /\nexport const Result = {\n Ok,\n Err,\n Defect,\n Do,\n fromNullable,\n fromThrowable,\n fromPromise,\n fromSafePromise,\n all,\n allAsync,\n allFromDict,\n allFromDictAsync,\n isOk,\n isErr,\n isDefect,\n isResult,\n} as const;\n\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and an\n// exhaustive, zero-dependency fold over a tagged error union.\n\nimport type { AsyncResult, Result } from \"./types.js\";\n\ntype Props = Record<string, unknown>;\n\n/\n The instance shape produced by a {@link TaggedError} class: an `Error` plus a\n * `_tag` discriminant and the (readonly) payload fields.\n \n @typeParam Tag - the string literal discriminant.\n * @typeParam A - the payload object type.\n /\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n Readonly<A> & { readonly _tag: Tag };\n\n/\n The class constructor returned by {@link TaggedError}. Generic in its payload:\n * apply it with an instantiation expression at the `extends` site.\n \n @remarks\n * When the payload is empty, the constructor takes no arguments (the\n * `keyof A extends never ? void : A` trick); otherwise it takes the payload.\n \n @typeParam Tag - the string literal discriminant.\n /\nexport type TaggedErrorConstructor<Tag extends string> = {\n new <A extends Props = {}>(args: keyof A extends never ? void : A): TaggedErrorInstance<Tag, A>;\n};\n\n/\n Build a base class for a tagged error — a class extending `Error` with a\n * `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.\n \n @remarks\n * Extend the returned class to declare a concrete error. Supply the payload with\n * an instantiation expression; omit it for a payload-less error. A `message`\n * field in the payload is forwarded to `Error`. The `_tag` always reflects\n * `tag` and cannot be overridden by the payload.\n \n `_tag` is the discriminant used by {@link matchTags}; `Error.name` is the\n * human-facing label in stack traces and logs. By default they coincide, but\n * they can be decoupled with `options.name` — so a tag can be namespaced for\n * collision-safety (`\"@my-lib/RetryableError\"`) without that slash-prefixed\n * string leaking into `Error.name`:\n \n ```ts\n * class RetryableError extends TaggedError(\"@my-lib/RetryableError\", {\n * name: \"RetryableError\",\n * })<{ message: string }> {}\n \n const e = new RetryableError({ message: \"boom\" });\n * e._tag; // \"@my-lib/RetryableError\" — namespaced discriminant\n * e.name; // \"RetryableError\" — clean display name\n * ```\n \n @typeParam Tag - the string literal discriminant.\n * @param tag - the discriminant value; also the default error `name`.\n * @param options - optional overrides. `options.name` sets `Error.name`\n * independently of `tag` (defaults to `tag`).\n \n @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class HttpError extends TaggedError(\"HttpError\")<{ status: number }> {}\n \n new NotFound()._tag; // \"NotFound\"\n * new HttpError({ status: 500 }).status; // 500\n * ```\n /\nexport function TaggedError<Tag extends string>(\n tag: Tag,\n options?: { readonly name?: string },\n): TaggedErrorConstructor<Tag> {\n const displayName = options?.name ?? tag;\n class TaggedErrorBase extends Error {\n readonly _tag!: Tag;\n\n constructor(props?: Props) {\n super(typeof props?.[\"message\"] === \"string\" ? (props[\"message\"] as string) : undefined);\n if (props) Object.assign(this, props);\n // The tag is authoritative — assign it after the payload so it can't be\n // clobbered. `name` is the display label, independent of the discriminant.\n (this as { _tag: Tag })._tag = tag;\n this.name = displayName;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n }\n\n return TaggedErrorBase as unknown as TaggedErrorConstructor<Tag>;\n}\n\n/\n The handler object {@link matchTags} requires: a branch per error tag, plus\n * `Ok` and `Defect`. Miss a tag and it will not compile — the exhaustiveness is\n * enforced by the type, with no `.exhaustive()` to forget.\n \n @typeParam T - the success value type.\n * @typeParam E - the tagged error union.\n * @typeParam R - the folded result type.\n /\nexport type TagHandlers<T, E extends { _tag: string }, R> = {\n Ok: (value: T) => R;\n Defect: (cause: unknown) => R;\n} & { [K in E[\"_tag\"]]: (error: Extract<E, { _tag: K }>) => R };\n\n/\n Exhaustively fold a {@link Result} (or {@link AsyncResult}) whose error type is\n * a tagged union, dispatching each error to the handler matching its `_tag`.\n \n @remarks\n * The `handlers` object must provide `Ok`, `Defect`, and exactly one function\n * per error tag; each tag's handler receives the narrowed error variant. A\n * missing tag is a compile error. For an `AsyncResult`, the fold resolves to a\n * `Promise<R>`.\n \n @typeParam T - the success value type.\n * @typeParam E - the tagged error union (`E extends { _tag: string }`).\n * @typeParam R - the folded result type.\n * @param result - the result to fold.\n * @param handlers - one branch per channel/tag.\n \n @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class Forbidden extends TaggedError(\"Forbidden\")<{ user: string }> {}\n \n declare const r: Result<number, NotFound \| Forbidden>;\n * matchTags(r, {\n * Ok: (n) => `got ${n}`,\n * Defect: (cause) => `bug: ${String(cause)}`,\n * NotFound: () => \"404\",\n * Forbidden: (e) => `403 for ${e.user}`,\n * });\n * ```\n */\nexport function matchTags<T, E extends { _tag: string }, R>(\n result: Result<T, E>,\n handlers: TagHandlers<T, E, R>,\n): R;\nexport function matchTags<T, E extends { _tag: string }, R>(\n result: AsyncResult<T, E>,\n handlers: TagHandlers<T, E, R>,\n): Promise<R>;\nexport function matchTags<T, E extends { _tag: string }, R>(\n result: Result<T, E> \| AsyncResult<T, E>,\n handlers: TagHandlers<T, E, R>,\n): R \| Promise<R> {\n const onErr = (error: E): R => {\n const handler = handlers[error._tag as E[\"_tag\"]] as unknown as (e: E) => R;\n return handler(error);\n };\n // Both Result and AsyncResult share `match`; the cast picks one signature for\n // the call while the public overloads keep the return type correct.\n return (result as Result<T, E>).match({ ok: handlers.Ok, err: onErr, defect: handlers.Defect });\n}\n"],"mappings":";;;;;;;;;;;;AA6BA,IAAa,cAAb,cAA8C,MAAM;;;;;CAKlD;CACA,YAAY,OAAU;EACpB,MAAM,kDAAkD;EACxD,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CAClD;AACF;;;;;;;;AASA,IAAM,MAAN,MAAgB;CACd,IAA2B,GAAkC;EAC3D,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,OAAO,MAAM,EAAE,KAAK,KAAK,CAAC;EAC5B,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,QAAmC,GAAmD;EACpF,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,OAAO,EAAE,KAAK,KAAK;EACrB,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,IAAwB,GAAqC;EAC3D,IAAI,KAAK,QAAQ,MAAM,OAAO;EAC9B,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,QAAgC,GAAyD;EACvF,IAAI,KAAK,QAAQ,MAAM,OAAO;EAC9B,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GAEtB,OAAO,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;EAC9C,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,KAEE,MACA,GACgC;EAChC,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GACtB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GAGxC,OAAO,MAAM;IAAE,GAAG,QAAQ,KAAK,KAAK;KAAI,OAAO,EAAE;GAAM,CAAC;EAI1D,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,IAEE,MACA,GAC2B;EAC3B,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,OAAO,MAAM;IAAE,GAAG,QAAQ,KAAK,KAAK;KAAI,OAAO,EAAE,KAAK,KAAK;GAAE,CAAC;EAIhE,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,GAA0B,OAAwB;EAChD,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,OAAO,MAAM,KAAK;CACpB;CAEA,OAA+B,GAAoC;EACjE,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,OAAO,OAAO,EAAE,KAAK,KAAK,CAAC;EAC7B,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,OAAkC,GAAmD;EACnF,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,OAAO,EAAE,KAAK,KAAK;EACrB,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,QAA+B,GAA0C;EACvE,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,OAAO,MAAM,EAAE,KAAK,KAAK,CAAC;EAC5B,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,OAA2B,GAAqC;EAC9D,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,WAAmC,GAAyD;EAC1F,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GAEtB,OAAO,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;EAC9C,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,cAEE,GACuB;EACvB,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,OAAO,EAAE,KAAK,KAAK;EACrB,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,UAA8B,GAA2C;EACvE,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,MAEE,OAKG;EACH,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,MAAM,GAAG,KAAK,KAAK;GAC5B,KAAK,OACH,OAAO,MAAM,IAAI,KAAK,KAAK;GAC7B,KAAK,UACH,OAAO,MAAM,OAAO,KAAK,KAAK;EAClC;CACF;CAEA,SAA8B;EAC5B,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,KAAK;GACd,KAAK,OACH,MAAM,IAAI,YAAY,KAAK,KAAK;GAClC,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,YAAiC;EAC/B,QAAQ,KAAK,KAAb;GACE,KAAK,OACH,OAAO,KAAK;GACd,KAAK,MACH,MAAM,IAAI,YAAY,KAAK,KAAK;GAClC,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,SAA6B,UAAgB;EAC3C,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO;CACT;CAEA,aAAiC,GAAuB;EACtD,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO,EAAE,KAAK,KAAK;CACrB;CAEA,YAAwC;EACtC,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO;CACT;CAEA,iBAAkD;EAChD,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;CAExC;CAEA,OAA+C;EAC7C,OAAO,KAAK,QAAQ;CACtB;CAEA,QAAiD;EAC/C,OAAO,KAAK,QAAQ;CACtB;CAEA,WAAuD;EACrD,OAAO,KAAK,QAAQ;CACtB;CAEA,UAA+C;EAC7C,OAAO,IAAI,SAAe,QAAQ,QAAQ,IAAI,CAAC;CACjD;AACF;AAEA,MAAM,eAAe,IAAI;;;;;;AAOzB,SAAgB,MAAY,OAAwB;CAClD,OAAO,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EAChD,KAAK;EACL;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,OAAa,OAAwB;CACnD,OAAO,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EAChD,KAAK;EACL;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,UAAgB,OAA8B;CAC5D,OAAO,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EAChD,KAAK;EACL;CACF,CAAC;AACH;;;;;;;;;;;;;AAcA,SAAgB,SAAS,GAA2C;CAClE,OAAO,aAAa;AACtB;;;;;;;;;;;AAYA,SAAS,YAAkB,MAA8C;CACvE,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,QAAQ,OAAwB;CACvC,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,MAAM,IAAI,UAAU,gEAAgE;CAEtF,OAAO;AACT;;;;;;;;AASA,IAAa,WAAb,MAAa,SAA4C;CAC1B;CAA7B,YAAY,SAAiD;EAAhC,KAAA,UAAA;CAAiC;CAG9D,KACE,aACA,YACsB;EACtB,OAAO,KAAK,QAAQ,KAAK,aAAa,UAAU;CAClD;CAEA,IAAO,GAAuC;EAC5C,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK,CAAC;GACzB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,QAAe,GAA6E;EAC1F,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK;GACxB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,IAAI,GAA0C;EAC5C,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,MAAM,OAAO;GAC3B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAgB,KAAK;GAC9B;EACF,CAAC,CACH;CACF;CAEA,QACE,GACwB;EACxB,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAE7B,OAAO,MAAM,QAAQ,OAAO,IAAI,YAAY,KAAK;GACnD,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,KACE,MACA,GACqC;EACrC,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,IAAI,MAAM,QAAQ,MAAM,OAAO,YAAY,KAAK;IAChD,OAAO,MAAM;KAAE,GAAG,QAAQ,EAAE,KAAK;MAAI,OAAO,MAAM;IAAM,CAAC;GAI3D,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,IAAyB,MAAS,GAAoD;EACpF,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,OAAO,MAAM;KAAE,GAAG,QAAQ,EAAE,KAAK;MAAI,OAAO,EAAE,EAAE,KAAK;IAAE,CAAC;GAI1D,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,GAAM,OAA6B;EACjC,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAO,EAAE,QAAQ,OAAO,MAAY,KAAK,IAAI,YAAY,CAAC,CAAE,CACjF;CACF;CAEA,OAAW,GAAyC;EAClD,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,OAAO,OAAO,EAAE,EAAE,KAAK,CAAC;GAC1B,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,OAAc,GAA6E;EACzF,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK;GACxB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,QAAW,GAA+C;EACxD,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,OAAO,MAAoB,EAAE,EAAE,KAAK,CAAC;GACvC,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,OAAO,GAA0C;EAC/C,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,OAAO,OAAO;GAC5B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAgB,KAAK;GAC9B;EACF,CAAC,CACH;CACF;CAEA,WACE,GACwB;EACxB,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAE7B,OAAO,MAAM,QAAQ,OAAO,YAAY,CAAC,IAAI,YAAY,KAAK;GAChE,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,cACE,GAC4B;EAC5B,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK;GACxB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,UAAU,GAAgD;EACxD,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAgB,KAAK;GAC9B;EACF,CAAC,CACH;CACF;CAEA,MAAS,OAIM;EACb,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,MAAM,KAAK,CAAC;CAChD;CAEA,SAAqB;EACnB,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,OAAO,CAAC;CAC5C;CACA,YAAwB;EACtB,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,CAAC;CAC/C;CACA,SAAS,UAAyB;EAChC,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,QAAQ,CAAC;CACtD;CACA,aAAa,GAAgC;EAC3C,OAAO,KAAK,QAAQ,MAAM,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,EAAE;GAC7B,IAAI,EAAE,QAAQ,UAAU,MAAM,EAAE;GAChC,OAAO,EAAE,EAAE,KAAK;EAClB,CAAC;CACH;CACA,YAA+B;EAC7B,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,CAAC;CAC/C;CACA,iBAAyC;EACvC,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,eAAe,CAAC;CACpD;AACF;;;;;;;;;;;;;;;AC7lBA,SAAgB,GAAM,OAA4B;CAChD,OAAO,MAAM,KAAK;AACpB;;;;;;;;;;;;;AAcA,SAAgB,IAAO,OAA4B;CACjD,OAAO,OAAO,KAAK;AACrB;;;;;;;;;;;;;AAcA,SAAgB,KAAW,GAAoC;CAC7D,OAAO,EAAE,QAAQ;AACnB;;;;;;AAMA,SAAgB,MAAY,GAAqC;CAC/D,OAAO,EAAE,QAAQ;AACnB;;;;;;AAMA,SAAgB,SAAe,GAAwC;CACrE,OAAO,EAAE,QAAQ;AACnB;;;ACjEA,MAAM,SAAwB,OAAO,iBAAiB;;;;;;;;;;;;;;;;;AAiCtD,SAAgB,OAAO,OAAwB;CAC7C,OAAO;GAAG,SAAS;EAAM;CAAM;AACjC;;;;;;;;AASA,SAAgB,eAAe,GAAyB;CACtD,OACE,OAAO,MAAM,YAAY,MAAM,QAAS,EAAmC,YAAY;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;ACrBA,SAAgB,KAAwB;CACtC,OAAO,GAAG,CAAC,CAAC;AACd;;;;;;;;;;;;;;;;;;;;;;ACHA,SAAgB,aACd,OACA,UAC2B;CAC3B,OAAO,UAAU,QAAQ,UAAU,KAAA,IAAY,IAAI,SAAS,CAAC,IAAI,GAAG,KAAuB;AAC7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,cACd,IACA,SAC+C;CAE/C,MAAM,SAAS;CACf,QAAQ,GAAG,SAA0B;EACnC,IAAI;GACF,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC;EACvB,SAAS,OAAO;GACd,OAAO,gBAAsB,OAAO,MAAM;EAC5C;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,YACd,SACA,SACoC;CAEpC,MAAM,SAAS;CAMf,OAAO,IAAI,UALD,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAA,CACnC,MACtC,UAAU,MAAY,KAAK,IAC3B,UAAU,gBAAsB,OAAO,MAAM,CAEhB,CAAC;AACnC;;;;;;;;;;;;;AAcA,SAAgB,gBACd,SACuB;CAMvB,OAAO,IAAI,UALD,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAA,CAC/B,MAC1C,UAAU,MAAgB,KAAK,IAC/B,UAAU,UAAoB,KAAK,CAEF,CAAC;AACvC;AAEA,SAAS,gBACP,OACA,SACc;CACd,IAAI;EACF,MAAM,IAAI,QAAQ,KAAK;EACvB,OAAO,eAAe,CAAC,IAAI,UAAgB,EAAE,KAAK,IAAI,OAAa,CAAC;CACtE,SAAS,MAAM;EAEb,OAAO,UAAgB,IAAI;CAC7B;AACF;;;;;;;AAmCA,SAAS,UAAU,SAAwE;CACzF,IAAI;CACJ,IAAI;CACJ,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,KAAK,SACd,IAAI,EAAE,QAAQ,UAAU,gBAAgB;MACnC,IAAI,EAAE,QAAQ,OAAO,aAAa;MAClC,OAAO,KAAK,EAAE,KAAK;CAE1B,OAAO,eAAe,YAAY,GAAG,MAAM;AAC7C;;;;;;;;AASA,SAAS,WAAW,SAAiD;CACnE,IAAI;CACJ,IAAI;CACJ,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,KAAK,MAAM,OAAO,QAAQ,OAAO,GAC3C,IAAI,EAAE,QAAQ,UAAU,gBAAgB;MACnC,IAAI,EAAE,QAAQ,OAAO,aAAa;MAErC,OAAO,eAAe,QAAQ,KAAK;EACjC,OAAO,EAAE;EACT,YAAY;EACZ,UAAU;EACV,cAAc;CAChB,CAAC;CAEL,OAAO,eAAe,YAAY,GAAG,MAAM;AAC7C;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,IACd,SACwE;CACxE,OAAO,UAAU,OAAO;AAI1B;;;;;;;;;;;;;;;;;AAkBA,SAAgB,YACd,SAC2D;CAC3D,OAAO,WAAW,OAAO;AAI3B;;;;;;;;;;;;;;;;;AAkBA,SAAgB,SACd,SACuF;CAMvF,OAAO,IAAI,SAHK,QAAQ,IAAI,OAAO,CAAC,CAAC,MAAM,aACzC,UAAU,QAA+C,CAEjC,CAAC;AAI7B;;;;;;;;;;;;;;;AAgBA,SAAgB,iBACd,SAC0E;CAC1E,MAAM,UAAU,OAAO,QAAQ,OAAO;CAStC,OAAO,IAAI,SARK,QAAQ,IAAI,QAAQ,KAAK,GAAG,QAAQ,EAAE,CAAC,CAAC,CAAC,MAAM,aAAa;EAE1E,MAAM,QAAsB,OAAO,OAAO,IAAI;EAC9C,QAAQ,SAAS,CAAC,MAAM,MAAM;GAC5B,MAAM,OAAO,SAAS;EACxB,CAAC;EACD,OAAO,WAAW,KAAK;CACzB,CAC0B,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;;;;;AC3SA,MAAa,SAAS;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACWA,SAAgB,YACd,KACA,SAC6B;CAC7B,MAAM,cAAc,SAAS,QAAQ;CACrC,MAAM,wBAAwB,MAAM;EAClC;EAEA,YAAY,OAAe;GACzB,MAAM,OAAO,QAAQ,eAAe,WAAY,MAAM,aAAwB,KAAA,CAAS;GACvF,IAAI,OAAO,OAAO,OAAO,MAAM,KAAK;GAGpC,KAAwB,OAAO;GAC/B,KAAK,OAAO;GACZ,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAClD;CACF;CAEA,OAAO;AACT;AAsDA,SAAgB,UACd,QACA,UACgB;CAChB,MAAM,SAAS,UAAgB;EAC7B,MAAM,UAAU,SAAS,MAAM;EAC/B,OAAO,QAAQ,KAAK;CACtB;CAGA,OAAQ,OAAwB,MAAM;EAAE,IAAI,SAAS;EAAI,KAAK;EAAO,QAAQ,SAAS;CAAO,CAAC;AAChG"}