@shirudo/result 1.1.0 → 1.2.0

package/dist/collections.d.mts

@@ -1,3 +1,101 @@
-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 };
+import { E as Awaitable, n as sequence, s as Result, t as all } from "./sequence-CmugKPbu.mjs";
+//#region src/core/sequenceRecord.d.ts
+type OkValueOf$3<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$3<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Like `sequence`, but for Records/Objects.
+ * Short-circuits on the first Err.
+ *
+ * A non-enumerable own property is an input only when it holds a `Result`, so a
+ * hidden helper field of another type is ignored. An array throws, because its
+ * indices would sequence into an object; use `sequence` for a list.
+ */
+declare function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any>; }>(record: R): Result<{ [K in keyof R]: OkValueOf$3<R[K]>; }, ErrValueOf$3<R[keyof R]>>;
+//#endregion
+//#region src/core/collectFirstOk.d.ts
+type OkValueOf$2<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$2<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+ * If no `Ok` is found, returns an `Err` containing the collected error values.
+ * Useful for "try multiple approaches until one works" patterns.
+ */
+declare function collectFirstOk<const Results extends readonly Result<any, any>[]>(results: Results): Result<OkValueOf$2<Results[number]>, ErrValueOf$2<Results[number]>[]>;
+//#endregion
+//#region src/core/collectFirstOkAsync.d.ts
+type CollectFirstOkAsyncInput$1 = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput$1<I> = ResolvedResult$1<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput$1<I> = ResolvedResult$1<I> extends Result<any, infer E> ? E : never;
+/**
+ * Async version of collectFirstOk.
+ *
+ * - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+ *   A thunk that throws synchronously is a programmer error: the call rejects
+ *   with that exception.
+ * - Processes inputs strictly sequentially (like `for ... of` + `await`).
+ * - Returns the first `Ok` and collects all errors if no `Ok` is found.
+ * - A fulfilled value that is not a `Result` is a programmer error: the call
+ *   rejects with `InvalidResultStateError`.
+ * - A rejected input counts as a failed attempt. Without `errorMapper` the
+ *   collected errors are `unknown[]`, because a rejection reason can be
+ *   anything. `errorMapper` turns each rejection reason into a typed error;
+ *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.
+ */
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, unknown[]>>;
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[], F>(inputs: Inputs, errorMapper: (error: unknown) => F): Promise<Result<OkValueOfInput$1<Inputs[number]>, Array<ErrValueOfInput$1<Inputs[number]> | F>>>;
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.d.ts
+type CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;
+/**
+ * Parallel version of `collectFirstOkAsync`.
+ *
+ * - Starts all inputs immediately (Promises or Thunks). A thunk that throws
+ *   synchronously is a programmer error: the call rejects with that exception,
+ *   as `collectFirstOkAsync` does.
+ * - Returns the first `Ok` as soon as it is available.
+ * - If no `Ok` is found, returns an `Err` with all error values (in input order).
+ * - A fulfilled value that is not a `Result` is a programmer error: the call
+ *   rejects with `InvalidResultStateError`, unless an `Ok` already won the race.
+ * - A rejected input counts as a failed attempt. Without `errorMapper` the
+ *   collected errors are `unknown[]`, because a rejection reason can be
+ *   anything. `errorMapper` turns each rejection reason into a typed error;
+ *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.
+ * - If multiple inputs provide an `Ok`, the one that completes first wins.
+ *   In case of simultaneous completion, the first observed result wins.
+ * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
+ */
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, unknown[]>>;
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(inputs: Inputs, errorMapper: (error: unknown) => F): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>>;
+//#endregion
+//#region src/core/collectAllErrors.d.ts
+type OkValueOf$1<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$1<R> = R extends Result<any, infer E> ? E : never;
+type CollectionValues<Results extends readonly Result<any, any>[]> = { -readonly [K in keyof Results]: OkValueOf$1<Results[K]>; };
+/**
+ * Combines a list of Results.
+ * Return Ok(values) only if all are Ok, otherwise Err([errors]).
+ */
+declare function collectAllErrors<const Results extends readonly Result<any, any>[]>(results: Results): Result<CollectionValues<Results>, Array<ErrValueOf$1<Results[number]>>>;
+//#endregion
+//#region src/core/partition.d.ts
+type OkValueOf<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Partitions Results into Ok values and Err errors.
+ */
+declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
+//#endregion
+//#region src/core/flatten.d.ts
+/**
+ * Flattens a nested Result.
+ * Result<Result<T, E>, E> → Result<T, E>
+ * Corresponds to Rust `flatten`.
+ */
+declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
+//#endregion
+export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };
+//# sourceMappingURL=collections.d.mts.map

