nalloc 0.2.2 → 0.5.0

package/build/http.d.ts

@@ -0,0 +1,31 @@
+import type { Result } from './types.js';
+/**
+ * Converts a fetch Response into a Result, treating a non-ok status as an Err.
+ * Native fetch only rejects on transport errors, never on 4xx/5xx; this closes that gap.
+ * The failed Response itself is the error - read its status, headers, or body from it.
+ * @param response - The Response to inspect
+ * @returns Ok(response) when response.ok, Err(response) otherwise
+ * @example
+ * import { Result } from 'nalloc';
+ * import { fromResponse } from 'nalloc/http';
+ * const res = Result.flatMap(await Result.fromPromise(fetch(url)), fromResponse);
+ */
+export declare function fromResponse(response: Response): Result<Response, Response>;
+/**
+ * Runs fetch and forces every failure mode into the error channel.
+ * Ok means the request connected AND returned a 2xx status; a non-2xx Response
+ * becomes Err(response), and a transport failure becomes Err with the thrown
+ * value (per spec: TypeError on network/CORS errors, DOMException on abort/timeout).
+ * The body is never read - it stays available to the caller.
+ * @param input - The fetch input (URL or Request)
+ * @param init - Optional fetch init
+ * @returns Promise of Ok(response) for 2xx, Err otherwise
+ * @example
+ * import { fromFetch } from 'nalloc/http';
+ * const res = await fromFetch(url);
+ * // Ok(Response)      -> connected and 2xx
+ * // Err(Response)     -> reached the server, non-2xx
+ * // Err(TypeError)    -> network/CORS failure
+ * // Err(DOMException) -> aborted or timed out
+ */
+export declare function fromFetch(input: string | URL | Request, init?: RequestInit): Promise<Result<Response, Response | TypeError | DOMException>>;

package/build/http.js

@@ -0,0 +1,13 @@
+import { err as ERR } from "./types.js";
+export function fromResponse(response) {
+    return response.ok ? response : ERR(response);
+}
+export async function fromFetch(input, init) {
+    try {
+        return fromResponse(await fetch(input, init));
+    } catch (error) {
+        return ERR(error);
+    }
+}
+
+//# sourceMappingURL=http.js.map

package/build/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/http.ts"],"sourcesContent":["import { err as ERR } from './types.js';\nimport type { Ok, Result } from './types.js';\n\n/**\n * Converts a fetch Response into a Result, treating a non-ok status as an Err.\n * Native fetch only rejects on transport errors, never on 4xx/5xx; this closes that gap.\n * The failed Response itself is the error - read its status, headers, or body from it.\n * @param response - The Response to inspect\n * @returns Ok(response) when response.ok, Err(response) otherwise\n * @example\n * import { Result } from 'nalloc';\n * import { fromResponse } from 'nalloc/http';\n * const res = Result.flatMap(await Result.fromPromise(fetch(url)), fromResponse);\n */\nexport function fromResponse(response: Response): Result<Response, Response> {\n  return response.ok ? (response as Ok<Response>) : ERR(response);\n}\n\n/**\n * Runs fetch and forces every failure mode into the error channel.\n * Ok means the request connected AND returned a 2xx status; a non-2xx Response\n * becomes Err(response), and a transport failure becomes Err with the thrown\n * value (per spec: TypeError on network/CORS errors, DOMException on abort/timeout).\n * The body is never read - it stays available to the caller.\n * @param input - The fetch input (URL or Request)\n * @param init - Optional fetch init\n * @returns Promise of Ok(response) for 2xx, Err otherwise\n * @example\n * import { fromFetch } from 'nalloc/http';\n * const res = await fromFetch(url);\n * // Ok(Response)      -> connected and 2xx\n * // Err(Response)     -> reached the server, non-2xx\n * // Err(TypeError)    -> network/CORS failure\n * // Err(DOMException) -> aborted or timed out\n */\nexport async function fromFetch(input: string | URL | Request, init?: RequestInit): Promise<Result<Response, Response | TypeError | DOMException>> {\n  try {\n    return fromResponse(await fetch(input, init));\n  } catch (error) {\n    return ERR(error as TypeError | DOMException);\n  }\n}\n"],"names":["err","ERR","fromResponse","response","ok","fromFetch","input","init","fetch","error"],"mappings":"AAAA,SAASA,OAAOC,GAAG,QAAQ,aAAa;AAcxC,OAAO,SAASC,aAAaC,QAAkB;IAC7C,OAAOA,SAASC,EAAE,GAAID,WAA4BF,IAAIE;AACxD;AAmBA,OAAO,eAAeE,UAAUC,KAA6B,EAAEC,IAAkB;IAC/E,IAAI;QACF,OAAOL,aAAa,MAAMM,MAAMF,OAAOC;IACzC,EAAE,OAAOE,OAAO;QACd,OAAOR,IAAIQ;IACb;AACF"}

