nalloc 0.0.1

package/build/result.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/result.ts"],"sourcesContent":["import { err as ERR, isOk, isErr, isSome, isNone, NONE, optionOf } from './types.js';\nimport type { Ok, Err, Result, Option, Widen, WidenNever } from './types.js';\n\nexport type { Ok, Err, Result };\nexport { isOk, isErr };\n\n/**\n * Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @param onError - Optional error transformer\n * @returns Ok(result) if successful, Err(error) if thrown\n * @example\n * tryCatch(() => JSON.parse('{\"a\":1}'))     // Ok({a: 1})\n * tryCatch(() => JSON.parse('invalid'))     // Err(SyntaxError)\n * tryCatch(() => { throw 'oops' }, e => e)  // Err('oops')\n */\nexport function tryCatch<T, E = unknown>(fn: () => T, onError?: (error: unknown) => E): Result<T, E> {\n  try {\n    return fn() as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryCatch. Executes a function and captures the result or error.\n * @param fn - Function to execute\n * @returns Ok(result) if successful, Err(error) if thrown\n */\nexport function of<T, E = unknown>(fn: () => T): Result<T, E> {\n  return tryCatch(fn);\n}\n\n/**\n * Executes an async function and captures the result or error.\n * @param fn - Async function to execute\n * @param onError - Optional error transformer\n * @returns Promise of Ok(result) if successful, Err(error) if rejected\n * @example\n * await tryAsync(() => fetch('/api').then(r => r.json())) // Ok(data) or Err(error)\n */\nexport async function tryAsync<T, E = unknown>(fn: () => Promise<T>, onError?: (error: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await fn()) as Ok<T>;\n  } catch (error) {\n    return ERR(onError ? onError(error) : (error as E));\n  }\n}\n\n/**\n * Alias for tryAsync. Executes an async function and captures the result or error.\n * @param fn - Async function to execute\n * @returns Promise of Ok(result) if successful, Err(error) if rejected\n */\nexport function ofAsync<T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>> {\n  return tryAsync(fn);\n}\n\n/**\n * Converts a Promise to a Result.\n * @param promise - The promise to convert\n * @param onRejected - Optional rejection handler\n * @returns Promise of Ok(value) if resolved, Err(error) if rejected\n * @example\n * await fromPromise(Promise.resolve(42))        // Ok(42)\n * await fromPromise(Promise.reject('error'))    // Err('error')\n */\nexport async function fromPromise<T, E = unknown>(promise: Promise<T>, onRejected?: (reason: unknown) => E): Promise<Result<T, E>> {\n  try {\n    return (await promise) as Ok<T>;\n  } catch (error) {\n    return ERR(onRejected ? onRejected(error) : (error as E));\n  }\n}\n\n/**\n * Unwraps an Ok value or returns a computed value for Err.\n * @param result - The Result to unwrap\n * @param onErr - Function called with error if Err\n * @returns The Ok value or result of onErr(error)\n * @example\n * unwrapOrReturn(ok(42), e => 0)          // 42\n * unwrapOrReturn(err('fail'), e => 0)     // 0\n */\nexport function unwrapOrReturn<T, E, const R>(result: Result<T, E>, onErr: (error: E) => R): T | R {\n  return isOk(result) ? result : onErr(result.error);\n}\n\n/**\n * Asserts that a Result is Ok, throwing if Err.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Err\n * @example\n * assertOk(ok(42))        // passes\n * assertOk(err('failed')) // throws Error\n */\nexport function assertOk<T, E>(result: Result<T, E>, message?: string): asserts result is Ok<T> {\n  if (isErr(result)) {\n    throw new Error(message ?? `Expected Ok result. Received error: ${String((result as Err<E>).error)}`);\n  }\n}\n\n/**\n * Asserts that a Result is Err, throwing if Ok.\n * @param result - The Result to assert\n * @param message - Custom error message\n * @throws Error if result is Ok\n * @example\n * assertErr(err('failed')) // passes\n * assertErr(ok(42))        // throws Error\n */\nexport function assertErr<T, E>(result: Result<T, E>, message?: string): asserts result is Err<E> {\n  if (isOk(result)) {\n    throw new Error(message ?? 'Expected Err result.');\n  }\n}\n\n/**\n * Checks if result is Err with a non-null error value.\n * @param result - The Result to check\n * @returns true if Err with Some error value\n */\nexport function isSomeErr<T, E>(result: Result<T, E>): boolean {\n  return isErr(result) && isSome((result as Err<E>).error);\n}\n\n/**\n * Transforms the Ok value, leaving Err unchanged.\n * @param result - The Result to map\n * @param fn - Transform function\n * @returns Ok(fn(value)) if Ok, Err unchanged\n * @example\n * map(ok(2), x => x * 2)   // Ok(4)\n * map(err('e'), x => x * 2) // Err('e')\n */\nexport function map<T, U, E>(result: Err<E>, fn: (value: T) => U): Err<E>;\nexport function map<T, U>(result: Ok<T>, fn: (value: T) => U): Ok<U>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isErr(result)) return result as Err<E>;\n  return fn(result as Ok<T>) as Ok<U>;\n}\n\n/**\n * Transforms the Err value, leaving Ok unchanged.\n * @param result - The Result to map\n * @param fn - Error transform function\n * @returns Err(fn(error)) if Err, Ok unchanged\n * @example\n * mapErr(err('e'), e => e.toUpperCase()) // Err('E')\n * mapErr(ok(42), e => e.toUpperCase())   // Ok(42)\n */\nexport function mapErr<T, E, F>(result: Ok<T>, fn: (error: E) => F): Ok<T>;\nexport function mapErr<E, F>(result: Err<E>, fn: (error: E) => F): Err<F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isOk(result)) return result;\n  return ERR(fn(result.error));\n}\n\n/**\n * Chains Result-returning functions. Returns Err if the input is Err.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n * @example\n * flatMap(ok(2), x => ok(x * 2))    // Ok(4)\n * flatMap(ok(2), x => err('fail'))  // Err('fail')\n * flatMap(err('e'), x => ok(x * 2)) // Err('e')\n */\nexport function flatMap<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  if (isErr(result)) return result as Err<E>;\n  return fn(result as Ok<T>);\n}\n\n/**\n * Alias for flatMap. Chains Result-returning functions.\n * @param result - The Result to chain\n * @param fn - Function returning a Result\n * @returns The result of fn(value) if Ok, Err unchanged\n */\nexport function andThen<T, U, E>(result: Err<E>, fn: (value: T) => Result<U, E>): Err<E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;\nexport function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return flatMap(result, fn);\n}\n\n/**\n * Executes a side effect if Ok, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function\n * @returns The original Result unchanged\n * @example\n * tap(ok(42), x => console.log(x)) // logs 42, returns Ok(42)\n */\nexport function tap<T, E>(result: Err<E>, fn: (value: T) => void): Err<E>;\nexport function tap<T>(result: Ok<T>, fn: (value: T) => void): Ok<T>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\nexport function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {\n  if (isOk(result)) {\n    fn(result);\n  }\n  return result;\n}\n\n/**\n * Executes a side effect if Err, then returns the original Result.\n * @param result - The Result to tap\n * @param fn - Side effect function for error\n * @returns The original Result unchanged\n * @example\n * tapErr(err('fail'), e => console.log(e)) // logs 'fail', returns Err('fail')\n */\nexport function tapErr<T, E>(result: Ok<T>, fn: (error: E) => void): Ok<T>;\nexport function tapErr<E>(result: Err<E>, fn: (error: E) => void): Err<E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\nexport function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {\n  if (isErr(result)) {\n    fn((result as Err<E>).error);\n  }\n  return result;\n}\n\n/**\n * Maps both Ok and Err values simultaneously.\n * @param result - The Result to map\n * @param okFn - Transform for Ok value\n * @param errFn - Transform for Err value\n * @returns Ok(okFn(value)) if Ok, Err(errFn(error)) if Err\n * @example\n * bimap(ok(2), x => x * 2, e => e.toUpperCase())   // Ok(4)\n * bimap(err('e'), x => x * 2, e => e.toUpperCase()) // Err('E')\n */\nexport function bimap<T, U, E, F>(result: Ok<T>, okFn: (value: T) => U, errFn: (error: E) => F): Ok<U>;\nexport function bimap<T, U, E, F>(result: Err<E>, okFn: (value: T) => U, errFn: (error: E) => F): Err<F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F>;\nexport function bimap<T, U, E, F>(result: Result<T, E>, okFn: (value: T) => U, errFn: (error: E) => F): Result<U, F> {\n  return isOk(result) ? (okFn(result) as Ok<U>) : ERR(errFn(result.error));\n}\n\n/**\n * Extracts the Ok value, throws if Err.\n * @param result - The Result to unwrap\n * @returns The contained Ok value\n * @throws Error if result is Err\n * @example\n * unwrap(ok(42))        // 42\n * unwrap(err('failed')) // throws Error\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) {\n    throw new Error(`Called unwrap on Err: ${String((result as Err<E>).error)}`);\n  }\n  return result as T;\n}\n\n/**\n * Extracts the Err value, throws if Ok.\n * @param result - The Result to unwrap\n * @returns The contained error\n * @throws Error if result is Ok\n * @example\n * unwrapErr(err('failed')) // 'failed'\n * unwrapErr(ok(42))        // throws Error\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) {\n    throw new Error(`Called unwrapErr on Ok: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Extracts the Ok value, or returns a default.\n * @param result - The Result to unwrap\n * @param defaultValue - Value if Err\n * @returns The Ok value or defaultValue\n * @example\n * unwrapOr(ok(42), 0)        // 42\n * unwrapOr(err('failed'), 0) // 0\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result : defaultValue;\n}\n\n/**\n * Extracts the Ok value, or computes a default from the error.\n * @param result - The Result to unwrap\n * @param fn - Function to compute default from error\n * @returns The Ok value or fn(error)\n * @example\n * unwrapOrElse(ok(42), e => 0)        // 42\n * unwrapOrElse(err('failed'), e => 0) // 0\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Maps the Ok value and returns it, or returns a default.\n * @param result - The Result to map\n * @param defaultValue - Value if Err\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultValue otherwise\n * @example\n * mapOr(ok(2), 0, x => x * 2)   // 4\n * mapOr(err('e'), 0, x => x * 2) // 0\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultValue;\n}\n\n/**\n * Maps the Ok value and returns it, or computes a default.\n * @param result - The Result to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Ok, defaultFn() otherwise\n * @example\n * mapOrElse(ok(2), () => 0, x => x * 2)   // 4\n * mapOrElse(err('e'), () => 0, x => x * 2) // 0\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isOk(result) ? fn(result) : defaultFn();\n}\n\n/**\n * Extracts the Ok value, throws with custom message if Err.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Err\n * @returns The Ok value\n * @throws Error with message if Err\n * @example\n * expect(ok(42), 'missing value')        // 42\n * expect(err('fail'), 'missing value')   // throws Error('missing value: fail')\n */\nexport function expect<T, E>(result: Result<T, E>, message: string): T {\n  if (isErr(result)) {\n    throw new Error(`${message}: ${String((result as Err<E>).error)}`);\n  }\n  return result as Ok<T>;\n}\n\n/**\n * Extracts the Err value, throws with custom message if Ok.\n * @param result - The Result to unwrap\n * @param message - Error message prefix if Ok\n * @returns The error value\n * @throws Error with message if Ok\n * @example\n * expectErr(err('fail'), 'expected error')  // 'fail'\n * expectErr(ok(42), 'expected error')       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message: string): E {\n  if (isOk(result)) {\n    throw new Error(`${message}: ${String(result)}`);\n  }\n  return result.error;\n}\n\n/**\n * Returns other if result is Ok, otherwise returns the Err.\n * @param result - First Result\n * @param other - Second Result\n * @returns other if result is Ok, result (Err) otherwise\n * @example\n * and(ok(1), ok(2))   // Ok(2)\n * and(err('e'), ok(2)) // Err('e')\n */\nexport function and<T, U, E>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n  return isOk(result) ? other : result;\n}\n\n/**\n * Returns result if Ok, otherwise returns other.\n * @param result - First Result\n * @param other - Fallback Result\n * @returns result if Ok, other otherwise\n * @example\n * or(ok(1), ok(2))    // Ok(1)\n * or(err('e'), ok(2)) // Ok(2)\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : other;\n}\n\n/**\n * Returns result if Ok, otherwise computes a fallback from the error.\n * @param result - First Result\n * @param fn - Function to compute fallback\n * @returns result if Ok, fn(error) otherwise\n * @example\n * orElse(ok(1), e => ok(0))    // Ok(1)\n * orElse(err('e'), e => ok(0)) // Ok(0)\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n  return isOk(result) ? result : fn(result.error);\n}\n\n/**\n * Converts a Result to an Option, discarding the error.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * toOption(ok(42))        // Some(42)\n * toOption(err('failed')) // None\n */\nexport function toOption<T, E>(result: Result<T, E>): Option<T> {\n  return isOk(result) ? optionOf(result) : NONE;\n}\n\n/**\n * Converts a Result's error to an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * toErrorOption(err('failed')) // Some('failed')\n * toErrorOption(ok(42))        // None\n */\nexport function toErrorOption<T, E>(result: Result<T, E>): Option<E> {\n  return isErr(result) ? optionOf((result as Err<E>).error) : NONE;\n}\n\n/**\n * Combines two Results into a Result of a tuple.\n * @param left - First Result\n * @param right - Second Result\n * @returns Ok([a, b]) if both Ok, first Err otherwise\n * @example\n * zip(ok(1), ok('a')) // Ok([1, 'a'])\n * zip(ok(1), err('e')) // Err('e')\n */\nexport function zip<T, U, E>(left: Result<T, E>, right: Result<U, E>): Result<[T, U], E> {\n  if (isErr(left)) return left as Err<E>;\n  if (isErr(right)) return right as Err<E>;\n  return [left as Ok<T>, right as Ok<U>] as Ok<[T, U]>;\n}\n\n/**\n * Combines two Results using a function.\n * @param left - First Result\n * @param right - Second Result\n * @param fn - Combining function\n * @returns Ok(fn(a, b)) if both Ok, first Err otherwise\n * @example\n * zipWith(ok(2), ok(3), (a, b) => a + b) // Ok(5)\n */\nexport function zipWith<T, U, V, E>(left: Result<T, E>, right: Result<U, E>, fn: (left: T, right: U) => V): Result<V, E> {\n  if (isErr(left)) return left as Err<E>;\n  if (isErr(right)) return right as Err<E>;\n  return fn(left as Ok<T>, right as Ok<U>) as Ok<V>;\n}\n\n/**\n * Flattens a nested Result.\n * @param result - Result containing a Result\n * @returns The inner Result\n * @example\n * flatten(ok(ok(42)))    // Ok(42)\n * flatten(ok(err('e')))  // Err('e')\n * flatten(err('outer'))  // Err('outer')\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n  return isErr(result) ? (result as Err<E>) : (result as Result<T, E>);\n}\n\n/**\n * Pattern matches on a Result, handling both Ok and Err cases.\n * @param result - The Result to match\n * @param onOk - Handler for Ok case\n * @param onErr - Handler for Err case\n * @returns Result of the matching handler\n * @example\n * match(ok(42), x => x * 2, e => 0)   // 84\n * match(err('e'), x => x * 2, e => 0) // 0\n */\nexport function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Separates an array of Results into Ok values and Err values.\n * @param results - Array of Results\n * @returns Tuple of [Ok values, Err values]\n * @example\n * partition([ok(1), err('a'), ok(2)]) // [[1, 2], ['a']]\n */\nexport function partition<T, E>(results: Result<T, E>[]): [T[], E[]] {\n  const oks: T[] = [];\n  const errs: E[] = [];\n\n  for (const result of results) {\n    if (isOk(result)) {\n      oks.push(result);\n    } else {\n      errs.push(result.error);\n    }\n  }\n\n  return [oks, errs];\n}\n\n/**\n * Collects an array of Results into a Result of an array. Fails on first Err.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n * @example\n * collect([ok(1), ok(2)])       // Ok([1, 2])\n * collect([ok(1), err('e')])    // Err('e')\n */\nexport function collect<T, E>(results: Result<T, E>[]): Result<T[], E> {\n  const values: T[] = [];\n\n  for (const result of results) {\n    if (isErr(result)) {\n      return result as Err<E>;\n    }\n    values.push(result as Ok<T>);\n  }\n\n  return values as Ok<T[]>;\n}\n\n/**\n * Collects all Results, returning all errors if any exist.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, Err(allErrors) otherwise\n * @example\n * collectAll([ok(1), ok(2)])           // Ok([1, 2])\n * collectAll([ok(1), err('a'), err('b')]) // Err(['a', 'b'])\n */\nexport function collectAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {\n  const [oks, errs] = partition(results);\n  return errs.length > 0 ? ERR(errs) : (oks as Ok<T[]>);\n}\n\n/**\n * Alias for collect with widened types. Collects Results into a Result of array.\n * @param results - Array of Results\n * @returns Ok(values) if all Ok, first Err otherwise\n */\nexport function all<T, E>(results: Result<T, E>[]): Result<Widen<T>[], WidenNever<E>> {\n  return collect(results) as Result<Widen<T>[], WidenNever<E>>;\n}\n\n/**\n * Returns the first Ok, or all errors if none succeed.\n * @param results - Array of Results\n * @returns First Ok found, or Err(allErrors) if all fail\n * @example\n * any([err('a'), ok(1), err('b')]) // Ok(1)\n * any([err('a'), err('b')])        // Err(['a', 'b'])\n */\nexport function any<T, E>(results: Result<T, E>[]): Result<Widen<T>, WidenNever<E>[]> {\n  const len = results.length;\n  const errors = new Array<WidenNever<E>>(len);\n  for (let i = 0; i < len; i++) {\n    const result = results[i];\n    if (isOk(result)) return result as Ok<Widen<T>>;\n    errors[i] = (result as Err<WidenNever<E>>).error;\n  }\n  return ERR(errors);\n}\n\n/**\n * Transposes a Result of Option to an Option of Result.\n * @param result - Result containing an Option\n * @returns Some(Ok(value)) if Ok(Some), None if Ok(None), Some(Err) if Err\n * @example\n * transpose(ok(some(42)))  // Some(Ok(42))\n * transpose(ok(none))      // None\n * transpose(err('e'))      // Some(Err('e'))\n */\nexport function transpose<T, E>(result: Result<Option<T>, E>): Option<Result<T, E>> {\n  if (isErr(result)) {\n    return ERR((result as Err<E>).error) as Option<Result<T, E>>;\n  }\n  const opt = result as Option<T>;\n  return isNone(opt) ? NONE : (opt as unknown as Ok<T> as Option<Result<T, E>>);\n}\n\n/**\n * Checks if Ok and the value satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Ok and predicate returns true\n * @example\n * isOkAnd(ok(4), x => x > 2)   // true\n * isOkAnd(ok(1), x => x > 2)   // false\n * isOkAnd(err('e'), x => x > 2) // false\n */\nexport function isOkAnd<T, E>(result: Result<T, E>, predicate: (value: T) => boolean): boolean {\n  return isOk(result) && predicate(result);\n}\n\n/**\n * Checks if Err and the error satisfies a predicate.\n * @param result - The Result to check\n * @param predicate - Test function\n * @returns true if Err and predicate returns true\n * @example\n * isErrAnd(err('fatal'), e => e.includes('fatal')) // true\n * isErrAnd(ok(42), e => true)                       // false\n */\nexport function isErrAnd<T, E>(result: Result<T, E>, predicate: (error: E) => boolean): boolean {\n  return isErr(result) && predicate((result as Err<E>).error);\n}\n\n/**\n * Maps an async function over an Ok value.\n * @param result - The Result to map\n * @param fn - Async transform function\n * @param onRejected - Optional rejection handler\n * @returns Promise of mapped Result\n * @example\n * await mapAsync(ok(2), async x => x * 2) // Ok(4)\n */\nexport async function mapAsync<T, U, E = unknown>(\n  result: Result<T, E>,\n  fn: (value: T) => Promise<U>,\n  onRejected?: (error: unknown) => E,\n): Promise<Result<U, E>> {\n  if (isErr(result)) return result as Err<E>;\n  return fromPromise(fn(result as Ok<T>), onRejected);\n}\n\n/**\n * Chains an async Result-returning function.\n * @param result - The Result to chain\n * @param fn - Async function returning a Result\n * @returns Promise of the chained Result\n * @example\n * await andThenAsync(ok(2), async x => ok(x * 2)) // Ok(4)\n */\nexport async function andThenAsync<T, U, E>(result: Result<T, E>, fn: (value: T) => Promise<Result<U, E>>): Promise<Result<U, E>> {\n  if (isErr(result)) return result as Err<E>;\n  return fn(result as Ok<T>);\n}\n\n/**\n * Pattern matches with async handlers.\n * @param result - The Result to match\n * @param onOk - Async handler for Ok\n * @param onErr - Async handler for Err\n * @returns Promise of the handler result\n */\nexport async function matchAsync<T, E, U>(result: Result<T, E>, onOk: (value: T) => Promise<U>, onErr: (error: E) => Promise<U>): Promise<U> {\n  return isOk(result) ? onOk(result) : onErr(result.error);\n}\n\n/**\n * Partitions an async iterable of Results.\n * @param results - Iterable of Promise Results\n * @returns Promise of [Ok values, Err values]\n * @example\n * await partitionAsync([Promise.resolve(ok(1)), Promise.resolve(err('a'))])\n * // [[1], ['a']]\n */\nexport async function partitionAsync<T, E>(results: Iterable<Promise<Result<T, E>>>): Promise<[Widen<T>[], WidenNever<E>[]]> {\n  const oks: Widen<T>[] = [];\n  const errs: WidenNever<E>[] = [];\n\n  for (const promise of results) {\n    const result = await promise;\n    if (isOk(result)) {\n      oks.push(result as Ok<Widen<T>>);\n    } else {\n      errs.push((result as Err<WidenNever<E>>).error);\n    }\n  }\n\n  return [oks, errs];\n}\n"],"names":["err","ERR","isOk","isErr","isSome","isNone","NONE","optionOf","tryCatch","fn","onError","error","of","tryAsync","ofAsync","fromPromise","promise","onRejected","unwrapOrReturn","result","onErr","assertOk","message","Error","String","assertErr","isSomeErr","map","mapErr","flatMap","andThen","tap","tapErr","bimap","okFn","errFn","unwrap","unwrapErr","unwrapOr","defaultValue","unwrapOrElse","mapOr","mapOrElse","defaultFn","expect","expectErr","and","other","or","orElse","toOption","toErrorOption","zip","left","right","zipWith","flatten","match","onOk","partition","results","oks","errs","push","collect","values","collectAll","length","all","any","len","errors","Array","i","transpose","opt","isOkAnd","predicate","isErrAnd","mapAsync","andThenAsync","matchAsync","partitionAsync"],"mappings":"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"}