package/dist/collections.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.mts","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"mappings":";;KAKK,YAAU,KAAK,UAAU,aAAa,UAAU;KAChD,aAAW,KAAK,UAAU,kBAAkB,KAAK;;;;;;;;;iBAUtC,qBAAqB,sBAAsB,WAAW,IAAI,qBACtE,QAAQ,IACT,UAAU,WAAW,IAAI,YAAU,EAAE,QAAO,aAAW,QAAQ;;;KCd7D,YAAU,KAAK,UAAU,aAAa,UAAU;KAChD,aAAW,KAAK,UAAU,kBAAkB,KAAK;;;;;;iBAOtC,qBAAqB,yBAAyB,oBAC1D,SAAS,UACV,OAAO,YAAU,kBAAkB,aAAW;;;KCR5C,6BACC,QAAQ,2BACD,UAAU;KAElB,iBAAe,KAAK,uBAAsB,KAAI,QAAQ,KAAK,UAAU,cAAc,KAAK;KACxF,iBAAe,KAAK,iBAAe,WAAW,aAAa,UAAU;KACrE,kBAAgB,KAAK,iBAAe,WAAW,kBAAkB,KAAK;;;;;;;;;;;;;;;;iBAiB3D,0BAA0B,wBAAwB,8BAC9D,QAAQ,SACT,QAAQ,OAAO,iBAAe;iBACjB,0BAA0B,wBAAwB,8BAA4B,GAC1F,QAAQ,QACR,cAAc,mBAAmB,IAClC,QAAQ,OAAO,iBAAe,iBAAiB,MAAM,kBAAgB,kBAAkB;;;KC7BrF,2BAA2B,QAAQ,2BAA2B,UAAU;KAExE,eAAe,KAAK,uBAAsB,KAAI,QAAQ,KAAK,UAAU,cAAc,KAAK;KACxF,eAAe,KAAK,eAAe,WAAW,aAAa,UAAU;KACrE,gBAAgB,KAAK,eAAe,WAAW,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;iBAoB3D,kCAAkC,wBAAwB,4BACtE,QAAQ,SACT,QAAQ,OAAO,eAAe;iBACjB,kCAAkC,wBAAwB,4BAA4B,GAClG,QAAQ,QACR,cAAc,mBAAmB,IAClC,QAAQ,OAAO,eAAe,iBAAiB,MAAM,gBAAgB,kBAAkB;;;KChCrF,YAAU,KAAK,UAAU,aAAa,UAAU;KAChD,aAAW,KAAK,UAAU,kBAAkB,KAAK;KACjD,iBAAiB,yBAAyB,mCAChC,WAAW,UAAU,YAAU,QAAQ;;;;;iBAOtC,uBAAuB,yBAAyB,oBAC5D,SAAS,UACV,OAAO,iBAAiB,UAAU,MAAM,aAAW;;;KCbjD,UAAU,KAAK,UAAU,aAAa,UAAU;KAChD,WAAW,KAAK,UAAU,kBAAkB,KAAK;;;;iBAKtC,gBAAgB,yBAAyB,oBACrD,SAAS,WACT,KAAK,MAAM,UAAU,mBAAmB,MAAM,MAAM,WAAW;;;;;;;;iBCHnD,QAAQ,GAAG,GAAG,QAAQ,OAAO,OAAO,GAAG,IAAI,KAAK,OAAO,GAAG"}

package/dist/collections.mjs

@@ -1,4 +1,176 @@
-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";
+import { c as ok, g as sequence, h as all, i as err, v as isResult } from "./result-DQCpkuOJ.mjs";
+import { p as InvalidResultStateError } from "./errors-MuakEcnM.mjs";
 
