nalloc 0.0.2 → 0.1.0

package/README.md

@@ -107,6 +107,40 @@ import { Option } from 'nalloc';
 Option.map(42, x => x * 2);               // value IS the Option
 ```
 
+### From oxide.ts
+
+```ts
+// oxide.ts
+import { Some, None, Ok, Err } from 'oxide.ts';
+const opt = Some(42);
+opt.map(x => x * 2);
+const result = Ok(42);
+result.mapErr(e => new Error(e));
+
+// nalloc - no wrapper objects on the happy path
+import { Option, Result, ok } from 'nalloc';
+Option.map(42, x => x * 2);              // 42 is the Option itself
+const result = ok(42);                    // zero allocation
+Result.mapErr(result, e => new Error(e));
+```
+
+### From ts-results
+
+```ts
+// ts-results
+import { Ok, Err, Some, None } from 'ts-results';
+const result = new Ok(42);
+result.map(x => x * 2);
+const opt = Some(42);
+opt.unwrapOr(0);
+
+// nalloc - same safety, zero allocations
+import { Option, Result, ok } from 'nalloc';
+const result = ok(42);                    // no wrapper
+Result.map(result, x => x * 2);
+Option.unwrapOr(42, 0);                  // value IS the Option
+```
+
 ### From Rust
 
 The API mirrors Rust's `Option` and `Result`:
@@ -350,14 +384,28 @@ Iter.tryForEach(items, item => processItem(item));
 
 ## Comparison
 
-| Feature | nalloc | neverthrow | fp-ts | oxide.ts |
-|---------|---------|------------|-------|----------|
-| Zero-alloc Option | Yes | No | No | No |
-| Zero-alloc Ok | Yes | No | No | No |
-| Bundle size | Tiny | Small | Large | Small |
-| Learning curve | Low | Low | High | Low |
-| Async support | Yes | Yes | Yes | Limited |
-| Tree-shakeable | Yes | Yes | Yes | Yes |
+| Feature | nalloc | neverthrow | fp-ts | oxide.ts | ts-results |
+|---------|---------|------------|-------|----------|------------|
+| Zero-alloc Option | Yes | No | No | No | No |
+| Zero-alloc Ok | Yes | No | No | No | No |
+| Bundle size | Tiny | Small | Large | Small | Small |
+| Learning curve | Low | Low | High | Low | Low |
+| Async support | Yes | Yes | Yes | Limited | No |
+| Tree-shakeable | Yes | Yes | Yes | Yes | Yes |
+| Iterator utilities | Yes | No | Yes | No | No |
+| safeTry (? operator) | Yes | Yes | No | No | No |
+
+## Alternatives
+
+Looking for a TypeScript Result/Option library? Here's how nalloc compares:
+
+- **neverthrow** - Popular, method-chaining API. Allocates a wrapper for every Ok and Err. nalloc avoids allocation on the happy path entirely.
+- **fp-ts / effect** - Full functional programming ecosystem with Either and Option. Powerful but heavy and steep learning curve. nalloc focuses on Result/Option with a simpler API.
+- **oxide.ts** - Rust-inspired with class-based wrappers. Every Some/Ok allocates an object. nalloc represents Some/Ok as the raw value.
+- **ts-results / ts-results-es** - Direct Rust port with class instances. Similar API surface to nalloc, but allocates on every construction.
+- **true-myth** - Result and Maybe with a functional API. Wraps all values. nalloc is a similar philosophy with zero-allocation design.
+
+nalloc is designed for codebases where allocation pressure matters - high-throughput servers, hot loops, and performance-sensitive paths - while keeping the same safety guarantees.
 
 ## License
 

package/build/option.cjs

@@ -174,9 +174,7 @@ function map(opt, fn) {
 function flatMap(opt, fn) {
     return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : fn(opt);
 }
-function andThen(opt, fn) {
-    return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : fn(opt);
-}
+const andThen = flatMap;
 function tap(opt, fn) {
     if ((0, _typescjs.isSome)(opt)) {
         fn(opt);
@@ -214,8 +212,9 @@ function orElse(opt, fn) {
     return (0, _typescjs.isSome)(opt) ? opt : fn();
 }
 function xor(opt, optb) {
-    if ((0, _typescjs.isSome)(opt) && (0, _typescjs.isNone)(optb)) return opt;
-    if ((0, _typescjs.isNone)(opt) && (0, _typescjs.isSome)(optb)) return optb;
+    const a = (0, _typescjs.isSome)(opt);
+    const b = (0, _typescjs.isSome)(optb);
+    if (a !== b) return a ? opt : optb;
     return _typescjs.NONE;
 }
 function and(opt, optb) {
@@ -248,7 +247,7 @@ function flatten(opt) {
     return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : opt;
 }
 function contains(opt, value) {
-    return (0, _typescjs.isSome)(opt) && opt === value;
+    return (0, _typescjs.isSome)(opt) && (opt === value || opt !== opt && value !== value);
 }
 function isSomeAnd(opt, predicate) {
     return (0, _typescjs.isSome)(opt) && predicate(opt);

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\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 function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\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 * 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  if (isSome(opt) && isNone(optb)) return opt;\n  if (isNone(opt) && isSome(optb)) return 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, NONE];\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;\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","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","value","promise","onRejected","error","NONE","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","other","a","b","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\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 * 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, NONE];\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","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","value","promise","onRejected","error","NONE","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","a","b","other","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":";;;;;;;;;;;QAuUgBA;eAAAA;;QAvKHC;eAAAA;;QAhGGC;eAAAA;;QAyVAC;eAAAA;;QApJAC;eAAAA;;QAxDAC;eAAAA;;QA9GAC;eAAAA;;QAkBAC;eAAAA;;QAqCAC;eAAAA;;QAqPAC;eAAAA;;QA1XAC;eAAAA;;QAaMC;eAAAA;;QA1BLC;eAAAA,gBAAM;;QA0LPC;eAAAA;;QA1LPC;eAAAA,gBAAM;;QAmaCC;eAAAA;;QAnSAC;eAAAA;;QA4OAC;eAAAA;;QAcAC;eAAAA;;QA2FAC;eAAAA;;QArdSC;eAAAA,kBAAE;;QA0gBXC;eAAAA;;QAfAC;eAAAA;;QAzBAC;eAAAA;;QAaAC;eAAAA;;QA5NAC;eAAAA;;QAeAC;eAAAA;;QAnNAC;eAAAA;;QA0FAC;eAAAA;;QAsQAC;eAAAA;;QAYAC;eAAAA;;QAYAC;eAAAA;;QAjPAC;eAAAA;;QAgBAC;eAAAA;;QAaAC;eAAAA;;QApMAC;eAAAA;;QA6SAC;eAAAA;;QA3CAC;eAAAA;;QA+BAC;eAAAA;;;0BApV8D;AAiBvE,SAAS5B,aAAgB6B,KAAwB;IACtD,OAAOnB,IAAAA,kBAAE,EAACmB;AACZ;AAWO,eAAe5B,YAAe6B,OAAmC,EAAEC,UAAkD;IAC1H,IAAI;QACF,MAAMF,QAAQ,MAAMC;QACpB,OAAOpB,IAAAA,kBAAE,EAACmB;IACZ,EAAE,OAAOG,OAAO;QACd,IAAI,CAACD,YAAY;YACf,OAAOE,cAAI;QACb;QACA,OAAOvB,IAAAA,kBAAE,EAACqB,WAAWC;IACvB;AACF;AAWO,SAASP,eAAqBS,GAAc,EAAEC,MAAe;IAClE,OAAO/B,IAAAA,gBAAM,EAAC8B,OAAQA,MAAmBC;AAC3C;AAWO,SAAS3C,WAAc0C,GAAc,EAAEE,OAAgB;IAC5D,IAAIlC,IAAAA,gBAAM,EAACgC,MAAM;QACf,MAAM,IAAIG,MAAMD,WAAW;IAC7B;AACF;AAeO,SAASnB,gBAAmBqB,CAAgB,GAEnD;AAUO,SAAS1C,UAAgB2C,MAAmB,EAAEC,EAA2B;IAC9E,MAAMC,YAAiB,EAAE;IACzB,KAAK,MAAMZ,SAASU,OAAQ;QAC1B,MAAMG,SAASF,GAAGX;QAClB,IAAIzB,IAAAA,gBAAM,EAACsC,SAASD,UAAUE,IAAI,CAACD;IACrC;IACA,OAAOD;AACT;AAWO,SAAS5C,QAAc0C,MAAmB,EAAEC,EAA2B;IAC5E,KAAK,MAAMX,SAASU,OAAQ;QAC1B,MAAMG,SAASF,GAAGX;QAClB,IAAIzB,IAAAA,gBAAM,EAACsC,SAAS,OAAOA;IAC7B;IACA,OAAOT,cAAI;AACb;AAaO,SAAS3B,IAAU4B,GAAc,EAAEM,EAAmC;IAC3E,IAAItC,IAAAA,gBAAM,EAACgC,MAAM,OAAOD,cAAI;IAC5B,MAAMW,SAASJ,GAAGN;IAClB,OAAOU,WAAW,QAAQA,WAAWC,YAAYZ,cAAI,GAAIW;AAC3D;AAcO,SAAS9C,QAAcoC,GAAc,EAAEM,EAA2B;IACvE,OAAOtC,IAAAA,gBAAM,EAACgC,OAAOD,cAAI,GAAGO,GAAGN;AACjC;AAQO,MAAM3C,UAA0BO;AAahC,SAASoB,IAAOgB,GAAc,EAAEM,EAAsB;IAC3D,IAAIpC,IAAAA,gBAAM,EAAC8B,MAAM;QACfM,GAAGN;IACL;IACA,OAAOA;AACT;AAYO,SAAS/B,SAAY+B,GAAc,EAAEY,SAAgC;IAC1E,OAAO5C,IAAAA,gBAAM,EAACgC,QAAQY,UAAUZ;AAClC;AAaO,SAASvC,OAAUuC,GAAc,EAAEY,SAAgC;IACxE,OAAO1C,IAAAA,gBAAM,EAAC8B,QAAQY,UAAUZ,OAAOA,MAAMD,cAAI;AACnD;AAWO,SAASX,OAAUY,GAAc;IACtC,IAAIhC,IAAAA,gBAAM,EAACgC,MAAM;QACf,MAAM,IAAIG,MAAM;IAClB;IACA,OAAOH;AACT;AAWO,SAASX,SAAYW,GAAc,EAAEa,YAAe;IACzD,OAAO3C,IAAAA,gBAAM,EAAC8B,OAAOA,MAAMa;AAC7B;AAWO,SAASvB,aAAgBU,GAAc,EAAEM,EAAW;IACzD,OAAOpC,IAAAA,gBAAM,EAAC8B,OAAOA,MAAMM;AAC7B;AAYO,SAAS9C,OAAUwC,GAAc,EAAEE,OAAe;IACvD,IAAIlC,IAAAA,gBAAM,EAACgC,MAAM;QACf,MAAM,IAAIG,MAAMD;IAClB;IACA,OAAOF;AACT;AAaO,SAASnB,GAAMmB,GAAc,EAAEc,IAAe;IACnD,OAAO5C,IAAAA,gBAAM,EAAC8B,OAAOA,MAAMc;AAC7B;AAaO,SAAShC,OAAUkB,GAAc,EAAEM,EAAmB;IAC3D,OAAOpC,IAAAA,gBAAM,EAAC8B,OAAOA,MAAMM;AAC7B;AAaO,SAASb,IAAOO,GAAc,EAAEc,IAAe;IACpD,MAAMC,IAAI7C,IAAAA,gBAAM,EAAC8B;IACjB,MAAMgB,IAAI9C,IAAAA,gBAAM,EAAC4C;IACjB,IAAIC,MAAMC,GAAG,OAAOD,IAAIf,MAAMc;IAC9B,OAAOf,cAAI;AACb;AAaO,SAAS3C,IAAU4C,GAAc,EAAEc,IAAe;IACvD,OAAO5C,IAAAA,gBAAM,EAAC8B,OAAOc,OAAOf,cAAI;AAClC;AAWO,SAASL,IAAUM,GAAc,EAAEiB,KAAgB;IACxD,OAAO/C,IAAAA,gBAAM,EAAC8B,QAAQ9B,IAAAA,gBAAM,EAAC+C,SAAU;QAACjB;QAAKiB;KAAM,GAAoBlB,cAAI;AAC7E;AAUO,SAASP,MAAYQ,GAAmB;IAC7C,IAAIhC,IAAAA,gBAAM,EAACgC,MAAM,OAAO;QAACD,cAAI;QAAEA,cAAI;KAAC;IACpC,MAAM,CAACgB,GAAGC,EAAE,GAAGhB;IACf,OAAO;QAACxB,IAAAA,kBAAE,EAACuC;QAAIvC,IAAAA,kBAAE,EAACwC;KAAG;AACvB;AAYO,SAAS3C,MAAY2B,GAAc,EAAEa,YAAe,EAAEP,EAAmB;IAC9E,OAAOpC,IAAAA,gBAAM,EAAC8B,OAAOM,GAAGN,OAAOa;AACjC;AAYO,SAASvC,UAAgB0B,GAAc,EAAEkB,SAAkB,EAAEZ,EAAmB;IACrF,OAAOpC,IAAAA,gBAAM,EAAC8B,OAAOM,GAAGN,OAAOkB;AACjC;AAWO,SAASrD,QAAWmC,GAAsB;IAC/C,OAAOhC,IAAAA,gBAAM,EAACgC,OAAOD,cAAI,GAAIC;AAC/B;AAYO,SAASzC,SAAYyC,GAAc,EAAEL,KAAQ;IAClD,OAAOzB,IAAAA,gBAAM,EAAC8B,QAASA,CAAAA,QAAQL,SAAUK,QAAQA,OAAOL,UAAUA,KAAK;AACzE;AAYO,SAASxB,UAAa6B,GAAc,EAAEY,SAAgC;IAC3E,OAAO1C,IAAAA,gBAAM,EAAC8B,QAAQY,UAAUZ;AAClC;AAUO,SAASf,QAAWe,GAAc;IACvC,OAAO9B,IAAAA,gBAAM,EAAC8B,OAAO;QAACA;KAAI,GAAImB,eAAK;AACrC;AAUO,SAASjC,WAAcc,GAAc;IAC1C,OAAO9B,IAAAA,gBAAM,EAAC8B,OAAOA,MAAM;AAC7B;AAUO,SAASb,YAAea,GAAc;IAC3C,OAAO9B,IAAAA,gBAAM,EAAC8B,OAAOA,MAAMW;AAC7B;AAYO,SAASpC,MAAYyB,GAAc,EAAEoB,MAAuB,EAAEnB,MAAe;IAClF,OAAO/B,IAAAA,gBAAM,EAAC8B,OAAOoB,OAAOpB,OAAOC;AACrC;AAWO,SAAStB,KAAWqB,GAAc,EAAEF,KAAQ;IACjD,OAAO5B,IAAAA,gBAAM,EAAC8B,OAAQA,MAA2BqB,IAAAA,aAAG,EAACvB;AACvD;AAWO,SAASlB,SAAeoB,GAAc,EAAEM,EAAW;IACxD,OAAOpC,IAAAA,gBAAM,EAAC8B,OAAQA,MAA2BqB,IAAAA,aAAG,EAACf;AACvD;AAUO,SAAS5B,KAAWgC,MAAoB;IAC7C,IAAI,CAACY,IAAAA,cAAI,EAACZ,WAAW,CAACxC,IAAAA,gBAAM,EAACwC,SAAS;QACpC,OAAOX,cAAI;IACb;IACA,OAAOW;AACT;AAUO,SAASjC,MAAYiC,MAAoB;IAC9C,IAAI,CAACa,IAAAA,eAAK,EAACb,SAAS;QAClB,OAAOX,cAAI;IACb;IACA,MAAMD,QAAQ,AAACY,OAAwBZ,KAAK;IAC5C,IAAI,CAAC5B,IAAAA,gBAAM,EAAC4B,QAAQ;QAClB,OAAOC,cAAI;IACb;IACA,OAAOD;AACT"}

package/build/option.d.ts

@@ -105,8 +105,7 @@ export declare function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U
  * @param fn - Function returning an Option
  * @returns The result of fn(value) if Some, None otherwise
  */
-export declare function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;
-export declare function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;
+export declare const andThen: typeof flatMap;
 /**
  * Executes a side effect if Some, then returns the original Option.
  * @param opt - The Option to tap

package/build/option.js

@@ -46,9 +46,7 @@ export function map(opt, fn) {
 export function flatMap(opt, fn) {
     return isNone(opt) ? NONE : fn(opt);
 }
-export function andThen(opt, fn) {
-    return isNone(opt) ? NONE : fn(opt);
-}
+export const andThen = flatMap;
 export function tap(opt, fn) {
     if (isSome(opt)) {
         fn(opt);
@@ -86,8 +84,9 @@ export function orElse(opt, fn) {
     return isSome(opt) ? opt : fn();
 }
 export function xor(opt, optb) {
-    if (isSome(opt) && isNone(optb)) return opt;
-    if (isNone(opt) && isSome(optb)) return optb;
+    const a = isSome(opt);
+    const b = isSome(optb);
+    if (a !== b) return a ? opt : optb;
     return NONE;
 }
 export function and(opt, optb) {
@@ -120,7 +119,7 @@ export function flatten(opt) {
     return isNone(opt) ? NONE : opt;
 }
 export function contains(opt, value) {
-    return isSome(opt) && opt === value;
+    return isSome(opt) && (opt === value || opt !== opt && value !== value);
 }
 export function isSomeAnd(opt, predicate) {
     return isSome(opt) && predicate(opt);

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\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 function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\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 * 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  if (isSome(opt) && isNone(optb)) return opt;\n  if (isNone(opt) && isSome(optb)) return 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, NONE];\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;\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","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","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","and","zip","other","unzip","a","b","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\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 * 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, NONE];\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","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","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

@@ -54,6 +54,9 @@ _export(exports, {
     get flatten () {
         return flatten;
     },
+    get fromPromise () {
+        return fromPromise;
+    },
     get isErr () {
         return _typescjs.isErr;
     },
@@ -171,6 +174,13 @@ function tryCatch(fn, onError) {
 function of(fn) {
     return tryCatch(fn);
 }
+async function fromPromise(promise, onError) {
+    try {
+        return await promise;
+    } catch (error) {
+        return (0, _typescjs.err)(onError ? onError(error) : error);
+    }
+}
 function tryCatchMaybePromise(fn, onError) {
     try {
         const result = fn();
@@ -192,7 +202,7 @@ function assertOk(result, message) {
 }
 function assertErr(result, message) {
     if ((0, _typescjs.isOk)(result)) {
-        throw new Error(message ?? 'Expected Err result.');
+        throw new Error(message ?? `Expected Err result. Received value: ${String(result)}`);
     }
 }
 function isSomeErr(result) {
@@ -210,9 +220,7 @@ function flatMap(result, fn) {
     if ((0, _typescjs.isErr)(result)) return result;
     return fn(result);
 }
-function andThen(result, fn) {
-    return (0, _typescjs.isErr)(result) ? result : fn(result);
-}
+const andThen = flatMap;
 function tap(result, fn) {
     if ((0, _typescjs.isOk)(result)) {
         fn(result);
@@ -326,15 +334,25 @@ function filterErr(results) {
     return errs;
 }
 function collect(results) {
-    const values = [];
-    for (const result of results){
+    const len = results.length;
+    const values = new Array(len);
+    for(let i = 0; i < len; i++){
+        const result = results[i];
         if ((0, _typescjs.isErr)(result)) return result;
-        values.push(result);
+        values[i] = result;
     }
     return values;
 }
 function collectAll(results) {
-    const [oks, errs] = partition(results);
+    const oks = [];
+    const errs = [];
+    for (const result of results){
+        if ((0, _typescjs.isOk)(result)) {
+            oks.push(result);
+        } else {
+            errs.push(result.error);
+        }
+    }
     return errs.length > 0 ? (0, _typescjs.err)(errs) : oks;
 }
 function all(results) {
@@ -395,18 +413,28 @@ function settleMaybePromise(values) {
 }
 async function partitionMaybePromiseAsync(values, oks, errs, startIndex = 0) {
     const suffixLength = values.length - startIndex;
-    const pending = new Array(suffixLength);
+    const pendingPromises = [];
     for(let i = 0; i < suffixLength; i++){
         const value = values[startIndex + i];
-        pending[i] = Promise.resolve(value).then((result)=>result, (error)=>(0, _typescjs.err)(error));
-    }
-    const resolved = await Promise.all(pending);
-    for(let i = 0; i < resolved.length; i++){
-        const result = resolved[i];
-        if ((0, _typescjs.isOk)(result)) {
-            oks.push(result);
+        if ((0, _typescjs.isThenable)(value)) {
+            pendingPromises.push(Promise.resolve(value).then((result)=>result, (error)=>(0, _typescjs.err)(error)));
         } else {
-            errs.push(result.error);
+            if ((0, _typescjs.isOk)(value)) {
+                oks.push(value);
+            } else {
+                errs.push(value.error);
+            }
+        }
+    }
+    if (pendingPromises.length > 0) {
+        const resolved = await Promise.all(pendingPromises);
+        for(let i = 0; i < resolved.length; i++){
+            const result = resolved[i];
+            if ((0, _typescjs.isOk)(result)) {
+                oks.push(result);
+            } else {
+                errs.push(result.error);
+            }
         }
     }
     return [