@nicolastoulemont/std 0.1.0

package/dist/option-CKHDOVea.mjs

@@ -0,0 +1,410 @@
+import { t as isPromise } from "./is-promise-BEl3eGZg.mjs";
+
+//#region src/option/option.types.ts
+/**
+* Singleton None value.
+*/
+const None = { __typename: "None" };
+
+//#endregion
+//#region src/option/option.ts
+/**
+* Create an Option with a value.
+*
+* @param value - The value to wrap
+* @returns An Option with some: true
+*
+* @example
+* ```ts
+* some(42) // { some: true, value: 42 }
+* ```
+*/
+const some = (value) => ({
+	some: true,
+	value,
+	*[Symbol.iterator]() {
+		return value;
+	}
+});
+/**
+* Create an Option with no value.
+*
+* @returns An Option with some: false
+*
+* @example
+* ```ts
+* none() // { some: false }
+* ```
+*/
+const none = () => ({
+	some: false,
+	*[Symbol.iterator]() {
+		yield None;
+		throw new Error("Unreachable: Do should short-circuit on None");
+	}
+});
+/**
+* Check if an Option has a value.
+*
+* @param option - The Option to check
+* @returns true if the Option is some
+*
+* @example
+* ```ts
+* const option = some(42)
+* if (isSome(option)) {
+*   console.log(option.value) // TypeScript knows value exists
+* }
+* ```
+*/
+const isSome = (option) => option.some;
+/**
+* Check if an Option has no value.
+*
+* @param option - The Option to check
+* @returns true if the Option is none
+*
+* @example
+* ```ts
+* const option = none()
+* if (isNone(option)) {
+*   console.log('No value') // TypeScript knows value doesn't exist
+* }
+* ```
+*/
+const isNone = (option) => !option.some;
+/**
+* Transform the value of an Option.
+* If the Option is none, it passes through unchanged.
+*
+* Supports both sync and async functions:
+* - Sync fn: returns Option<U>
+* - Async fn: returns Promise<Option<U>>
+*
+* @param fn - Function to transform the value
+* @returns A function that takes an Option and returns a new Option
+*
+* @example
+* ```ts
+* // Sync usage
+* pipe(
+*   some(5),
+*   map(n => n * 2)
+* ) // { some: true, value: 10 }
+*
+* // Async usage
+* await pipe(
+*   some(userId),
+*   map(async id => await fetchName(id))
+* ) // Promise<Option<string>>
+* ```
+*/
+const map = (fn) => (option) => {
+	if (!option.some) return option;
+	const mapped = fn(option.value);
+	if (mapped instanceof Promise) return mapped.then(some);
+	return some(mapped);
+};
+/**
+* Chain operations that return Options.
+* If the Option is none, it passes through unchanged.
+*
+* Supports both sync and async functions:
+* - Sync fn: returns Option<U>
+* - Async fn: returns Promise<Option<U>>
+*
+* @param fn - Function that takes a value and returns an Option (or Promise<Option>)
+* @returns A function that takes an Option and returns a new Option
+*
+* @example
+* ```ts
+* const findUser = (id: number) =>
+*   id > 0 ? some({ id, name: 'Alice' }) : none()
+*
+* // Sync usage
+* pipe(
+*   some(10),
+*   flatMap(id => findUser(id))
+* ) // { some: true, value: { id: 10, name: 'Alice' } }
+*
+* // Async usage
+* await pipe(
+*   some(userId),
+*   flatMap(async id => some(await fetchUser(id)))
+* ) // Promise<Option<User>>
+* ```
+*/
+const flatMap = (fn) => (option) => option.some ? fn(option.value) : option;
+/**
+* Perform a side effect on the value without modifying the Option.
+* Useful for debugging, logging, or other side effects in a pipeline.
+* If the Option is none, the function is not called.
+*
+* Supports both sync and async functions:
+* - Sync fn: returns Option<T>
+* - Async fn: returns Promise<Option<T>>
+*
+* @param fn - Function to call with the value (return value is ignored)
+* @returns A function that takes an Option and returns the same Option
+*
+* @example
+* ```ts
+* // Sync usage
+* pipe(
+*   some(42),
+*   tap(console.log),  // logs 42
+*   map(n => n * 2)
+* ) // { some: true, value: 84 }
+*
+* // Async usage
+* await pipe(
+*   some(42),
+*   tap(async v => await logToServer(v)),
+*   map(n => n * 2)
+* ) // Promise<Option<84>>
+* ```
+*/
+const tap = (fn) => (option) => {
+	if (!option.some) return option;
+	const sideEffect = fn(option.value);
+	if (sideEffect instanceof Promise) return sideEffect.then(() => option);
+	return option;
+};
+/**
+* Recover from none by providing an alternative Option.
+* If the Option is some, it passes through unchanged.
+*
+* Supports both sync and async functions:
+* - Sync fn: returns Option<T | U>
+* - Async fn: returns Promise<Option<T | U>>
+*
+* @param fn - Function that returns an alternative Option
+* @returns A function that takes an Option and returns a new Option
+*
+* @example
+* ```ts
+* // Sync recovery
+* pipe(
+*   none(),
+*   orElse(() => some(defaultValue))
+* ) // { some: true, value: defaultValue }
+*
+* // Async recovery
+* await pipe(
+*   none(),
+*   orElse(async () => some(await fetchFromAPI()))
+* ) // Promise<Option<T>>
+*
+* // Chain multiple fallbacks
+* pipe(
+*   none(),
+*   orElse(() => tryCache()),
+*   orElse(() => tryAPI()),
+*   orElse(() => some(fallback))
+* )
+* ```
+*/
+const orElse = (fn) => (option) => option.some ? option : fn();
+/**
+* Filter an Option based on a predicate.
+* If the predicate returns false, converts to none.
+* If the Option is already none, it passes through unchanged.
+*
+* @param predicate - Function that returns true to keep the value
+* @returns A function that takes an Option and returns a new Option
+*
+* @example
+* ```ts
+* pipe(
+*   some(5),
+*   filter(n => n > 10)
+* ) // { some: false }
+*
+* pipe(
+*   some(15),
+*   filter(n => n > 10)
+* ) // { some: true, value: 15 }
+*
+* // With complex validation
+* pipe(
+*   some(user),
+*   filter(u => u.age >= 18)
+* )
+* ```
+*/
+const filter = (predicate) => (option) => {
+	if (!option.some) return option;
+	return predicate(option.value) ? option : none();
+};
+function all(options) {
+	if (Array.isArray(options)) {
+		const values$1 = [];
+		for (const option of options) {
+			if (!option.some) return option;
+			values$1.push(option.value);
+		}
+		return some(values$1);
+	}
+	const values = {};
+	for (const [key, option] of Object.entries(options)) {
+		const o = option;
+		if (!o.some) return option;
+		values[key] = o.value;
+	}
+	return some(values);
+}
+/**
+* Get the value or a default value.
+*
+* @param defaultValue - Value to return if the Option is none
+* @returns A function that takes an Option and returns the value or default
+*
+* @example
+* ```ts
+* pipe(some(42), unwrapOr(0)) // 42
+* pipe(none(), unwrapOr(0)) // 0
+* ```
+*/
+const unwrapOr = (defaultValue) => (option) => option.some ? option.value : defaultValue;
+/**
+* Get the value or compute a value.
+*
+* @param fn - Function to compute a value
+* @returns A function that takes an Option and returns the value or computed value
+*
+* @example
+* ```ts
+* pipe(
+*   none(),
+*   unwrapOrElse(() => generateDefault())
+* ) // generateDefault()
+* ```
+*/
+const unwrapOrElse = (fn) => (option) => option.some ? option.value : fn();
+/**
+* Pattern match on an Option, handling both some and none cases.
+*
+* @param handlers - Object with some and none handlers
+* @returns A function that takes an Option and returns the handler result
+*
+* @example
+* ```ts
+* pipe(
+*   some(42),
+*   match({
+*     some: n => `Got ${n}`,
+*     none: () => 'No value'
+*   })
+* ) // 'Got 42'
+* ```
+*/
+const match = (handlers) => (option) => option.some ? handlers.some(option.value) : handlers.none();
+/**
+* Convert a nullable value to an Option.
+* null and undefined become none, other values become some.
+*
+* @param value - The value to convert
+* @returns An Option
+*
+* @example
+* ```ts
+* fromNullable(42) // { some: true, value: 42 }
+* fromNullable(null) // { some: false }
+* fromNullable(undefined) // { some: false }
+* ```
+*/
+const fromNullable = (value) => value === null || value === void 0 ? none() : some(value);
+/**
+* Wrap a function that might throw into an Option.
+* Supports both sync and async functions with automatic type inference.
+*
+* - Sync fn: returns Option<T>
+* - Async fn: returns Promise<Option<T>>
+*
+* **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),
+* you should add an explicit return type annotation. This is because TypeScript's
+* conditional types cannot determine if `any` is a Promise or not, resulting in a
+* union type `Promise<Option<unknown>> | Option<any>` that won't work
+* with Option utilities like `isSome` or `isNone`.
+*
+* @param fn - Function that might throw (sync or async)
+* @returns An Option with the return value or none
+*
+* @example
+* ```ts
+* // Sync usage
+* fromTry(() => JSON.parse('{"valid": true}'))
+* // { some: true, value: { valid: true } }
+*
+* fromTry(() => JSON.parse('not json'))
+* // { some: false }
+*
+* // When fn returns `any`, add explicit return type:
+* fromTry((): unknown => JSON.parse(input))
+* fromTry((): MyType => JSON.parse(input))
+*
+* // Async usage
+* await fromTry(async () => await fetch('/api/user'))
+* // Promise<Option<Response>>
+*
+* await fromTry(async () => {
+*   throw new Error('network error')
+* })
+* // Promise<{ some: false }>
+* ```
+*/
+const fromTry = (fn) => {
+	try {
+		const result = fn();
+		if (isPromise(result)) return result.then(some).catch(() => none());
+		return some(result);
+	} catch {
+		return none();
+	}
+};
+/**
+* Option namespace containing all utility functions for working with Option types.
+*
+* Option represents either the presence (some) or absence (none) of a value.
+* Use this for optional values without needing to track why the value is missing.
+*
+* @see {@link Result} for success/failure with error information
+* @see {@link Either} for two valid outcomes
+*
+* @example
+* ```ts
+* import { Option, pipe } from '@repo/std'
+* import type { Option as OptionType } from '@repo/std'
+*
+* const findUser = (id: number): OptionType<User> =>
+*   id > 0 ? Option.some({ id, name: 'Alice' }) : Option.none()
+*
+* const result = pipe(
+*   Option.some(10),
+*   Option.flatMap(findUser),
+*   Option.map(user => user.name),
+*   Option.unwrapOr('Unknown')
+* )
+* ```
+*/
+const Option = {
+	some,
+	none,
+	isSome,
+	isNone,
+	map,
+	flatMap,
+	tap,
+	orElse,
+	filter,
+	all,
+	unwrapOr,
+	unwrapOrElse,
+	match,
+	fromNullable,
+	fromTry
+};
+
+//#endregion
+export { None as n, Option as t };
+//# sourceMappingURL=option-CKHDOVea.mjs.map