-export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };
+//#region src/core/sequenceRecord.ts
+/**
+* Like `sequence`, but for Records/Objects.
+* Short-circuits on the first Err.
+*
+* A non-enumerable own property is an input only when it holds a `Result`, so a
+* hidden helper field of another type is ignored. An array throws, because its
+* indices would sequence into an object; use `sequence` for a list.
+*/
+function sequenceRecord(record) {
+	if (Array.isArray(record)) throw new InvalidResultStateError("sequenceRecord");
+	const out = {};
+	for (const key of Reflect.ownKeys(record)) {
+		const result = record[key];
+		if (!isResult(result)) {
+			if (!Object.getOwnPropertyDescriptor(record, key)?.enumerable) continue;
+			throw new InvalidResultStateError("sequenceRecord");
+		}
+		if (result.isOk()) {
+			out[key] = result.value;
+			continue;
+		}
+		if (result.isErr()) return result;
+		throw new InvalidResultStateError("sequenceRecord");
+	}
+	return ok(out);
+}
+
+//#endregion
+//#region src/core/collectFirstOk.ts
+/**
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
+*/
+function collectFirstOk(results) {
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) return ok(result.value);
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("collectFirstOk");
+	}
+	return err(errors);
+}
+
+//#endregion
+//#region src/core/collectFirstOkAsync.ts
+async function collectFirstOkAsync(inputs, errorMapper) {
+	const errors = [];
+	for (const input of inputs) {
+		const pendingResult = typeof input === "function" ? input() : input;
+		let result;
+		try {
+			result = await pendingResult;
+		} catch (error) {
+			errors.push(errorMapper ? errorMapper(error) : error);
+			continue;
+		}
+		if (isResult(result)) {
+			if (result.isOk()) return ok(result.value);
+			if (result.isErr()) {
+				errors.push(result.error);
+				continue;
+			}
+		}
+		throw new InvalidResultStateError("collectFirstOkAsync");
+	}
+	return err(errors);
+}
+
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.ts
+async function collectFirstOkParallelAsync(inputs, errorMapper) {
+	if (inputs.length === 0) return err([]);
+	const started = [];
+	try {
+		for (const input of inputs) started.push(typeof input === "function" ? Promise.resolve(input()) : input);
+	} catch (bug) {
+		for (const promise of started) promise.catch(() => {});
+		throw bug;
+	}
+	const firstOk = new Promise((resolve, reject) => {
+		for (const promise of started) promise.then((value) => {
+			if (!isResult(value)) reject(new InvalidResultStateError("collectFirstOkParallelAsync"));
+			else if (value.isOk()) resolve(ok(value.value));
+		}, () => {});
+	});
+	const allErrors = Promise.allSettled(started).then((settled) => {
+		const errors = [];
+		for (const entry of settled) {
+			if (entry.status === "rejected") {
+				errors.push(errorMapper ? errorMapper(entry.reason) : entry.reason);
+				continue;
+			}
+			const result = entry.value;
+			if (isResult(result)) {
+				if (result.isErr()) {
+					errors.push(result.error);
+					continue;
+				}
+				if (result.isOk()) continue;
+			}
+			throw new InvalidResultStateError("collectFirstOkParallelAsync");
+		}
+		return err(errors);
+	});
+	return Promise.race([firstOk, allErrors]);
+}
+
+//#endregion
+//#region src/core/collectAllErrors.ts
+/**
+* Combines a list of Results.
+* Return Ok(values) only if all are Ok, otherwise Err([errors]).
+*/
+function collectAllErrors(results) {
+	const values = [];
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			values.push(result.value);
+			continue;
+		}
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("collectAllErrors");
+	}
+	return errors.length === 0 ? ok(values) : err(errors);
+}
+
+//#endregion
+//#region src/core/partition.ts
+/**
+* Partitions Results into Ok values and Err errors.
+*/
+function partition(results) {
+	const oks = [];
+	const errs = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			oks.push(result.value);
+			continue;
+		}
+		if (result.isErr()) {
+			errs.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("partition");
+	}
+	return [oks, errs];
+}
+
+//#endregion
+//#region src/core/flatten.ts
+/**
+* Flattens a nested Result.
+* Result<Result<T, E>, E> → Result<T, E>
+* Corresponds to Rust `flatten`.
+*/
+function flatten(result) {
+	if (result.isOk()) return result.value;
+	if (result.isErr()) return result;
+	throw new InvalidResultStateError("flatten");
+}
+
+//#endregion
+export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };
+//# sourceMappingURL=collections.mjs.map