package/build/nonempty.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get assertNonEmpty () {
+        return assertNonEmpty;
+    },
+    get fromArray () {
+        return fromArray;
+    },
+    get isNonEmpty () {
+        return isNonEmpty;
+    }
+});
+const _typescjs = require("./types.cjs");
+function isNonEmpty(values) {
+    return values.length > 0;
+}
+function assertNonEmpty(values, message) {
+    if (values.length === 0) {
+        throw new Error(message ?? 'Expected array to be non-empty');
+    }
+}
+function fromArray(values) {
+    return values.length > 0 ? values : _typescjs.NONE;
+}
+
+//# sourceMappingURL=nonempty.cjs.map

package/build/nonempty.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/nonempty.ts"],"sourcesContent":["import { NONE } from './types.js';\nimport type { Option, Some } from './types.js';\n\n/** An array proven to contain at least one element. The runtime value is a plain array. */\nexport type NonEmptyArray<T> = [T, ...T[]];\n\n/** A readonly array proven to contain at least one element. The runtime value is a plain array. */\nexport type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];\n\n/**\n * Checks whether an array has at least one element.\n * @param values - The array to check\n * @returns true if the array is non-empty\n * @example\n * isNonEmpty([])     // false\n * isNonEmpty([1])    // true\n */\nexport function isNonEmpty<T>(values: readonly T[]): values is ReadonlyNonEmptyArray<T> {\n  return values.length > 0;\n}\n\n/**\n * Asserts that an array is non-empty, throwing otherwise.\n * @param values - The array to check\n * @param message - Custom error message\n * @throws Error if the array is empty\n * @example\n * assertNonEmpty([1]) // passes\n * assertNonEmpty([])  // throws Error\n */\nexport function assertNonEmpty<T>(values: readonly T[], message?: string): asserts values is ReadonlyNonEmptyArray<T> {\n  if (values.length === 0) {\n    throw new Error(message ?? 'Expected array to be non-empty');\n  }\n}\n\n/**\n * Converts an array to an Option of a non-empty array. Returns the same array\n * value when non-empty - no allocation or cloning.\n * @param values - The array to convert\n * @returns Some(values) typed as non-empty if length > 0, None otherwise\n * @example\n * fromArray([])     // None\n * fromArray([1, 2]) // Some([1, 2]) with non-empty type\n */\nexport function fromArray<T>(values: readonly T[]): Option<ReadonlyNonEmptyArray<T>> {\n  return values.length > 0 ? (values as Some<ReadonlyNonEmptyArray<T>>) : NONE;\n}\n"],"names":["assertNonEmpty","fromArray","isNonEmpty","values","length","message","Error","NONE"],"mappings":";;;;;;;;;;;QA8BgBA;eAAAA;;QAeAC;eAAAA;;QA5BAC;eAAAA;;;0BAjBK;AAiBd,SAASA,WAAcC,MAAoB;IAChD,OAAOA,OAAOC,MAAM,GAAG;AACzB;AAWO,SAASJ,eAAkBG,MAAoB,EAAEE,OAAgB;IACtE,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,MAAM,IAAIE,MAAMD,WAAW;IAC7B;AACF;AAWO,SAASJ,UAAaE,MAAoB;IAC/C,OAAOA,OAAOC,MAAM,GAAG,IAAKD,SAA4CI,cAAI;AAC9E"}