package/dist/option-CKHDOVea.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-CKHDOVea.mjs","names":["NoneValue","values"],"sources":["../src/option/option.types.ts","../src/option/option.ts"],"sourcesContent":["import type { Yieldable } from \"../gen/gen.types\"\n\n// ============================================================================\n// None Type\n// ============================================================================\n\n/**\n * Marker type for Option's absence in the Do computation context.\n * When an Option is yielded in Do, None becomes part of the error union.\n */\nexport type None = { readonly __typename: \"None\" }\n\n/**\n * Singleton None value.\n */\nexport const None: None = { __typename: \"None\" }\n\n// ============================================================================\n// Option Type\n// ============================================================================\n\n/**\n * A discriminated union representing either a value (some) or absence (none).\n * Compatible with ts-pattern for exhaustive matching.\n * Implements Yieldable protocol for use in Do computations with yield*.\n */\nexport type Option<T> = Yieldable<T, None> & ({ readonly some: true; readonly value: T } | { readonly some: false })\n\n// ============================================================================\n// Async-aware transformation types\n// ============================================================================\n\n/**\n * Compute the return type of `map` based on whether fn returns a Promise.\n * - If fn returns Promise<U>, result is Promise<Option<U>>\n * - If fn returns U, result is Option<U>\n */\nexport type MapReturn<FnReturn> = FnReturn extends Promise<infer U> ? Promise<Option<U>> : Option<FnReturn>\n\n/**\n * Compute the return type of `flatMap` based on whether fn returns a Promise.\n * - If fn returns Promise<Option<U>>, result is Promise<Option<U>>\n * - If fn returns Option<U>, result is Option<U>\n */\nexport type FlatMapReturn<FnReturn> =\n  FnReturn extends Promise<Option<infer U>> ? Promise<Option<U>> : FnReturn extends Option<infer U> ? Option<U> : never\n\n/**\n * Compute the return type of `tap` based on whether fn returns a Promise.\n * - If fn returns Promise<any>, result is Promise<Option<T>>\n * - If fn returns any, result is Option<T>\n * The result value is always unchanged.\n */\n// oxlint-disable-next-line no-explicit-any\nexport type TapReturn<FnReturn, T> = FnReturn extends Promise<any> ? Promise<Option<T>> : Option<T>\n\n/**\n * Compute the return type of `orElse` based on whether fn returns a Promise.\n * - If fn returns Promise<Option<U>>, result is Promise<Option<T | U>>\n * - If fn returns Option<U>, result is Option<T | U>\n */\nexport type OrElseReturn<FnReturn, T> =\n  FnReturn extends Promise<Option<infer U>>\n    ? Promise<Option<T | U>>\n    : FnReturn extends Option<infer U>\n      ? Option<T | U>\n      : never\n\n/**\n * Compute the return type of `fromTry` based on whether fn returns a Promise.\n * - If fn returns Promise<T>, result is Promise<Option<T>>\n * - If fn returns T, result is Option<T>\n */\nexport type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Option<U>> : Option<T>\n\n// ============================================================================\n// All/Combine types\n// ============================================================================\n\n/**\n * Extract the value type from an Option.\n * Uses structural matching to extract the value type from the some branch.\n */\nexport type OptionValue<O> = O extends { readonly some: true; readonly value: infer T } ? T : never\n\n/**\n * Compute return type for `all` with array input.\n * Preserves tuple structure and extracts value types from each position.\n */\nexport type AllArrayReturn<T extends readonly Option<unknown>[]> = Option<{\n  -readonly [K in keyof T]: OptionValue<T[K]>\n}>\n\n/**\n * Compute return type for `all` with object input.\n * Preserves object structure and extracts value types from each key.\n */\nexport type AllObjectReturn<T extends Record<string, Option<unknown>>> = Option<{\n  -readonly [K in keyof T]: OptionValue<T[K]>\n}>\n\n// ============================================================================\n// Function Interfaces for improved pipe inference\n// ============================================================================\n\n/**\n * Interface for flatMap - using method syntax improves generic inference in pipe chains.\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionFlatMap = {\n  <A, B>(fn: (value: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => Option<B>): (option: Option<A>) => Option<B>\n}\n\n/**\n * Interface for map function.\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionMap = {\n  <A, B>(fn: (value: A) => Promise<B>): (option: Option<A>) => Promise<Option<B>>\n  <A, B>(fn: (value: A) => B): (option: Option<A>) => Option<B>\n}\n\n/**\n * Interface for tap function.\n */\nexport type OptionTap = {\n  <A, R>(fn: (value: A) => R): (option: Option<A>) => R extends Promise<unknown> ? Promise<Option<A>> : Option<A>\n}\n\n/**\n * Interface for orElse function.\n * Note: Async overload must come first for proper overload resolution.\n */\nexport type OptionOrElse = {\n  <A, B>(fn: () => Promise<Option<B>>): (option: Option<A>) => Promise<Option<A | B>>\n  <A, B>(fn: () => Option<B>): (option: Option<A>) => Option<A | B>\n}\n\n/**\n * Interface for filter function.\n */\nexport type OptionFilter = {\n  <A>(predicate: (value: A) => boolean): (option: Option<A>) => Option<A>\n}\n","import { isPromise } from \"../shared/is-promise\"\nimport { None as NoneValue } from \"./option.types\"\nimport type {\n  AllArrayReturn,\n  AllObjectReturn,\n  Option as OptionType,\n  OptionFlatMap,\n  OptionMap,\n  OptionTap,\n  OptionOrElse,\n  OptionFilter,\n  None,\n  FromTryReturn,\n} from \"./option.types\"\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create an Option with a value.\n *\n * @param value - The value to wrap\n * @returns An Option with some: true\n *\n * @example\n * ```ts\n * some(42) // { some: true, value: 42 }\n * ```\n */\nexport const some = <T>(value: T): OptionType<T> => ({\n  some: true,\n  value,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<None, T, unknown> {\n    return value\n  },\n})\n\n/**\n * Create an Option with no value.\n *\n * @returns An Option with some: false\n *\n * @example\n * ```ts\n * none() // { some: false }\n * ```\n */\nexport const none = <T>(): OptionType<T> => ({\n  some: false,\n  *[Symbol.iterator](): Generator<None, never, unknown> {\n    yield NoneValue\n    throw new Error(\"Unreachable: Do should short-circuit on None\")\n  },\n})\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if an Option has a value.\n *\n * @param option - The Option to check\n * @returns true if the Option is some\n *\n * @example\n * ```ts\n * const option = some(42)\n * if (isSome(option)) {\n *   console.log(option.value) // TypeScript knows value exists\n * }\n * ```\n */\nexport const isSome = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { some: true }> => option.some\n\n/**\n * Check if an Option has no value.\n *\n * @param option - The Option to check\n * @returns true if the Option is none\n *\n * @example\n * ```ts\n * const option = none()\n * if (isNone(option)) {\n *   console.log('No value') // TypeScript knows value doesn't exist\n * }\n * ```\n */\nexport const isNone = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { some: false }> => !option.some\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the value of an Option.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function to transform the value\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * // Sync usage\n * pipe(\n *   some(5),\n *   map(n => n * 2)\n * ) // { some: true, value: 10 }\n *\n * // Async usage\n * await pipe(\n *   some(userId),\n *   map(async id => await fetchName(id))\n * ) // Promise<Option<string>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: OptionMap = (fn) => (option) => {\n  if (!option.some) return option as any\n  const mapped = fn(option.value)\n  if (mapped instanceof Promise) {\n    return mapped.then(some) as any\n  }\n  return some(mapped) as any\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Options.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that takes a value and returns an Option (or Promise<Option>)\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * const findUser = (id: number) =>\n *   id > 0 ? some({ id, name: 'Alice' }) : none()\n *\n * // Sync usage\n * pipe(\n *   some(10),\n *   flatMap(id => findUser(id))\n * ) // { some: true, value: { id: 10, name: 'Alice' } }\n *\n * // Async usage\n * await pipe(\n *   some(userId),\n *   flatMap(async id => some(await fetchUser(id)))\n * ) // Promise<Option<User>>\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: OptionFlatMap = (fn) => (option) => (option.some ? fn(option.value) : option) as any\n\n/**\n * Perform a side effect on the value without modifying the Option.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Option is none, the function is not called.\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * @param fn - Function to call with the value (return value is ignored)\n * @returns A function that takes an Option and returns the same Option\n *\n * @example\n * ```ts\n * // Sync usage\n * pipe(\n *   some(42),\n *   tap(console.log),  // logs 42\n *   map(n => n * 2)\n * ) // { some: true, value: 84 }\n *\n * // Async usage\n * await pipe(\n *   some(42),\n *   tap(async v => await logToServer(v)),\n *   map(n => n * 2)\n * ) // Promise<Option<84>>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: OptionTap = (fn) => (option) => {\n  if (!option.some) return option as any\n  const sideEffect = fn(option.value)\n  if (sideEffect instanceof Promise) {\n    return sideEffect.then(() => option) as any\n  }\n  return option as any\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from none by providing an alternative Option.\n * If the Option is some, it passes through unchanged.\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<T | U>\n * - Async fn: returns Promise<Option<T | U>>\n *\n * @param fn - Function that returns an alternative Option\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * // Sync recovery\n * pipe(\n *   none(),\n *   orElse(() => some(defaultValue))\n * ) // { some: true, value: defaultValue }\n *\n * // Async recovery\n * await pipe(\n *   none(),\n *   orElse(async () => some(await fetchFromAPI()))\n * ) // Promise<Option<T>>\n *\n * // Chain multiple fallbacks\n * pipe(\n *   none(),\n *   orElse(() => tryCache()),\n *   orElse(() => tryAPI()),\n *   orElse(() => some(fallback))\n * )\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: OptionOrElse = (fn) => (option) => (option.some ? option : fn()) as any\n\n/**\n * Filter an Option based on a predicate.\n * If the predicate returns false, converts to none.\n * If the Option is already none, it passes through unchanged.\n *\n * @param predicate - Function that returns true to keep the value\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * pipe(\n *   some(5),\n *   filter(n => n > 10)\n * ) // { some: false }\n *\n * pipe(\n *   some(15),\n *   filter(n => n > 10)\n * ) // { some: true, value: 15 }\n *\n * // With complex validation\n * pipe(\n *   some(user),\n *   filter(u => u.age >= 18)\n * )\n * ```\n */\nexport const filter: OptionFilter = (predicate) => (option) => {\n  if (!option.some) return option\n  return predicate(option.value) ? option : none()\n}\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Options into a single Option.\n * Supports both array and object inputs.\n *\n * - If all Options are some, returns some with all values\n * - If any Option is none, returns none (short-circuits)\n *\n * @example\n * ```ts\n * // Array form (use `as const` for tuple types) - returns Option<[number, string]>\n * const [num, str] = pipe(\n *   Option.all([parseNumber(input), parseString(other)] as const),\n *   Option.unwrapOr([0, ''])\n * )\n *\n * // Object form - returns Option<{ user: User, config: Config }>\n * pipe(\n *   Option.all({ user: findUser(id), config: loadConfig() }),\n *   Option.tap(({ user, config }) => console.log(user.name, config.theme))\n * )\n * ```\n */\nexport function all<T extends readonly OptionType<unknown>[]>(options: T): AllArrayReturn<T>\nexport function all<T extends Record<string, OptionType<unknown>>>(options: T): AllObjectReturn<T>\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport function all(options: any): any {\n  if (Array.isArray(options)) {\n    const values: unknown[] = []\n    for (const option of options) {\n      if (!option.some) return option\n      values.push(option.value)\n    }\n    return some(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, option] of Object.entries(options)) {\n    const o = option as OptionType<unknown>\n    if (!o.some) return option\n    values[key] = o.value\n  }\n  return some(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the value or a default value.\n *\n * @param defaultValue - Value to return if the Option is none\n * @returns A function that takes an Option and returns the value or default\n *\n * @example\n * ```ts\n * pipe(some(42), unwrapOr(0)) // 42\n * pipe(none(), unwrapOr(0)) // 0\n * ```\n */\nexport const unwrapOr =\n  <T>(defaultValue: T) =>\n  (option: OptionType<T>): T =>\n    option.some ? option.value : defaultValue\n\n/**\n * Get the value or compute a value.\n *\n * @param fn - Function to compute a value\n * @returns A function that takes an Option and returns the value or computed value\n *\n * @example\n * ```ts\n * pipe(\n *   none(),\n *   unwrapOrElse(() => generateDefault())\n * ) // generateDefault()\n * ```\n */\nexport const unwrapOrElse =\n  <T>(fn: () => T) =>\n  (option: OptionType<T>): T =>\n    option.some ? option.value : fn()\n\n/**\n * Pattern match on an Option, handling both some and none cases.\n *\n * @param handlers - Object with some and none handlers\n * @returns A function that takes an Option and returns the handler result\n *\n * @example\n * ```ts\n * pipe(\n *   some(42),\n *   match({\n *     some: n => `Got ${n}`,\n *     none: () => 'No value'\n *   })\n * ) // 'Got 42'\n * ```\n */\nexport const match =\n  <T, U>(handlers: { some: (value: T) => U; none: () => U }) =>\n  (option: OptionType<T>): U =>\n    option.some ? handlers.some(option.value) : handlers.none()\n\n// ============================================================================\n// Conversions\n// ============================================================================\n\n/**\n * Convert a nullable value to an Option.\n * null and undefined become none, other values become some.\n *\n * @param value - The value to convert\n * @returns An Option\n *\n * @example\n * ```ts\n * fromNullable(42) // { some: true, value: 42 }\n * fromNullable(null) // { some: false }\n * fromNullable(undefined) // { some: false }\n * ```\n */\nexport const fromNullable = <T>(value: T | null | undefined): OptionType<T> =>\n  value === null || value === undefined ? none<T>() : some(value)\n\n/**\n * Wrap a function that might throw into an Option.\n * Supports both sync and async functions with automatic type inference.\n *\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),\n * you should add an explicit return type annotation. This is because TypeScript's\n * conditional types cannot determine if `any` is a Promise or not, resulting in a\n * union type `Promise<Option<unknown>> | Option<any>` that won't work\n * with Option utilities like `isSome` or `isNone`.\n *\n * @param fn - Function that might throw (sync or async)\n * @returns An Option with the return value or none\n *\n * @example\n * ```ts\n * // Sync usage\n * fromTry(() => JSON.parse('{\"valid\": true}'))\n * // { some: true, value: { valid: true } }\n *\n * fromTry(() => JSON.parse('not json'))\n * // { some: false }\n *\n * // When fn returns `any`, add explicit return type:\n * fromTry((): unknown => JSON.parse(input))\n * fromTry((): MyType => JSON.parse(input))\n *\n * // Async usage\n * await fromTry(async () => await fetch('/api/user'))\n * // Promise<Option<Response>>\n *\n * await fromTry(async () => {\n *   throw new Error('network error')\n * })\n * // Promise<{ some: false }>\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for conditional return type */\nexport const fromTry = <T>(fn: () => T): FromTryReturn<T> => {\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      return result.then(some).catch(() => none()) as unknown as FromTryReturn<T>\n    }\n    return some(result) as unknown as FromTryReturn<T>\n  } catch {\n    return none() as unknown as FromTryReturn<T>\n  }\n}\n\n// ============================================================================\n// Namespace\n// ============================================================================\n\n/**\n * Option namespace containing all utility functions for working with Option types.\n *\n * Option represents either the presence (some) or absence (none) of a value.\n * Use this for optional values without needing to track why the value is missing.\n *\n * @see {@link Result} for success/failure with error information\n * @see {@link Either} for two valid outcomes\n *\n * @example\n * ```ts\n * import { Option, pipe } from '@repo/std'\n * import type { Option as OptionType } from '@repo/std'\n *\n * const findUser = (id: number): OptionType<User> =>\n *   id > 0 ? Option.some({ id, name: 'Alice' }) : Option.none()\n *\n * const result = pipe(\n *   Option.some(10),\n *   Option.flatMap(findUser),\n *   Option.map(user => user.name),\n *   Option.unwrapOr('Unknown')\n * )\n * ```\n */\nexport const Option = {\n  some,\n  none,\n  isSome,\n  isNone,\n  map,\n  flatMap,\n  tap,\n  orElse,\n  filter,\n  all,\n  unwrapOr,\n  unwrapOrElse,\n  match,\n  fromNullable,\n  fromTry,\n} as const\n"],"mappings":";;;;;;AAeA,MAAa,OAAa,EAAE,YAAY,QAAQ;;;;;;;;;;;;;;;ACehD,MAAa,QAAW,WAA6B;CACnD,MAAM;CACN;CAEA,EAAE,OAAO,YAAyC;AAChD,SAAO;;CAEV;;;;;;;;;;;AAYD,MAAa,cAAgC;CAC3C,MAAM;CACN,EAAE,OAAO,YAA6C;AACpD,QAAMA;AACN,QAAM,IAAI,MAAM,+CAA+C;;CAElE;;;;;;;;;;;;;;;AAoBD,MAAa,UAAa,WAA4E,OAAO;;;;;;;;;;;;;;;AAgB7G,MAAa,UAAa,WAA6E,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiC/G,MAAa,OAAkB,QAAQ,WAAW;AAChD,KAAI,CAAC,OAAO,KAAM,QAAO;CACzB,MAAM,SAAS,GAAG,OAAO,MAAM;AAC/B,KAAI,kBAAkB,QACpB,QAAO,OAAO,KAAK,KAAK;AAE1B,QAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCrB,MAAa,WAA0B,QAAQ,WAAY,OAAO,OAAO,GAAG,OAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC5F,MAAa,OAAkB,QAAQ,WAAW;AAChD,KAAI,CAAC,OAAO,KAAM,QAAO;CACzB,MAAM,aAAa,GAAG,OAAO,MAAM;AACnC,KAAI,sBAAsB,QACxB,QAAO,WAAW,WAAW,OAAO;AAEtC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCT,MAAa,UAAwB,QAAQ,WAAY,OAAO,OAAO,SAAS,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BpF,MAAa,UAAwB,eAAe,WAAW;AAC7D,KAAI,CAAC,OAAO,KAAM,QAAO;AACzB,QAAO,UAAU,OAAO,MAAM,GAAG,SAAS,MAAM;;AAgClD,SAAgB,IAAI,SAAmB;AACrC,KAAI,MAAM,QAAQ,QAAQ,EAAE;EAC1B,MAAMC,WAAoB,EAAE;AAC5B,OAAK,MAAM,UAAU,SAAS;AAC5B,OAAI,CAAC,OAAO,KAAM,QAAO;AACzB,YAAO,KAAK,OAAO,MAAM;;AAE3B,SAAO,KAAKA,SAAO;;CAGrB,MAAM,SAAkC,EAAE;AAC1C,MAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,QAAQ,EAAE;EACnD,MAAM,IAAI;AACV,MAAI,CAAC,EAAE,KAAM,QAAO;AACpB,SAAO,OAAO,EAAE;;AAElB,QAAO,KAAK,OAAO;;;;;;;;;;;;;;AAoBrB,MAAa,YACP,kBACH,WACC,OAAO,OAAO,OAAO,QAAQ;;;;;;;;;;;;;;;AAgBjC,MAAa,gBACP,QACH,WACC,OAAO,OAAO,OAAO,QAAQ,IAAI;;;;;;;;;;;;;;;;;;AAmBrC,MAAa,SACJ,cACN,WACC,OAAO,OAAO,SAAS,KAAK,OAAO,MAAM,GAAG,SAAS,MAAM;;;;;;;;;;;;;;;AAoB/D,MAAa,gBAAmB,UAC9B,UAAU,QAAQ,UAAU,SAAY,MAAS,GAAG,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CjE,MAAa,WAAc,OAAkC;AAC3D,KAAI;EACF,MAAM,SAAS,IAAI;AACnB,MAAI,UAAU,OAAO,CACnB,QAAO,OAAO,KAAK,KAAK,CAAC,YAAY,MAAM,CAAC;AAE9C,SAAO,KAAK,OAAO;SACb;AACN,SAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCjB,MAAa,SAAS;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/option.types-D6TYG_i3.d.mts

