@shirudo/result 1.0.1 → 1.1.1

package/README.md

@@ -1,15 +1,18 @@
 # @shirudo/result
 
-Robust, type-safe error handling for TypeScript.
+A `Result<T, E>` type for TypeScript. Functions return their failures instead of throwing them.
 
-`@shirudo/result` models expected failures as values instead of hidden exceptions. Functions return `Result<T, E>`, callers must handle both states, and TypeScript narrows access to `value` and `error` only when the state is known.
+```ts docs-check:skip
+function loadUser(id: string): Result<User, UserError>
+```
+
+The failure is part of the signature: callers see exactly what can go wrong, the compiler insists both cases are handled, and `value`/`error` are only accessible after narrowing. What used to be a forgotten `catch` is now a type error.
+
+The rest of the package is tooling around that one type: pipe operators, async variants, generator-based do-notation, exhaustive error matching, and collection helpers. The library has zero dependencies, ships as ESM and CJS, and runs on Node 20+ and edge runtimes.
 
 [![CI](https://github.com/shi-rudo/result-ts/actions/workflows/ci.yml/badge.svg)](https://github.com/shi-rudo/result-ts/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/@shirudo/result.svg)](https://www.npmjs.com/package/@shirudo/result)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.7%2B-blue.svg)](https://www.typescriptlang.org/)
-[![Node](https://img.shields.io/badge/Node-%3E%3D20-green.svg)](https://nodejs.org/)
-![Edge Runtime](https://img.shields.io/badge/Edge_Runtime-compatible-brightgreen.svg)
 
 ## Installation
 
@@ -22,12 +25,13 @@ yarn add @shirudo/result
 ## Quick Start
 
 ```ts
-import { Result } from '@shirudo/result';
+import { err, ok, type Result } from '@shirudo/result';
+import { map, match } from '@shirudo/result/operators';
 
 type User = { id: string; email: string; active: boolean };
 type UserError =
-    | { type: 'not-found'; id: string }
-    | { type: 'inactive'; id: string };
+    | { code: 'not-found'; id: string }
+    | { code: 'inactive'; id: string };
 
 const users = new Map<string, User>([
     ['1', { id: '1', email: 'ada@example.com', active: true }],
@@ -35,35 +39,53 @@ const users = new Map<string, User>([
 
 function loadUser(id: string): Result<User, UserError> {
     const user = users.get(id);
-    if (!user) return Result.err({ type: 'not-found', id });
-    if (!user.active) return Result.err({ type: 'inactive', id });
-    return Result.ok(user);
+    if (!user) return err({ code: 'not-found', id });
+    if (!user.active) return err({ code: 'inactive', id });
+    return ok(user);
 }
 
+// Narrow explicitly:
 const result = loadUser('1');
-
 if (result.isOk()) {
-    console.log(result.value.email);
-} else {
-    switch (result.error.type) {
-        case 'not-found':
-            console.error(`Missing user ${result.error.id}`);
-            break;
-        case 'inactive':
-            console.error(`Inactive user ${result.error.id}`);
-            break;
-    }
+    console.log(result.value.email); // `value` is only accessible in this branch
 }
+
+// Or compose and resolve in one expression. `map` only runs on Ok,
+// and the error keeps its type all the way to `match`:
+const message = loadUser('1').pipe(
+    map(user => `Welcome back, ${user.email}`),
+    match({
+        ok: greeting => greeting,
+        err: error =>
+            error.code === 'not-found'
+                ? `No user with id ${error.id}`
+                : `User ${error.id} is deactivated`,
+    }),
+);
 ```
 
-## Why This Library
+## Why Result Instead of try/catch?
+
+TypeScript cannot type a `catch` block: every thrown value arrives as `unknown`, and nothing in a function's signature reveals that it throws at all. Callers either remember to catch, or they find out in production.
+
+A `Result<User, UserError>` puts the failure into the signature. The compiler forces both states to be handled, narrows `value` and `error` access to the matching state (as in the Quick Start above), and keeps the error type intact across every transformation.
+
+## Why This Library?
+
+There are several Result implementations for TypeScript. This one is built around a few hard guarantees:
+
+- **Error types that cannot lie.** Declaring an explicit error type requires an error mapper: `fromPromise<User, ApiError>(promise)` without one is a compile error, so `E` never silently holds an unmapped `unknown`. And bugs inside the mapper itself are rethrown instead of being disguised as `Err` values.
+- **Exhaustive matching, checked at compile time.** `matchError().when(NotFoundError, ...).run()` only compiles once every error case is handled, and `matchTag` does the same for discriminated unions. Add a new error variant, and every unhandled match site turns red.
+- **Four interchangeable styles, one type.** Explicit `isOk()`/`isErr()` checks, `pipe`/`pipeAsync` operator chains, generator-based do-notation (`task`), and builder-based error matching all work on the same immutable, frozen `Result`. Use whichever style fits each call site.
+- **Safe at runtime boundaries.** `isResult()` validates an internal brand plus payload shape instead of accepting lookalike objects, and `toSerialized()`/`fromSerialized()` round-trip Results through JSON without ambiguity.
+- **Zero dependencies, runs anywhere.** The package ships ESM and CJS builds with tree-shakeable subpath exports, and it runs on Node 20+ and in edge runtimes.
+- **Verified, not promised.** Every TypeScript snippet in this README and the docs is compile-checked in CI, the API is covered by 400+ runtime tests plus compile-time type tests, and the package exports are verified for ESM, CJS, and TypeScript consumers.
 
-- `Ok` does not expose `error`, and `Err` does not expose `value`; accidental reads require proper narrowing.
-- `isResult` uses a stable internal brand plus payload validation instead of accepting random lookalike objects.
-- `Result.fromPromise()` maps promise rejections but rethrows bugs inside the error mapper.
-- Sync, async, generator, collection, and matching workflows are first-class.
-- README and docs TypeScript snippets are compile-checked.
-- Package exports are tested for ESM, CJS, and TypeScript consumers.
+## When Not to Use It
+
+- If your codebase is already built on [Effect](https://effect.website/), you do not need this package. Its `Either`/`Exit` types come with the surrounding ecosystem.
+- For short scripts and prototypes, plain `try`/`catch` is often the simpler tool. The value of typed errors grows with the number of call sites that must handle them.
+- Keep throwing for programmer errors. Broken invariants and failed assertions should crash loudly; `Result` is for failures the caller is expected to handle.
 
 ## Common Workflows
 
@@ -74,14 +96,14 @@ import { Result } from '@shirudo/result';
 
 const parseJson = Result.fromThrowable(
     JSON.parse,
-    error => ({ type: 'parse' as const, cause: error }),
+    error => ({ code: 'parse' as const, cause: error }),
 );
 
 const parsed = parseJson('{"valid": true}');
 
 const response = await Result.fromPromise(
     Promise.resolve({ ok: true }),
-    error => ({ type: 'network' as const, cause: error }),
+    error => ({ code: 'network' as const, cause: error }),
 );
 ```
 
@@ -131,27 +153,53 @@ function findUser(id: string) {
 function ensureEmail(user: { id: string; email?: string }) {
     return user.email
         ? Result.ok(user.email)
-        : Result.err({ type: 'missing-email' as const, id: user.id });
+        : Result.err({ code: 'missing-email' as const, id: user.id });
 }
 
-const email = task(function* () {
+const emailResult = await task(function* () {
     const user = yield* findUser('1');
     return yield* ensureEmail(user);
 });
 ```
 
+### Handle error classes exhaustively
+
+```ts
+import { Result } from '@shirudo/result';
+
+class NotFoundError extends Error {
+    readonly code = 'not-found';
+}
+class RateLimitError extends Error {
+    readonly code = 'rate-limited';
+    constructor(readonly retryAfter: number) {
+        super(`rate limited, retry in ${retryAfter}s`);
+    }
+}
+
+const result: Result<string, NotFoundError | RateLimitError> = Result.err(new RateLimitError(30));
+
+if (result.isErr()) {
+    const message = result
+        .matchError()
+        .when(NotFoundError, () => 'No such record')
+        .when(RateLimitError, error => `Retry in ${error.retryAfter}s`)
+        .run(); // run() only compiles because every error class is handled
+}
+```
+
 ### Match discriminated-union errors
 
 ```ts
 import { Result, matchTag } from '@shirudo/result';
 
 type DomainError =
-    | { type: 'network'; retryAfter: number }
-    | { type: 'validation'; field: string };
+    | { code: 'network'; retryAfter: number }
+    | { code: 'validation'; field: string };
 
-const failed = Result.err<DomainError>({ type: 'network', retryAfter: 30 });
+const failed = Result.err<DomainError>({ code: 'network', retryAfter: 30 });
 
-const message = matchTag(failed, 'type', {
+const message = matchTag(failed, 'code', {
     network: error => `Retry in ${error.retryAfter}s`,
     validation: error => `Invalid field: ${error.field}`,
 });
@@ -186,7 +234,7 @@ The full documentation lives in `docs/` and is built with VitePress.
 - [Collections](docs/api/collections.md)
 - [Error Classes](docs/api/errors.md)
 - [Version 1 Migration](docs/migration/v1.md)
-- [Design Decisions](docs/decisions/lazy-async-abstraction.md)
+- [Design Decisions](docs/decisions/lazy-async-abstraction.md) ([Defensive State Checks](docs/decisions/defensive-state-checks.md))
 
 ## Development
 

package/dist/collections.cjs

@@ -1,9 +1,10 @@
-const require_result = require('./result-CY-KIivk.cjs');
-const require_flatten = require('./flatten-Df9U40nO.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_result = require('./result-BBOGxvSH.cjs');
+const require_flatten = require('./flatten-B_XIkaOK.cjs');
 
 exports.all = require_result.all;
 exports.collectAllErrors = require_flatten.collectAllErrors;
-exports.collectFirstOk = require_result.collectFirstOk;
+exports.collectFirstOk = require_flatten.collectFirstOk;
 exports.collectFirstOkAsync = require_flatten.collectFirstOkAsync;
 exports.collectFirstOkParallelAsync = require_flatten.collectFirstOkParallelAsync;
 exports.flatten = require_flatten.flatten;

package/dist/collections.d.cts

@@ -1,3 +1,3 @@
-import { E as collectFirstOk, n as sequence, t as all } from "./sequence-Br6tAIIu.cjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-DK7eJKPx.cjs";
+import { n as sequence, t as all } from "./sequence-DDwePRLd.cjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-D0K8UcQH.cjs";
 export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/collections.d.mts

@@ -1,3 +1,3 @@
-import { E as collectFirstOk, n as sequence, t as all } from "./sequence-C0jlR3AY.mjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-B8bN6fiI.mjs";
+import { n as sequence, t as all } from "./sequence-DDwePRLd.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-C7D6Kttf.mjs";
 export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/collections.mjs

@@ -1,4 +1,4 @@
-import { L as all, R as sequence, x as collectFirstOk } from "./result-DKKaNdOx.mjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-C6Y9hx79.mjs";
+import { g as sequence, h as all } from "./result-q9Na2bGa.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-ChTL5BfA.mjs";
 
 export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/errors.cjs

@@ -1,21 +1,132 @@
-const require_errors = require('./errors-D2EMzJQl.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-exports.ERR_EXPECT_ERR = require_errors.ERR_EXPECT_ERR;
-exports.ERR_EXPECT_OK = require_errors.ERR_EXPECT_OK;
-exports.ERR_INVALID_RESULT_STATE = require_errors.ERR_INVALID_RESULT_STATE;
-exports.ERR_INVALID_STATE = require_errors.ERR_INVALID_STATE;
-exports.ERR_MATCH_ERR_HANDLER_NOT_RESULT = require_errors.ERR_MATCH_ERR_HANDLER_NOT_RESULT;
-exports.ERR_MATCH_ON_OK = require_errors.ERR_MATCH_ON_OK;
-exports.ERR_TASK_YIELD_NOT_RESULT = require_errors.ERR_TASK_YIELD_NOT_RESULT;
-exports.ERR_UNWRAP_ERR_ON_OK = require_errors.ERR_UNWRAP_ERR_ON_OK;
-exports.ERR_UNWRAP_ON_ERR = require_errors.ERR_UNWRAP_ON_ERR;
-exports.ExpectErrError = require_errors.ExpectErrError;
-exports.ExpectOkError = require_errors.ExpectOkError;
-exports.InvalidResultStateError = require_errors.InvalidResultStateError;
-exports.MatchErrHandlerNotResultError = require_errors.MatchErrHandlerNotResultError;
-exports.MatchOnOkError = require_errors.MatchOnOkError;
-exports.ResultError = require_errors.ResultError;
-exports.ResultTypeError = require_errors.ResultTypeError;
-exports.TaskYieldNotResultError = require_errors.TaskYieldNotResultError;
-exports.UnwrapErrOnOkError = require_errors.UnwrapErrOnOkError;
-exports.UnwrapOnErrError = require_errors.UnwrapOnErrError;
+//#region src/errors.ts
+const ERR_INVALID_RESULT_STATE = "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+const ERR_INVALID_STATE = ERR_INVALID_RESULT_STATE;
+const ERR_TASK_YIELD_NOT_RESULT = "ERR_TASK_YIELD_NOT_RESULT";
+const ERR_MATCH_ON_OK = "ERR_MATCH_ON_OK";
+const ERR_MATCH_ERR_HANDLER_NOT_RESULT = "ERR_MATCH_ERR_HANDLER_NOT_RESULT";
+const ERR_MATCH_TAG_MISSING_HANDLER = "ERR_MATCH_TAG_MISSING_HANDLER";
+const ERR_UNWRAP_ON_ERR = "ERR_UNWRAP_ON_ERR";
+const ERR_UNWRAP_ERR_ON_OK = "ERR_UNWRAP_ERR_ON_OK";
+const ERR_EXPECT_OK = "ERR_EXPECT_OK";
+const ERR_EXPECT_ERR = "ERR_EXPECT_ERR";
+const formatResultErrorMessage = (code, message, context) => {
+	if (context) return `${code}: ${message} (context: ${context})`;
+	return `${code}: ${message}`;
+};
+var ResultError = class extends Error {
+	code;
+	context;
+	constructor(message, code, context) {
+		super(formatResultErrorMessage(code, message, context));
+		this.code = code;
+		this.context = context;
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+var ResultTypeError = class extends TypeError {
+	code;
+	context;
+	constructor(message, code, context) {
+		super(formatResultErrorMessage(code, message, context));
+		this.code = code;
+		this.context = context;
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+const INVALID_RESULT_STATE_MESSAGE = "Unreachable: Result is neither Ok nor Err";
+var InvalidResultStateError = class extends ResultError {
+	constructor(context) {
+		super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_RESULT_STATE, context);
+	}
+};
+var TaskYieldNotResultError = class extends ResultTypeError {
+	yieldedValue;
+	constructor(yieldedValue) {
+		super("task() expected yielded values to be Result. Use `yield*` on a Result.", ERR_TASK_YIELD_NOT_RESULT);
+		this.yieldedValue = yieldedValue;
+	}
+};
+var MatchOnOkError = class extends ResultTypeError {
+	constructor(methodName = "match") {
+		super(`${methodName}() can only be called on Err results. Use \`if (result.isErr()) { ... }\` first.`, ERR_MATCH_ON_OK);
+	}
+};
+var MatchErrHandlerNotResultError = class extends ResultTypeError {
+	handlerName;
+	returnedValue;
+	constructor(handlerName, returnedValue) {
+		super(`matchErr().${handlerName}() handlers must return a Result. Wrap values with ok(...) or err(...).`, ERR_MATCH_ERR_HANDLER_NOT_RESULT);
+		this.handlerName = handlerName;
+		this.returnedValue = returnedValue;
+	}
+};
+var MatchTagMissingHandlerError = class extends ResultTypeError {
+	tagValue;
+	constructor(tagValue) {
+		super(`matchTag() has no handler for tag "${String(tagValue)}".`, ERR_MATCH_TAG_MISSING_HANDLER);
+		this.tagValue = tagValue;
+	}
+};
+var UnwrapOnErrError = class extends ResultTypeError {
+	errorValue;
+	constructor(errorValue) {
+		super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);
+		this.errorValue = errorValue;
+	}
+};
+var UnwrapErrOnOkError = class extends ResultTypeError {
+	okValue;
+	constructor(okValue) {
+		super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);
+		this.okValue = okValue;
+	}
+};
+var ExpectOkError = class extends ResultError {
+	expectedMessage;
+	errorValue;
+	constructor(expectedMessage, errorValue) {
+		super(errorValue === void 0 ? expectedMessage : `${expectedMessage}: ${String(errorValue)}`, ERR_EXPECT_OK);
+		this.expectedMessage = expectedMessage;
+		this.errorValue = errorValue;
+		if (errorValue !== void 0) this.cause = errorValue;
+	}
+};
+var ExpectErrError = class extends ResultError {
+	expectedMessage;
+	okValue;
+	constructor(expectedMessage, okValue) {
+		super(okValue === void 0 ? expectedMessage : `${expectedMessage}: ${String(okValue)}`, ERR_EXPECT_ERR);
+		this.expectedMessage = expectedMessage;
+		this.okValue = okValue;
+		if (okValue !== void 0) this.cause = okValue;
+	}
+};
+
+//#endregion
+exports.ERR_EXPECT_ERR = ERR_EXPECT_ERR;
+exports.ERR_EXPECT_OK = ERR_EXPECT_OK;
+exports.ERR_INVALID_RESULT_STATE = ERR_INVALID_RESULT_STATE;
+exports.ERR_INVALID_STATE = ERR_INVALID_STATE;
+exports.ERR_MATCH_ERR_HANDLER_NOT_RESULT = ERR_MATCH_ERR_HANDLER_NOT_RESULT;
+exports.ERR_MATCH_ON_OK = ERR_MATCH_ON_OK;
+exports.ERR_MATCH_TAG_MISSING_HANDLER = ERR_MATCH_TAG_MISSING_HANDLER;
+exports.ERR_TASK_YIELD_NOT_RESULT = ERR_TASK_YIELD_NOT_RESULT;
+exports.ERR_UNWRAP_ERR_ON_OK = ERR_UNWRAP_ERR_ON_OK;
+exports.ERR_UNWRAP_ON_ERR = ERR_UNWRAP_ON_ERR;
+exports.ExpectErrError = ExpectErrError;
+exports.ExpectOkError = ExpectOkError;
+exports.InvalidResultStateError = InvalidResultStateError;
+exports.MatchErrHandlerNotResultError = MatchErrHandlerNotResultError;
+exports.MatchOnOkError = MatchOnOkError;
+exports.MatchTagMissingHandlerError = MatchTagMissingHandlerError;
+exports.ResultError = ResultError;
+exports.ResultTypeError = ResultTypeError;
+exports.TaskYieldNotResultError = TaskYieldNotResultError;
+exports.UnwrapErrOnOkError = UnwrapErrOnOkError;
+exports.UnwrapOnErrError = UnwrapOnErrError;
+//# sourceMappingURL=errors.cjs.map

package/dist/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export const ERR_INVALID_RESULT_STATE = 'ERR_INVALID_RESULT_STATE' as const;\n/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */\nexport const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE = ERR_INVALID_RESULT_STATE;\nexport const ERR_TASK_YIELD_NOT_RESULT = 'ERR_TASK_YIELD_NOT_RESULT' as const;\nexport const ERR_MATCH_ON_OK = 'ERR_MATCH_ON_OK' as const;\nexport const ERR_MATCH_ERR_HANDLER_NOT_RESULT = 'ERR_MATCH_ERR_HANDLER_NOT_RESULT' as const;\nexport const ERR_MATCH_TAG_MISSING_HANDLER = 'ERR_MATCH_TAG_MISSING_HANDLER' as const;\nexport const ERR_UNWRAP_ON_ERR = 'ERR_UNWRAP_ON_ERR' as const;\nexport const ERR_UNWRAP_ERR_ON_OK = 'ERR_UNWRAP_ERR_ON_OK' as const;\nexport const ERR_EXPECT_OK = 'ERR_EXPECT_OK' as const;\nexport const ERR_EXPECT_ERR = 'ERR_EXPECT_ERR' as const;\n\nexport type ResultErrorCode =\n    | typeof ERR_INVALID_RESULT_STATE\n    | typeof ERR_TASK_YIELD_NOT_RESULT\n    | typeof ERR_MATCH_ON_OK\n    | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT\n    | typeof ERR_MATCH_TAG_MISSING_HANDLER\n    | typeof ERR_UNWRAP_ON_ERR\n    | typeof ERR_UNWRAP_ERR_ON_OK\n    | typeof ERR_EXPECT_OK\n    | typeof ERR_EXPECT_ERR;\n\nconst formatResultErrorMessage = (code: ResultErrorCode, message: string, context?: string): string => {\n    if (context) {\n        return `${code}: ${message} (context: ${context})`;\n    }\n    return `${code}: ${message}`;\n};\n\nexport class ResultError extends Error {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nexport class ResultTypeError extends TypeError {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nconst INVALID_RESULT_STATE_MESSAGE = 'Unreachable: Result is neither Ok nor Err';\n\nexport class InvalidResultStateError extends ResultError {\n    constructor(context?: string) {\n        super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_RESULT_STATE, context);\n    }\n}\n\nexport class TaskYieldNotResultError extends ResultTypeError {\n    readonly yieldedValue: unknown;\n\n    constructor(yieldedValue: unknown) {\n        super('task() expected yielded values to be Result. Use `yield*` on a Result.', ERR_TASK_YIELD_NOT_RESULT);\n        this.yieldedValue = yieldedValue;\n    }\n}\n\nexport class MatchOnOkError extends ResultTypeError {\n    constructor(methodName = 'match') {\n        super(`${methodName}() can only be called on Err results. Use \\`if (result.isErr()) { ... }\\` first.`, ERR_MATCH_ON_OK);\n    }\n}\n\nexport class MatchErrHandlerNotResultError extends ResultTypeError {\n    readonly handlerName: string;\n    readonly returnedValue: unknown;\n\n    constructor(handlerName: string, returnedValue: unknown) {\n        super(`matchErr().${handlerName}() handlers must return a Result. Wrap values with ok(...) or err(...).`, ERR_MATCH_ERR_HANDLER_NOT_RESULT);\n        this.handlerName = handlerName;\n        this.returnedValue = returnedValue;\n    }\n}\n\nexport class MatchTagMissingHandlerError extends ResultTypeError {\n    readonly tagValue: unknown;\n\n    constructor(tagValue: unknown) {\n        super(`matchTag() has no handler for tag \"${String(tagValue)}\".`, ERR_MATCH_TAG_MISSING_HANDLER);\n        this.tagValue = tagValue;\n    }\n}\n\nexport class UnwrapOnErrError extends ResultTypeError {\n    readonly errorValue: unknown;\n\n    constructor(errorValue: unknown) {\n        super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);\n        this.errorValue = errorValue;\n    }\n}\n\nexport class UnwrapErrOnOkError extends ResultTypeError {\n    readonly okValue: unknown;\n\n    constructor(okValue: unknown) {\n        super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);\n        this.okValue = okValue;\n    }\n}\n\nexport class ExpectOkError extends ResultError {\n    readonly expectedMessage: string;\n    readonly errorValue: unknown;\n\n    constructor(expectedMessage: string, errorValue?: unknown) {\n        super(errorValue === undefined ? expectedMessage : `${expectedMessage}: ${String(errorValue)}`, ERR_EXPECT_OK);\n        this.expectedMessage = expectedMessage;\n        this.errorValue = errorValue;\n        if (errorValue !== undefined) this.cause = errorValue;\n    }\n}\n\nexport class ExpectErrError extends ResultError {\n    readonly expectedMessage: string;\n    readonly okValue: unknown;\n\n    constructor(expectedMessage: string, okValue?: unknown) {\n        super(okValue === undefined ? expectedMessage : `${expectedMessage}: ${String(okValue)}`, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n        this.okValue = okValue;\n        if (okValue !== undefined) this.cause = okValue;\n    }\n}\n"],"mappings":";;;AAAA,MAAa,2BAA2B;;AAExC,MAAa,oBAAqD;AAClE,MAAa,4BAA4B;AACzC,MAAa,kBAAkB;AAC/B,MAAa,mCAAmC;AAChD,MAAa,gCAAgC;AAC7C,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AACpC,MAAa,gBAAgB;AAC7B,MAAa,iBAAiB;AAa9B,MAAM,4BAA4B,MAAuB,SAAiB,YAA6B;CACnG,IAAI,SACA,OAAO,GAAG,KAAK,IAAI,QAAQ,aAAa,QAAQ;CAEpD,OAAO,GAAG,KAAK,IAAI;AACvB;AAEA,IAAa,cAAb,cAAiC,MAAM;CACnC,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;EAClE,MAAM,yBAAyB,MAAM,SAAS,OAAO,CAAC;EACtD,KAAK,OAAO;EACZ,KAAK,UAAU;EACf,KAAK,OAAO,IAAI,OAAO;EACvB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CACpD;AACJ;AAEA,IAAa,kBAAb,cAAqC,UAAU;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;EAClE,MAAM,yBAAyB,MAAM,SAAS,OAAO,CAAC;EACtD,KAAK,OAAO;EACZ,KAAK,UAAU;EACf,KAAK,OAAO,IAAI,OAAO;EACvB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CACpD;AACJ;AAEA,MAAM,+BAA+B;AAErC,IAAa,0BAAb,cAA6C,YAAY;CACrD,YAAY,SAAkB;EAC1B,MAAM,8BAA8B,0BAA0B,OAAO;CACzE;AACJ;AAEA,IAAa,0BAAb,cAA6C,gBAAgB;CACzD,AAAS;CAET,YAAY,cAAuB;EAC/B,MAAM,0EAA0E,yBAAyB;EACzG,KAAK,eAAe;CACxB;AACJ;AAEA,IAAa,iBAAb,cAAoC,gBAAgB;CAChD,YAAY,aAAa,SAAS;EAC9B,MAAM,GAAG,WAAW,mFAAmF,eAAe;CAC1H;AACJ;AAEA,IAAa,gCAAb,cAAmD,gBAAgB;CAC/D,AAAS;CACT,AAAS;CAET,YAAY,aAAqB,eAAwB;EACrD,MAAM,cAAc,YAAY,0EAA0E,gCAAgC;EAC1I,KAAK,cAAc;EACnB,KAAK,gBAAgB;CACzB;AACJ;AAEA,IAAa,8BAAb,cAAiD,gBAAgB;CAC7D,AAAS;CAET,YAAY,UAAmB;EAC3B,MAAM,sCAAsC,OAAO,QAAQ,EAAE,KAAK,6BAA6B;EAC/F,KAAK,WAAW;CACpB;AACJ;AAEA,IAAa,mBAAb,cAAsC,gBAAgB;CAClD,AAAS;CAET,YAAY,YAAqB;EAC7B,MAAM,2BAA2B,OAAO,UAAU,KAAK,iBAAiB;EACxE,KAAK,aAAa;CACtB;AACJ;AAEA,IAAa,qBAAb,cAAwC,gBAAgB;CACpD,AAAS;CAET,YAAY,SAAkB;EAC1B,MAAM,6BAA6B,OAAO,OAAO,KAAK,oBAAoB;EAC1E,KAAK,UAAU;CACnB;AACJ;AAEA,IAAa,gBAAb,cAAmC,YAAY;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,iBAAyB,YAAsB;EACvD,MAAM,eAAe,SAAY,kBAAkB,GAAG,gBAAgB,IAAI,OAAO,UAAU,KAAK,aAAa;EAC7G,KAAK,kBAAkB;EACvB,KAAK,aAAa;EAClB,IAAI,eAAe,QAAW,KAAK,QAAQ;CAC/C;AACJ;AAEA,IAAa,iBAAb,cAAoC,YAAY;CAC5C,AAAS;CACT,AAAS;CAET,YAAY,iBAAyB,SAAmB;EACpD,MAAM,YAAY,SAAY,kBAAkB,GAAG,gBAAgB,IAAI,OAAO,OAAO,KAAK,cAAc;EACxG,KAAK,kBAAkB;EACvB,KAAK,UAAU;EACf,IAAI,YAAY,QAAW,KAAK,QAAQ;CAC5C;AACJ"}

package/dist/errors.d.cts

@@ -1,2 +1,63 @@
-import { _ as ResultTypeError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapOnErrError, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultErrorCode, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as TaskYieldNotResultError, y as UnwrapErrOnOkError } from "./errors-BFjY06EV.cjs";
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//#region src/errors.d.ts
+declare const ERR_INVALID_RESULT_STATE: "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+declare const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE;
+declare const ERR_TASK_YIELD_NOT_RESULT: "ERR_TASK_YIELD_NOT_RESULT";
+declare const ERR_MATCH_ON_OK: "ERR_MATCH_ON_OK";
+declare const ERR_MATCH_ERR_HANDLER_NOT_RESULT: "ERR_MATCH_ERR_HANDLER_NOT_RESULT";
+declare const ERR_MATCH_TAG_MISSING_HANDLER: "ERR_MATCH_TAG_MISSING_HANDLER";
+declare const ERR_UNWRAP_ON_ERR: "ERR_UNWRAP_ON_ERR";
+declare const ERR_UNWRAP_ERR_ON_OK: "ERR_UNWRAP_ERR_ON_OK";
+declare const ERR_EXPECT_OK: "ERR_EXPECT_OK";
+declare const ERR_EXPECT_ERR: "ERR_EXPECT_ERR";
+type ResultErrorCode = typeof ERR_INVALID_RESULT_STATE | typeof ERR_TASK_YIELD_NOT_RESULT | typeof ERR_MATCH_ON_OK | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT | typeof ERR_MATCH_TAG_MISSING_HANDLER | typeof ERR_UNWRAP_ON_ERR | typeof ERR_UNWRAP_ERR_ON_OK | typeof ERR_EXPECT_OK | typeof ERR_EXPECT_ERR;
+declare class ResultError extends Error {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class ResultTypeError extends TypeError {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class InvalidResultStateError extends ResultError {
+  constructor(context?: string);
+}
+declare class TaskYieldNotResultError extends ResultTypeError {
+  readonly yieldedValue: unknown;
+  constructor(yieldedValue: unknown);
+}
+declare class MatchOnOkError extends ResultTypeError {
+  constructor(methodName?: string);
+}
+declare class MatchErrHandlerNotResultError extends ResultTypeError {
+  readonly handlerName: string;
+  readonly returnedValue: unknown;
+  constructor(handlerName: string, returnedValue: unknown);
+}
+declare class MatchTagMissingHandlerError extends ResultTypeError {
+  readonly tagValue: unknown;
+  constructor(tagValue: unknown);
+}
+declare class UnwrapOnErrError extends ResultTypeError {
+  readonly errorValue: unknown;
+  constructor(errorValue: unknown);
+}
+declare class UnwrapErrOnOkError extends ResultTypeError {
+  readonly okValue: unknown;
+  constructor(okValue: unknown);
+}
+declare class ExpectOkError extends ResultError {
+  readonly expectedMessage: string;
+  readonly errorValue: unknown;
+  constructor(expectedMessage: string, errorValue?: unknown);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  readonly okValue: unknown;
+  constructor(expectedMessage: string, okValue?: unknown);
+}
+//#endregion
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//# sourceMappingURL=errors.d.cts.map

package/dist/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../src/errors.ts"],"mappings":";cAAa,wBAAA;AAAb;AAAA,cAEa,iBAAA,SAA0B,wBAAA;AAAA,cAC1B,yBAAA;AAAA,cACA,eAAA;AAAA,cACA,gCAAA;AAAA,cACA,6BAAA;AAAA,cACA,iBAAA;AAAA,cACA,oBAAA;AAAA,cACA,aAAA;AAAA,cACA,cAAA;AAAA,KAED,eAAA,UACC,wBAAA,UACA,yBAAA,UACA,eAAA,UACA,gCAAA,UACA,6BAAA,UACA,iBAAA,UACA,oBAAA,UACA,aAAA,UACA,cAAA;AAAA,cASA,WAAA,SAAoB,KAAA;EAAA,SACpB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAS3C,eAAA,SAAwB,SAAA;EAAA,SACxB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAW3C,uBAAA,SAAgC,WAAA;EACzC,WAAA,CAAY,OAAA;AAAA;AAAA,cAKH,uBAAA,SAAgC,eAAA;EAAA,SAChC,YAAA;EAET,WAAA,CAAY,YAAA;AAAA;AAAA,cAMH,cAAA,SAAuB,eAAA;EAChC,WAAA,CAAY,UAAA;AAAA;AAAA,cAKH,6BAAA,SAAsC,eAAA;EAAA,SACtC,WAAA;EAAA,SACA,aAAA;EAET,WAAA,CAAY,WAAA,UAAqB,aAAA;AAAA;AAAA,cAOxB,2BAAA,SAAoC,eAAA;EAAA,SACpC,QAAA;EAET,WAAA,CAAY,QAAA;AAAA;AAAA,cAMH,gBAAA,SAAyB,eAAA;EAAA,SACzB,UAAA;EAET,WAAA,CAAY,UAAA;AAAA;AAAA,cAMH,kBAAA,SAA2B,eAAA;EAAA,SAC3B,OAAA;EAET,WAAA,CAAY,OAAA;AAAA;AAAA,cAMH,aAAA,SAAsB,WAAA;EAAA,SACtB,eAAA;EAAA,SACA,UAAA;EAET,WAAA,CAAY,eAAA,UAAyB,UAAA;AAAA;AAAA,cAQ5B,cAAA,SAAuB,WAAA;EAAA,SACvB,eAAA;EAAA,SACA,OAAA;EAET,WAAA,CAAY,eAAA,UAAyB,OAAA;AAAA"}

package/dist/errors.d.mts

@@ -1,2 +1,63 @@
-import { _ as ResultTypeError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapOnErrError, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultErrorCode, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as TaskYieldNotResultError, y as UnwrapErrOnOkError } from "./errors-C5qGMRiU.mjs";
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//#region src/errors.d.ts
+declare const ERR_INVALID_RESULT_STATE: "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+declare const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE;
+declare const ERR_TASK_YIELD_NOT_RESULT: "ERR_TASK_YIELD_NOT_RESULT";
+declare const ERR_MATCH_ON_OK: "ERR_MATCH_ON_OK";
+declare const ERR_MATCH_ERR_HANDLER_NOT_RESULT: "ERR_MATCH_ERR_HANDLER_NOT_RESULT";
+declare const ERR_MATCH_TAG_MISSING_HANDLER: "ERR_MATCH_TAG_MISSING_HANDLER";
+declare const ERR_UNWRAP_ON_ERR: "ERR_UNWRAP_ON_ERR";
+declare const ERR_UNWRAP_ERR_ON_OK: "ERR_UNWRAP_ERR_ON_OK";
+declare const ERR_EXPECT_OK: "ERR_EXPECT_OK";
+declare const ERR_EXPECT_ERR: "ERR_EXPECT_ERR";
+type ResultErrorCode = typeof ERR_INVALID_RESULT_STATE | typeof ERR_TASK_YIELD_NOT_RESULT | typeof ERR_MATCH_ON_OK | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT | typeof ERR_MATCH_TAG_MISSING_HANDLER | typeof ERR_UNWRAP_ON_ERR | typeof ERR_UNWRAP_ERR_ON_OK | typeof ERR_EXPECT_OK | typeof ERR_EXPECT_ERR;
+declare class ResultError extends Error {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class ResultTypeError extends TypeError {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class InvalidResultStateError extends ResultError {
+  constructor(context?: string);
+}
+declare class TaskYieldNotResultError extends ResultTypeError {
+  readonly yieldedValue: unknown;
+  constructor(yieldedValue: unknown);
+}
+declare class MatchOnOkError extends ResultTypeError {
+  constructor(methodName?: string);
+}
+declare class MatchErrHandlerNotResultError extends ResultTypeError {
+  readonly handlerName: string;
+  readonly returnedValue: unknown;
+  constructor(handlerName: string, returnedValue: unknown);
+}
+declare class MatchTagMissingHandlerError extends ResultTypeError {
+  readonly tagValue: unknown;
+  constructor(tagValue: unknown);
+}
+declare class UnwrapOnErrError extends ResultTypeError {
+  readonly errorValue: unknown;
+  constructor(errorValue: unknown);
+}
+declare class UnwrapErrOnOkError extends ResultTypeError {
+  readonly okValue: unknown;
+  constructor(okValue: unknown);
+}
+declare class ExpectOkError extends ResultError {
+  readonly expectedMessage: string;
+  readonly errorValue: unknown;
+  constructor(expectedMessage: string, errorValue?: unknown);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  readonly okValue: unknown;
+  constructor(expectedMessage: string, okValue?: unknown);
+}
+//#endregion
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";cAAa,wBAAA;AAAb;AAAA,cAEa,iBAAA,SAA0B,wBAAA;AAAA,cAC1B,yBAAA;AAAA,cACA,eAAA;AAAA,cACA,gCAAA;AAAA,cACA,6BAAA;AAAA,cACA,iBAAA;AAAA,cACA,oBAAA;AAAA,cACA,aAAA;AAAA,cACA,cAAA;AAAA,KAED,eAAA,UACC,wBAAA,UACA,yBAAA,UACA,eAAA,UACA,gCAAA,UACA,6BAAA,UACA,iBAAA,UACA,oBAAA,UACA,aAAA,UACA,cAAA;AAAA,cASA,WAAA,SAAoB,KAAA;EAAA,SACpB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAS3C,eAAA,SAAwB,SAAA;EAAA,SACxB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAW3C,uBAAA,SAAgC,WAAA;EACzC,WAAA,CAAY,OAAA;AAAA;AAAA,cAKH,uBAAA,SAAgC,eAAA;EAAA,SAChC,YAAA;EAET,WAAA,CAAY,YAAA;AAAA;AAAA,cAMH,cAAA,SAAuB,eAAA;EAChC,WAAA,CAAY,UAAA;AAAA;AAAA,cAKH,6BAAA,SAAsC,eAAA;EAAA,SACtC,WAAA;EAAA,SACA,aAAA;EAET,WAAA,CAAY,WAAA,UAAqB,aAAA;AAAA;AAAA,cAOxB,2BAAA,SAAoC,eAAA;EAAA,SACpC,QAAA;EAET,WAAA,CAAY,QAAA;AAAA;AAAA,cAMH,gBAAA,SAAyB,eAAA;EAAA,SACzB,UAAA;EAET,WAAA,CAAY,UAAA;AAAA;AAAA,cAMH,kBAAA,SAA2B,eAAA;EAAA,SAC3B,OAAA;EAET,WAAA,CAAY,OAAA;AAAA;AAAA,cAMH,aAAA,SAAsB,WAAA;EAAA,SACtB,eAAA;EAAA,SACA,UAAA;EAET,WAAA,CAAY,eAAA,UAAyB,UAAA;AAAA;AAAA,cAQ5B,cAAA,SAAuB,WAAA;EAAA,SACvB,eAAA;EAAA,SACA,OAAA;EAET,WAAA,CAAY,eAAA,UAAyB,OAAA;AAAA"}