package/build/safe.cjs

@@ -0,0 +1,88 @@
+"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 Option () {
+        return _optioncjs;
+    },
+    get Result () {
+        return _resultcjs;
+    },
+    get err () {
+        return _typescjs.err;
+    },
+    get none () {
+        return _typescjs.none;
+    },
+    get ok () {
+        return ok;
+    },
+    get some () {
+        return some;
+    }
+});
+const _typescjs = require("./types.cjs");
+const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
+const _resultcjs = /*#__PURE__*/ _interop_require_wildcard(require("./result.cjs"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function some(value) {
+    if (value === null || value === undefined) {
+        throw new TypeError('some() requires a non-nullable value');
+    }
+    return (0, _typescjs.some)(value);
+}
+function ok(value) {
+    if ((0, _typescjs.isErr)(value)) {
+        throw new TypeError('ok() cannot wrap an Err value');
+    }
+    return (0, _typescjs.ok)(value);
+}
+
+//# sourceMappingURL=safe.cjs.map

package/build/safe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["import { some as someUnsafe, ok as okUnsafe, err, none, isErr } from './types.js';\nimport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  ValueType,\n} from './types.js';\n\nexport type { Some, None, Ok, Err, OptionType, OptionValue, IsOption, InferSome, ResultType, ResultValue, ResultErrorType, IsResult, InferErr };\n\nexport { none, err };\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n\n/**\n * Creates a Some value with runtime validation.\n * Throws if the value is null or undefined.\n * @param value - The value to wrap (must be non-nullable)\n * @returns The value typed as Some\n * @throws {TypeError} If value is null or undefined\n * @example\n * some(42)        // Some(42)\n * some(null)      // throws TypeError\n * some(undefined) // throws TypeError\n */\nexport function some<T>(value: T): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnsafe(value as ValueType<T>);\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * Throws if the value is an Err (prevents accidental double-wrapping).\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws {TypeError} If value is an Err\n * @example\n * ok(42)           // Ok(42)\n * ok(err('fail'))  // throws TypeError\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnsafe(value);\n}\n"],"names":["Option","Result","err","none","ok","some","value","undefined","TypeError","someUnsafe","isErr","okUnsafe"],"mappings":";;;;;;;;;;;QAqBYA;;;QACAC;;;QAFGC;eAAAA,aAAG;;QAATC;eAAAA,cAAI;;QAgCGC;eAAAA;;QAjBAC;eAAAA;;;0BAnCqD;mEAqB7C;mEACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAajB,SAASA,KAAQC,KAAQ;IAC9B,IAAIA,UAAU,QAAQA,UAAUC,WAAW;QACzC,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOC,IAAAA,cAAU,EAACH;AACpB;AAYO,SAASF,GAAME,KAAQ;IAC5B,IAAII,IAAAA,eAAK,EAACJ,QAAQ;QAChB,MAAM,IAAIE,UAAU;IACtB;IACA,OAAOG,IAAAA,YAAQ,EAACL;AAClB"}

package/build/safe.d.ts

@@ -0,0 +1,29 @@
+import { err, none } from './types.js';
+import type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, ValueType } from './types.js';
+export type { Some, None, Ok, Err, OptionType, OptionValue, IsOption, InferSome, ResultType, ResultValue, ResultErrorType, IsResult, InferErr };
+export { none, err };
+export * as Option from './option.js';
+export * as Result from './result.js';
+/**
+ * Creates a Some value with runtime validation.
+ * Throws if the value is null or undefined.
+ * @param value - The value to wrap (must be non-nullable)
+ * @returns The value typed as Some
+ * @throws {TypeError} If value is null or undefined
+ * @example
+ * some(42)        // Some(42)
+ * some(null)      // throws TypeError
+ * some(undefined) // throws TypeError
+ */
+export declare function some<T>(value: T): Some<ValueType<T>>;
+/**
+ * Creates an Ok value with runtime validation.
+ * Throws if the value is an Err (prevents accidental double-wrapping).
+ * @param value - The success value
+ * @returns The value typed as Ok
+ * @throws {TypeError} If value is an Err
+ * @example
+ * ok(42)           // Ok(42)
+ * ok(err('fail'))  // throws TypeError
+ */
+export declare function ok<T>(value: T): Ok<T>;