package/dist/collections.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.mjs","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"sourcesContent":["import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\nimport { isResult } from './isResult';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Like `sequence`, but for Records/Objects.\n * Short-circuits on the first Err.\n *\n * A non-enumerable own property is an input only when it holds a `Result`, so a\n * hidden helper field of another type is ignored. An array throws, because its\n * indices would sequence into an object; use `sequence` for a list.\n */\nexport function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any> }>(\n    record: R\n): Result<{ [K in keyof R]: OkValueOf<R[K]> }, ErrValueOf<R[keyof R]>> {\n    type Out = { [K in keyof R]: OkValueOf<R[K]> };\n    type E = ErrValueOf<R[keyof R]>;\n\n    // An array reaches this point only from JavaScript, and it would sequence\n    // into an object keyed by its indices: `length` is a non-enumerable\n    // non-Result and the rule below would skip it. A list of Results belongs to\n    // `sequence()`, so the mistake fails here instead of returning a wrong shape.\n    if (Array.isArray(record)) throw new InvalidResultStateError('sequenceRecord');\n\n    const out: Partial<Out> = {};\n\n    // `Reflect.ownKeys` keeps the symbol keys, which the signature supports, and\n    // it also visits the non-enumerable properties. `keyof R` sees those too, so\n    // a hidden Result stays an input. A hidden value of another type is a helper\n    // field that the caller attached, and it is skipped instead of rejected.\n    for (const key of Reflect.ownKeys(record) as Array<keyof R>) {\n        const result = record[key];\n\n        if (!isResult(result)) {\n            if (!Object.getOwnPropertyDescriptor(record, key)?.enumerable) continue;\n            throw new InvalidResultStateError('sequenceRecord');\n        }\n\n        if (result.isOk()) {\n            out[key] = result.value as Out[typeof key];\n            continue;\n        }\n        if (result.isErr()) return result as unknown as Result<Out, E>;\n        throw new InvalidResultStateError('sequenceRecord');\n    }\n\n    return ok<Out, E>(out as Out);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Parse a set of `Result`s, short-circuits when an input value is `Ok`.\n * If no `Ok` is found, returns an `Err` containing the collected error values.\n * Useful for \"try multiple approaches until one works\" patterns.\n */\nexport function collectFirstOk<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]> {\n    const errors: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            return ok<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]>(\n                result.value as OkValueOf<Results[number]>\n            );\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectFirstOk');\n    }\n\n    return err<ErrValueOf<Results[number]>[], OkValueOf<Results[number]>>(errors);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport type { Awaitable } from './pipeable';\nimport { isResult } from './isResult';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput =\n    | Promise<Result<any, any>>\n    | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Async version of collectFirstOk.\n *\n * - Takes either already started Promises or \"Thunks\" (`() => Awaitable<Result<...>>`).\n *   A thunk that throws synchronously is a programmer error: the call rejects\n *   with that exception.\n * - Processes inputs strictly sequentially (like `for ... of` + `await`).\n * - Returns the first `Ok` and collects all errors if no `Ok` is found.\n * - A fulfilled value that is not a `Result` is a programmer error: the call\n *   rejects with `InvalidResultStateError`.\n * - A rejected input counts as a failed attempt. Without `errorMapper` the\n *   collected errors are `unknown[]`, because a rejection reason can be\n *   anything. `errorMapper` turns each rejection reason into a typed error;\n *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.\n */\nexport function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, unknown[]>>;\nexport function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>>;\nexport async function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper?: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>> {\n    type OkValue = OkValueOfInput<Inputs[number]>;\n    type ErrValue = ErrValueOfInput<Inputs[number]> | F;\n\n    const errors: ErrValue[] = [];\n\n    for (const input of inputs) {\n        const pendingResult = typeof input === 'function' ? input() : input;\n        let result: unknown;\n        try {\n            result = await pendingResult;\n        } catch (error) {\n            errors.push(errorMapper ? errorMapper(error) : (error as F));\n            continue;\n        }\n\n        if (isResult(result)) {\n            if (result.isOk()) {\n                return ok<OkValue, ErrValue[]>(result.value as OkValue);\n            }\n            if (result.isErr()) {\n                errors.push(result.error as ErrValue);\n                continue;\n            }\n        }\n        throw new InvalidResultStateError('collectFirstOkAsync');\n    }\n\n    return err<ErrValue[], OkValue>(errors);\n}\n","import type { Awaitable } from './pipeable';\nimport type { Result } from './result';\nimport { err, ok } from './result';\nimport { isResult } from './isResult';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Parallel version of `collectFirstOkAsync`.\n *\n * - Starts all inputs immediately (Promises or Thunks). A thunk that throws\n *   synchronously is a programmer error: the call rejects with that exception,\n *   as `collectFirstOkAsync` does.\n * - Returns the first `Ok` as soon as it is available.\n * - If no `Ok` is found, returns an `Err` with all error values (in input order).\n * - A fulfilled value that is not a `Result` is a programmer error: the call\n *   rejects with `InvalidResultStateError`, unless an `Ok` already won the race.\n * - A rejected input counts as a failed attempt. Without `errorMapper` the\n *   collected errors are `unknown[]`, because a rejection reason can be\n *   anything. `errorMapper` turns each rejection reason into a typed error;\n *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.\n * - If multiple inputs provide an `Ok`, the one that completes first wins.\n *   In case of simultaneous completion, the first observed result wins.\n * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.\n */\nexport function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, unknown[]>>;\nexport function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>>;\nexport async function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper?: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>> {\n    type OkValue = OkValueOfInput<Inputs[number]>;\n    type ErrValue = ErrValueOfInput<Inputs[number]> | F;\n\n    if (inputs.length === 0) {\n        return err<ErrValue[], OkValue>([]);\n    }\n\n    // Discarding the outcomes of the attempts that already started keeps an\n    // abandoned rejection from surfacing as an unhandled rejection.\n    const started: Promise<unknown>[] = [];\n    try {\n        for (const input of inputs) {\n            started.push(typeof input === 'function' ? Promise.resolve(input()) : input);\n        }\n    } catch (bug) {\n        for (const promise of started) promise.catch(() => {});\n        throw bug;\n    }\n\n    const firstOk = new Promise<Result<OkValue, ErrValue[]>>((resolve, reject) => {\n        for (const promise of started) {\n            promise.then(\n                (value) => {\n                    if (!isResult(value)) {\n                        reject(new InvalidResultStateError('collectFirstOkParallelAsync'));\n                    } else if (value.isOk()) {\n                        resolve(ok<OkValue, ErrValue[]>(value.value as OkValue));\n                    }\n                },\n                () => {\n                    // A rejection is a failed attempt; allSettled below collects it.\n                }\n            );\n        }\n    });\n\n    const allErrors = Promise.allSettled(started).then((settled) => {\n        const errors: ErrValue[] = [];\n        for (const entry of settled) {\n            if (entry.status === 'rejected') {\n                errors.push(errorMapper ? errorMapper(entry.reason) : (entry.reason as F));\n                continue;\n            }\n            const result = entry.value;\n            if (isResult(result)) {\n                if (result.isErr()) {\n                    errors.push(result.error as ErrValue);\n                    continue;\n                }\n                if (result.isOk()) continue;\n            }\n            throw new InvalidResultStateError('collectFirstOkParallelAsync');\n        }\n        return err<ErrValue[], OkValue>(errors);\n    });\n\n    return Promise.race([firstOk, allErrors]);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\ntype CollectionValues<Results extends readonly Result<any, any>[]> = {\n    -readonly [K in keyof Results]: OkValueOf<Results[K]>;\n};\n\n/**\n * Combines a list of Results.\n * Return Ok(values) only if all are Ok, otherwise Err([errors]).\n */\nexport function collectAllErrors<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<CollectionValues<Results>, Array<ErrValueOf<Results[number]>>> {\n    const values: Array<OkValueOf<Results[number]>> = [];\n    const errors: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            values.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectAllErrors');\n    }\n\n    return errors.length === 0\n        ? ok<CollectionValues<Results>, Array<ErrValueOf<Results[number]>>>(values as CollectionValues<Results>)\n        : err<Array<ErrValueOf<Results[number]>>, CollectionValues<Results>>(errors);\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Partitions Results into Ok values and Err errors.\n */\nexport function partition<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>] {\n    const oks: Array<OkValueOf<Results[number]>> = [];\n    const errs: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            oks.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) {\n            errs.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('partition');\n    }\n\n    return [oks, errs];\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Flattens a nested Result.\n * Result<Result<T, E>, E> → Result<T, E>\n * Corresponds to Rust `flatten`.\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) return result as unknown as Result<T, E>;\n    throw new InvalidResultStateError('flatten');\n}\n"],"mappings":"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"}