@@ -0,0 +1,89 @@
+import { g as Yieldable } from "./result.types-Ce7AEOzj.mjs";
+
+//#region src/option/option.types.d.ts
+
+/**
+ * Marker type for Option's absence in the Do computation context.
+ * When an Option is yielded in Do, None becomes part of the error union.
+ */
+type None = {
+  readonly __typename: "None";
+};
+/**
+ * Singleton None value.
+ */
+declare const None: None;
+/**
+ * A discriminated union representing either a value (some) or absence (none).
+ * Compatible with ts-pattern for exhaustive matching.
+ * Implements Yieldable protocol for use in Do computations with yield*.
+ */
+type Option<T> = Yieldable<T, None> & ({
+  readonly some: true;
+  readonly value: T;
+} | {
+  readonly some: false;
+});
+/**
+ * Compute the return type of `fromTry` based on whether fn returns a Promise.
+ * - If fn returns Promise<T>, result is Promise<Option<T>>
+ * - If fn returns T, result is Option<T>
+ */
+type FromTryReturn<T> = T extends Promise<infer U> ? Promise<Option<U>> : Option<T>;
+/**
+ * Extract the value type from an Option.
+ * Uses structural matching to extract the value type from the some branch.
+ */
+type OptionValue<O> = O extends {
+  readonly some: true;
+  readonly value: infer T;
+} ? T : never;
+/**
+ * Compute return type for `all` with array input.
+ * Preserves tuple structure and extracts value types from each position.
+ */
+type AllArrayReturn<T extends readonly Option<unknown>[]> = Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>;
+/**
+ * Compute return type for `all` with object input.
+ * Preserves object structure and extracts value types from each key.
+ */
+type AllObjectReturn<T extends Record<string, Option<unknown>>> = Option<{ -readonly [K in keyof T]: OptionValue<T[K]> }>;
+/**
+ * Interface for flatMap - using method syntax improves generic inference in pipe chains.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type OptionFlatMap = {
+  <A, B>(fn: (value: A) => Promise<Option<B>>): (option: Option<A>) => Promise<Option<B>>;
+  <A, B>(fn: (value: A) => Option<B>): (option: Option<A>) => Option<B>;
+};
+/**
+ * Interface for map function.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type OptionMap = {
+  <A, B>(fn: (value: A) => Promise<B>): (option: Option<A>) => Promise<Option<B>>;
+  <A, B>(fn: (value: A) => B): (option: Option<A>) => Option<B>;
+};
+/**
+ * Interface for tap function.
+ */
+type OptionTap = {
+  <A, R>(fn: (value: A) => R): (option: Option<A>) => R extends Promise<unknown> ? Promise<Option<A>> : Option<A>;
+};
+/**
+ * Interface for orElse function.
+ * Note: Async overload must come first for proper overload resolution.
+ */
+type OptionOrElse = {
+  <A, B>(fn: () => Promise<Option<B>>): (option: Option<A>) => Promise<Option<A | B>>;
+  <A, B>(fn: () => Option<B>): (option: Option<A>) => Option<A | B>;
+};
+/**
+ * Interface for filter function.
+ */
+type OptionFilter = {
+  <A>(predicate: (value: A) => boolean): (option: Option<A>) => Option<A>;
+};
+//#endregion
+export { Option as a, OptionMap as c, None as i, OptionOrElse as l, AllObjectReturn as n, OptionFilter as o, FromTryReturn as r, OptionFlatMap as s, AllArrayReturn as t, OptionTap as u };
+//# sourceMappingURL=option.types-D6TYG_i3.d.mts.map