package/build/safe.js

@@ -0,0 +1,18 @@
+import { some as someUnsafe, ok as okUnsafe, err, none, isErr } from "./types.js";
+export { none, err };
+export * as Option from "./option.js";
+export * as Result from "./result.js";
+export function some(value) {
+    if (value === null || value === undefined) {
+        throw new TypeError('some() requires a non-nullable value');
+    }
+    return someUnsafe(value);
+}
+export function ok(value) {
+    if (isErr(value)) {
+        throw new TypeError('ok() cannot wrap an Err value');
+    }
+    return okUnsafe(value);
+}
+
+//# sourceMappingURL=safe.js.map

package/build/safe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/safe.ts"],"sourcesContent":["import { some as someUnsafe, ok as okUnsafe, err, none, isErr } from './types.js';\nimport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n  ValueType,\n} from './types.js';\n\nexport type { Some, None, Ok, Err, OptionType, OptionValue, IsOption, InferSome, ResultType, ResultValue, ResultErrorType, IsResult, InferErr };\n\nexport { none, err };\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n\n/**\n * Creates a Some value with runtime validation.\n * Throws if the value is null or undefined.\n * @param value - The value to wrap (must be non-nullable)\n * @returns The value typed as Some\n * @throws {TypeError} If value is null or undefined\n * @example\n * some(42)        // Some(42)\n * some(null)      // throws TypeError\n * some(undefined) // throws TypeError\n */\nexport function some<T>(value: T): Some<ValueType<T>> {\n  if (value === null || value === undefined) {\n    throw new TypeError('some() requires a non-nullable value');\n  }\n  return someUnsafe(value as ValueType<T>);\n}\n\n/**\n * Creates an Ok value with runtime validation.\n * Throws if the value is an Err (prevents accidental double-wrapping).\n * @param value - The success value\n * @returns The value typed as Ok\n * @throws {TypeError} If value is an Err\n * @example\n * ok(42)           // Ok(42)\n * ok(err('fail'))  // throws TypeError\n */\nexport function ok<T>(value: T): Ok<T> {\n  if (isErr(value)) {\n    throw new TypeError('ok() cannot wrap an Err value');\n  }\n  return okUnsafe(value);\n}\n"],"names":["some","someUnsafe","ok","okUnsafe","err","none","isErr","Option","Result","value","undefined","TypeError"],"mappings":"AAAA,SAASA,QAAQC,UAAU,EAAEC,MAAMC,QAAQ,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,QAAQ,aAAa;AAoBlF,SAASD,IAAI,EAAED,GAAG,GAAG;AACrB,OAAO,KAAKG,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc;AAatC,OAAO,SAASR,KAAQS,KAAQ;IAC9B,IAAIA,UAAU,QAAQA,UAAUC,WAAW;QACzC,MAAM,IAAIC,UAAU;IACtB;IACA,OAAOV,WAAWQ;AACpB;AAYA,OAAO,SAASP,GAAMO,KAAQ;IAC5B,IAAIH,MAAMG,QAAQ;QAChB,MAAM,IAAIE,UAAU;IACtB;IACA,OAAOR,SAASM;AAClB"}