package/dist/errors-CVgC7NII.cjs

@@ -0,0 +1,278 @@
+
+//#region src/describeValue.ts
+const describeUnprintable = (value) => {
+	try {
+		return Object.prototype.toString.call(value);
+	} catch {
+		return `[unprintable ${typeof value}]`;
+	}
+};
+/**
+* Formats a foreign value for an error message.
+*
+* `String(value)` runs the `toString`, `valueOf` or `Symbol.toPrimitive` of
+* that value. An object with a null prototype has none of them, and a hostile
+* one throws. Without this guard the conversion failure replaces the coded
+* library error, and a caller that matches on the code never sees it.
+*/
+function describeValue(value) {
+	try {
+		return String(value);
+	} catch {
+		return describeUnprintable(value);
+	}
+}
+/**
+* Formats the `message` of a foreign error value, or the value itself when it
+* carries none. The property access belongs to the value, not to this library:
+* a getter or a Proxy trap can throw, and then the value itself is described.
+*/
+function describeErrorMessage(value) {
+	try {
+		if (value !== null && typeof value === "object" && "message" in value) return describeValue(value.message);
+	} catch {}
+	return describeValue(value);
+}
+
+//#endregion
+//#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 "${describeValue(tagValue)}".`, ERR_MATCH_TAG_MISSING_HANDLER);
+		this.tagValue = tagValue;
+	}
+};
+var UnwrapOnErrError = class extends ResultTypeError {
+	errorValue;
+	constructor(errorValue) {
+		super(`Called unwrap() on Err: ${describeValue(errorValue)}`, ERR_UNWRAP_ON_ERR);
+		this.errorValue = errorValue;
+	}
+};
+var UnwrapErrOnOkError = class extends ResultTypeError {
+	okValue;
+	constructor(okValue) {
+		super(`Called unwrapErr() on Ok: ${describeValue(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}: ${describeValue(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}: ${describeValue(okValue)}`, ERR_EXPECT_ERR);
+		this.expectedMessage = expectedMessage;
+		this.okValue = okValue;
+		if (okValue !== void 0) this.cause = okValue;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ERR_EXPECT_ERR', {
+  enumerable: true,
+  get: function () {
+    return ERR_EXPECT_ERR;
+  }
+});
+Object.defineProperty(exports, 'ERR_EXPECT_OK', {
+  enumerable: true,
+  get: function () {
+    return ERR_EXPECT_OK;
+  }
+});
+Object.defineProperty(exports, 'ERR_INVALID_RESULT_STATE', {
+  enumerable: true,
+  get: function () {
+    return ERR_INVALID_RESULT_STATE;
+  }
+});
+Object.defineProperty(exports, 'ERR_INVALID_STATE', {
+  enumerable: true,
+  get: function () {
+    return ERR_INVALID_STATE;
+  }
+});
+Object.defineProperty(exports, 'ERR_MATCH_ERR_HANDLER_NOT_RESULT', {
+  enumerable: true,
+  get: function () {
+    return ERR_MATCH_ERR_HANDLER_NOT_RESULT;
+  }
+});
+Object.defineProperty(exports, 'ERR_MATCH_ON_OK', {
+  enumerable: true,
+  get: function () {
+    return ERR_MATCH_ON_OK;
+  }
+});
+Object.defineProperty(exports, 'ERR_MATCH_TAG_MISSING_HANDLER', {
+  enumerable: true,
+  get: function () {
+    return ERR_MATCH_TAG_MISSING_HANDLER;
+  }
+});
+Object.defineProperty(exports, 'ERR_TASK_YIELD_NOT_RESULT', {
+  enumerable: true,
+  get: function () {
+    return ERR_TASK_YIELD_NOT_RESULT;
+  }
+});
+Object.defineProperty(exports, 'ERR_UNWRAP_ERR_ON_OK', {
+  enumerable: true,
+  get: function () {
+    return ERR_UNWRAP_ERR_ON_OK;
+  }
+});
+Object.defineProperty(exports, 'ERR_UNWRAP_ON_ERR', {
+  enumerable: true,
+  get: function () {
+    return ERR_UNWRAP_ON_ERR;
+  }
+});
+Object.defineProperty(exports, 'ExpectErrError', {
+  enumerable: true,
+  get: function () {
+    return ExpectErrError;
+  }
+});
+Object.defineProperty(exports, 'ExpectOkError', {
+  enumerable: true,
+  get: function () {
+    return ExpectOkError;
+  }
+});
+Object.defineProperty(exports, 'InvalidResultStateError', {
+  enumerable: true,
+  get: function () {
+    return InvalidResultStateError;
+  }
+});
+Object.defineProperty(exports, 'MatchErrHandlerNotResultError', {
+  enumerable: true,
+  get: function () {
+    return MatchErrHandlerNotResultError;
+  }
+});
+Object.defineProperty(exports, 'MatchOnOkError', {
+  enumerable: true,
+  get: function () {
+    return MatchOnOkError;
+  }
+});
+Object.defineProperty(exports, 'MatchTagMissingHandlerError', {
+  enumerable: true,
+  get: function () {
+    return MatchTagMissingHandlerError;
+  }
+});
+Object.defineProperty(exports, 'ResultError', {
+  enumerable: true,
+  get: function () {
+    return ResultError;
+  }
+});
+Object.defineProperty(exports, 'ResultTypeError', {
+  enumerable: true,
+  get: function () {
+    return ResultTypeError;
+  }
+});
+Object.defineProperty(exports, 'TaskYieldNotResultError', {
+  enumerable: true,
+  get: function () {
+    return TaskYieldNotResultError;
+  }
+});
+Object.defineProperty(exports, 'UnwrapErrOnOkError', {
+  enumerable: true,
+  get: function () {
+    return UnwrapErrOnOkError;
+  }
+});
+Object.defineProperty(exports, 'UnwrapOnErrError', {
+  enumerable: true,
+  get: function () {
+    return UnwrapOnErrError;
+  }
+});
+Object.defineProperty(exports, 'describeErrorMessage', {
+  enumerable: true,
+  get: function () {
+    return describeErrorMessage;
+  }
+});
+//# sourceMappingURL=errors-CVgC7NII.cjs.map