package/dist/option.types-D6TYG_i3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.types-D6TYG_i3.d.mts","names":[],"sources":["../src/option/option.types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/pipe/index.d.mts

@@ -0,0 +1,2 @@
+import { t as pipe } from "../index-yyBTq8Ys.mjs";
+export { pipe };

package/dist/pipe/index.mjs

@@ -0,0 +1,3 @@
+import { t as pipe } from "../pipe-GYxZNkPB.mjs";
+
+export { pipe };

package/dist/pipe-GYxZNkPB.mjs

@@ -0,0 +1,10 @@
+import { t as flow } from "./flow-pRdnqmMY.mjs";
+
+//#region src/pipe/pipe.ts
+function pipe(arg, ...fns) {
+	return flow(...fns)(arg);
+}
+
+//#endregion
+export { pipe as t };
+//# sourceMappingURL=pipe-GYxZNkPB.mjs.map

package/dist/pipe-GYxZNkPB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-GYxZNkPB.mjs","names":[],"sources":["../src/pipe/pipe.ts"],"sourcesContent":["import { flow } from \"../flow/flow\"\nimport type { PipeReturn } from \"../pipe/pipe.types\"\nimport type { λ } from \"../shared/lambda.types\"\n\n/**\n * Like `flow` but takes an argument as its first parameter and invokes the pipe\n * with it.\n *\n * Note: unlike in `flow`, the first function of the pipe must take exactly one\n * argument.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link flow} for point-free function composition (returns a function)\n *\n * @example\n * ```typescript\n * // Type inference in action\n * pipe(\n *   2,\n *   (n) => n * 2,      // n: number (inferred from initial value)\n *   (n) => n + 1,      // n: number (inferred from previous return)\n *   (n) => n.toString() // n: number (inferred from previous return)\n * )  // -> \"5\"\n *\n * // With type transformations\n * pipe(\n *   5,\n *   (n) => n.toString(),  // number -> string\n *   (s) => s.length,      // string -> number (inferred!)\n *   (n) => n * 2          // number -> number (inferred!)\n * )\n *\n * // With async functions - Promises are automatically unwrapped\n * await pipe(\n *   5,\n *   async (n) => n * 2,   // number -> Promise<number>\n *   (n) => n.toString(),  // n: number (Promise unwrapped!)\n *   async (s) => s.length // string -> Promise<number>\n * )\n * ```\n */\n// 1 function\nexport function pipe<A, B>(arg: A, f1: (arg: A) => B): PipeReturn<[typeof f1], A>\n// 2 functions\nexport function pipe<A, B, C>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): PipeReturn<[typeof f1, typeof f2], A>\n// 3 functions\nexport function pipe<A, B, C, D>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): PipeReturn<[typeof f1, typeof f2, typeof f3], A>\n// 4 functions\nexport function pipe<A, B, C, D, E>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4], A>\n// 5 functions\nexport function pipe<A, B, C, D, E, F>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5], A>\n// 6 functions\nexport function pipe<A, B, C, D, E, F, G>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6], A>\n// 7 functions\nexport function pipe<A, B, C, D, E, F, G, H>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7], A>\n// 8 functions\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8], A>\n// 9 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9], A>\n// 10 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): PipeReturn<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10],\n  A\n>\n// 11 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ],\n  A\n>\n// 12 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ],\n  A\n>\n// 13 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ],\n  A\n>\n// 14 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ],\n  A\n>\n// 15 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ],\n  A\n>\n// Implementation signature (fallback for 16+ functions)\n// oxlint-disable-next-line no-explicit-any\nexport function pipe<A, Fns extends [(arg: A) => any, ...λ[]]>(arg: A, ...fns: Fns): PipeReturn<Fns, A> {\n  // @ts-expect-error - we want to use the any type here\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion -- Required for pipe implementation\n  return (flow(...(fns as [λ, ...λ[]])) as any)(arg)\n}\n"],"mappings":";;;AA6TA,SAAgB,KAA+C,KAAQ,GAAG,KAA8B;AAGtG,QAAQ,KAAK,GAAI,IAAoB,CAAS,IAAI"}

package/dist/predicate/index.d.mts

@@ -0,0 +1,2 @@
+import { n as Predicate$1, r as Refinement, t as Predicate } from "../index-CcPnhWje.mjs";
+export { Predicate, Predicate$1 as PredicateType, Refinement };

package/dist/predicate/index.mjs

@@ -0,0 +1,3 @@
+import { t as Predicate } from "../predicate-B6-EdVgW.mjs";
+
+export { Predicate };