package/build/nonempty.d.ts

@@ -0,0 +1,34 @@
+import type { Option } from './types.js';
+/** An array proven to contain at least one element. The runtime value is a plain array. */
+export type NonEmptyArray<T> = [T, ...T[]];
+/** A readonly array proven to contain at least one element. The runtime value is a plain array. */
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+/**
+ * Checks whether an array has at least one element.
+ * @param values - The array to check
+ * @returns true if the array is non-empty
+ * @example
+ * isNonEmpty([])     // false
+ * isNonEmpty([1])    // true
+ */
+export declare function isNonEmpty<T>(values: readonly T[]): values is ReadonlyNonEmptyArray<T>;
+/**
+ * Asserts that an array is non-empty, throwing otherwise.
+ * @param values - The array to check
+ * @param message - Custom error message
+ * @throws Error if the array is empty
+ * @example
+ * assertNonEmpty([1]) // passes
+ * assertNonEmpty([])  // throws Error
+ */
+export declare function assertNonEmpty<T>(values: readonly T[], message?: string): asserts values is ReadonlyNonEmptyArray<T>;
+/**
+ * Converts an array to an Option of a non-empty array. Returns the same array
+ * value when non-empty - no allocation or cloning.
+ * @param values - The array to convert
+ * @returns Some(values) typed as non-empty if length > 0, None otherwise
+ * @example
+ * fromArray([])     // None
+ * fromArray([1, 2]) // Some([1, 2]) with non-empty type
+ */
+export declare function fromArray<T>(values: readonly T[]): Option<ReadonlyNonEmptyArray<T>>;

package/build/nonempty.js

@@ -0,0 +1,14 @@
+import { NONE } from "./types.js";
+export function isNonEmpty(values) {
+    return values.length > 0;
+}
+export function assertNonEmpty(values, message) {
+    if (values.length === 0) {
+        throw new Error(message ?? 'Expected array to be non-empty');
+    }
+}
+export function fromArray(values) {
+    return values.length > 0 ? values : NONE;
+}
+
+//# sourceMappingURL=nonempty.js.map

package/build/nonempty.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/nonempty.ts"],"sourcesContent":["import { NONE } from './types.js';\nimport type { Option, Some } from './types.js';\n\n/** An array proven to contain at least one element. The runtime value is a plain array. */\nexport type NonEmptyArray<T> = [T, ...T[]];\n\n/** A readonly array proven to contain at least one element. The runtime value is a plain array. */\nexport type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];\n\n/**\n * Checks whether an array has at least one element.\n * @param values - The array to check\n * @returns true if the array is non-empty\n * @example\n * isNonEmpty([])     // false\n * isNonEmpty([1])    // true\n */\nexport function isNonEmpty<T>(values: readonly T[]): values is ReadonlyNonEmptyArray<T> {\n  return values.length > 0;\n}\n\n/**\n * Asserts that an array is non-empty, throwing otherwise.\n * @param values - The array to check\n * @param message - Custom error message\n * @throws Error if the array is empty\n * @example\n * assertNonEmpty([1]) // passes\n * assertNonEmpty([])  // throws Error\n */\nexport function assertNonEmpty<T>(values: readonly T[], message?: string): asserts values is ReadonlyNonEmptyArray<T> {\n  if (values.length === 0) {\n    throw new Error(message ?? 'Expected array to be non-empty');\n  }\n}\n\n/**\n * Converts an array to an Option of a non-empty array. Returns the same array\n * value when non-empty - no allocation or cloning.\n * @param values - The array to convert\n * @returns Some(values) typed as non-empty if length > 0, None otherwise\n * @example\n * fromArray([])     // None\n * fromArray([1, 2]) // Some([1, 2]) with non-empty type\n */\nexport function fromArray<T>(values: readonly T[]): Option<ReadonlyNonEmptyArray<T>> {\n  return values.length > 0 ? (values as Some<ReadonlyNonEmptyArray<T>>) : NONE;\n}\n"],"names":["NONE","isNonEmpty","values","length","assertNonEmpty","message","Error","fromArray"],"mappings":"AAAA,SAASA,IAAI,QAAQ,aAAa;AAiBlC,OAAO,SAASC,WAAcC,MAAoB;IAChD,OAAOA,OAAOC,MAAM,GAAG;AACzB;AAWA,OAAO,SAASC,eAAkBF,MAAoB,EAAEG,OAAgB;IACtE,IAAIH,OAAOC,MAAM,KAAK,GAAG;QACvB,MAAM,IAAIG,MAAMD,WAAW;IAC7B;AACF;AAWA,OAAO,SAASE,UAAaL,MAAoB;IAC/C,OAAOA,OAAOC,MAAM,GAAG,IAAKD,SAA4CF;AAC1E"}