package/dist/errors-CVgC7NII.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CVgC7NII.cjs","names":[],"sources":["../src/describeValue.ts","../src/errors.ts"],"sourcesContent":["// `Object.prototype.toString` reads `Symbol.toStringTag`, which can be a\n// getter that throws, so even the fallback needs its own guard.\nconst describeUnprintable = (value: unknown): string => {\n    try {\n        return Object.prototype.toString.call(value);\n    } catch {\n        return `[unprintable ${typeof value}]`;\n    }\n};\n\n/**\n * Formats a foreign value for an error message.\n *\n * `String(value)` runs the `toString`, `valueOf` or `Symbol.toPrimitive` of\n * that value. An object with a null prototype has none of them, and a hostile\n * one throws. Without this guard the conversion failure replaces the coded\n * library error, and a caller that matches on the code never sees it.\n */\nexport function describeValue(value: unknown): string {\n    try {\n        return String(value);\n    } catch {\n        return describeUnprintable(value);\n    }\n}\n\n/**\n * Formats the `message` of a foreign error value, or the value itself when it\n * carries none. The property access belongs to the value, not to this library:\n * a getter or a Proxy trap can throw, and then the value itself is described.\n */\nexport function describeErrorMessage(value: unknown): string {\n    try {\n        if (value !== null && typeof value === 'object' && 'message' in value) {\n            return describeValue((value as { message: unknown }).message);\n        }\n    } catch {\n        // The `in` check or the getter threw, so fall through to the value.\n    }\n\n    return describeValue(value);\n}\n","import { describeValue } from './describeValue';\n\nexport 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 \"${describeValue(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: ${describeValue(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: ${describeValue(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}: ${describeValue(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}: ${describeValue(okValue)}`, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n        this.okValue = okValue;\n        if (okValue !== undefined) this.cause = okValue;\n    }\n}\n"],"mappings":"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"}