package/build/testing.cjs

@@ -0,0 +1,111 @@
+"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 expectErr () {
+        return expectErr;
+    },
+    get expectNone () {
+        return expectNone;
+    },
+    get expectOk () {
+        return expectOk;
+    },
+    get expectSome () {
+        return expectSome;
+    },
+    get extendExpect () {
+        return extendExpect;
+    },
+    get matchers () {
+        return matchers;
+    }
+});
+const _typescjs = require("./types.cjs");
+const _devtoolscjs = require("./devtools.cjs");
+function expectOk(result, message) {
+    if ((0, _typescjs.isOk)(result)) {
+        return result;
+    }
+    const fallback = message ?? `Expected Ok(...) but received ${(0, _devtoolscjs.formatResult)(result)}`;
+    throw new Error(fallback);
+}
+function expectErr(result, message) {
+    if ((0, _typescjs.isErr)(result)) {
+        return result.error;
+    }
+    const fallback = message ?? `Expected Err(...) but received ${(0, _devtoolscjs.formatResult)(result)}`;
+    throw new Error(fallback);
+}
+function expectSome(opt, message) {
+    if ((0, _typescjs.isSome)(opt)) {
+        return opt;
+    }
+    const fallback = message ?? `Expected Some(...) but received ${(0, _devtoolscjs.formatOption)(opt)}`;
+    throw new Error(fallback);
+}
+function expectNone(opt, message) {
+    if ((0, _typescjs.isNone)(opt)) {
+        return;
+    }
+    const fallback = message ?? `Expected None but received ${(0, _devtoolscjs.formatOption)(opt)}`;
+    throw new Error(fallback);
+}
+const resultMatchers = {
+    toBeOk (received) {
+        const pass = (0, _typescjs.isOk)(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Result is Ok as expected.' : `Expected Ok(...) but received ${(0, _devtoolscjs.formatResult)(received)}`
+        };
+    },
+    toBeErr (received) {
+        const pass = (0, _typescjs.isErr)(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Result is Err as expected.' : `Expected Err(...) but received ${(0, _devtoolscjs.formatResult)(received)}`
+        };
+    },
+    toContainErr (received, expected) {
+        const pass = (0, _typescjs.isErr)(received) && received.error === expected;
+        return {
+            pass,
+            message: ()=>{
+                if (pass) return `Err matched expected value ${String(expected)}.`;
+                return `Expected Err(${String(expected)}) but received ${(0, _devtoolscjs.formatResult)(received)}`;
+            }
+        };
+    }
+};
+const optionMatchers = {
+    toBeSome (received) {
+        const pass = (0, _typescjs.isSome)(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Option is Some as expected.' : `Expected Some(...) but received ${(0, _devtoolscjs.formatOption)(received)}`
+        };
+    },
+    toBeNone (received) {
+        const pass = (0, _typescjs.isNone)(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Option is None as expected.' : `Expected None but received ${(0, _devtoolscjs.formatOption)(received)}`
+        };
+    }
+};
+const matchers = {
+    ...resultMatchers,
+    ...optionMatchers
+};
+function extendExpect(expectLike) {
+    expectLike.extend(matchers);
+}
+
+//# sourceMappingURL=testing.cjs.map