package/build/option.cjs

@@ -157,7 +157,7 @@ function assertSome(opt, message) {
         throw new Error(message ?? 'Expected Option to contain a value');
     }
 }
-function satisfiesOption(_) {}
+function satisfiesOption(value) {}
 function filterMap(values, fn) {
     const collected = [];
     for (const value of values){

package/build/option.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\nconst NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Executes a side effect if None, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tapNone(none, () => console.log('missing')) // logs 'missing', returns None\n */\nexport function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;\nexport function tapNone(opt: None, fn: () => void): None;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {\n  if (isNone(opt)) {\n    fn();\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && (opt === value || (opt !== opt && value !== value));\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["and","andThen","assertSome","contains","expect","filter","filterMap","findMap","flatMap","flatten","fromNullable","fromPromise","isNone","isNoneOr","isSome","isSomeAnd","map","mapOr","mapOrElse","match","of","ofErr","ofOk","okOr","okOrElse","or","orElse","satisfiesOption","tap","tapNone","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","NONE_PAIR","Object","freeze","NONE","value","promise","onRejected","error","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","a","b","other","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":"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"}
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\nconst NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param value - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\n// oxlint-disable-next-line no-unused-vars\nexport function satisfiesOption<T>(value: Option<T> | T): asserts value is Option<T> {}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Executes a side effect if None, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tapNone(none, () => console.log('missing')) // logs 'missing', returns None\n */\nexport function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;\nexport function tapNone(opt: None, fn: () => void): None;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {\n  if (isNone(opt)) {\n    fn();\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && (opt === value || (opt !== opt && value !== value));\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["and","andThen","assertSome","contains","expect","filter","filterMap","findMap","flatMap","flatten","fromNullable","fromPromise","isNone","isNoneOr","isSome","isSomeAnd","map","mapOr","mapOrElse","match","of","ofErr","ofOk","okOr","okOrElse","or","orElse","satisfiesOption","tap","tapNone","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","NONE_PAIR","Object","freeze","NONE","value","promise","onRejected","error","opt","onNone","message","Error","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","a","b","other","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":"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"}

package/build/option.d.ts

@@ -50,13 +50,13 @@ export declare function assertSome<T>(opt: Option<T>, message?: string): asserts
  * runtime to preserve zero-allocation semantics. Use assertSome() if you
  * need runtime validation that a value is Some.
  *
- * @param _ - The value to assert as Option (not validated at runtime)
+ * @param value - The value to assert as Option (not validated at runtime)
  * @example
  * const value: number | null = getValue();
  * satisfiesOption(value); // Compiles, but no runtime check
  * // value is now typed as Option<number>
  */
-export declare function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T>;
+export declare function satisfiesOption<T>(value: Option<T> | T): asserts value is Option<T>;
 /**
  * Maps and filters an iterable, collecting only Some values.
  * @param values - The iterable to process

package/build/option.js

@@ -26,7 +26,7 @@ export function assertSome(opt, message) {
         throw new Error(message ?? 'Expected Option to contain a value');
     }
 }
-export function satisfiesOption(_) {}
+export function satisfiesOption(value) {}
 export function filterMap(values, fn) {
     const collected = [];
     for (const value of values){

package/build/option.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\nconst NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Executes a side effect if None, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tapNone(none, () => console.log('missing')) // logs 'missing', returns None\n */\nexport function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;\nexport function tapNone(opt: None, fn: () => void): None;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {\n  if (isNone(opt)) {\n    fn();\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && (opt === value || (opt !== opt && value !== value));\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["NONE","EMPTY","isSome","isNone","optionOf","of","err","isOk","isErr","NONE_PAIR","Object","freeze","fromNullable","value","fromPromise","promise","onRejected","error","unwrapOrReturn","opt","onNone","assertSome","message","Error","satisfiesOption","_","filterMap","values","fn","collected","mapped","push","findMap","map","result","undefined","flatMap","andThen","tap","tapNone","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","a","b","and","zip","other","unzip","mapOr","mapOrElse","defaultFn","flatten","contains","isSomeAnd","toArray","toNullable","toUndefined","match","onSome","okOr","okOrElse","ofOk","ofErr"],"mappings":"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"}
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\nconst NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param value - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\n// oxlint-disable-next-line no-unused-vars\nexport function satisfiesOption<T>(value: Option<T> | T): asserts value is Option<T> {}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Executes a side effect if None, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tapNone(none, () => console.log('missing')) // logs 'missing', returns None\n */\nexport function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;\nexport function tapNone(opt: None, fn: () => void): None;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {\n  if (isNone(opt)) {\n    fn();\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && (opt === value || (opt !== opt && value !== value));\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["NONE","EMPTY","isSome","isNone","optionOf","of","err","isOk","isErr","NONE_PAIR","Object","freeze","fromNullable","value","fromPromise","promise","onRejected","error","unwrapOrReturn","opt","onNone","assertSome","message","Error","satisfiesOption","filterMap","values","fn","collected","mapped","push","findMap","map","result","undefined","flatMap","andThen","tap","tapNone","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","a","b","and","zip","other","unzip","mapOr","mapOrElse","defaultFn","flatten","contains","isSomeAnd","toArray","toNullable","toUndefined","match","onSome","okOr","okOrElse","ofOk","ofErr"],"mappings":"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"}

package/build/result.cjs

@@ -57,9 +57,6 @@ _export(exports, {
     get fromPromise () {
         return fromPromise;
     },
-    get fromSchema () {
-        return fromSchema;
-    },
     get gen () {
         return gen;
     },
@@ -215,14 +212,6 @@ async function fromPromise(promise, onError) {
         return (0, _typescjs.err)(onError ? onError(error) : error);
     }
 }
-function schemaResultToResult(sr) {
-    return sr.issues ? (0, _typescjs.err)(sr.issues) : sr.value;
-}
-function fromSchema(schema, value) {
-    const sr = schema['~standard'].validate(value);
-    if ((0, _typescjs.isThenable)(sr)) return sr.then(schemaResultToResult);
-    return schemaResultToResult(sr);
-}
 function tryCatchMaybePromise(fn, onError) {
     try {
         const result = fn();
@@ -414,7 +403,7 @@ function any(results) {
 }
 function transpose(result) {
     if ((0, _typescjs.isErr)(result)) {
-        return (0, _typescjs.err)(result.error);
+        return result;
     }
     const opt = result;
     return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : opt;
@@ -526,22 +515,25 @@ async function safeTryAsync(fn) {
     }
 }
 function* unwrapYield(result) {
-    if ((0, _typescjs.isErr)(result)) {
-        yield result;
-        return undefined;
-    }
+    if ((0, _typescjs.isErr)(result)) yield result;
     return result;
 }
 function gen(fn) {
     const iter = fn(unwrapYield);
     const step = iter.next();
-    if (!step.done) return step.value;
+    if (!step.done) {
+        iter.return(undefined);
+        return step.value;
+    }
     return step.value;
 }
 async function genAsync(fn) {
     const iter = fn(unwrapYield);
     const step = await iter.next();
-    if (!step.done) return step.value;
+    if (!step.done) {
+        await iter.return(undefined);
+        return step.value;
+    }
     return step.value;
 }