@dangayle/rustlike 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,443 +1,2 @@
-import { _ as isNone, a as asyncIterFromIterable, b as toPanicString, c as iterFromArray, d as None, f as Ok, g as isErr, h as Some, i as asyncIterFromGenerator, l as iterFromGenerator, m as Result, n as asyncIter, o as Iter, p as Option, r as asyncIterFromArray, s as iter, t as AsyncIter, u as Err, v as isOk, y as isSome } from "./async-iter-aLdg-qp2.mjs";
-
-//#region src/async.ts
-/**
-* AsyncResult<T, E> - Handling asynchronous Results chaining
-*/
-var AsyncResult = class AsyncResult {
-	constructor(promise) {
-		this.promise = promise;
-	}
-	/**
-	* Create an AsyncResult from a Promise<Result<T, E>>
-	*/
-	static fromPromise(promise) {
-		return new AsyncResult(promise);
-	}
-	/**
-	* Create an AsyncResult that resolves to Ok(value)
-	*/
-	static ok(value) {
-		return new AsyncResult(Promise.resolve(Ok(value)));
-	}
-	/**
-	* Create an AsyncResult that resolves to Err(error)
-	*/
-	static err(error) {
-		return new AsyncResult(Promise.resolve(Err(error)));
-	}
-	/**
-	* Wrap an async function that might reject into an AsyncResult.
-	* This is the async equivalent of Result.fromThrowable().
-	*
-	* @example
-	* const result = await AsyncResult.fromThrowable(() => fetch('/api/users'));
-	* // AsyncResult<Response, unknown>
-	*/
-	static fromThrowable(fn) {
-		try {
-			return new AsyncResult(fn().then((value) => Ok(value)).catch((error) => Err(error)));
-		} catch (e) {
-			return new AsyncResult(Promise.resolve(Err(e)));
-		}
-	}
-	/**
-	* Map the inner Ok value using a synchronous or asynchronous function.
-	* If the function returns a Promise, it is awaited.
-	*/
-	map(fn) {
-		return new AsyncResult(this.promise.then(async (res) => {
-			if (res.isErr()) return res;
-			return Ok(await fn(res.value));
-		}));
-	}
-	/**
-	* Map the inner Err value using a synchronous or asynchronous function.
-	*/
-	mapErr(fn) {
-		return new AsyncResult(this.promise.then(async (res) => {
-			if (res.isOk()) return res;
-			return Err(await fn(res.error));
-		}));
-	}
-	/**
-	* Chain another Result-returning operation (sync or async).
-	* Supports returning: Result, AsyncResult, or Promise<Result>.
-	*/
-	andThen(fn) {
-		return new AsyncResult(this.promise.then(async (res) => {
-			if (res.isErr()) return res;
-			const next = fn(res.value);
-			if (next instanceof AsyncResult) return await next.toPromise();
-			return await next;
-		}));
-	}
-	/**
-	* Handle the error case with another Result-returning operation.
-	*/
-	orElse(fn) {
-		return new AsyncResult(this.promise.then(async (res) => {
-			if (res.isOk()) return res;
-			const next = fn(res.error);
-			if (next instanceof AsyncResult) return await next.toPromise();
-			return await next;
-		}));
-	}
-	/**
-	* Inspect the Ok value if present, without modifying it.
-	* The callback can be synchronous or asynchronous.
-	*/
-	inspect(fn) {
-		return new AsyncResult(this.promise.then(async (res) => {
-			if (res.isOk()) await fn(res.value);
-			return res;
-		}));
-	}
-	/**
-	* Inspect the Err value if present, without modifying it.
-	* The callback can be synchronous or asynchronous.
-	*/
-	inspectErr(fn) {
-		return new AsyncResult(this.promise.then(async (res) => {
-			if (res.isErr()) await fn(res.error);
-			return res;
-		}));
-	}
-	/**
-	* Pattern match on the result (async).
-	*/
-	match(handlers) {
-		return this.promise.then((res) => res.match(handlers));
-	}
-	/**
-	* Unwrap the value or throw (reject).
-	*/
-	async unwrap() {
-		return (await this.promise).unwrap();
-	}
-	/**
-	* Unwrap or return default.
-	*/
-	async unwrapOr(defaultValue) {
-		return (await this.promise).unwrapOr(defaultValue);
-	}
-	/**
-	* Unwrap or compute default.
-	*/
-	async unwrapOrElse(fn) {
-		const res = await this.promise;
-		if (res.isOk()) return res.value;
-		return await fn(res.error);
-	}
-	/**
-	* Returns true if the result is Ok and contains the given value.
-	*/
-	contains(value) {
-		return this.promise.then((r) => r.contains(value));
-	}
-	/**
-	* Returns true if the result is Err and contains the given error.
-	*/
-	containsErr(error) {
-		return this.promise.then((r) => r.containsErr(error));
-	}
-	/**
-	* Returns `other` if the result is Ok, otherwise returns the Err value of self.
-	*/
-	and(other) {
-		return new AsyncResult(this.promise.then((r) => r.isOk() ? other.promise : Promise.resolve(r)));
-	}
-	/**
-	* Returns `other` if the result is Err, otherwise returns the Ok value of self.
-	*/
-	or(other) {
-		return new AsyncResult(this.promise.then((r) => r.isErr() ? other.promise : Promise.resolve(r)));
-	}
-	/**
-	* Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.
-	*/
-	flatten() {
-		return new AsyncResult(this.promise.then((r) => r.flatten()));
-	}
-	/**
-	* Converts from Result<T, E> to Option<T>, discarding the error if any.
-	*/
-	toOption() {
-		return this.promise.then((r) => r.toOption());
-	}
-	/**
-	* Converts from Result<T, E> to Option<E>, discarding the success value if any.
-	*/
-	err() {
-		return this.promise.then((r) => r.err());
-	}
-	/**
-	* Returns the contained Ok value, or throws with the provided message.
-	*/
-	expect(message) {
-		return this.promise.then((r) => r.expect(message));
-	}
-	/**
-	* Returns the contained Err value, or throws if Ok.
-	*/
-	unwrapErr() {
-		return this.promise.then((r) => r.unwrapErr());
-	}
-	/**
-	* Returns the contained Err value, or throws with the provided message.
-	*/
-	expectErr(message) {
-		return this.promise.then((r) => r.expectErr(message));
-	}
-	/**
-	* Get the underlying Promise<Result<T, E>>
-	*/
-	toPromise() {
-		return this.promise;
-	}
-	/**
-	* Implement PromiseLike to allow `await asyncResult`
-	*/
-	then(onfulfilled, onrejected) {
-		return this.promise.then(onfulfilled, onrejected);
-	}
-};
-
-//#endregion
-//#region src/match.ts
-/**
-* Exhaustive pattern matching utilities
-*
-* Ensures all cases are handled in discriminated unions.
-*/
-/**
-* Use in the default case of a switch to ensure exhaustiveness.
-* If the switch is not exhaustive, TypeScript will error because
-* the unhandled case type cannot be assigned to 'never'.
-*
-* @example
-* type Shape = { kind: 'circle'; radius: number } | { kind: 'rect'; w: number; h: number };
-*
-* function area(s: Shape): number {
-*   switch (s.kind) {
-*     case 'circle': return Math.PI * s.radius ** 2;
-*     case 'rect': return s.w * s.h;
-*     default: return assertNever(s);
-*   }
-* }
-*/
-function assertNever(x, message) {
-	if (message) throw new Error(message);
-	throw new Error(`Unexpected value: ${toPanicString(x)}`);
-}
-/**
-* Type-safe exhaustive matching for discriminated unions.
-* Supports an optional catch-all '_' handler.
-*
-* @example
-* type Action =
-*   | { type: 'increment'; amount: number }
-*   | { type: 'decrement'; amount: number }
-*   | { type: 'reset' };
-*
-* const result = match(action, 'type', {
-*   increment: (a) => state + a.amount,
-*   decrement: (a) => state - a.amount,
-*   reset: () => 0,
-* });
-*
-* // With catch-all
-* const result = match(action, 'type', {
-*   increment: (a) => state + a.amount,
-*   _: () => state // catch-all
-* });
-*/
-function match(value, discriminant, handlers) {
-	const key = value[discriminant];
-	const handlersRecord = handlers;
-	const handler = handlersRecord[key];
-	if (handler) return handler(value);
-	const catchAll = handlersRecord._;
-	if (catchAll) return catchAll(value);
-	return assertNever(value, `Unhandled variant: ${key}`);
-}
-/**
-* Match on a discriminated union using the 'kind' discriminant (common pattern).
-*
-* @example
-* type Shape =
-*   | { kind: 'circle'; radius: number }
-*   | { kind: 'rect'; w: number; h: number };
-*
-* const area = matchKind(shape, {
-*   circle: (s) => Math.PI * s.radius ** 2,
-*   rect: (s) => s.w * s.h,
-* });
-*
-* // With catch-all
-* const isCircle = matchKind(shape, {
-*   circle: () => true,
-*   _: () => false
-* });
-*/
-function matchKind(value, handlers) {
-	return match(value, "kind", handlers);
-}
-/**
-* Match on a discriminated union using the 'type' discriminant (common pattern).
-*
-* @example
-* type Action =
-*   | { type: 'add'; item: string }
-*   | { type: 'remove'; id: number };
-*
-* const result = matchType(action, {
-*   add: (a) => [...items, a.item],
-*   remove: (a) => items.filter((_, i) => i !== a.id),
-* });
-*/
-function matchType(value, handlers) {
-	return match(value, "type", handlers);
-}
-
-//#endregion
-//#region src/types.ts
-/**
-* Immutability and utility types for Rust-like TypeScript
-*/
-/**
-* Create a branded type constructor
-*
-* @example
-* const UserId = brand<number, 'UserId'>();
-* const id = UserId(42); // type is Brand<number, 'UserId'>
-*/
-const brand = () => (value) => value;
-/**
-* Check if array is non-empty (type guard)
-*/
-const isNonEmpty = (arr) => arr.length > 0;
-/**
-* Create a non-empty array from values
-*/
-const nonEmpty = (first, ...rest) => [first, ...rest];
-/**
-* Get the first element of a non-empty array (guaranteed to exist)
-*/
-const head = (arr) => arr[0];
-/**
-* Create a newtype with validation (Rust's newtype pattern + smart constructor).
-* Implements the "parse, don't validate" pattern - make invalid states unrepresentable.
-*
-* @example
-* const EmailAddress = newtype<string, 'Email'>(
-*   (s) => s.includes('@'),
-*   "Invalid email"
-* );
-*
-* const email = EmailAddress.parse(userInput);
-* // Result<Brand<string, 'Email'>, string>
-*
-* @example
-* const PositiveNumber = newtype<number, 'Positive'>(
-*   (n) => n > 0,
-*   (n) => `Expected positive, got ${n}`
-* );
-*/
-const newtype = (validate, error) => {
-	const getError = (value) => {
-		if (typeof error === "function") return error(value);
-		return error;
-	};
-	return {
-		parse: (value) => {
-			if (validate(value)) return Ok(value);
-			return Err(getError(value));
-		},
-		unsafe: (value) => value
-	};
-};
-
-//#endregion
-//#region src/interop.ts
-/**
-* Interop helpers for wrapping third-party and standard library code
-*/
-/**
-* One-shot: wrap a single throwing operation in a Result.
-* Use {@link safeTry} to create a reusable safe wrapper instead.
-*
-* @example
-* const result = tryCatch(() => JSON.parse(userInput));
-* // Result<unknown, unknown>
-*/
-const tryCatch = (fn) => {
-	try {
-		return Ok(fn());
-	} catch (e) {
-		return Err(e);
-	}
-};
-/**
-* Wrap any async function that might reject to return Result
-*
-* @example
-* const result = await tryAsync(() => axios.get('/api/users'));
-* // Result<AxiosResponse, AxiosError>
-*/
-const tryAsync = async (fn) => {
-	try {
-		return Ok(await fn());
-	} catch (e) {
-		return Err(e);
-	}
-};
-/**
-* Create a reusable Option-returning version of any function that may return
-* T | null | undefined or throw. Returns None on null, undefined, or throw.
-*
-* @example
-* const safeFind = safeCall((id: number) => users.find(u => u.id === id));
-* const user = safeFind(42); // Option<User>
-*/
-const safeCall = (fn) => (...args) => {
-	try {
-		return Option.from(fn(...args));
-	} catch {
-		return None;
-	}
-};
-/**
-* Create a reusable Option-returning version of any async function that may return
-* T | null | undefined or reject. Returns None on null, undefined, or rejection.
-*
-* @example
-* const safeFetch = safeCallAsync((url: string) => fetch(url).then(r => r.ok ? r : null));
-* const response = await safeFetch('/api'); // Option<Response>
-*/
-const safeCallAsync = (fn) => async (...args) => {
-	try {
-		return Option.from(await fn(...args));
-	} catch {
-		return None;
-	}
-};
-/**
-* Reusable: wrap a throwing function so every call returns a Result.
-* Use {@link tryCatch} for one-shot operations instead.
-*
-* @example
-* const safeJsonParse = safeTry(JSON.parse);
-* const data = safeJsonParse(input); // Result<unknown, unknown>
-*/
-const safeTry = (fn) => (...args) => {
-	try {
-		return Ok(fn(...args));
-	} catch (e) {
-		return Err(e);
-	}
-};
-
-//#endregion
-export { AsyncIter, AsyncResult, Err, Iter, None, Ok, Option, Result, Some, assertNever, asyncIter, asyncIterFromArray, asyncIterFromGenerator, asyncIterFromIterable, brand, head, isErr, isNonEmpty, isNone, isOk, isSome, iter, iterFromArray, iterFromGenerator, match, matchKind, matchType, newtype, nonEmpty, safeCall, safeCallAsync, safeTry, tryAsync, tryCatch };
+import{_ as e,a as t,b as n,c as r,d as i,f as a,g as o,h as s,i as c,l,m as u,n as d,o as f,p,r as m,s as h,t as g,u as _,v,y}from"./async-iter-D51Pm8tA.mjs";var b=class e{constructor(e){this.promise=e}static fromPromise(t){return new e(t)}static ok(t){return new e(Promise.resolve(a(t)))}static err(t){return new e(Promise.resolve(_(t)))}static fromThrowable(t){try{return new e(t().then(e=>a(e)).catch(e=>_(e)))}catch(t){return new e(Promise.resolve(_(t)))}}map(t){return new e(this.promise.then(async e=>e.isErr()?e:a(await t(e.value))))}mapErr(t){return new e(this.promise.then(async e=>e.isOk()?e:_(await t(e.error))))}andThen(t){return new e(this.promise.then(async n=>{if(n.isErr())return n;let r=t(n.value);return r instanceof e?await r.toPromise():await r}))}orElse(t){return new e(this.promise.then(async n=>{if(n.isOk())return n;let r=t(n.error);return r instanceof e?await r.toPromise():await r}))}inspect(t){return new e(this.promise.then(async e=>(e.isOk()&&await t(e.value),e)))}inspectErr(t){return new e(this.promise.then(async e=>(e.isErr()&&await t(e.error),e)))}match(e){return this.promise.then(t=>t.match(e))}async unwrap(){return(await this.promise).unwrap()}async unwrapOr(e){return(await this.promise).unwrapOr(e)}async unwrapOrElse(e){let t=await this.promise;return t.isOk()?t.value:await e(t.error)}contains(e){return this.promise.then(t=>t.contains(e))}containsErr(e){return this.promise.then(t=>t.containsErr(e))}and(t){return new e(this.promise.then(e=>e.isOk()?t.promise:Promise.resolve(e)))}or(t){return new e(this.promise.then(e=>e.isErr()?t.promise:Promise.resolve(e)))}flatten(){return new e(this.promise.then(e=>e.flatten()))}toOption(){return this.promise.then(e=>e.toOption())}err(){return this.promise.then(e=>e.err())}expect(e){return this.promise.then(t=>t.expect(e))}unwrapErr(){return this.promise.then(e=>e.unwrapErr())}expectErr(e){return this.promise.then(t=>t.expectErr(e))}toPromise(){return this.promise}then(e,t){return this.promise.then(e,t)}};function x(e,t){throw t?Error(t):Error(`Unexpected value: ${n(e)}`)}function S(e,t,n){let r=e[t],i=n,a=i[r];if(a)return a(e);let o=i._;return o?o(e):x(e,`Unhandled variant: ${r}`)}function C(e,t){return S(e,`kind`,t)}function w(e,t){return S(e,`type`,t)}const T=()=>e=>e,E=e=>e.length>0,D=(e,...t)=>[e,...t],O=e=>e[0],k=(e,t)=>{let n=e=>typeof t==`function`?t(e):t;return{parse:t=>e(t)?a(t):_(n(t)),unsafe:e=>e}},A=e=>{try{return a(e())}catch(e){return _(e)}},j=async e=>{try{return a(await e())}catch(e){return _(e)}},M=e=>(...t)=>{try{return p.from(e(...t))}catch{return i}},N=e=>async(...t)=>{try{return p.from(await e(...t))}catch{return i}},P=e=>(...t)=>{try{return a(e(...t))}catch(e){return _(e)}};export{g as AsyncIter,b as AsyncResult,_ as Err,f as Iter,i as None,a as Ok,p as Option,u as Result,s as Some,x as assertNever,d as asyncIter,m as asyncIterFromArray,c as asyncIterFromGenerator,t as asyncIterFromIterable,T as brand,O as head,o as isErr,E as isNonEmpty,e as isNone,v as isOk,y as isSome,h as iter,r as iterFromArray,l as iterFromGenerator,S as match,C as matchKind,w as matchType,k as newtype,D as nonEmpty,M as safeCall,N as safeCallAsync,P as safeTry,j as tryAsync,A as tryCatch};
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/async.ts","../src/match.ts","../src/types.ts","../src/interop.ts"],"sourcesContent":["/**\n * AsyncResult<T, E> - Handling asynchronous Results chaining\n */\n\nimport { Result, Ok, Err, Option } from \"./core\";\n\nexport class AsyncResult<T, E> implements PromiseLike<Result<T, E>> {\n  constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n  /**\n   * Create an AsyncResult from a Promise<Result<T, E>>\n   */\n  static fromPromise<T, E>(promise: Promise<Result<T, E>>): AsyncResult<T, E> {\n    return new AsyncResult(promise);\n  }\n\n  /**\n   * Create an AsyncResult that resolves to Ok(value)\n   */\n  static ok<T, E = never>(value: T): AsyncResult<T, E> {\n    return new AsyncResult(Promise.resolve(Ok(value)));\n  }\n\n  /**\n   * Create an AsyncResult that resolves to Err(error)\n   */\n  static err<E, T = never>(error: E): AsyncResult<T, E> {\n    return new AsyncResult(Promise.resolve(Err(error)));\n  }\n\n  /**\n   * Wrap an async function that might reject into an AsyncResult.\n   * This is the async equivalent of Result.fromThrowable().\n   *\n   * @example\n   * const result = await AsyncResult.fromThrowable(() => fetch('/api/users'));\n   * // AsyncResult<Response, unknown>\n   */\n  static fromThrowable<T, E = unknown>(fn: () => Promise<T>): AsyncResult<T, E> {\n    try {\n      return new AsyncResult(\n        fn()\n          .then((value) => Ok(value) as Result<T, E>)\n          // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n          // narrows via the E parameter (defaulting to `unknown`).\n          .catch((error: unknown) => Err(error as E) as Result<T, E>),\n      );\n    } catch (e) {\n      return new AsyncResult(Promise.resolve(Err(e as E) as Result<T, E>));\n    }\n  }\n\n  /**\n   * Map the inner Ok value using a synchronous or asynchronous function.\n   * If the function returns a Promise, it is awaited.\n   */\n  map<U>(fn: (value: T) => U | Promise<U>): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) return res as unknown as Result<U, E>;\n        // If the mapping function throws, we let Promise rejection propagate\n        // to stay consistent with sync map throwing (Rust panics on map errors).\n        const value = await fn(res.value);\n        return Ok(value);\n      }),\n    );\n  }\n\n  /**\n   * Map the inner Err value using a synchronous or asynchronous function.\n   */\n  mapErr<F>(fn: (error: E) => F | Promise<F>): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) return res as unknown as Result<T, F>;\n        const error = await fn(res.error);\n        return Err(error);\n      }),\n    );\n  }\n\n  /**\n   * Chain another Result-returning operation (sync or async).\n   * Supports returning: Result, AsyncResult, or Promise<Result>.\n   */\n  andThen<U>(\n    fn: (value: T) => Result<U, E> | AsyncResult<U, E> | Promise<Result<U, E>>,\n  ): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) return res as unknown as Result<U, E>;\n\n        const next = fn(res.value);\n        if (next instanceof AsyncResult) {\n          return await next.toPromise();\n        }\n        return await next;\n      }),\n    );\n  }\n\n  /**\n   * Handle the error case with another Result-returning operation.\n   */\n  orElse<F>(\n    fn: (error: E) => Result<T, F> | AsyncResult<T, F> | Promise<Result<T, F>>,\n  ): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) return res as unknown as Result<T, F>;\n\n        const next = fn(res.error);\n        if (next instanceof AsyncResult) {\n          return await next.toPromise();\n        }\n        return await next;\n      }),\n    );\n  }\n\n  /**\n   * Inspect the Ok value if present, without modifying it.\n   * The callback can be synchronous or asynchronous.\n   */\n  inspect(fn: (value: T) => void | Promise<void>): AsyncResult<T, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) {\n          await fn(res.value);\n        }\n        return res;\n      }),\n    );\n  }\n\n  /**\n   * Inspect the Err value if present, without modifying it.\n   * The callback can be synchronous or asynchronous.\n   */\n  inspectErr(fn: (error: E) => void | Promise<void>): AsyncResult<T, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) {\n          await fn(res.error);\n        }\n        return res;\n      }),\n    );\n  }\n\n  /**\n   * Pattern match on the result (async).\n   */\n  match<U>(handlers: {\n    ok: (value: T) => U | Promise<U>;\n    err: (error: E) => U | Promise<U>;\n  }): Promise<U> {\n    return this.promise.then((res) => res.match(handlers));\n  }\n\n  /**\n   * Unwrap the value or throw (reject).\n   */\n  async unwrap(): Promise<T> {\n    const res = await this.promise;\n    return res.unwrap();\n  }\n\n  /**\n   * Unwrap or return default.\n   */\n  async unwrapOr(defaultValue: T): Promise<T> {\n    const res = await this.promise;\n    return res.unwrapOr(defaultValue);\n  }\n\n  /**\n   * Unwrap or compute default.\n   */\n  async unwrapOrElse(fn: (error: E) => T | Promise<T>): Promise<T> {\n    const res = await this.promise;\n    if (res.isOk()) return res.value;\n    return await fn(res.error);\n  }\n\n  /**\n   * Returns true if the result is Ok and contains the given value.\n   */\n  contains(value: T): Promise<boolean> {\n    return this.promise.then((r) => r.contains(value));\n  }\n\n  /**\n   * Returns true if the result is Err and contains the given error.\n   */\n  containsErr(error: E): Promise<boolean> {\n    return this.promise.then((r) => r.containsErr(error));\n  }\n\n  /**\n   * Returns `other` if the result is Ok, otherwise returns the Err value of self.\n   */\n  and<U>(other: AsyncResult<U, E>): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then((r) =>\n        r.isOk() ? other.promise : Promise.resolve(r as unknown as Result<U, E>),\n      ),\n    );\n  }\n\n  /**\n   * Returns `other` if the result is Err, otherwise returns the Ok value of self.\n   */\n  or<F>(other: AsyncResult<T, F>): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then((r) =>\n        r.isErr() ? other.promise : Promise.resolve(r as unknown as Result<T, F>),\n      ),\n    );\n  }\n\n  /**\n   * Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.\n   */\n  flatten<U>(this: AsyncResult<Result<U, E>, E>): AsyncResult<U, E> {\n    return new AsyncResult(this.promise.then((r) => r.flatten()));\n  }\n\n  /**\n   * Converts from Result<T, E> to Option<T>, discarding the error if any.\n   */\n  toOption(): Promise<Option<T>> {\n    return this.promise.then((r) => r.toOption());\n  }\n\n  /**\n   * Converts from Result<T, E> to Option<E>, discarding the success value if any.\n   */\n  err(): Promise<Option<E>> {\n    return this.promise.then((r) => r.err());\n  }\n\n  /**\n   * Returns the contained Ok value, or throws with the provided message.\n   */\n  expect(message: string): Promise<T> {\n    return this.promise.then((r) => r.expect(message));\n  }\n\n  /**\n   * Returns the contained Err value, or throws if Ok.\n   */\n  unwrapErr(): Promise<E> {\n    return this.promise.then((r) => r.unwrapErr());\n  }\n\n  /**\n   * Returns the contained Err value, or throws with the provided message.\n   */\n  expectErr(message: string): Promise<E> {\n    return this.promise.then((r) => r.expectErr(message));\n  }\n\n  /**\n   * Get the underlying Promise<Result<T, E>>\n   */\n  toPromise(): Promise<Result<T, E>> {\n    return this.promise;\n  }\n\n  /**\n   * Implement PromiseLike to allow `await asyncResult`\n   */\n  then<TResult1 = Result<T, E>, TResult2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required by PromiseLike interface\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.promise.then(onfulfilled, onrejected);\n  }\n}\n","/**\n * Exhaustive pattern matching utilities\n *\n * Ensures all cases are handled in discriminated unions.\n */\n\nimport { toPanicString } from \"./core\";\n\n/**\n * Use in the default case of a switch to ensure exhaustiveness.\n * If the switch is not exhaustive, TypeScript will error because\n * the unhandled case type cannot be assigned to 'never'.\n *\n * @example\n * type Shape = { kind: 'circle'; radius: number } | { kind: 'rect'; w: number; h: number };\n *\n * function area(s: Shape): number {\n *   switch (s.kind) {\n *     case 'circle': return Math.PI * s.radius ** 2;\n *     case 'rect': return s.w * s.h;\n *     default: return assertNever(s);\n *   }\n * }\n */\nexport function assertNever(x: never, message?: string): never {\n  if (message) {\n    throw new Error(message);\n  }\n  throw new Error(`Unexpected value: ${toPanicString(x)}`);\n}\n\n/**\n * Type-safe exhaustive matching for discriminated unions.\n * Supports an optional catch-all '_' handler.\n *\n * @example\n * type Action =\n *   | { type: 'increment'; amount: number }\n *   | { type: 'decrement'; amount: number }\n *   | { type: 'reset' };\n *\n * const result = match(action, 'type', {\n *   increment: (a) => state + a.amount,\n *   decrement: (a) => state - a.amount,\n *   reset: () => 0,\n * });\n *\n * // With catch-all\n * const result = match(action, 'type', {\n *   increment: (a) => state + a.amount,\n *   _: () => state // catch-all\n * });\n */\nexport function match<T extends Record<K, string>, K extends keyof T, R>(\n  value: T,\n  discriminant: K,\n  handlers:\n    | { [P in T[K]]: (value: Extract<T, Record<K, P>>) => R }\n    | ({ [P in T[K]]?: (value: Extract<T, Record<K, P>>) => R } & { _: (value: T) => R }),\n): R {\n  const key = value[discriminant] as T[K];\n  const handlersRecord = handlers as Record<PropertyKey, ((value: T) => R) | undefined>;\n  const handler = handlersRecord[key];\n\n  if (handler) {\n    return handler(value);\n  }\n\n  const catchAll = handlersRecord._;\n  if (catchAll) {\n    return catchAll(value);\n  }\n\n  // This should be unreachable if types are correct\n  return assertNever(value as never, `Unhandled variant: ${key}`);\n}\n\n/**\n * Match on a discriminated union using the 'kind' discriminant (common pattern).\n *\n * @example\n * type Shape =\n *   | { kind: 'circle'; radius: number }\n *   | { kind: 'rect'; w: number; h: number };\n *\n * const area = matchKind(shape, {\n *   circle: (s) => Math.PI * s.radius ** 2,\n *   rect: (s) => s.w * s.h,\n * });\n *\n * // With catch-all\n * const isCircle = matchKind(shape, {\n *   circle: () => true,\n *   _: () => false\n * });\n */\nexport function matchKind<T extends { kind: string }, R>(\n  value: T,\n  handlers:\n    | { [P in T[\"kind\"]]: (value: Extract<T, { kind: P }>) => R }\n    | ({ [P in T[\"kind\"]]?: (value: Extract<T, { kind: P }>) => R } & { _: (value: T) => R }),\n): R {\n  return match(\n    value,\n    \"kind\",\n    handlers as { [P in T[\"kind\"]]: (value: Extract<T, Record<\"kind\", P>>) => R },\n  );\n}\n\n/**\n * Match on a discriminated union using the 'type' discriminant (common pattern).\n *\n * @example\n * type Action =\n *   | { type: 'add'; item: string }\n *   | { type: 'remove'; id: number };\n *\n * const result = matchType(action, {\n *   add: (a) => [...items, a.item],\n *   remove: (a) => items.filter((_, i) => i !== a.id),\n * });\n */\nexport function matchType<T extends { type: string }, R>(\n  value: T,\n  handlers:\n    | { [P in T[\"type\"]]: (value: Extract<T, { type: P }>) => R }\n    | ({ [P in T[\"type\"]]?: (value: Extract<T, { type: P }>) => R } & { _: (value: T) => R }),\n): R {\n  return match(\n    value,\n    \"type\",\n    handlers as { [P in T[\"type\"]]: (value: Extract<T, Record<\"type\", P>>) => R },\n  );\n}\n","/**\n * Immutability and utility types for Rust-like TypeScript\n */\n\nimport { Result, Ok, Err } from \"./core\";\n\n/**\n * Recursively make all properties readonly (deep immutability)\n */\nexport type DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : T extends Map<infer K, infer V>\n    ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>\n    : T extends Set<infer U>\n      ? ReadonlySet<DeepReadonly<U>>\n      : T extends object\n        ? { readonly [P in keyof T]: DeepReadonly<T[P]> }\n        : T;\n\n/**\n * Make specific properties readonly\n */\nexport type ReadonlyPick<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>;\n\n/**\n * Branded type for nominal typing (like Rust's newtype pattern)\n *\n * @example\n * type UserId = Brand<number, 'UserId'>;\n * type OrderId = Brand<number, 'OrderId'>;\n *\n * // These are now incompatible even though both are numbers\n * const userId: UserId = 1 as UserId;\n * const orderId: OrderId = userId; // Error!\n */\nexport type Brand<T, B> = T & { readonly __brand: B };\n\n/**\n * Create a branded type constructor\n *\n * @example\n * const UserId = brand<number, 'UserId'>();\n * const id = UserId(42); // type is Brand<number, 'UserId'>\n */\nexport const brand =\n  <T, B>() =>\n  (value: T): Brand<T, B> =>\n    value as Brand<T, B>;\n\n/**\n * NonEmpty array type - guarantees at least one element\n */\nexport type NonEmptyArray<T> = readonly [T, ...T[]];\n\n/**\n * Check if array is non-empty (type guard)\n */\nexport const isNonEmpty = <T>(arr: readonly T[]): arr is NonEmptyArray<T> => arr.length > 0;\n\n/**\n * Create a non-empty array from values\n */\nexport const nonEmpty = <T>(first: T, ...rest: T[]): NonEmptyArray<T> => [first, ...rest];\n\n/**\n * Get the first element of a non-empty array (guaranteed to exist)\n */\nexport const head = <T>(arr: NonEmptyArray<T>): T => arr[0];\n\n/**\n * Create a newtype with validation (Rust's newtype pattern + smart constructor).\n * Implements the \"parse, don't validate\" pattern - make invalid states unrepresentable.\n *\n * @example\n * const EmailAddress = newtype<string, 'Email'>(\n *   (s) => s.includes('@'),\n *   \"Invalid email\"\n * );\n *\n * const email = EmailAddress.parse(userInput);\n * // Result<Brand<string, 'Email'>, string>\n *\n * @example\n * const PositiveNumber = newtype<number, 'Positive'>(\n *   (n) => n > 0,\n *   (n) => `Expected positive, got ${n}`\n * );\n */\nexport const newtype = <T, B, E = string>(\n  validate: (value: T) => boolean,\n  error: E | ((value: T) => E),\n): {\n  parse: (value: T) => Result<Brand<T, B>, E>;\n  unsafe: (value: T) => Brand<T, B>;\n} => {\n  const getError = (value: T): E => {\n    if (typeof error === \"function\") {\n      return (error as (value: T) => E)(value);\n    }\n    return error;\n  };\n\n  return {\n    /**\n     * Parse and validate the input, returning a Result with the branded type on success.\n     */\n    parse: (value: T): Result<Brand<T, B>, E> => {\n      if (validate(value)) {\n        return Ok(value as Brand<T, B>);\n      }\n      return Err(getError(value));\n    },\n\n    /**\n     * Unsafely cast a value to the branded type without validation.\n     * Use only when you know the value is valid (e.g., from a trusted source).\n     */\n    unsafe: (value: T): Brand<T, B> => value as Brand<T, B>,\n  };\n};\n","/**\n * Interop helpers for wrapping third-party and standard library code\n */\n\nimport { Option, None, Result, Ok, Err } from \"./core\";\n\n/**\n * One-shot: wrap a single throwing operation in a Result.\n * Use {@link safeTry} to create a reusable safe wrapper instead.\n *\n * @example\n * const result = tryCatch(() => JSON.parse(userInput));\n * // Result<unknown, unknown>\n */\nexport const tryCatch = <T, E = unknown>(fn: () => T): Result<T, E> => {\n  try {\n    return Ok(fn());\n  } catch (e) {\n    // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n    // narrows via the E parameter (defaulting to `unknown`). This is safe\n    // because the caller opts into the cast by specifying E.\n    return Err(e as E);\n  }\n};\n\n/**\n * Wrap any async function that might reject to return Result\n *\n * @example\n * const result = await tryAsync(() => axios.get('/api/users'));\n * // Result<AxiosResponse, AxiosError>\n */\nexport const tryAsync = async <T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>> => {\n  try {\n    return Ok(await fn());\n  } catch (e) {\n    // Cast: see tryCatch — caller narrows E via the type parameter.\n    return Err(e as E);\n  }\n};\n\n/**\n * Create a reusable Option-returning version of any function that may return\n * T | null | undefined or throw. Returns None on null, undefined, or throw.\n *\n * @example\n * const safeFind = safeCall((id: number) => users.find(u => u.id === id));\n * const user = safeFind(42); // Option<User>\n */\nexport const safeCall =\n  <Args extends unknown[], T>(fn: (...args: Args) => T | null | undefined) =>\n  (...args: Args): Option<T> => {\n    try {\n      return Option.from(fn(...args));\n    } catch {\n      return None;\n    }\n  };\n\n/**\n * Create a reusable Option-returning version of any async function that may return\n * T | null | undefined or reject. Returns None on null, undefined, or rejection.\n *\n * @example\n * const safeFetch = safeCallAsync((url: string) => fetch(url).then(r => r.ok ? r : null));\n * const response = await safeFetch('/api'); // Option<Response>\n */\nexport const safeCallAsync =\n  <Args extends unknown[], T>(fn: (...args: Args) => Promise<T | null | undefined>) =>\n  async (...args: Args): Promise<Option<T>> => {\n    try {\n      return Option.from(await fn(...args));\n    } catch {\n      return None;\n    }\n  };\n\n/**\n * Reusable: wrap a throwing function so every call returns a Result.\n * Use {@link tryCatch} for one-shot operations instead.\n *\n * @example\n * const safeJsonParse = safeTry(JSON.parse);\n * const data = safeJsonParse(input); // Result<unknown, unknown>\n */\nexport const safeTry =\n  <Args extends unknown[], T, E = unknown>(fn: (...args: Args) => T) =>\n  (...args: Args): Result<T, E> => {\n    try {\n      return Ok(fn(...args));\n    } catch (e) {\n      // Cast: see tryCatch — caller narrows E via the type parameter.\n      return Err(e as E);\n    }\n  };\n"],"mappings":";;;;;;AAMA,IAAa,cAAb,MAAa,YAAuD;CAClE,YAAY,AAAiB,SAAgC;EAAhC;;;;;CAK7B,OAAO,YAAkB,SAAmD;AAC1E,SAAO,IAAI,YAAY,QAAQ;;;;;CAMjC,OAAO,GAAiB,OAA6B;AACnD,SAAO,IAAI,YAAY,QAAQ,QAAQ,GAAG,MAAM,CAAC,CAAC;;;;;CAMpD,OAAO,IAAkB,OAA6B;AACpD,SAAO,IAAI,YAAY,QAAQ,QAAQ,IAAI,MAAM,CAAC,CAAC;;;;;;;;;;CAWrD,OAAO,cAA8B,IAAyC;AAC5E,MAAI;AACF,UAAO,IAAI,YACT,IAAI,CACD,MAAM,UAAU,GAAG,MAAM,CAAiB,CAG1C,OAAO,UAAmB,IAAI,MAAW,CAAiB,CAC9D;WACM,GAAG;AACV,UAAO,IAAI,YAAY,QAAQ,QAAQ,IAAI,EAAO,CAAiB,CAAC;;;;;;;CAQxE,IAAO,IAAqD;AAC1D,SAAO,IAAI,YACT,KAAK,QAAQ,KAAK,OAAO,QAAQ;AAC/B,OAAI,IAAI,OAAO,CAAE,QAAO;AAIxB,UAAO,GADO,MAAM,GAAG,IAAI,MAAM,CACjB;IAChB,CACH;;;;;CAMH,OAAU,IAAqD;AAC7D,SAAO,IAAI,YACT,KAAK,QAAQ,KAAK,OAAO,QAAQ;AAC/B,OAAI,IAAI,MAAM,CAAE,QAAO;AAEvB,UAAO,IADO,MAAM,GAAG,IAAI,MAAM,CAChB;IACjB,CACH;;;;;;CAOH,QACE,IACmB;AACnB,SAAO,IAAI,YACT,KAAK,QAAQ,KAAK,OAAO,QAAQ;AAC/B,OAAI,IAAI,OAAO,CAAE,QAAO;GAExB,MAAM,OAAO,GAAG,IAAI,MAAM;AAC1B,OAAI,gBAAgB,YAClB,QAAO,MAAM,KAAK,WAAW;AAE/B,UAAO,MAAM;IACb,CACH;;;;;CAMH,OACE,IACmB;AACnB,SAAO,IAAI,YACT,KAAK,QAAQ,KAAK,OAAO,QAAQ;AAC/B,OAAI,IAAI,MAAM,CAAE,QAAO;GAEvB,MAAM,OAAO,GAAG,IAAI,MAAM;AAC1B,OAAI,gBAAgB,YAClB,QAAO,MAAM,KAAK,WAAW;AAE/B,UAAO,MAAM;IACb,CACH;;;;;;CAOH,QAAQ,IAA2D;AACjE,SAAO,IAAI,YACT,KAAK,QAAQ,KAAK,OAAO,QAAQ;AAC/B,OAAI,IAAI,MAAM,CACZ,OAAM,GAAG,IAAI,MAAM;AAErB,UAAO;IACP,CACH;;;;;;CAOH,WAAW,IAA2D;AACpE,SAAO,IAAI,YACT,KAAK,QAAQ,KAAK,OAAO,QAAQ;AAC/B,OAAI,IAAI,OAAO,CACb,OAAM,GAAG,IAAI,MAAM;AAErB,UAAO;IACP,CACH;;;;;CAMH,MAAS,UAGM;AACb,SAAO,KAAK,QAAQ,MAAM,QAAQ,IAAI,MAAM,SAAS,CAAC;;;;;CAMxD,MAAM,SAAqB;AAEzB,UADY,MAAM,KAAK,SACZ,QAAQ;;;;;CAMrB,MAAM,SAAS,cAA6B;AAE1C,UADY,MAAM,KAAK,SACZ,SAAS,aAAa;;;;;CAMnC,MAAM,aAAa,IAA8C;EAC/D,MAAM,MAAM,MAAM,KAAK;AACvB,MAAI,IAAI,MAAM,CAAE,QAAO,IAAI;AAC3B,SAAO,MAAM,GAAG,IAAI,MAAM;;;;;CAM5B,SAAS,OAA4B;AACnC,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,MAAM,CAAC;;;;;CAMpD,YAAY,OAA4B;AACtC,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,YAAY,MAAM,CAAC;;;;;CAMvD,IAAO,OAA6C;AAClD,SAAO,IAAI,YACT,KAAK,QAAQ,MAAM,MACjB,EAAE,MAAM,GAAG,MAAM,UAAU,QAAQ,QAAQ,EAA6B,CACzE,CACF;;;;;CAMH,GAAM,OAA6C;AACjD,SAAO,IAAI,YACT,KAAK,QAAQ,MAAM,MACjB,EAAE,OAAO,GAAG,MAAM,UAAU,QAAQ,QAAQ,EAA6B,CAC1E,CACF;;;;;CAMH,UAAkE;AAChE,SAAO,IAAI,YAAY,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,CAAC,CAAC;;;;;CAM/D,WAA+B;AAC7B,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,CAAC;;;;;CAM/C,MAA0B;AACxB,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,KAAK,CAAC;;;;;CAM1C,OAAO,SAA6B;AAClC,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,OAAO,QAAQ,CAAC;;;;;CAMpD,YAAwB;AACtB,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,WAAW,CAAC;;;;;CAMhD,UAAU,SAA6B;AACrC,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,QAAQ,CAAC;;;;;CAMvD,YAAmC;AACjC,SAAO,KAAK;;;;;CAMd,KACE,aAEA,YACkC;AAClC,SAAO,KAAK,QAAQ,KAAK,aAAa,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9PrD,SAAgB,YAAY,GAAU,SAAyB;AAC7D,KAAI,QACF,OAAM,IAAI,MAAM,QAAQ;AAE1B,OAAM,IAAI,MAAM,qBAAqB,cAAc,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;AAyB1D,SAAgB,MACd,OACA,cACA,UAGG;CACH,MAAM,MAAM,MAAM;CAClB,MAAM,iBAAiB;CACvB,MAAM,UAAU,eAAe;AAE/B,KAAI,QACF,QAAO,QAAQ,MAAM;CAGvB,MAAM,WAAW,eAAe;AAChC,KAAI,SACF,QAAO,SAAS,MAAM;AAIxB,QAAO,YAAY,OAAgB,sBAAsB,MAAM;;;;;;;;;;;;;;;;;;;;;AAsBjE,SAAgB,UACd,OACA,UAGG;AACH,QAAO,MACL,OACA,QACA,SACD;;;;;;;;;;;;;;;AAgBH,SAAgB,UACd,OACA,UAGG;AACH,QAAO,MACL,OACA,QACA,SACD;;;;;;;;;;;;;;;ACxFH,MAAa,eAEV,UACC;;;;AAUJ,MAAa,cAAiB,QAA+C,IAAI,SAAS;;;;AAK1F,MAAa,YAAe,OAAU,GAAG,SAAgC,CAAC,OAAO,GAAG,KAAK;;;;AAKzF,MAAa,QAAW,QAA6B,IAAI;;;;;;;;;;;;;;;;;;;;AAqBzD,MAAa,WACX,UACA,UAIG;CACH,MAAM,YAAY,UAAgB;AAChC,MAAI,OAAO,UAAU,WACnB,QAAQ,MAA0B,MAAM;AAE1C,SAAO;;AAGT,QAAO;EAIL,QAAQ,UAAqC;AAC3C,OAAI,SAAS,MAAM,CACjB,QAAO,GAAG,MAAqB;AAEjC,UAAO,IAAI,SAAS,MAAM,CAAC;;EAO7B,SAAS,UAA0B;EACpC;;;;;;;;;;;;;;;;ACxGH,MAAa,YAA4B,OAA8B;AACrE,KAAI;AACF,SAAO,GAAG,IAAI,CAAC;UACR,GAAG;AAIV,SAAO,IAAI,EAAO;;;;;;;;;;AAWtB,MAAa,WAAW,OAAuB,OAAgD;AAC7F,KAAI;AACF,SAAO,GAAG,MAAM,IAAI,CAAC;UACd,GAAG;AAEV,SAAO,IAAI,EAAO;;;;;;;;;;;AAYtB,MAAa,YACiB,QAC3B,GAAG,SAA0B;AAC5B,KAAI;AACF,SAAO,OAAO,KAAK,GAAG,GAAG,KAAK,CAAC;SACzB;AACN,SAAO;;;;;;;;;;;AAYb,MAAa,iBACiB,OAC5B,OAAO,GAAG,SAAmC;AAC3C,KAAI;AACF,SAAO,OAAO,KAAK,MAAM,GAAG,GAAG,KAAK,CAAC;SAC/B;AACN,SAAO;;;;;;;;;;;AAYb,MAAa,WAC8B,QACxC,GAAG,SAA6B;AAC/B,KAAI;AACF,SAAO,GAAG,GAAG,GAAG,KAAK,CAAC;UACf,GAAG;AAEV,SAAO,IAAI,EAAO"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/async.ts","../src/match.ts","../src/types.ts","../src/interop.ts"],"sourcesContent":["/**\n * AsyncResult<T, E> - Handling asynchronous Results chaining\n */\n\nimport { Result, Ok, Err, Option } from \"./core\";\n\nexport class AsyncResult<T, E> implements PromiseLike<Result<T, E>> {\n  constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n  /**\n   * Create an AsyncResult from a Promise<Result<T, E>>\n   */\n  static fromPromise<T, E>(promise: Promise<Result<T, E>>): AsyncResult<T, E> {\n    return new AsyncResult(promise);\n  }\n\n  /**\n   * Create an AsyncResult that resolves to Ok(value)\n   */\n  static ok<T, E = never>(value: T): AsyncResult<T, E> {\n    return new AsyncResult(Promise.resolve(Ok(value)));\n  }\n\n  /**\n   * Create an AsyncResult that resolves to Err(error)\n   */\n  static err<E, T = never>(error: E): AsyncResult<T, E> {\n    return new AsyncResult(Promise.resolve(Err(error)));\n  }\n\n  /**\n   * Wrap an async function that might reject into an AsyncResult.\n   * This is the async equivalent of Result.fromThrowable().\n   *\n   * @example\n   * const result = await AsyncResult.fromThrowable(() => fetch('/api/users'));\n   * // AsyncResult<Response, unknown>\n   */\n  static fromThrowable<T, E = unknown>(fn: () => Promise<T>): AsyncResult<T, E> {\n    try {\n      return new AsyncResult(\n        fn()\n          .then((value) => Ok(value) as Result<T, E>)\n          // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n          // narrows via the E parameter (defaulting to `unknown`).\n          .catch((error: unknown) => Err(error as E) as Result<T, E>),\n      );\n    } catch (e) {\n      return new AsyncResult(Promise.resolve(Err(e as E) as Result<T, E>));\n    }\n  }\n\n  /**\n   * Map the inner Ok value using a synchronous or asynchronous function.\n   * If the function returns a Promise, it is awaited.\n   */\n  map<U>(fn: (value: T) => U | Promise<U>): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) return res as unknown as Result<U, E>;\n        // If the mapping function throws, we let Promise rejection propagate\n        // to stay consistent with sync map throwing (Rust panics on map errors).\n        const value = await fn(res.value);\n        return Ok(value);\n      }),\n    );\n  }\n\n  /**\n   * Map the inner Err value using a synchronous or asynchronous function.\n   */\n  mapErr<F>(fn: (error: E) => F | Promise<F>): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) return res as unknown as Result<T, F>;\n        const error = await fn(res.error);\n        return Err(error);\n      }),\n    );\n  }\n\n  /**\n   * Chain another Result-returning operation (sync or async).\n   * Supports returning: Result, AsyncResult, or Promise<Result>.\n   */\n  andThen<U>(\n    fn: (value: T) => Result<U, E> | AsyncResult<U, E> | Promise<Result<U, E>>,\n  ): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) return res as unknown as Result<U, E>;\n\n        const next = fn(res.value);\n        if (next instanceof AsyncResult) {\n          return await next.toPromise();\n        }\n        return await next;\n      }),\n    );\n  }\n\n  /**\n   * Handle the error case with another Result-returning operation.\n   */\n  orElse<F>(\n    fn: (error: E) => Result<T, F> | AsyncResult<T, F> | Promise<Result<T, F>>,\n  ): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) return res as unknown as Result<T, F>;\n\n        const next = fn(res.error);\n        if (next instanceof AsyncResult) {\n          return await next.toPromise();\n        }\n        return await next;\n      }),\n    );\n  }\n\n  /**\n   * Inspect the Ok value if present, without modifying it.\n   * The callback can be synchronous or asynchronous.\n   */\n  inspect(fn: (value: T) => void | Promise<void>): AsyncResult<T, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isOk()) {\n          await fn(res.value);\n        }\n        return res;\n      }),\n    );\n  }\n\n  /**\n   * Inspect the Err value if present, without modifying it.\n   * The callback can be synchronous or asynchronous.\n   */\n  inspectErr(fn: (error: E) => void | Promise<void>): AsyncResult<T, E> {\n    return new AsyncResult(\n      this.promise.then(async (res) => {\n        if (res.isErr()) {\n          await fn(res.error);\n        }\n        return res;\n      }),\n    );\n  }\n\n  /**\n   * Pattern match on the result (async).\n   */\n  match<U>(handlers: {\n    ok: (value: T) => U | Promise<U>;\n    err: (error: E) => U | Promise<U>;\n  }): Promise<U> {\n    return this.promise.then((res) => res.match(handlers));\n  }\n\n  /**\n   * Unwrap the value or throw (reject).\n   */\n  async unwrap(): Promise<T> {\n    const res = await this.promise;\n    return res.unwrap();\n  }\n\n  /**\n   * Unwrap or return default.\n   */\n  async unwrapOr(defaultValue: T): Promise<T> {\n    const res = await this.promise;\n    return res.unwrapOr(defaultValue);\n  }\n\n  /**\n   * Unwrap or compute default.\n   */\n  async unwrapOrElse(fn: (error: E) => T | Promise<T>): Promise<T> {\n    const res = await this.promise;\n    if (res.isOk()) return res.value;\n    return await fn(res.error);\n  }\n\n  /**\n   * Returns true if the result is Ok and contains the given value.\n   */\n  contains(value: T): Promise<boolean> {\n    return this.promise.then((r) => r.contains(value));\n  }\n\n  /**\n   * Returns true if the result is Err and contains the given error.\n   */\n  containsErr(error: E): Promise<boolean> {\n    return this.promise.then((r) => r.containsErr(error));\n  }\n\n  /**\n   * Returns `other` if the result is Ok, otherwise returns the Err value of self.\n   */\n  and<U>(other: AsyncResult<U, E>): AsyncResult<U, E> {\n    return new AsyncResult(\n      this.promise.then((r) =>\n        r.isOk() ? other.promise : Promise.resolve(r as unknown as Result<U, E>),\n      ),\n    );\n  }\n\n  /**\n   * Returns `other` if the result is Err, otherwise returns the Ok value of self.\n   */\n  or<F>(other: AsyncResult<T, F>): AsyncResult<T, F> {\n    return new AsyncResult(\n      this.promise.then((r) =>\n        r.isErr() ? other.promise : Promise.resolve(r as unknown as Result<T, F>),\n      ),\n    );\n  }\n\n  /**\n   * Converts from AsyncResult<Result<U, E>, E> to AsyncResult<U, E>.\n   */\n  flatten<U>(this: AsyncResult<Result<U, E>, E>): AsyncResult<U, E> {\n    return new AsyncResult(this.promise.then((r) => r.flatten()));\n  }\n\n  /**\n   * Converts from Result<T, E> to Option<T>, discarding the error if any.\n   */\n  toOption(): Promise<Option<T>> {\n    return this.promise.then((r) => r.toOption());\n  }\n\n  /**\n   * Converts from Result<T, E> to Option<E>, discarding the success value if any.\n   */\n  err(): Promise<Option<E>> {\n    return this.promise.then((r) => r.err());\n  }\n\n  /**\n   * Returns the contained Ok value, or throws with the provided message.\n   */\n  expect(message: string): Promise<T> {\n    return this.promise.then((r) => r.expect(message));\n  }\n\n  /**\n   * Returns the contained Err value, or throws if Ok.\n   */\n  unwrapErr(): Promise<E> {\n    return this.promise.then((r) => r.unwrapErr());\n  }\n\n  /**\n   * Returns the contained Err value, or throws with the provided message.\n   */\n  expectErr(message: string): Promise<E> {\n    return this.promise.then((r) => r.expectErr(message));\n  }\n\n  /**\n   * Get the underlying Promise<Result<T, E>>\n   */\n  toPromise(): Promise<Result<T, E>> {\n    return this.promise;\n  }\n\n  /**\n   * Implement PromiseLike to allow `await asyncResult`\n   */\n  then<TResult1 = Result<T, E>, TResult2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required by PromiseLike interface\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.promise.then(onfulfilled, onrejected);\n  }\n}\n","/**\n * Exhaustive pattern matching utilities\n *\n * Ensures all cases are handled in discriminated unions.\n */\n\nimport { toPanicString } from \"./core\";\n\n/**\n * Use in the default case of a switch to ensure exhaustiveness.\n * If the switch is not exhaustive, TypeScript will error because\n * the unhandled case type cannot be assigned to 'never'.\n *\n * @example\n * type Shape = { kind: 'circle'; radius: number } | { kind: 'rect'; w: number; h: number };\n *\n * function area(s: Shape): number {\n *   switch (s.kind) {\n *     case 'circle': return Math.PI * s.radius ** 2;\n *     case 'rect': return s.w * s.h;\n *     default: return assertNever(s);\n *   }\n * }\n */\nexport function assertNever(x: never, message?: string): never {\n  if (message) {\n    throw new Error(message);\n  }\n  throw new Error(`Unexpected value: ${toPanicString(x)}`);\n}\n\n/**\n * Type-safe exhaustive matching for discriminated unions.\n * Supports an optional catch-all '_' handler.\n *\n * @example\n * type Action =\n *   | { type: 'increment'; amount: number }\n *   | { type: 'decrement'; amount: number }\n *   | { type: 'reset' };\n *\n * const result = match(action, 'type', {\n *   increment: (a) => state + a.amount,\n *   decrement: (a) => state - a.amount,\n *   reset: () => 0,\n * });\n *\n * // With catch-all\n * const result = match(action, 'type', {\n *   increment: (a) => state + a.amount,\n *   _: () => state // catch-all\n * });\n */\nexport function match<T extends Record<K, string>, K extends keyof T, R>(\n  value: T,\n  discriminant: K,\n  handlers:\n    | { [P in T[K]]: (value: Extract<T, Record<K, P>>) => R }\n    | ({ [P in T[K]]?: (value: Extract<T, Record<K, P>>) => R } & { _: (value: T) => R }),\n): R {\n  const key = value[discriminant] as T[K];\n  const handlersRecord = handlers as Record<PropertyKey, ((value: T) => R) | undefined>;\n  const handler = handlersRecord[key];\n\n  if (handler) {\n    return handler(value);\n  }\n\n  const catchAll = handlersRecord._;\n  if (catchAll) {\n    return catchAll(value);\n  }\n\n  // This should be unreachable if types are correct\n  return assertNever(value as never, `Unhandled variant: ${key}`);\n}\n\n/**\n * Match on a discriminated union using the 'kind' discriminant (common pattern).\n *\n * @example\n * type Shape =\n *   | { kind: 'circle'; radius: number }\n *   | { kind: 'rect'; w: number; h: number };\n *\n * const area = matchKind(shape, {\n *   circle: (s) => Math.PI * s.radius ** 2,\n *   rect: (s) => s.w * s.h,\n * });\n *\n * // With catch-all\n * const isCircle = matchKind(shape, {\n *   circle: () => true,\n *   _: () => false\n * });\n */\nexport function matchKind<T extends { kind: string }, R>(\n  value: T,\n  handlers:\n    | { [P in T[\"kind\"]]: (value: Extract<T, { kind: P }>) => R }\n    | ({ [P in T[\"kind\"]]?: (value: Extract<T, { kind: P }>) => R } & { _: (value: T) => R }),\n): R {\n  return match(\n    value,\n    \"kind\",\n    handlers as { [P in T[\"kind\"]]: (value: Extract<T, Record<\"kind\", P>>) => R },\n  );\n}\n\n/**\n * Match on a discriminated union using the 'type' discriminant (common pattern).\n *\n * @example\n * type Action =\n *   | { type: 'add'; item: string }\n *   | { type: 'remove'; id: number };\n *\n * const result = matchType(action, {\n *   add: (a) => [...items, a.item],\n *   remove: (a) => items.filter((_, i) => i !== a.id),\n * });\n */\nexport function matchType<T extends { type: string }, R>(\n  value: T,\n  handlers:\n    | { [P in T[\"type\"]]: (value: Extract<T, { type: P }>) => R }\n    | ({ [P in T[\"type\"]]?: (value: Extract<T, { type: P }>) => R } & { _: (value: T) => R }),\n): R {\n  return match(\n    value,\n    \"type\",\n    handlers as { [P in T[\"type\"]]: (value: Extract<T, Record<\"type\", P>>) => R },\n  );\n}\n","/**\n * Immutability and utility types for Rust-like TypeScript\n */\n\nimport { Result, Ok, Err } from \"./core\";\n\n/**\n * Recursively make all properties readonly (deep immutability)\n */\nexport type DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : T extends Map<infer K, infer V>\n    ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>\n    : T extends Set<infer U>\n      ? ReadonlySet<DeepReadonly<U>>\n      : T extends object\n        ? { readonly [P in keyof T]: DeepReadonly<T[P]> }\n        : T;\n\n/**\n * Make specific properties readonly\n */\nexport type ReadonlyPick<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>;\n\n/**\n * Branded type for nominal typing (like Rust's newtype pattern)\n *\n * @example\n * type UserId = Brand<number, 'UserId'>;\n * type OrderId = Brand<number, 'OrderId'>;\n *\n * // These are now incompatible even though both are numbers\n * const userId: UserId = 1 as UserId;\n * const orderId: OrderId = userId; // Error!\n */\nexport type Brand<T, B> = T & { readonly __brand: B };\n\n/**\n * Create a branded type constructor\n *\n * @example\n * const UserId = brand<number, 'UserId'>();\n * const id = UserId(42); // type is Brand<number, 'UserId'>\n */\nexport const brand =\n  <T, B>() =>\n  (value: T): Brand<T, B> =>\n    value as Brand<T, B>;\n\n/**\n * NonEmpty array type - guarantees at least one element\n */\nexport type NonEmptyArray<T> = readonly [T, ...T[]];\n\n/**\n * Check if array is non-empty (type guard)\n */\nexport const isNonEmpty = <T>(arr: readonly T[]): arr is NonEmptyArray<T> => arr.length > 0;\n\n/**\n * Create a non-empty array from values\n */\nexport const nonEmpty = <T>(first: T, ...rest: T[]): NonEmptyArray<T> => [first, ...rest];\n\n/**\n * Get the first element of a non-empty array (guaranteed to exist)\n */\nexport const head = <T>(arr: NonEmptyArray<T>): T => arr[0];\n\n/**\n * Create a newtype with validation (Rust's newtype pattern + smart constructor).\n * Implements the \"parse, don't validate\" pattern - make invalid states unrepresentable.\n *\n * @example\n * const EmailAddress = newtype<string, 'Email'>(\n *   (s) => s.includes('@'),\n *   \"Invalid email\"\n * );\n *\n * const email = EmailAddress.parse(userInput);\n * // Result<Brand<string, 'Email'>, string>\n *\n * @example\n * const PositiveNumber = newtype<number, 'Positive'>(\n *   (n) => n > 0,\n *   (n) => `Expected positive, got ${n}`\n * );\n */\nexport const newtype = <T, B, E = string>(\n  validate: (value: T) => boolean,\n  error: E | ((value: T) => E),\n): {\n  parse: (value: T) => Result<Brand<T, B>, E>;\n  unsafe: (value: T) => Brand<T, B>;\n} => {\n  const getError = (value: T): E => {\n    if (typeof error === \"function\") {\n      return (error as (value: T) => E)(value);\n    }\n    return error;\n  };\n\n  return {\n    /**\n     * Parse and validate the input, returning a Result with the branded type on success.\n     */\n    parse: (value: T): Result<Brand<T, B>, E> => {\n      if (validate(value)) {\n        return Ok(value as Brand<T, B>);\n      }\n      return Err(getError(value));\n    },\n\n    /**\n     * Unsafely cast a value to the branded type without validation.\n     * Use only when you know the value is valid (e.g., from a trusted source).\n     */\n    unsafe: (value: T): Brand<T, B> => value as Brand<T, B>,\n  };\n};\n","/**\n * Interop helpers for wrapping third-party and standard library code\n */\n\nimport { Option, None, Result, Ok, Err } from \"./core\";\n\n/**\n * One-shot: wrap a single throwing operation in a Result.\n * Use {@link safeTry} to create a reusable safe wrapper instead.\n *\n * @example\n * const result = tryCatch(() => JSON.parse(userInput));\n * // Result<unknown, unknown>\n */\nexport const tryCatch = <T, E = unknown>(fn: () => T): Result<T, E> => {\n  try {\n    return Ok(fn());\n  } catch (e) {\n    // Cast: TypeScript catch blocks type errors as `unknown`. The caller\n    // narrows via the E parameter (defaulting to `unknown`). This is safe\n    // because the caller opts into the cast by specifying E.\n    return Err(e as E);\n  }\n};\n\n/**\n * Wrap any async function that might reject to return Result\n *\n * @example\n * const result = await tryAsync(() => axios.get('/api/users'));\n * // Result<AxiosResponse, AxiosError>\n */\nexport const tryAsync = async <T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>> => {\n  try {\n    return Ok(await fn());\n  } catch (e) {\n    // Cast: see tryCatch — caller narrows E via the type parameter.\n    return Err(e as E);\n  }\n};\n\n/**\n * Create a reusable Option-returning version of any function that may return\n * T | null | undefined or throw. Returns None on null, undefined, or throw.\n *\n * @example\n * const safeFind = safeCall((id: number) => users.find(u => u.id === id));\n * const user = safeFind(42); // Option<User>\n */\nexport const safeCall =\n  <Args extends unknown[], T>(fn: (...args: Args) => T | null | undefined) =>\n  (...args: Args): Option<T> => {\n    try {\n      return Option.from(fn(...args));\n    } catch {\n      return None;\n    }\n  };\n\n/**\n * Create a reusable Option-returning version of any async function that may return\n * T | null | undefined or reject. Returns None on null, undefined, or rejection.\n *\n * @example\n * const safeFetch = safeCallAsync((url: string) => fetch(url).then(r => r.ok ? r : null));\n * const response = await safeFetch('/api'); // Option<Response>\n */\nexport const safeCallAsync =\n  <Args extends unknown[], T>(fn: (...args: Args) => Promise<T | null | undefined>) =>\n  async (...args: Args): Promise<Option<T>> => {\n    try {\n      return Option.from(await fn(...args));\n    } catch {\n      return None;\n    }\n  };\n\n/**\n * Reusable: wrap a throwing function so every call returns a Result.\n * Use {@link tryCatch} for one-shot operations instead.\n *\n * @example\n * const safeJsonParse = safeTry(JSON.parse);\n * const data = safeJsonParse(input); // Result<unknown, unknown>\n */\nexport const safeTry =\n  <Args extends unknown[], T, E = unknown>(fn: (...args: Args) => T) =>\n  (...args: Args): Result<T, E> => {\n    try {\n      return Ok(fn(...args));\n    } catch (e) {\n      // Cast: see tryCatch — caller narrows E via the type parameter.\n      return Err(e as E);\n    }\n  };\n"],"mappings":"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"}