{"version":3,"file":"type-utils.mjs","sources":["../../../src/lib/shared/type-utils.ts"],"sourcesContent":["/**\n * @file Unified Type Utilities\n * @description Centralized type guards, type utilities, and type narrowing functions.\n *\n * This module consolidates type guards from:\n * - utils/guardUtils.ts\n * - Various inline implementations across the codebase\n *\n * @module shared/type-utils\n */\n\n// =============================================================================\n// Primitive Type Guards\n// =============================================================================\n\n/**\n * Check if value is defined (not null or undefined).\n *\n * @example\n * ```ts\n * const items = [1, null, 2, undefined, 3];\n * const defined = items.filter(isDefined); // [1, 2, 3]\n * ```\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n  return value !== null && value !== undefined;\n}\n\n/**\n * Check if value is null or undefined.\n */\nexport function isNullish(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * Check if value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Check if value is a non-empty string (after trimming whitespace).\n */\nexport function isNonEmptyString(value: unknown): value is string {\n  return typeof value === 'string' && value.trim().length > 0;\n}\n\n/**\n * Check if value is a number (not NaN).\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !isNaN(value);\n}\n\n/**\n * Check if value is a finite number.\n */\nexport function isFiniteNumber(value: unknown): value is number {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Check if value is a positive number.\n */\nexport function isPositiveNumber(value: unknown): value is number {\n  return isNumber(value) && value > 0;\n}\n\n/**\n * Check if value is a non-negative number (>= 0).\n */\nexport function isNonNegativeNumber(value: unknown): value is number {\n  return isNumber(value) && value >= 0;\n}\n\n/**\n * Check if value is an integer.\n */\nexport function isInteger(value: unknown): value is number {\n  return isNumber(value) && Number.isInteger(value);\n}\n\n/**\n * Check if value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Check if value is a symbol.\n */\nexport function isSymbol(value: unknown): value is symbol {\n  return typeof value === 'symbol';\n}\n\n/**\n * Check if value is a bigint.\n */\nexport function isBigInt(value: unknown): value is bigint {\n  return typeof value === 'bigint';\n}\n\n// =============================================================================\n// Complex Type Guards\n// =============================================================================\n\n/**\n * Check if value is a function.\n */\nexport function isFunction(value: unknown): value is (...args: unknown[]) => unknown {\n  return typeof value === 'function';\n}\n\n/**\n * Check if value is a plain object (not null, not array).\n *\n * @example\n * ```ts\n * isObject({}) // true\n * isObject([]) // false\n * isObject(null) // false\n * ```\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Check if value is a plain object (stricter - checks prototype).\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (!isObject(value)) return false;\n  const proto = Object.getPrototypeOf(value) as unknown;\n  return proto === null || proto === Object.prototype;\n}\n\n/**\n * Check if value is an array.\n */\nexport function isArray<T = unknown>(value: unknown): value is T[] {\n  return Array.isArray(value);\n}\n\n/**\n * Check if value is a non-empty array.\n */\nexport function isNonEmptyArray<T = unknown>(value: unknown): value is [T, ...T[]] {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Check if value is an array of a specific type.\n *\n * @example\n * ```ts\n * const maybeStrings: unknown = ['a', 'b', 'c'];\n * if (isArrayOf(maybeStrings, isString)) {\n *   // maybeStrings is string[]\n * }\n * ```\n */\nexport function isArrayOf<T>(value: unknown, guard: (item: unknown) => item is T): value is T[] {\n  return Array.isArray(value) && value.every(guard);\n}\n\n/**\n * Check if value is a Date object (and valid).\n */\nexport function isDate(value: unknown): value is Date {\n  return value instanceof Date && !isNaN(value.getTime());\n}\n\n/**\n * Check if value is a valid date string.\n */\nexport function isDateString(value: unknown): value is string {\n  if (!isString(value)) return false;\n  const date = new Date(value);\n  return !isNaN(date.getTime());\n}\n\n/**\n * Check if value is a Promise.\n */\nexport function isPromise<T = unknown>(value: unknown): value is Promise<T> {\n  return (\n    value instanceof Promise ||\n    (isObject(value) && isFunction(value.then) && isFunction(value.catch))\n  );\n}\n\n/**\n * Check if value is an Error.\n */\nexport function isError(value: unknown): value is Error {\n  return value instanceof Error;\n}\n\n/**\n * Check if value is a RegExp.\n */\nexport function isRegExp(value: unknown): value is RegExp {\n  return value instanceof RegExp;\n}\n\n/**\n * Check if value is a Map.\n */\nexport function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V> {\n  return value instanceof Map;\n}\n\n/**\n * Check if value is a Set.\n */\nexport function isSet<T = unknown>(value: unknown): value is Set<T> {\n  return value instanceof Set;\n}\n\n/**\n * Check if value is a WeakMap.\n */\nexport function isWeakMap<K extends object = object, V = unknown>(\n  value: unknown\n): value is WeakMap<K, V> {\n  return value instanceof WeakMap;\n}\n\n/**\n * Check if value is a WeakSet.\n */\nexport function isWeakSet<T extends object = object>(value: unknown): value is WeakSet<T> {\n  return value instanceof WeakSet;\n}\n\n// =============================================================================\n// Format Validators\n// =============================================================================\n\n/**\n * Check if value is a valid email address.\n */\nexport function isEmail(value: unknown): value is string {\n  if (!isString(value)) return false;\n  const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n  return emailRegex.test(value);\n}\n\n/**\n * Check if value is a valid URL.\n */\nexport function isUrl(value: unknown): value is string {\n  if (!isString(value)) return false;\n  try {\n    new URL(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if value is a valid UUID (v1-v5).\n */\nexport function isUuid(value: unknown): value is string {\n  if (!isString(value)) return false;\n  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n  return uuidRegex.test(value);\n}\n\n/**\n * Check if value is a valid JSON string.\n */\nexport function isJsonString(value: unknown): value is string {\n  if (!isString(value)) return false;\n  try {\n    JSON.parse(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if value is a valid ISO date string.\n */\nexport function isIsoDateString(value: unknown): value is string {\n  if (!isString(value)) return false;\n  const isoRegex = /^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}:\\d{2}(\\.\\d{3})?(Z|[+-]\\d{2}:\\d{2})?)?$/;\n  return isoRegex.test(value) && !isNaN(Date.parse(value));\n}\n\n// =============================================================================\n// Object Property Guards\n// =============================================================================\n\n/**\n * Check if object has a specific key.\n *\n * @example\n * ```ts\n * const obj: unknown = { name: 'John' };\n * if (hasKey(obj, 'name')) {\n *   // obj.name is unknown but accessible\n * }\n * ```\n */\nexport function hasKey<K extends string>(obj: unknown, key: K): obj is Record<K, unknown> {\n  return isObject(obj) && key in obj;\n}\n\n/**\n * Check if object has all required keys.\n *\n * @example\n * ```ts\n * const obj: unknown = { name: 'John', age: 30 };\n * if (hasKeys(obj, ['name', 'age'])) {\n *   // obj has both name and age\n * }\n * ```\n */\nexport function hasKeys<K extends string>(\n  obj: unknown,\n  keys: readonly K[]\n): obj is Record<K, unknown> {\n  return isObject(obj) && keys.every((key) => key in obj);\n}\n\n/**\n * Check if object has a key with a specific type.\n *\n * @example\n * ```ts\n * const obj: unknown = { count: 42 };\n * if (hasTypedKey(obj, 'count', isNumber)) {\n *   // obj.count is number\n * }\n * ```\n */\nexport function hasTypedKey<K extends string, T>(\n  obj: unknown,\n  key: K,\n  guard: (value: unknown) => value is T\n): obj is Record<K, T> {\n  return hasKey(obj, key) && guard(obj[key]);\n}\n\n// =============================================================================\n// Type Narrowing Utilities\n// =============================================================================\n\n/**\n * Assert that a value matches a type guard, throwing if it doesn't.\n *\n * @example\n * ```ts\n * function processUser(data: unknown) {\n *   assert(data, isObject, 'Expected object');\n *   // data is Record<string, unknown>\n * }\n * ```\n */\nexport function assert<T>(\n  value: unknown,\n  guard: (value: unknown) => value is T,\n  message?: string\n): asserts value is T {\n  if (!guard(value)) {\n    throw new TypeError(message ?? 'Type assertion failed');\n  }\n}\n\n/**\n * Check if value is one of allowed values.\n *\n * @example\n * ```ts\n * const status: unknown = 'active';\n * if (isOneOf(status, ['active', 'inactive', 'pending'] as const)) {\n *   // status is 'active' | 'inactive' | 'pending'\n * }\n * ```\n */\nexport function isOneOf<T>(value: unknown, allowedValues: readonly T[]): value is T {\n  return allowedValues.includes(value as T);\n}\n\n/**\n * Narrow type or return undefined.\n *\n * @example\n * ```ts\n * const maybeString = narrow(value, isString);\n * // maybeString is string | undefined\n * ```\n */\nexport function narrow<T>(value: unknown, guard: (value: unknown) => value is T): T | undefined {\n  return guard(value) ? value : undefined;\n}\n\n/**\n * Narrow type or return default value.\n *\n * @example\n * ```ts\n * const name = narrowOr(value, isString, 'Anonymous');\n * // name is string (never undefined)\n * ```\n */\nexport function narrowOr<T>(\n  value: unknown,\n  guard: (value: unknown) => value is T,\n  defaultValue: T\n): T {\n  return guard(value) ? value : defaultValue;\n}\n\n// =============================================================================\n// Type Guard Factories\n// =============================================================================\n\n/**\n * Create a type guard for object shape.\n *\n * @example\n * ```ts\n * interface User {\n *   name: string;\n *   age: number;\n * }\n *\n * const isUser = createShapeGuard<User>({\n *   name: isString,\n *   age: isNumber,\n * });\n *\n * if (isUser(data)) {\n *   // data is User\n * }\n * ```\n */\nexport function createShapeGuard<T extends Record<string, unknown>>(shape: {\n  [K in keyof T]: (value: unknown) => value is T[K];\n}): (value: unknown) => value is T {\n  return (value: unknown): value is T => {\n    if (!isObject(value)) return false;\n\n    for (const key of Object.keys(shape) as (keyof T)[]) {\n      if (!(key in value) || !shape[key](value[key as string])) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\n/**\n * Create a type guard for optional object shape (allows undefined values).\n */\nexport function createPartialShapeGuard<T extends Record<string, unknown>>(shape: {\n  [K in keyof T]: (value: unknown) => value is T[K];\n}): (value: unknown) => value is Partial<T> {\n  return (value: unknown): value is Partial<T> => {\n    if (!isObject(value)) return false;\n\n    for (const key of Object.keys(shape) as (keyof T)[]) {\n      const propValue = value[key as string];\n      if (propValue !== undefined && !shape[key](propValue)) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\n/**\n * Create a type guard for union types.\n *\n * @example\n * ```ts\n * const isStringOrNumber = createUnionGuard(isString, isNumber);\n * ```\n */\nexport function createUnionGuard<T extends unknown[]>(\n  ...guards: { [K in keyof T]: (value: unknown) => value is T[K] }\n): (value: unknown) => value is T[number] {\n  return (value: unknown): value is T[number] => {\n    return guards.some((guard) => guard(value));\n  };\n}\n\n// =============================================================================\n// JSON Utilities\n// =============================================================================\n\n/**\n * Safe JSON parse with type guard.\n *\n * @example\n * ```ts\n * const user = safeJsonParse(jsonString, isUser);\n * if (user) {\n *   // user is User\n * }\n * ```\n */\nexport function safeJsonParse<T>(\n  json: string,\n  guard: (value: unknown) => value is T\n): T | undefined {\n  try {\n    const parsed: unknown = JSON.parse(json);\n    return guard(parsed) ? parsed : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Safe JSON parse returning result tuple.\n */\nexport function safeJsonParseResult<T>(\n  json: string,\n  guard: (value: unknown) => value is T\n): [T, null] | [null, Error] {\n  try {\n    const parsed: unknown = JSON.parse(json);\n    if (guard(parsed)) {\n      return [parsed, null];\n    }\n    return [null, new TypeError('JSON does not match expected type')];\n  } catch (error) {\n    return [null, error instanceof Error ? error : new Error(String(error))];\n  }\n}\n\n// =============================================================================\n// Type Utility Types\n// =============================================================================\n\n/**\n * Extract keys of type T from object U\n */\nexport type KeysOfType<U, T> = {\n  [K in keyof U]: U[K] extends T ? K : never;\n}[keyof U];\n\n/**\n * Make specific keys required\n */\nexport type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;\n\n/**\n * Make specific keys optional\n */\nexport type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n\n/**\n * Deep partial type\n */\nexport type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;\n\n/**\n * Deep readonly type\n */\nexport type DeepReadonly<T> = T extends object\n  ? { readonly [P in keyof T]: DeepReadonly<T[P]> }\n  : T;\n\n/**\n * Non-nullable values of an array\n */\nexport type NonNullableArray<T> = T extends (infer U)[] ? NonNullable<U>[] : never;\n\n/**\n * Awaited type (unwrap Promise)\n */\nexport type Awaited<T> = T extends Promise<infer U> ? U : T;\n\n/**\n * Function return type\n */\nexport type ReturnTypeOf<T> = T extends (...args: unknown[]) => infer R ? R : never;\n\n/**\n * Function parameters type\n */\nexport type ParametersOf<T> = T extends (...args: infer P) => unknown ? P : never;\n\n// =============================================================================\n// Branded Types - Compile-time safety for primitive values\n// =============================================================================\n\n/**\n * Unique symbol for branded types.\n * @internal\n */\nexport declare const __brand: unique symbol;\n\n/**\n * Creates a branded (nominal) type from a base type.\n *\n * Branded types provide compile-time safety by making structurally\n * identical types incompatible. This prevents accidental misuse of\n * values that represent different concepts (e.g., milliseconds vs seconds).\n *\n * @template T - The base type to brand\n * @template B - The brand identifier string\n *\n * @example\n * ```ts\n * type UserId = Brand<string, 'UserId'>;\n * type OrderId = Brand<string, 'OrderId'>;\n *\n * declare function getUser(id: UserId): User;\n *\n * const userId = 'user-123' as UserId;\n * const orderId = 'order-456' as OrderId;\n *\n * getUser(userId);  // OK\n * getUser(orderId); // Compile error - OrderId is not assignable to UserId\n * ```\n */\nexport type Brand<T, B extends string> = T & { readonly [__brand]: B };\n\n/**\n * Time duration in milliseconds.\n *\n * Use for all timing values like timeouts, intervals, and durations.\n *\n * @example\n * ```ts\n * const timeout: Milliseconds = ms(5000);\n * const delay: Milliseconds = ms(100);\n * ```\n */\nexport type Milliseconds = Brand<number, 'Milliseconds'>;\n\n/**\n * Time duration in seconds.\n *\n * Use for longer durations or when interacting with APIs that expect seconds.\n *\n * @example\n * ```ts\n * const tokenLifetime: Seconds = sec(3600); // 1 hour\n * ```\n */\nexport type Seconds = Brand<number, 'Seconds'>;\n\n/**\n * Distance/size in pixels.\n *\n * Use for all pixel-based measurements in layouts and UI.\n *\n * @example\n * ```ts\n * const width: Pixels = px(320);\n * const margin: Pixels = px(16);\n * ```\n */\nexport type Pixels = Brand<number, 'Pixels'>;\n\n/**\n * Percentage value (typically 0-100).\n *\n * Use for ratios, progress indicators, and percentage-based calculations.\n *\n * @example\n * ```ts\n * const progress: Percentage = pct(75);\n * const opacity: Percentage = pct(50);\n * ```\n */\nexport type Percentage = Brand<number, 'Percentage'>;\n\n/**\n * Creates a Milliseconds branded value.\n *\n * @param value - The numeric value in milliseconds\n * @returns A branded Milliseconds value\n *\n * @example\n * ```ts\n * const timeout = ms(5000); // 5 seconds\n * const debounce = ms(300);\n * ```\n */\nexport const ms = (value: number): Milliseconds => value as Milliseconds;\n\n/**\n * Creates a Seconds branded value.\n *\n * @param value - The numeric value in seconds\n * @returns A branded Seconds value\n *\n * @example\n * ```ts\n * const duration = sec(60); // 1 minute\n * const ttl = sec(3600);    // 1 hour\n * ```\n */\nexport const sec = (value: number): Seconds => value as Seconds;\n\n/**\n * Creates a Pixels branded value.\n *\n * @param value - The numeric value in pixels\n * @returns A branded Pixels value\n *\n * @example\n * ```ts\n * const width = px(320);\n * const padding = px(16);\n * ```\n */\nexport const px = (value: number): Pixels => value as Pixels;\n\n/**\n * Creates a Percentage branded value.\n *\n * @param value - The numeric value as a percentage (typically 0-100)\n * @returns A branded Percentage value\n *\n * @example\n * ```ts\n * const complete = pct(100);\n * const halfway = pct(50);\n * ```\n */\nexport const pct = (value: number): Percentage => value as Percentage;\n\n/**\n * Converts Seconds to Milliseconds.\n *\n * @param seconds - Duration in seconds\n * @returns Equivalent duration in milliseconds\n *\n * @example\n * ```ts\n * const timeout = secondsToMs(sec(5)); // 5000ms\n * ```\n */\nexport const secondsToMs = (seconds: Seconds): Milliseconds => ms((seconds as number) * 1000);\n\n/**\n * Converts Milliseconds to Seconds.\n *\n * @param milliseconds - Duration in milliseconds\n * @returns Equivalent duration in seconds\n *\n * @example\n * ```ts\n * const duration = msToSeconds(ms(5000)); // 5s\n * ```\n */\nexport const msToSeconds = (milliseconds: Milliseconds): Seconds =>\n  sec((milliseconds as number) / 1000);\n\n// =============================================================================\n// Result Type - Functional error handling\n// =============================================================================\n\n/**\n * Result type for operations that can fail.\n *\n * Provides a type-safe alternative to throwing exceptions, following the\n * functional programming Either pattern. Forces explicit handling of both\n * success and failure cases at compile time.\n *\n * @template T - The success value type\n * @template E - The error type (defaults to Error)\n *\n * @example\n * ```ts\n * function divide(a: number, b: number): Result<number, string> {\n *   if (b === 0) {\n *     return err('Division by zero');\n *   }\n *   return ok(a / b);\n * }\n *\n * const result = divide(10, 2);\n * if (isOk(result)) {\n *   console.log('Result:', result.value); // 5\n * } else {\n *   console.error('Error:', result.error);\n * }\n * ```\n */\nexport type Result<T, E = Error> =\n  | { readonly ok: true; readonly value: T }\n  | { readonly ok: false; readonly error: E };\n\n/**\n * Creates a successful Result containing the given value.\n *\n * @template T - The value type\n * @param value - The success value\n * @returns A successful Result containing the value\n *\n * @example\n * ```ts\n * const result = ok(42);\n * // result.ok === true\n * // result.value === 42\n * ```\n */\nexport function ok<T>(value: T): Result<T, never> {\n  return { ok: true, value };\n}\n\n/**\n * Creates a failed Result containing the given error.\n *\n * @template E - The error type\n * @param error - The error value\n * @returns A failed Result containing the error\n *\n * @example\n * ```ts\n * const result = err(new Error('Something went wrong'));\n * // result.ok === false\n * // result.error.message === 'Something went wrong'\n * ```\n */\nexport function err<E>(error: E): Result<never, E> {\n  return { ok: false, error };\n}\n\n/**\n * Type guard to check if a Result is successful.\n *\n * @template T - The success value type\n * @template E - The error type\n * @param result - The Result to check\n * @returns True if the result is successful, narrowing the type\n *\n * @example\n * ```ts\n * const result: Result<User, ApiError> = await fetchUser(id);\n * if (isOk(result)) {\n *   // result.value is User here\n *   console.log(result.value.name);\n * }\n * ```\n */\nexport function isOk<T, E>(result: Result<T, E>): result is { ok: true; value: T } {\n  return result.ok;\n}\n\n/**\n * Type guard to check if a Result is a failure.\n *\n * @template T - The success value type\n * @template E - The error type\n * @param result - The Result to check\n * @returns True if the result is a failure, narrowing the type\n *\n * @example\n * ```ts\n * const result: Result<User, ApiError> = await fetchUser(id);\n * if (isErr(result)) {\n *   // result.error is ApiError here\n *   console.error(result.error.message);\n * }\n * ```\n */\nexport function isErr<T, E>(result: Result<T, E>): result is { ok: false; error: E } {\n  return !result.ok;\n}\n\n/**\n * Maps a successful Result value using the provided function.\n *\n * If the Result is a failure, returns the failure unchanged.\n *\n * @template T - The original success type\n * @template U - The mapped success type\n * @template E - The error type\n * @param result - The Result to map\n * @param fn - The mapping function\n * @returns A new Result with the mapped value or the original error\n *\n * @example\n * ```ts\n * const numResult: Result<number, string> = ok(5);\n * const strResult = mapResult(numResult, n => n.toString());\n * // strResult is Result<string, string> with value \"5\"\n * ```\n */\nexport function mapResult<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  return isOk(result) ? ok(fn(result.value)) : (result as unknown as Result<U, E>);\n}\n\n/**\n * Maps a failed Result error using the provided function.\n *\n * If the Result is successful, returns it unchanged.\n *\n * @template T - The success type\n * @template E - The original error type\n * @template F - The mapped error type\n * @param result - The Result to map\n * @param fn - The error mapping function\n * @returns A new Result with the mapped error or the original value\n *\n * @example\n * ```ts\n * const result: Result<number, string> = err('failed');\n * const mapped = mapError(result, msg => new Error(msg));\n * // mapped is Result<number, Error>\n * ```\n */\nexport function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  return isErr(result) ? err(fn(result.error)) : (result as unknown as Result<T, F>);\n}\n\n/**\n * Chains Result-returning operations.\n *\n * If the Result is successful, applies the function to the value.\n * If the Result is a failure, returns the failure unchanged.\n *\n * @template T - The original success type\n * @template U - The chained success type\n * @template E - The error type\n * @param result - The Result to chain\n * @param fn - The chaining function that returns a new Result\n * @returns The Result from the chaining function or the original error\n *\n * @example\n * ```ts\n * const parseNumber = (s: string): Result<number, string> => {\n *   const n = parseInt(s, 10);\n *   return isNaN(n) ? err('Invalid number') : ok(n);\n * };\n *\n * const double = (n: number): Result<number, string> => ok(n * 2);\n *\n * const result = flatMapResult(parseNumber('5'), double);\n * // result is ok(10)\n * ```\n */\nexport function flatMapResult<T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, E>\n): Result<U, E> {\n  return isOk(result) ? fn(result.value) : (result as unknown as Result<U, E>);\n}\n\n/**\n * Unwraps a Result, returning the value if successful or throwing if failed.\n *\n * @template T - The success type\n * @template E - The error type\n * @param result - The Result to unwrap\n * @returns The success value\n * @throws The error if the Result is a failure\n *\n * @example\n * ```ts\n * const result = ok(42);\n * const value = unwrapResult(result); // 42\n *\n * const failed = err(new Error('oops'));\n * unwrapResult(failed); // throws Error('oops')\n * ```\n */\nexport function unwrapResult<T, E>(result: Result<T, E>): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  if (isErr(result)) {\n    throw result.error instanceof Error ? result.error : new Error(String(result.error));\n  }\n  throw new TypeError('Invalid Result type');\n}\n\n/**\n * Unwraps a Result, returning the value if successful or a default value if failed.\n *\n * @template T - The success type\n * @template E - The error type\n * @param result - The Result to unwrap\n * @param defaultValue - The default value to return on failure\n * @returns The success value or the default value\n *\n * @example\n * ```ts\n * const success = ok(42);\n * unwrapOr(success, 0); // 42\n *\n * const failed = err(new Error('oops'));\n * unwrapOr(failed, 0); // 0\n * ```\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  return isOk(result) ? result.value : defaultValue;\n}\n"],"names":["isDefined","value","isNullish","isString","isNonEmptyString","isNumber","isFiniteNumber","isPositiveNumber","isNonNegativeNumber","isInteger","isBoolean","isSymbol","isBigInt","isFunction","isObject","isPlainObject","proto","isArray","isNonEmptyArray","isArrayOf","guard","isDate","isDateString","date","isPromise","isError","isRegExp","isMap","isSet","isWeakMap","isWeakSet","isEmail","isUrl","isUuid","isJsonString","isIsoDateString","hasKey","obj","key","hasKeys","keys","hasTypedKey","assert","message","isOneOf","allowedValues","narrow","narrowOr","defaultValue","createShapeGuard","shape","createPartialShapeGuard","propValue","createUnionGuard","guards","safeJsonParse","json","parsed","safeJsonParseResult","error","ms","sec","px","ok","err","isOk","result","isErr"],"mappings":"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"}