package/build/testing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing.ts"],"sourcesContent":["import { isOk, isErr, isSome, isNone, Result, Err, Option } from './types.js';\nimport { formatOption, formatResult } from './devtools.js';\n\n/** Result shape returned by custom matchers. */\ntype MatcherResult = { pass: boolean; message(): string };\n\n/**\n * Asserts that a Result is Ok and returns the value.\n * Throws if the Result is Err.\n * @param result - The Result to check\n * @param message - Optional custom error message\n * @returns The Ok value\n * @throws {Error} If the Result is Err\n * @example\n * expectOk(ok(42))        // returns 42\n * expectOk(err('fail'))   // throws Error\n */\nexport function expectOk<T, E>(result: Result<T, E>, message?: string): T {\n  if (isOk(result)) {\n    return result;\n  }\n\n  const fallback = message ?? `Expected Ok(...) but received ${formatResult(result)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that a Result is Err and returns the error.\n * Throws if the Result is Ok.\n * @param result - The Result to check\n * @param message - Optional custom error message\n * @returns The error value\n * @throws {Error} If the Result is Ok\n * @example\n * expectErr(err('fail'))  // returns 'fail'\n * expectErr(ok(42))       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message?: string): E {\n  if (isErr(result)) {\n    return (result as Err<E>).error;\n  }\n\n  const fallback = message ?? `Expected Err(...) but received ${formatResult(result)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that an Option is Some and returns the value.\n * Throws if the Option is None.\n * @param opt - The Option to check\n * @param message - Optional custom error message\n * @returns The Some value\n * @throws {Error} If the Option is None\n * @example\n * expectSome(42)   // returns 42\n * expectSome(null) // throws Error\n */\nexport function expectSome<T>(opt: Option<T>, message?: string): T {\n  if (isSome(opt)) {\n    return opt;\n  }\n  const fallback = message ?? `Expected Some(...) but received ${formatOption(opt)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that an Option is None.\n * Throws if the Option is Some.\n * @param opt - The Option to check\n * @param message - Optional custom error message\n * @throws {Error} If the Option is Some\n * @example\n * expectNone(null) // succeeds\n * expectNone(42)   // throws Error\n */\nexport function expectNone<T>(opt: Option<T>, message?: string): void {\n  if (isNone(opt)) {\n    return;\n  }\n  const fallback = message ?? `Expected None but received ${formatOption(opt)}`;\n  throw new Error(fallback);\n}\n\nconst resultMatchers = {\n  toBeOk(this: unknown, received: Result<unknown, unknown>): MatcherResult {\n    const pass = isOk(received);\n    return {\n      pass,\n      message: () => (pass ? 'Result is Ok as expected.' : `Expected Ok(...) but received ${formatResult(received)}`),\n    };\n  },\n  toBeErr(this: unknown, received: Result<unknown, unknown>): MatcherResult {\n    const pass = isErr(received);\n    return {\n      pass,\n      message: () => (pass ? 'Result is Err as expected.' : `Expected Err(...) but received ${formatResult(received)}`),\n    };\n  },\n  toContainErr(this: unknown, received: Result<unknown, unknown>, expected: unknown): MatcherResult {\n    const pass = isErr(received) && (received as Err<unknown>).error === expected;\n    return {\n      pass,\n      message: () => {\n        if (pass) return `Err matched expected value ${String(expected)}.`;\n        return `Expected Err(${String(expected)}) but received ${formatResult(received)}`;\n      },\n    };\n  },\n};\n\nconst optionMatchers = {\n  toBeSome(this: unknown, received: Option<unknown>): MatcherResult {\n    const pass = isSome(received);\n    return {\n      pass,\n      message: () => (pass ? 'Option is Some as expected.' : `Expected Some(...) but received ${formatOption(received)}`),\n    };\n  },\n  toBeNone(this: unknown, received: Option<unknown>): MatcherResult {\n    const pass = isNone(received);\n    return {\n      pass,\n      message: () => (pass ? 'Option is None as expected.' : `Expected None but received ${formatOption(received)}`),\n    };\n  },\n};\n\n/**\n * Custom matchers for Jest/Vitest.\n * Includes toBeOk, toBeErr, toContainErr, toBeSome, toBeNone.\n * Use with expect.extend(matchers) or extendExpect(expect).\n */\nexport const matchers = {\n  ...resultMatchers,\n  ...optionMatchers,\n};\n\n/** Interface for test frameworks with an extend method (Jest, Vitest). */\nexport type ExpectLike = {\n  extend(matchers: Record<string, (...args: any[]) => MatcherResult>): void;\n};\n\n/**\n * Extends a test framework's expect with Option and Result matchers.\n * @param expectLike - The expect object to extend (Jest/Vitest)\n * @example\n * import { expect } from 'vitest';\n * import { extendExpect } from 'nalloc/testing';\n * extendExpect(expect);\n *\n * // Now you can use:\n * expect(result).toBeOk();\n * expect(result).toBeErr();\n * expect(option).toBeSome();\n * expect(option).toBeNone();\n */\nexport function extendExpect(expectLike: ExpectLike): void {\n  expectLike.extend(matchers);\n}\n"],"names":["expectErr","expectNone","expectOk","expectSome","extendExpect","matchers","result","message","isOk","fallback","formatResult","Error","isErr","error","opt","isSome","formatOption","isNone","resultMatchers","toBeOk","received","pass","toBeErr","toContainErr","expected","String","optionMatchers","toBeSome","toBeNone","expectLike","extend"],"mappings":";;;;;;;;;;;QAqCgBA;eAAAA;;QAsCAC;eAAAA;;QA1DAC;eAAAA;;QAwCAC;eAAAA;;QAmGAC;eAAAA;;QAxBHC;eAAAA;;;0BApIoD;6BACtB;AAgBpC,SAASH,SAAeI,MAAoB,EAAEC,OAAgB;IACnE,IAAIC,IAAAA,cAAI,EAACF,SAAS;QAChB,OAAOA;IACT;IAEA,MAAMG,WAAWF,WAAW,CAAC,8BAA8B,EAAEG,IAAAA,yBAAY,EAACJ,SAAS;IACnF,MAAM,IAAIK,MAAMF;AAClB;AAaO,SAAST,UAAgBM,MAAoB,EAAEC,OAAgB;IACpE,IAAIK,IAAAA,eAAK,EAACN,SAAS;QACjB,OAAO,AAACA,OAAkBO,KAAK;IACjC;IAEA,MAAMJ,WAAWF,WAAW,CAAC,+BAA+B,EAAEG,IAAAA,yBAAY,EAACJ,SAAS;IACpF,MAAM,IAAIK,MAAMF;AAClB;AAaO,SAASN,WAAcW,GAAc,EAAEP,OAAgB;IAC5D,IAAIQ,IAAAA,gBAAM,EAACD,MAAM;QACf,OAAOA;IACT;IACA,MAAML,WAAWF,WAAW,CAAC,gCAAgC,EAAES,IAAAA,yBAAY,EAACF,MAAM;IAClF,MAAM,IAAIH,MAAMF;AAClB;AAYO,SAASR,WAAca,GAAc,EAAEP,OAAgB;IAC5D,IAAIU,IAAAA,gBAAM,EAACH,MAAM;QACf;IACF;IACA,MAAML,WAAWF,WAAW,CAAC,2BAA2B,EAAES,IAAAA,yBAAY,EAACF,MAAM;IAC7E,MAAM,IAAIH,MAAMF;AAClB;AAEA,MAAMS,iBAAiB;IACrBC,QAAsBC,QAAkC;QACtD,MAAMC,OAAOb,IAAAA,cAAI,EAACY;QAClB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,8BAA8B,CAAC,8BAA8B,EAAEX,IAAAA,yBAAY,EAACU,WAAW;QAChH;IACF;IACAE,SAAuBF,QAAkC;QACvD,MAAMC,OAAOT,IAAAA,eAAK,EAACQ;QACnB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,+BAA+B,CAAC,+BAA+B,EAAEX,IAAAA,yBAAY,EAACU,WAAW;QAClH;IACF;IACAG,cAA4BH,QAAkC,EAAEI,QAAiB;QAC/E,MAAMH,OAAOT,IAAAA,eAAK,EAACQ,aAAa,AAACA,SAA0BP,KAAK,KAAKW;QACrE,OAAO;YACLH;YACAd,SAAS;gBACP,IAAIc,MAAM,OAAO,CAAC,2BAA2B,EAAEI,OAAOD,UAAU,CAAC,CAAC;gBAClE,OAAO,CAAC,aAAa,EAAEC,OAAOD,UAAU,eAAe,EAAEd,IAAAA,yBAAY,EAACU,WAAW;YACnF;QACF;IACF;AACF;AAEA,MAAMM,iBAAiB;IACrBC,UAAwBP,QAAyB;QAC/C,MAAMC,OAAON,IAAAA,gBAAM,EAACK;QACpB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,gCAAgC,CAAC,gCAAgC,EAAEL,IAAAA,yBAAY,EAACI,WAAW;QACpH;IACF;IACAQ,UAAwBR,QAAyB;QAC/C,MAAMC,OAAOJ,IAAAA,gBAAM,EAACG;QACpB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,gCAAgC,CAAC,2BAA2B,EAAEL,IAAAA,yBAAY,EAACI,WAAW;QAC/G;IACF;AACF;AAOO,MAAMf,WAAW;IACtB,GAAGa,cAAc;IACjB,GAAGQ,cAAc;AACnB;AAqBO,SAAStB,aAAayB,UAAsB;IACjDA,WAAWC,MAAM,CAACzB;AACpB"}

package/build/testing.d.ts

@@ -0,0 +1,85 @@
+import { Result, Option } from './types.js';
+/** Result shape returned by custom matchers. */
+type MatcherResult = {
+    pass: boolean;
+    message(): string;
+};
+/**
+ * Asserts that a Result is Ok and returns the value.
+ * Throws if the Result is Err.
+ * @param result - The Result to check
+ * @param message - Optional custom error message
+ * @returns The Ok value
+ * @throws {Error} If the Result is Err
+ * @example
+ * expectOk(ok(42))        // returns 42
+ * expectOk(err('fail'))   // throws Error
+ */
+export declare function expectOk<T, E>(result: Result<T, E>, message?: string): T;
+/**
+ * Asserts that a Result is Err and returns the error.
+ * Throws if the Result is Ok.
+ * @param result - The Result to check
+ * @param message - Optional custom error message
+ * @returns The error value
+ * @throws {Error} If the Result is Ok
+ * @example
+ * expectErr(err('fail'))  // returns 'fail'
+ * expectErr(ok(42))       // throws Error
+ */
+export declare function expectErr<T, E>(result: Result<T, E>, message?: string): E;
+/**
+ * Asserts that an Option is Some and returns the value.
+ * Throws if the Option is None.
+ * @param opt - The Option to check
+ * @param message - Optional custom error message
+ * @returns The Some value
+ * @throws {Error} If the Option is None
+ * @example
+ * expectSome(42)   // returns 42
+ * expectSome(null) // throws Error
+ */
+export declare function expectSome<T>(opt: Option<T>, message?: string): T;
+/**
+ * Asserts that an Option is None.
+ * Throws if the Option is Some.
+ * @param opt - The Option to check
+ * @param message - Optional custom error message
+ * @throws {Error} If the Option is Some
+ * @example
+ * expectNone(null) // succeeds
+ * expectNone(42)   // throws Error
+ */
+export declare function expectNone<T>(opt: Option<T>, message?: string): void;
+/**
+ * Custom matchers for Jest/Vitest.
+ * Includes toBeOk, toBeErr, toContainErr, toBeSome, toBeNone.
+ * Use with expect.extend(matchers) or extendExpect(expect).
+ */
+export declare const matchers: {
+    toBeSome(this: unknown, received: Option<unknown>): MatcherResult;
+    toBeNone(this: unknown, received: Option<unknown>): MatcherResult;
+    toBeOk(this: unknown, received: Result<unknown, unknown>): MatcherResult;
+    toBeErr(this: unknown, received: Result<unknown, unknown>): MatcherResult;
+    toContainErr(this: unknown, received: Result<unknown, unknown>, expected: unknown): MatcherResult;
+};
+/** Interface for test frameworks with an extend method (Jest, Vitest). */
+export type ExpectLike = {
+    extend(matchers: Record<string, (...args: any[]) => MatcherResult>): void;
+};
+/**
+ * Extends a test framework's expect with Option and Result matchers.
+ * @param expectLike - The expect object to extend (Jest/Vitest)
+ * @example
+ * import { expect } from 'vitest';
+ * import { extendExpect } from 'nalloc/testing';
+ * extendExpect(expect);
+ *
+ * // Now you can use:
+ * expect(result).toBeOk();
+ * expect(result).toBeErr();
+ * expect(option).toBeSome();
+ * expect(option).toBeNone();
+ */
+export declare function extendExpect(expectLike: ExpectLike): void;
+export {};

package/build/testing.js

@@ -0,0 +1,81 @@
+import { isOk, isErr, isSome, isNone } from "./types.js";
+import { formatOption, formatResult } from "./devtools.js";
+export function expectOk(result, message) {
+    if (isOk(result)) {
+        return result;
+    }
+    const fallback = message ?? `Expected Ok(...) but received ${formatResult(result)}`;
+    throw new Error(fallback);
+}
+export function expectErr(result, message) {
+    if (isErr(result)) {
+        return result.error;
+    }
+    const fallback = message ?? `Expected Err(...) but received ${formatResult(result)}`;
+    throw new Error(fallback);
+}
+export function expectSome(opt, message) {
+    if (isSome(opt)) {
+        return opt;
+    }
+    const fallback = message ?? `Expected Some(...) but received ${formatOption(opt)}`;
+    throw new Error(fallback);
+}
+export function expectNone(opt, message) {
+    if (isNone(opt)) {
+        return;
+    }
+    const fallback = message ?? `Expected None but received ${formatOption(opt)}`;
+    throw new Error(fallback);
+}
+const resultMatchers = {
+    toBeOk (received) {
+        const pass = isOk(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Result is Ok as expected.' : `Expected Ok(...) but received ${formatResult(received)}`
+        };
+    },
+    toBeErr (received) {
+        const pass = isErr(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Result is Err as expected.' : `Expected Err(...) but received ${formatResult(received)}`
+        };
+    },
+    toContainErr (received, expected) {
+        const pass = isErr(received) && received.error === expected;
+        return {
+            pass,
+            message: ()=>{
+                if (pass) return `Err matched expected value ${String(expected)}.`;
+                return `Expected Err(${String(expected)}) but received ${formatResult(received)}`;
+            }
+        };
+    }
+};
+const optionMatchers = {
+    toBeSome (received) {
+        const pass = isSome(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Option is Some as expected.' : `Expected Some(...) but received ${formatOption(received)}`
+        };
+    },
+    toBeNone (received) {
+        const pass = isNone(received);
+        return {
+            pass,
+            message: ()=>pass ? 'Option is None as expected.' : `Expected None but received ${formatOption(received)}`
+        };
+    }
+};
+export const matchers = {
+    ...resultMatchers,
+    ...optionMatchers
+};
+export function extendExpect(expectLike) {
+    expectLike.extend(matchers);
+}
+
+//# sourceMappingURL=testing.js.map

package/build/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing.ts"],"sourcesContent":["import { isOk, isErr, isSome, isNone, Result, Err, Option } from './types.js';\nimport { formatOption, formatResult } from './devtools.js';\n\n/** Result shape returned by custom matchers. */\ntype MatcherResult = { pass: boolean; message(): string };\n\n/**\n * Asserts that a Result is Ok and returns the value.\n * Throws if the Result is Err.\n * @param result - The Result to check\n * @param message - Optional custom error message\n * @returns The Ok value\n * @throws {Error} If the Result is Err\n * @example\n * expectOk(ok(42))        // returns 42\n * expectOk(err('fail'))   // throws Error\n */\nexport function expectOk<T, E>(result: Result<T, E>, message?: string): T {\n  if (isOk(result)) {\n    return result;\n  }\n\n  const fallback = message ?? `Expected Ok(...) but received ${formatResult(result)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that a Result is Err and returns the error.\n * Throws if the Result is Ok.\n * @param result - The Result to check\n * @param message - Optional custom error message\n * @returns The error value\n * @throws {Error} If the Result is Ok\n * @example\n * expectErr(err('fail'))  // returns 'fail'\n * expectErr(ok(42))       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message?: string): E {\n  if (isErr(result)) {\n    return (result as Err<E>).error;\n  }\n\n  const fallback = message ?? `Expected Err(...) but received ${formatResult(result)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that an Option is Some and returns the value.\n * Throws if the Option is None.\n * @param opt - The Option to check\n * @param message - Optional custom error message\n * @returns The Some value\n * @throws {Error} If the Option is None\n * @example\n * expectSome(42)   // returns 42\n * expectSome(null) // throws Error\n */\nexport function expectSome<T>(opt: Option<T>, message?: string): T {\n  if (isSome(opt)) {\n    return opt;\n  }\n  const fallback = message ?? `Expected Some(...) but received ${formatOption(opt)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that an Option is None.\n * Throws if the Option is Some.\n * @param opt - The Option to check\n * @param message - Optional custom error message\n * @throws {Error} If the Option is Some\n * @example\n * expectNone(null) // succeeds\n * expectNone(42)   // throws Error\n */\nexport function expectNone<T>(opt: Option<T>, message?: string): void {\n  if (isNone(opt)) {\n    return;\n  }\n  const fallback = message ?? `Expected None but received ${formatOption(opt)}`;\n  throw new Error(fallback);\n}\n\nconst resultMatchers = {\n  toBeOk(this: unknown, received: Result<unknown, unknown>): MatcherResult {\n    const pass = isOk(received);\n    return {\n      pass,\n      message: () => (pass ? 'Result is Ok as expected.' : `Expected Ok(...) but received ${formatResult(received)}`),\n    };\n  },\n  toBeErr(this: unknown, received: Result<unknown, unknown>): MatcherResult {\n    const pass = isErr(received);\n    return {\n      pass,\n      message: () => (pass ? 'Result is Err as expected.' : `Expected Err(...) but received ${formatResult(received)}`),\n    };\n  },\n  toContainErr(this: unknown, received: Result<unknown, unknown>, expected: unknown): MatcherResult {\n    const pass = isErr(received) && (received as Err<unknown>).error === expected;\n    return {\n      pass,\n      message: () => {\n        if (pass) return `Err matched expected value ${String(expected)}.`;\n        return `Expected Err(${String(expected)}) but received ${formatResult(received)}`;\n      },\n    };\n  },\n};\n\nconst optionMatchers = {\n  toBeSome(this: unknown, received: Option<unknown>): MatcherResult {\n    const pass = isSome(received);\n    return {\n      pass,\n      message: () => (pass ? 'Option is Some as expected.' : `Expected Some(...) but received ${formatOption(received)}`),\n    };\n  },\n  toBeNone(this: unknown, received: Option<unknown>): MatcherResult {\n    const pass = isNone(received);\n    return {\n      pass,\n      message: () => (pass ? 'Option is None as expected.' : `Expected None but received ${formatOption(received)}`),\n    };\n  },\n};\n\n/**\n * Custom matchers for Jest/Vitest.\n * Includes toBeOk, toBeErr, toContainErr, toBeSome, toBeNone.\n * Use with expect.extend(matchers) or extendExpect(expect).\n */\nexport const matchers = {\n  ...resultMatchers,\n  ...optionMatchers,\n};\n\n/** Interface for test frameworks with an extend method (Jest, Vitest). */\nexport type ExpectLike = {\n  extend(matchers: Record<string, (...args: any[]) => MatcherResult>): void;\n};\n\n/**\n * Extends a test framework's expect with Option and Result matchers.\n * @param expectLike - The expect object to extend (Jest/Vitest)\n * @example\n * import { expect } from 'vitest';\n * import { extendExpect } from 'nalloc/testing';\n * extendExpect(expect);\n *\n * // Now you can use:\n * expect(result).toBeOk();\n * expect(result).toBeErr();\n * expect(option).toBeSome();\n * expect(option).toBeNone();\n */\nexport function extendExpect(expectLike: ExpectLike): void {\n  expectLike.extend(matchers);\n}\n"],"names":["isOk","isErr","isSome","isNone","formatOption","formatResult","expectOk","result","message","fallback","Error","expectErr","error","expectSome","opt","expectNone","resultMatchers","toBeOk","received","pass","toBeErr","toContainErr","expected","String","optionMatchers","toBeSome","toBeNone","matchers","extendExpect","expectLike","extend"],"mappings":"AAAA,SAASA,IAAI,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,QAA6B,aAAa;AAC9E,SAASC,YAAY,EAAEC,YAAY,QAAQ,gBAAgB;AAgB3D,OAAO,SAASC,SAAeC,MAAoB,EAAEC,OAAgB;IACnE,IAAIR,KAAKO,SAAS;QAChB,OAAOA;IACT;IAEA,MAAME,WAAWD,WAAW,CAAC,8BAA8B,EAAEH,aAAaE,SAAS;IACnF,MAAM,IAAIG,MAAMD;AAClB;AAaA,OAAO,SAASE,UAAgBJ,MAAoB,EAAEC,OAAgB;IACpE,IAAIP,MAAMM,SAAS;QACjB,OAAO,AAACA,OAAkBK,KAAK;IACjC;IAEA,MAAMH,WAAWD,WAAW,CAAC,+BAA+B,EAAEH,aAAaE,SAAS;IACpF,MAAM,IAAIG,MAAMD;AAClB;AAaA,OAAO,SAASI,WAAcC,GAAc,EAAEN,OAAgB;IAC5D,IAAIN,OAAOY,MAAM;QACf,OAAOA;IACT;IACA,MAAML,WAAWD,WAAW,CAAC,gCAAgC,EAAEJ,aAAaU,MAAM;IAClF,MAAM,IAAIJ,MAAMD;AAClB;AAYA,OAAO,SAASM,WAAcD,GAAc,EAAEN,OAAgB;IAC5D,IAAIL,OAAOW,MAAM;QACf;IACF;IACA,MAAML,WAAWD,WAAW,CAAC,2BAA2B,EAAEJ,aAAaU,MAAM;IAC7E,MAAM,IAAIJ,MAAMD;AAClB;AAEA,MAAMO,iBAAiB;IACrBC,QAAsBC,QAAkC;QACtD,MAAMC,OAAOnB,KAAKkB;QAClB,OAAO;YACLC;YACAX,SAAS,IAAOW,OAAO,8BAA8B,CAAC,8BAA8B,EAAEd,aAAaa,WAAW;QAChH;IACF;IACAE,SAAuBF,QAAkC;QACvD,MAAMC,OAAOlB,MAAMiB;QACnB,OAAO;YACLC;YACAX,SAAS,IAAOW,OAAO,+BAA+B,CAAC,+BAA+B,EAAEd,aAAaa,WAAW;QAClH;IACF;IACAG,cAA4BH,QAAkC,EAAEI,QAAiB;QAC/E,MAAMH,OAAOlB,MAAMiB,aAAa,AAACA,SAA0BN,KAAK,KAAKU;QACrE,OAAO;YACLH;YACAX,SAAS;gBACP,IAAIW,MAAM,OAAO,CAAC,2BAA2B,EAAEI,OAAOD,UAAU,CAAC,CAAC;gBAClE,OAAO,CAAC,aAAa,EAAEC,OAAOD,UAAU,eAAe,EAAEjB,aAAaa,WAAW;YACnF;QACF;IACF;AACF;AAEA,MAAMM,iBAAiB;IACrBC,UAAwBP,QAAyB;QAC/C,MAAMC,OAAOjB,OAAOgB;QACpB,OAAO;YACLC;YACAX,SAAS,IAAOW,OAAO,gCAAgC,CAAC,gCAAgC,EAAEf,aAAac,WAAW;QACpH;IACF;IACAQ,UAAwBR,QAAyB;QAC/C,MAAMC,OAAOhB,OAAOe;QACpB,OAAO;YACLC;YACAX,SAAS,IAAOW,OAAO,gCAAgC,CAAC,2BAA2B,EAAEf,aAAac,WAAW;QAC/G;IACF;AACF;AAOA,OAAO,MAAMS,WAAW;IACtB,GAAGX,cAAc;IACjB,GAAGQ,cAAc;AACnB,EAAE;AAqBF,OAAO,SAASI,aAAaC,UAAsB;IACjDA,WAAWC,MAAM,CAACH;AACpB"}

package/build/types.cjs

@@ -0,0 +1,78 @@
+"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 NONE () {
+        return NONE;
+    },
+    get err () {
+        return err;
+    },
+    get isErr () {
+        return isErr;
+    },
+    get isNone () {
+        return isNone;
+    },
+    get isOk () {
+        return isOk;
+    },
+    get isSome () {
+        return isSome;
+    },
+    get none () {
+        return none;
+    },
+    get ok () {
+        return ok;
+    },
+    get optionOf () {
+        return optionOf;
+    },
+    get some () {
+        return some;
+    }
+});
+const NONE = undefined;
+function isSome(opt) {
+    return opt !== null && opt !== undefined;
+}
+function isNone(opt) {
+    return opt === null || opt === undefined;
+}
+function optionOf(value) {
+    return isNone(value) ? NONE : value;
+}
+function some(value) {
+    return value;
+}
+const none = NONE;
+const ERR_BRAND = Symbol.for('nalloc.ResultError');
+function ResultErrorCtor(error) {
+    this.error = error;
+}
+ResultErrorCtor.prototype[ERR_BRAND] = true;
+function hasErrBrand(value) {
+    return value?.[ERR_BRAND] === true;
+}
+function isOk(result) {
+    return !hasErrBrand(result);
+}
+function isErr(result) {
+    return hasErrBrand(result);
+}
+function ok(value) {
+    return value;
+}
+function err(error) {
+    return new ResultErrorCtor(error);
+}
+
+//# sourceMappingURL=types.cjs.map

package/build/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/** Values that represent None (absence of a value). */\nexport type NoneValueType = null | undefined | void;\n\n/** Widens literal types to their base types for better type inference. */\nexport type Widen<T> = T extends string\n  ? string\n  : T extends number\n    ? number\n    : T extends boolean\n      ? boolean\n      : T extends bigint\n        ? bigint\n        : T extends symbol\n          ? symbol\n          : T;\n\n/** Widens never to unknown, otherwise preserves the type. */\nexport type WidenNever<T> = [T] extends [never] ? unknown : T;\n\n/** Excludes None values from a type, leaving only valid Some values. */\nexport type ValueType<T> = Exclude<T, NoneValueType>;\n\nexport declare const SOME_BRAND: unique symbol;\n\n/** Represents a value that is present. The value itself is the Some - no wrapper object. */\nexport type Some<T> = ValueType<T> & { readonly [SOME_BRAND]: true };\n\n/** Represents the absence of a value (null or undefined). */\nexport type None = NoneValueType & { readonly [SOME_BRAND]: false };\n\n/** Constant representing None. Use this instead of null/undefined for clarity. */\nexport const NONE = undefined as None;\n\n/** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */\nexport type Option<T> = Some<ValueType<T>> | None;\n\n/** Extracts the value type from an Option type. */\nexport type OptionValue<TOption> = TOption extends Option<infer TValue> ? TValue : never;\n\n/** Type predicate: true if T is an Option type. */\nexport type IsOption<T> = T extends Option<any> ? true : false;\n\n/** Infers the Some type from a value, preserving the inner type. */\nexport type InferSome<T> = T extends Some<infer TValue> ? Some<ValueType<TValue>> : never;\n\n/**\n * Checks if an Option contains a value (is Some).\n * @param opt - The Option to check\n * @returns true if the Option is Some, false if None\n * @example\n * isSome(42)        // true\n * isSome(null)      // false\n * isSome(undefined) // false\n */\nexport function isSome<T>(opt: Some<T>): true;\nexport function isSome(opt: None): false;\nexport function isSome<T>(opt: unknown): opt is Some<T>;\nexport function isSome(opt: unknown): boolean {\n  return opt !== null && opt !== undefined;\n}\n\n/**\n * Checks if an Option is None (absent).\n * @param opt - The Option to check\n * @returns true if the Option is None, false if Some\n * @example\n * isNone(null)      // true\n * isNone(undefined) // true\n * isNone(42)        // false\n */\nexport function isNone<T>(opt: Some<T>): false;\nexport function isNone(opt: None): true;\nexport function isNone(opt: unknown): opt is None;\nexport function isNone(opt: unknown): boolean {\n  return opt === null || opt === undefined;\n}\n\n/**\n * Creates an Option from a nullable value. Returns None for null/undefined, Some otherwise.\n * @param value - The value to wrap\n * @returns Some(value) if value is non-null, None otherwise\n * @example\n * optionOf(42)        // Some(42)\n * optionOf(null)      // None\n * optionOf(undefined) // None\n */\nexport function optionOf(value: null): None;\nexport function optionOf(value: undefined): None;\nexport function optionOf<T>(value: T): T extends NoneValueType ? None : Some<T>;\nexport function optionOf<T>(value: T): Option<T> {\n  return isNone(value as Option<T>) ? NONE : (value as Some<T>);\n}\n\n/**\n * Creates a Some value. Does not validate - use safe.some() for validation.\n * @param value - The value to wrap (must be non-null)\n * @returns The value typed as Some\n * @example\n * some(42) // Some(42)\n */\nexport function some<T>(value: ValueType<T>): Some<ValueType<T>> {\n  return value as Some<ValueType<T>>;\n}\n\n/** Constant representing None. Alias for NONE. */\nexport const none: None = NONE;\n\ndeclare const OK_BRAND: unique symbol;\n\n/** Represents a successful Result value. The value itself is the Ok - no wrapper object. */\nexport type Ok<T> = T & { readonly [OK_BRAND]: true };\n\nconst ERR_BRAND = Symbol.for('nalloc.ResultError');\n\ninterface ResultErrorShape<E> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultErrorCtor.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/** The error wrapper type used internally. */\nexport type ResultError<E> = ResultErrorShape<E>;\n\nfunction hasErrBrand(value: unknown): value is ResultError<unknown> {\n  return (value as Record<symbol, unknown>)?.[ERR_BRAND] === true;\n}\n\n/** Represents a failed Result containing an error. */\nexport type Err<E> = ResultError<E>;\n\n/** A value that is either successful (Ok) or failed (Err). Ok is the value itself; Err wraps the error. */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** Extracts the success value type from a Result type. */\nexport type ResultValue<TResult> = TResult extends Result<infer TValue, any> ? TValue : never;\n\n/** Extracts the error type from a Result type. */\nexport type ResultErrorType<TResult> = TResult extends Result<any, infer TError> ? TError : never;\n\n/** Type predicate: true if T is a Result type. */\nexport type IsResult<T> = T extends Result<any, any> ? true : false;\n\n/** Infers the Err type from a value, preserving the error type. */\nexport type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;\n\n/**\n * Checks if a Result is Ok (successful).\n * @param result - The Result to check\n * @returns true if the Result is Ok, false if Err\n * @example\n * isOk(42)           // true (Ok value)\n * isOk(err('fail'))  // false\n */\nexport function isOk<T>(result: Ok<T>): true;\nexport function isOk<E>(result: Err<E>): false;\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T>;\nexport function isOk<T, E>(result: Result<T, E>): boolean {\n  return !hasErrBrand(result);\n}\n\n/**\n * Checks if a Result is Err (failed).\n * @param result - The Result to check\n * @returns true if the Result is Err, false if Ok\n * @example\n * isErr(err('fail')) // true\n * isErr(42)          // false (Ok value)\n */\nexport function isErr<E>(result: Err<E>): true;\nexport function isErr(result: Ok<any>): false;\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E>;\nexport function isErr<T, E>(result: Result<T, E>): boolean {\n  return hasErrBrand(result);\n}\n\n/**\n * Creates an Ok value. Does not validate - use safe.ok() for validation.\n * @param value - The success value\n * @returns The value typed as Ok\n * @example\n * ok(42) // Ok(42)\n */\nexport function ok<T>(value: T): Ok<T> {\n  return value as Ok<T>;\n}\n\n/**\n * Creates an Err value wrapping an error.\n * @param error - The error value\n * @returns An Err containing the error\n * @example\n * err('something went wrong') // Err('something went wrong')\n * err(new Error('failed'))    // Err(Error)\n */\nexport function err<E>(error: E): Err<E> {\n  return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);\n}\n"],"names":["NONE","err","isErr","isNone","isOk","isSome","none","ok","optionOf","some","undefined","opt","value","ERR_BRAND","Symbol","for","ResultErrorCtor","error","prototype","hasErrBrand","result"],"mappings":";;;;;;;;;;;QA+BaA;eAAAA;;QAuKGC;eAAAA;;QAvBAC;eAAAA;;QAtGAC;eAAAA;;QAuFAC;eAAAA;;QAvGAC;eAAAA;;QAgDHC;eAAAA;;QAiFGC;eAAAA;;QAjGAC;eAAAA;;QAWAC;eAAAA;;;AArET,MAAMT,OAAOU;AA0Bb,SAASL,OAAOM,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQD;AACjC;AAcO,SAASP,OAAOQ,GAAY;IACjC,OAAOA,QAAQ,QAAQA,QAAQD;AACjC;AAcO,SAASF,SAAYI,KAAQ;IAClC,OAAOT,OAAOS,SAAsBZ,OAAQY;AAC9C;AASO,SAASH,KAAQG,KAAmB;IACzC,OAAOA;AACT;AAGO,MAAMN,OAAaN;AAO1B,MAAMa,YAAYC,OAAOC,GAAG,CAAC;AAO7B,SAASC,gBAA8CC,KAAQ;IAC7D,AAAC,IAAI,CAAkBA,KAAK,GAAGA;AACjC;AACCD,gBAAgBE,SAAS,AAA0B,CAACL,UAAU,GAAG;AAKlE,SAASM,YAAYP,KAAc;IACjC,OAAO,AAACA,OAAmC,CAACC,UAAU,KAAK;AAC7D;AA+BO,SAAST,KAAWgB,MAAoB;IAC7C,OAAO,CAACD,YAAYC;AACtB;AAaO,SAASlB,MAAYkB,MAAoB;IAC9C,OAAOD,YAAYC;AACrB;AASO,SAASb,GAAMK,KAAQ;IAC5B,OAAOA;AACT;AAUO,SAASX,IAAOgB,KAAQ;IAC7B,OAAO,IAAKD,gBAAwDC;AACtE"}