@nicolastoulemont/std 0.6.0 → 0.7.0

package/dist/index-8Ne4GdOG.d.mts

@@ -1,288 +0,0 @@
-//#region src/predicate/predicate.types.d.ts
-/**
- * A predicate function that tests a value and returns a boolean.
- *
- * @template T - The type of value being tested
- */
-type Predicate$1<in T> = (value: T) => boolean;
-/**
- * A refinement predicate that narrows type T to subtype U.
- * This is a type guard - when it returns true, TypeScript knows
- * the value is of the narrower type U.
- *
- * @template T - The base type
- * @template U - The narrower type (must extend T)
- *
- * @example
- * ```ts
- * // Built-in refinement
- * const isString: Refinement<unknown, string> = (v): v is string =>
- *   typeof v === "string"
- *
- * // Usage with filter
- * const mixed: (string | number)[] = ["a", 1, "b", 2]
- * const strings: string[] = mixed.filter(isString)
- * ```
- */
-type Refinement<in T, out U extends T> = (value: T) => value is U;
-//#endregion
-//#region src/predicate/predicate.d.ts
-/**
- * Negate a predicate.
- * Returns true when the original predicate returns false, and vice versa.
- *
- * @template T - The type being tested
- * @param predicate - The predicate to negate
- * @returns A new predicate that returns the opposite boolean
- *
- * @example
- * ```ts
- * const isEven = (n: number) => n % 2 === 0
- * const isOdd = Predicate.not(isEven)
- *
- * isOdd(3) // true
- * isOdd(4) // false
- *
- * // Works in filter
- * [1, 2, 3, 4].filter(Predicate.not(isEven)) // [1, 3]
- * ```
- */
-declare const not: <T>(predicate: Predicate$1<T>) => Predicate$1<T>;
-/**
- * Combine predicates with logical AND.
- * Returns true only when ALL predicates return true.
- * Short-circuits on first false (lazy evaluation).
- *
- * @template T - The type being tested
- * @param predicates - The predicates to combine
- * @returns A new predicate that returns true if all predicates pass
- *
- * @example
- * ```ts
- * const isPositive = (n: number) => n > 0
- * const isEven = (n: number) => n % 2 === 0
- * const isLessThan100 = (n: number) => n < 100
- *
- * const isValidNumber = Predicate.and(isPositive, isEven, isLessThan100)
- *
- * isValidNumber(42) // true
- * isValidNumber(-2) // false (not positive)
- * isValidNumber(101) // false (not less than 100)
- * ```
- */
-declare const and: <T>(...predicates: readonly Predicate$1<T>[]) => Predicate$1<T>;
-/**
- * Combine predicates with logical OR.
- * Returns true when ANY predicate returns true.
- * Short-circuits on first true (lazy evaluation).
- *
- * @template T - The type being tested
- * @param predicates - The predicates to combine
- * @returns A new predicate that returns true if any predicate passes
- *
- * @example
- * ```ts
- * const isZero = (n: number) => n === 0
- * const isNegative = (n: number) => n < 0
- *
- * const isNotPositive = Predicate.or(isZero, isNegative)
- *
- * isNotPositive(0) // true
- * isNotPositive(-5) // true
- * isNotPositive(5) // false
- * ```
- */
-declare const or: <T>(...predicates: readonly Predicate$1<T>[]) => Predicate$1<T>;
-/**
- * Create a predicate that tests if ALL elements in an array match.
- * Returns true for empty arrays (vacuous truth).
- *
- * @template T - The element type
- * @param predicate - The predicate to test each element
- * @returns A predicate that takes an array and returns true if all match
- *
- * @example
- * ```ts
- * const isPositive = (n: number) => n > 0
- * const allPositive = Predicate.all(isPositive)
- *
- * allPositive([1, 2, 3]) // true
- * allPositive([1, -2, 3]) // false
- * allPositive([]) // true (vacuous truth)
- *
- * // Useful for validation
- * const areAllAdults = Predicate.all((u: User) => u.age >= 18)
- * ```
- */
-declare const all: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
-/**
- * Create a predicate that tests if ANY element in an array matches.
- * Returns false for empty arrays.
- *
- * @template T - The element type
- * @param predicate - The predicate to test each element
- * @returns A predicate that takes an array and returns true if any match
- *
- * @example
- * ```ts
- * const isNegative = (n: number) => n < 0
- * const hasNegative = Predicate.some(isNegative)
- *
- * hasNegative([1, -2, 3]) // true
- * hasNegative([1, 2, 3]) // false
- * hasNegative([]) // false
- * ```
- */
-declare const some: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
-/**
- * Create a predicate that tests if NO elements in an array match.
- * Returns true for empty arrays (vacuous truth).
- * Equivalent to `not(some(predicate))`.
- *
- * @template T - The element type
- * @param predicate - The predicate that should NOT match any element
- * @returns A predicate that takes an array and returns true if none match
- *
- * @example
- * ```ts
- * const isNegative = (n: number) => n < 0
- * const noNegatives = Predicate.none(isNegative)
- *
- * noNegatives([1, 2, 3]) // true
- * noNegatives([1, -2, 3]) // false
- * noNegatives([]) // true (vacuous truth)
- * ```
- */
-declare const none: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
-/**
- * Combine refinements with logical AND, preserving type narrowing.
- * Use this instead of `and` when you need to preserve type guard behavior.
- *
- * @template T - The base type
- * @template U - The narrowed type (must extend T)
- * @param refinements - The refinements to combine
- * @returns A refinement that narrows to U if all refinements pass
- *
- * @example
- * ```ts
- * type User = { name: string; age: number; verified?: boolean }
- * type Adult = User & { age: number } // age >= 18
- * type VerifiedAdult = Adult & { verified: true }
- *
- * const isAdult = (u: User): u is Adult => u.age >= 18
- * const isVerified = (u: User): u is User & { verified: true } => u.verified === true
- *
- * // Combined refinement preserves type narrowing
- * const isVerifiedAdult = Predicate.andRefinement<User, VerifiedAdult>(isAdult, isVerified)
- *
- * if (isVerifiedAdult(user)) {
- *   user.verified // TypeScript knows this is true
- * }
- * ```
- */
-declare const andRefinement: <T, U extends T>(...refinements: readonly Refinement<T, U>[]) => Refinement<T, U>;
-/**
- * Combine refinements with logical OR, preserving type narrowing.
- * Use this instead of `or` when you need to preserve type guard behavior.
- *
- * @template T - The base type
- * @template U - The narrowed type (must extend T)
- * @param refinements - The refinements to combine
- * @returns A refinement that narrows to U if any refinement passes
- *
- * @example
- * ```ts
- * const isString = (v: unknown): v is string => typeof v === "string"
- * const isNumber = (v: unknown): v is number => typeof v === "number"
- *
- * const isStringOrNumber = Predicate.orRefinement<unknown, string | number>(isString, isNumber)
- *
- * if (isStringOrNumber(value)) {
- *   // value is string | number
- * }
- * ```
- */
-declare const orRefinement: <T, U extends T>(...refinements: readonly Refinement<T, U>[]) => Refinement<T, U>;
-/**
- * Create a predicate from a constant boolean value.
- * Useful for testing or as a placeholder.
- *
- * @template T - The type (can be anything)
- * @param value - The constant boolean to return
- * @returns A predicate that always returns the given value
- *
- * @example
- * ```ts
- * const alwaysTrue = Predicate.constant(true)
- * const alwaysFalse = Predicate.constant(false)
- *
- * alwaysTrue("anything") // true
- * alwaysFalse(42) // false
- * ```
- */
-declare const constant: <T>(value: boolean) => Predicate$1<T>;
-/**
- * Create a predicate that checks strict equality.
- *
- * @template T - The type being compared
- * @param expected - The value to compare against
- * @returns A predicate that returns true if value === expected
- *
- * @example
- * ```ts
- * const isZero = Predicate.equals(0)
- * const isHello = Predicate.equals("hello")
- *
- * isZero(0) // true
- * isZero(1) // false
- *
- * // Works with references too
- * const obj = { a: 1 }
- * const isObj = Predicate.equals(obj)
- * isObj(obj) // true
- * isObj({ a: 1 }) // false (different reference)
- * ```
- */
-declare const equals: <T>(expected: T) => Predicate$1<T>;
-/**
- * Predicate namespace containing composable boolean functions.
- *
- * Predicates are functions that test values and return booleans.
- * This namespace provides combinators to build complex predicates
- * from simple ones, with support for type guards (refinements).
- *
- * @example
- * ```ts
- * import { Predicate, pipe } from "@nicolastoulemont/std"
- *
- * // Basic predicates
- * const isPositive = (n: number) => n > 0
- * const isEven = (n: number) => n % 2 === 0
- *
- * // Combine with and/or
- * const isPositiveEven = Predicate.and(isPositive, isEven)
- * const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))
- *
- * // Array predicates
- * const allPositive = Predicate.all(isPositive)
- * const hasNegative = Predicate.some(Predicate.not(isPositive))
- *
- * // Use with filter
- * [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]
- * ```
- */
-declare const Predicate: {
-  readonly not: <T>(predicate: Predicate$1<T>) => Predicate$1<T>;
-  readonly and: <T>(...predicates: readonly Predicate$1<T>[]) => Predicate$1<T>;
-  readonly or: <T>(...predicates: readonly Predicate$1<T>[]) => Predicate$1<T>;
-  readonly all: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
-  readonly some: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
-  readonly none: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
-  readonly andRefinement: <T, U extends T>(...refinements: readonly Refinement<T, U>[]) => Refinement<T, U>;
-  readonly orRefinement: <T, U extends T>(...refinements: readonly Refinement<T, U>[]) => Refinement<T, U>;
-  readonly constant: <T>(value: boolean) => Predicate$1<T>;
-  readonly equals: <T>(expected: T) => Predicate$1<T>;
-};
-//#endregion
-export { constant as a, not as c, some as d, Predicate$1 as f, andRefinement as i, or as l, all as n, equals as o, Refinement as p, and as r, none as s, Predicate as t, orRefinement as u };
-//# sourceMappingURL=index-8Ne4GdOG.d.mts.map

package/dist/index-8Ne4GdOG.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-8Ne4GdOG.d.mts","names":[],"sources":["../src/predicate/predicate.types.ts","../src/predicate/predicate.ts"],"sourcesContent":[],"mappings":";;AAKA;AAqBA;;;AAAuE,KArB3D,WAqB2D,CAAA,IAAA,CAAA,GAAA,CAAA,KAAA,EArBjC,CAqBiC,EAAA,GAAA,OAAA;;;;;ACJvE;;;;;;AA0BA;;;;;;AA8BA;;;AAAiF,KDpDrE,UCoDqE,CAAA,IAAA,EAAA,cDpDtC,CCoDsC,CAAA,GAAA,CAAA,KAAA,EDpDzB,CCoDyB,EAAA,GAAA,KAAA,IDpDV,CCoDU;;;ADzEjF;AAqBA;;;;;;;;ACJA;;;;;;AA0BA;;;;;AAAiF,cA1BpE,GA0BoE,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EA1B/C,WA0B+C,CA1BjC,CA0BiC,CAAA,EAAA,GA1B5B,WA0B4B,CA1Bd,CA0Bc,CAAA;AA8BjF;;;;;;AA8BA;;;;;;AAsBA;;;;;;AAuBA;;;;AAAsD,cAzGzC,GAyGyC,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SAzGP,WAyGO,CAzGO,CAyGP,CAAA,EAAA,EAAA,GAzGc,WAyGd,CAzG4B,CAyG5B,CAAA;;AA8BtD;;;;;;;;;AA8BA;;;;;;;;;AA0BA;AA0BA;AAAoC,cA3LvB,EA2LuB,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SA3LU,WA2LV,CA3LwB,CA2LxB,CAAA,EAAA,EAAA,GA3L+B,WA2L/B,CA3L6C,CA2L7C,CAAA;;;;AA+BpC;;;;;;;;;;;;;;;;;;AAtKmC,cAtBtB,GAsBsB,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EAtBD,WAsBC,CAtBa,CAsBb,CAAA,EAAA,GAtBkB,WAsBlB,CAAA,SAtByC,CAsBzC,EAAA,CAAA;;;;;;;;;;;;;;;;;;;AAmFsE,cAnF5F,IAmF4F,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EAnFtE,WAmFsE,CAnFxD,CAmFwD,CAAA,EAAA,GAnFnD,WAmFmD,CAAA,SAnF5B,CAmF4B,EAAA,CAAA;;;;;;;;;;;;;;;;;;;;cA5D5F,qBAAsB,YAAc,OAAK,qBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BhE,6BAA8B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;cA8B7F,4BAA6B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;cA0B5F,iCAAgC,YAAc;;;;;;;;;;;;;;;;;;;;;;;cA0B9C,sBAAuB,MAAI,YAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BzC;+BAlRqB,YAAc,OAAK,YAAc;4CA0BpB,YAAc,SAAO,YAAc;2CA8BpC,YAAc,SAAO,YAAc;+BA8B/C,YAAc,OAAK,qBAAuB;gCAsBzC,YAAc,OAAK,qBAAuB;gCAuB1C,YAAc,OAAK,qBAAuB;wCA8BlC,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;uCA8BhE,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;4CA0B5D,YAAc;iCA0BvB,MAAI,YAAc"}

package/dist/index-B2l8_CiD.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B2l8_CiD.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;AAqCA;;;;;AA6BA;;;;AAA4C,cA7B/B,EA6B+B,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EA7Bf,CA6Be,EAAA,GA7BX,QA6BW,CA7BA,CA6BA,EAAA,KAAA,CAAA;AAoC5C;;;;;;;;;AAiBA;;AAAkD,cArDrC,GAqDqC,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EArDpB,CAqDoB,EAAA,GArDhB,QAqDgB,CAAA,KAAA,EArDE,CAqDF,CAAA;;;;;;;AAyClD;AA6CA;AA+CA;AAyCA;AAqDA;AAyCA;AA0CA;AA+CA;AA2Ba,cAjZA,IAoZZ,EAAA,CAAA,CAAA,EAH0B,CAAA,CAAA,CAAA,MAAA,EAjZQ,QAoZlC,CApZ6C,CAoZ7C,EApZgD,CAoZhD,CAAA,EAAA,GAAA,MAAA,IApZ+D,OAoZ/D,CApZuE,QAoZvE,CApZkF,CAoZlF,EApZqF,CAoZrF,CAAA,EAAA;EA8BY,IAAA,EAAA,IAIZ;AAoCD,CAAA,CAAA;AAyDA;;;;;;;;;;;;;;AAlgB+C,cAAlC,KAAkC,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,MAAA,EAAX,QAAW,CAAA,CAAA,EAAG,CAAH,CAAA,EAAA,GAAA,MAAA,IAAkB,OAAlB,CAA0B,QAA1B,CAAqC,CAArC,EAAwC,CAAxC,CAAA,EAAA;EAAG,IAAA,EAAA,KAAA;CAAd,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCvB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6CL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqDL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCR,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;cA0CR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;cA+CL,UAAU;;;;;;;;;;;;;;;;;;;;;;;cA2BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCd,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCP,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;cAyDT;0BAplBgB,MAAI,SAAW;2BA6Bd,MAAI,gBAAkB;gCAoCjB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;iCAiBlD,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG"}

package/dist/index-BOrJQBPO.d.mts

@@ -1,80 +0,0 @@
-import { n as λ, t as ApplyFn } from "./apply-fn.types-0g_9eXRy.mjs";
-
-//#region src/flow/flow.types.d.ts
-
-/**
- * The return type of a flow composition - a function with the first function's
- * parameters that returns the final computed type.
- */
-type FlowdFun<Fns extends λ[]> = Fns extends [infer First extends λ, ...any[]] ? (...args: Parameters<First>) => FlowReturn<Fns, ReturnType<First>> : never;
-/**
- * Recursively compute the return type of a flow chain.
- * Threads the actual types through each function for better generic inference.
- */
-type FlowReturn<Fns extends λ[], Input> = Fns extends [any, infer Second extends λ, ...infer Rest extends λ[]] ? Input extends Promise<infer Awaited> ? Promise<FlowReturnAsync<[Second, ...Rest], Awaited>> : FlowReturn<[Second, ...Rest], ApplyFn<Second, Input>> : Input extends Promise<infer Awaited> ? Promise<Awaited> : Input;
-/**
- * Continue flow computation after encountering a Promise.
- */
-type FlowReturnAsync<Fns extends λ[], Input> = Fns extends [infer First extends λ, ...infer Rest extends λ[]] ? Rest extends [] ? ApplyFn<First, Input> extends Promise<infer Awaited> ? Awaited : ApplyFn<First, Input> : ApplyFn<First, Input> extends Promise<infer Awaited> ? FlowReturnAsync<Rest, Awaited> : FlowReturnAsync<Rest, ApplyFn<First, Input>> : Input;
-//#endregion
-//#region src/flow/flow.d.ts
-/**
- * Given a list of functions returns a function that will execute the given
- * functions one after another, always passing the result of the previous
- * function as an argument to the next function.
- *
- * If one of the given functions returns a promise, the promise will be resolved
- * before being passed to the next function.
- *
- * Type inference: This function provides automatic type inference for chains of
- * 1-15 functions. Each function's parameter type is automatically inferred from
- * the previous function's return type. For chains longer than 15 functions,
- * types must be explicitly specified.
- *
- * Async support: Functions can return Promises. The runtime automatically awaits
- * Promises before passing values to subsequent functions, and parameter types
- * use `Awaited<T>` to reflect this behavior. The final return type will be
- * Promise<T> if any function returns a Promise.
- *
- * @see {@link pipe} for immediate execution with an initial value
- *
- * @example
- * ```typescript
- * const join = (...chars: string[]) => chars.join('')
- * flow(join, parseInt)('1', '2', '3')  // -> 123
- *
- * const square = (n: number) => n ** 2
- *
- * // this is equivalent to: square(square(square(2)))
- * flow(square, square, square)(2)  // -> 256
- *
- * // Type inference in action
- * const fn = flow(
- *   (n: number) => n * 2,      // First function must be typed
- *   (n) => n + 1,               // n: number (inferred!)
- *   (n) => n.toString()         // n: number (inferred!)
- * )
- *
- * // also works with promises:
- * // fetchNumber :: async () => Promise<number>
- * flow(fetchNumber, n => n.toString())  // async () => Promise<string>
- * ```
- */
-declare function flow<A extends unknown[], B>(f1: (...args: A) => B): FlowdFun<[typeof f1]>;
-declare function flow<A extends unknown[], B, C>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C): FlowdFun<[typeof f1, typeof f2]>;
-declare function flow<A extends unknown[], B, C, D>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D): FlowdFun<[typeof f1, typeof f2, typeof f3]>;
-declare function flow<A extends unknown[], B, C, D, E>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4]>;
-declare function flow<A extends unknown[], B, C, D, E, F>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J, f10: (arg: Awaited<J>) => K): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J, f10: (arg: Awaited<J>) => K, f11: (arg: Awaited<K>) => L): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10, typeof f11]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J, f10: (arg: Awaited<J>) => K, f11: (arg: Awaited<K>) => L, f12: (arg: Awaited<L>) => M): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10, typeof f11, typeof f12]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J, f10: (arg: Awaited<J>) => K, f11: (arg: Awaited<K>) => L, f12: (arg: Awaited<L>) => M, f13: (arg: Awaited<M>) => N): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10, typeof f11, typeof f12, typeof f13]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J, f10: (arg: Awaited<J>) => K, f11: (arg: Awaited<K>) => L, f12: (arg: Awaited<L>) => M, f13: (arg: Awaited<M>) => N, f14: (arg: Awaited<N>) => O): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10, typeof f11, typeof f12, typeof f13, typeof f14]>;
-declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(f1: (...args: A) => B, f2: (arg: Awaited<B>) => C, f3: (arg: Awaited<C>) => D, f4: (arg: Awaited<D>) => E, f5: (arg: Awaited<E>) => F, f6: (arg: Awaited<F>) => G, f7: (arg: Awaited<G>) => H, f8: (arg: Awaited<H>) => I, f9: (arg: Awaited<I>) => J, f10: (arg: Awaited<J>) => K, f11: (arg: Awaited<K>) => L, f12: (arg: Awaited<L>) => M, f13: (arg: Awaited<M>) => N, f14: (arg: Awaited<N>) => O, f15: (arg: Awaited<O>) => P): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10, typeof f11, typeof f12, typeof f13, typeof f14, typeof f15]>;
-//#endregion
-export { flow as t };
-//# sourceMappingURL=index-BOrJQBPO.d.mts.map

package/dist/index-BOrJQBPO.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BOrJQBPO.d.mts","names":[],"sources":["../src/flow/flow.types.ts","../src/flow/flow.ts"],"sourcesContent":[],"mappings":"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hB,ED9BgB,EAAA,OC8BL,ED9BK,EAAA,OC8BM,ED9BN,EAAA,OC8BiB,ED9BjB,CAAA,CAAA;AAEpB,iBC8BA,ID9BA,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EC+BA,CD/BA,EAAA,GC+BM,CD/BN,EAAA,EAAA,EAAA,CAAA,GAAA,ECgCJ,ODhCI,CCgCI,CDhCJ,CAAA,EAAA,GCgCW,CDhCX,EAAA,EAAA,EAAA,CAAA,GAAA,ECiCJ,ODjCI,CCiCI,CDjCJ,CAAA,EAAA,GCiCW,CDjCX,EAAA,EAAA,EAAA,CAAA,GAAA,ECkCJ,ODlCI,CCkCI,CDlCJ,CAAA,EAAA,GCkCW,CDlCX,EAAA,EAAA,EAAA,CAAA,GAAA,ECmCJ,ODnCI,CCmCI,CDnCJ,CAAA,EAAA,GCmCW,CDnCX,CAAA,ECoCb,QDpCa,CAAA,CAAA,OCoCI,EDpCJ,EAAA,OCoCe,EDpCf,EAAA,OCoC0B,EDpC1B,EAAA,OCoCqC,EDpCrC,EAAA,OCoCgD,EDpChD,CAAA,CAAA;AAAO,iBCsCP,IDtCO,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECuCP,CDvCO,EAAA,GCuCD,CDvCC,EAAA,EAAA,EAAA,CAAA,GAAA,ECwCX,ODxCW,CCwCH,CDxCG,CAAA,EAAA,GCwCI,CDxCJ,EAAA,EAAA,EAAA,CAAA,GAAA,ECyCX,ODzCW,CCyCH,CDzCG,CAAA,EAAA,GCyCI,CDzCJ,EAAA,EAAA,EAAA,CAAA,GAAA,EC0CX,OD1CW,CC0CH,CD1CG,CAAA,EAAA,GC0CI,CD1CJ,EAAA,EAAA,EAAA,CAAA,GAAA,EC2CX,OD3CW,CC2CH,CD3CG,CAAA,EAAA,GC2CI,CD3CJ,EAAA,EAAA,EAAA,CAAA,GAAA,EC4CX,OD5CW,CC4CH,CD5CG,CAAA,EAAA,GC4CI,CD5CJ,CAAA,EC6CpB,QD7CoB,CAAA,CAAA,OC6CH,ED7CG,EAAA,OC6CQ,ED7CR,EAAA,OC6CmB,ED7CnB,EAAA,OC6C8B,ED7C9B,EAAA,OC6CyC,ED7CzC,EAAA,OC6CoD,ED7CpD,CAAA,CAAA;AAAf,iBC+CQ,ID/CR,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECgDQ,CDhDR,EAAA,GCgDc,CDhDd,EAAA,EAAA,EAAA,CAAA,GAAA,ECiDI,ODjDJ,CCiDY,CDjDZ,CAAA,EAAA,GCiDmB,CDjDnB,EAAA,EAAA,EAAA,CAAA,GAAA,ECkDI,ODlDJ,CCkDY,CDlDZ,CAAA,EAAA,GCkDmB,CDlDnB,EAAA,EAAA,EAAA,CAAA,GAAA,ECmDI,ODnDJ,CCmDY,CDnDZ,CAAA,EAAA,GCmDmB,CDnDnB,EAAA,EAAA,EAAA,CAAA,GAAA,ECoDI,ODpDJ,CCoDY,CDpDZ,CAAA,EAAA,GCoDmB,CDpDnB,EAAA,EAAA,EAAA,CAAA,GAAA,ECqDI,ODrDJ,CCqDY,CDrDZ,CAAA,EAAA,GCqDmB,CDrDnB,EAAA,EAAA,EAAA,CAAA,GAAA,ECsDI,ODtDJ,CCsDY,CDtDZ,CAAA,EAAA,GCsDmB,CDtDnB,CAAA,ECuDL,QDvDK,CAAA,CAAA,OCuDY,EDvDZ,EAAA,OCuDuB,EDvDvB,EAAA,OCuDkC,EDvDlC,EAAA,OCuD6C,EDvD7C,EAAA,OCuDwD,EDvDxD,EAAA,OCuDmE,EDvDnE,EAAA,OCuD8E,EDvD9E,CAAA,CAAA;AACM,iBCwDE,IDxDF,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECyDE,CDzDF,EAAA,GCyDQ,CDzDR,EAAA,EAAA,EAAA,CAAA,GAAA,EC0DF,OD1DE,CC0DM,CD1DN,CAAA,EAAA,GC0Da,CD1Db,EAAA,EAAA,EAAA,CAAA,GAAA,EC2DF,OD3DE,CC2DM,CD3DN,CAAA,EAAA,GC2Da,CD3Db,EAAA,EAAA,EAAA,CAAA,GAAA,EC4DF,OD5DE,CC4DM,CD5DN,CAAA,EAAA,GC4Da,CD5Db,EAAA,EAAA,EAAA,CAAA,GAAA,EC6DF,OD7DE,CC6DM,CD7DN,CAAA,EAAA,GC6Da,CD7Db,EAAA,EAAA,EAAA,CAAA,GAAA,EC8DF,OD9DE,CC8DM,CD9DN,CAAA,EAAA,GC8Da,CD9Db,EAAA,EAAA,EAAA,CAAA,GAAA,EC+DF,OD/DE,CC+DM,CD/DN,CAAA,EAAA,GC+Da,CD/Db,EAAA,EAAA,EAAA,CAAA,GAAA,ECgEF,ODhEE,CCgEM,CDhEN,CAAA,EAAA,GCgEa,CDhEb,CAAA,ECiEX,QDjEW,CAAA,CAAA,OCiEM,EDjEN,EAAA,OCiEiB,EDjEjB,EAAA,OCiE4B,EDjE5B,EAAA,OCiEuC,EDjEvC,EAAA,OCiEkD,EDjElD,EAAA,OCiE6D,EDjE7D,EAAA,OCiEwE,EDjExE,EAAA,OCiEmF,EDjEnF,CAAA,CAAA;AAAO,iBCmEL,IDnEK,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECoEL,CDpEK,EAAA,GCoEC,CDpED,EAAA,EAAA,EAAA,CAAA,GAAA,ECqET,ODrES,CCqED,CDrEC,CAAA,EAAA,GCqEM,CDrEN,EAAA,EAAA,EAAA,CAAA,GAAA,ECsET,ODtES,CCsED,CDtEC,CAAA,EAAA,GCsEM,CDtEN,EAAA,EAAA,EAAA,CAAA,GAAA,ECuET,ODvES,CCuED,CDvEC,CAAA,EAAA,GCuEM,CDvEN,EAAA,EAAA,EAAA,CAAA,GAAA,ECwET,ODxES,CCwED,CDxEC,CAAA,EAAA,GCwEM,CDxEN,EAAA,EAAA,EAAA,CAAA,GAAA,ECyET,ODzES,CCyED,CDzEC,CAAA,EAAA,GCyEM,CDzEN,EAAA,EAAA,EAAA,CAAA,GAAA,EC0ET,OD1ES,CC0ED,CD1EC,CAAA,EAAA,GC0EM,CD1EN,EAAA,EAAA,EAAA,CAAA,GAAA,EC2ET,OD3ES,CC2ED,CD3EC,CAAA,EAAA,GC2EM,CD3EN,EAAA,EAAA,EAAA,CAAA,GAAA,EC4ET,OD5ES,CC4ED,CD5EC,CAAA,EAAA,GC4EM,CD5EN,CAAA,EC6ElB,QD7EkB,CAAA,CAAA,OC6ED,ED7EC,EAAA,OC6EU,ED7EV,EAAA,OC6EqB,ED7ErB,EAAA,OC6EgC,ED7EhC,EAAA,OC6E2C,ED7E3C,EAAA,OC6EsD,ED7EtD,EAAA,OC6EiE,ED7EjE,EAAA,OC6E4E,ED7E5E,EAAA,OC6EuF,ED7EvF,CAAA,CAAA;AAAf,iBC+EU,ID/EV,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECgFU,CDhFV,EAAA,GCgFgB,CDhFhB,EAAA,EAAA,EAAA,CAAA,GAAA,ECiFM,ODjFN,CCiFc,CDjFd,CAAA,EAAA,GCiFqB,CDjFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECkFM,ODlFN,CCkFc,CDlFd,CAAA,EAAA,GCkFqB,CDlFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECmFM,ODnFN,CCmFc,CDnFd,CAAA,EAAA,GCmFqB,CDnFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECoFM,ODpFN,CCoFc,CDpFd,CAAA,EAAA,GCoFqB,CDpFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECqFM,ODrFN,CCqFc,CDrFd,CAAA,EAAA,GCqFqB,CDrFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECsFM,ODtFN,CCsFc,CDtFd,CAAA,EAAA,GCsFqB,CDtFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECuFM,ODvFN,CCuFc,CDvFd,CAAA,EAAA,GCuFqB,CDvFrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECwFM,ODxFN,CCwFc,CDxFd,CAAA,EAAA,GCwFqB,CDxFrB,EAAA,GAAA,EAAA,CAAA,GAAA,ECyFO,ODzFP,CCyFe,CDzFf,CAAA,EAAA,GCyFsB,CDzFtB,CAAA,EC0FH,QD1FG,CAAA,CAA8B,OC2F1B,ED3F0B,EACZ,OC0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"}

package/dist/index-BsXtpnw-.d.mts

@@ -1,225 +0,0 @@
-import { c as FxTypeId } from "./fx.types-B34asVRX.mjs";
-
-//#region src/err/err.types.d.ts
-
-/**
- * A tagged error type with a discriminator and optional data.
- * Uses `_tag` to match the existing pattern from `data/tagged`.
- * Implements Fx protocol so it can be yielded in Fx.gen computations.
- *
- * @template Tag - The error tag (discriminator string)
- * @template Data - Additional error data (optional)
- *
- * @example
- * ```ts
- * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
- * type ValidationError = TaggedError<"ValidationError", { field: string; message: string }>
- * type UnauthorizedError = TaggedError<"UnauthorizedError"> // No additional data
- * ```
- */
-type TaggedError$1<Tag extends string, Data extends object = object> = {
-  readonly _tag: Tag;
-  readonly [FxTypeId]: {
-    readonly _A: () => never;
-    readonly _E: () => TaggedError$1<Tag, Data>;
-    readonly _R: () => never;
-  };
-  [Symbol.iterator](): Generator<TaggedError$1<Tag, Data>, never, unknown>;
-} & Readonly<Data>;
-/**
- * Type for instances created by the TaggedError class factory.
- * Extends Error and includes the tag, data, Fx protocol, and Yieldable protocol.
- * When yielded, yields itself as an Fx type for proper inference.
- *
- * @template Tag - The error tag (discriminator string)
- * @template Data - Additional error data (optional)
- */
-type TaggedErrorInstance<Tag extends string, Data extends object = object> = TaggedError$1<Tag, Data> & Error;
-/**
- * Type for the class returned by TaggedError factory.
- * Supports the Effect-style curried syntax: `TaggedError("Tag")<{ data }>` and `TaggedError("Tag")`
- *
- * @template Tag - The error tag (discriminator string)
- */
-type TaggedErrorFactory<Tag extends string> = {
-  new <Data extends object = object>(...args: keyof Data extends never ? [] : [data: Data]): TaggedErrorInstance<Tag, Data>;
-  readonly _tag: Tag;
-};
-/**
- * Extract the tag from a tagged error type.
- *
- * @template E - A TaggedError type
- *
- * @example
- * ```ts
- * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
- * type Tag = ErrorTag<NotFoundError> // "NotFoundError"
- * ```
- */
-type ErrorTag<E> = E extends TaggedError$1<infer Tag> ? Tag : never;
-/**
- * Extract the data (excluding _tag) from a tagged error type.
- *
- * @template E - A TaggedError type
- *
- * @example
- * ```ts
- * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
- * type Data = ErrorData<NotFoundError> // { id: string }
- * ```
- */
-type ErrorData<E> = E extends TaggedError$1<string, infer Data> ? Data : never;
-//#endregion
-//#region src/err/err.d.ts
-/**
- * Helper type to extract data fields from a TaggedError (excluding _tag and Fx protocol)
- */
-type DataOf<E extends TaggedError<string>> = Omit<E, "_tag" | typeof FxTypeId | typeof Symbol.iterator>;
-/**
- * Helper type to check if data is empty (only has _tag)
- */
-type IsEmptyData<Data> = keyof Data extends never ? true : false;
-/**
- * Create a constructor function for a tagged error type.
- * If the error has no additional data, returns a function that takes no arguments.
- * If the error has data, returns a function that requires the data object.
- *
- * @template E - The tagged error type
- * @param tag - The error tag (must match E's _tag)
- * @returns A constructor function for the error type
- *
- * @example
- * ```ts
- * // Error with data
- * type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
- * const NotFound = Err.tagged<NotFoundError>("NotFoundError")
- * const err = NotFound({ resourceId: "user-123" })
- * // { _tag: "NotFoundError", resourceId: "user-123" }
- *
- * // Error without data
- * type UnauthorizedError = TaggedError<"UnauthorizedError">
- * const Unauthorized = Err.tagged<UnauthorizedError>("UnauthorizedError")
- * const err = Unauthorized()
- * // { _tag: "UnauthorizedError" }
- * ```
- */
-declare const tagged: <E extends TaggedError<string>>(tag: E["_tag"]) => IsEmptyData<DataOf<E>> extends true ? () => E : (data: DataOf<E>) => E;
-/**
- * Create a class-based tagged error type (Effect-style syntax).
- * Returns a class that can be extended to create custom error types.
- * Errors are native Error objects with proper stack traces and instanceof support.
- * Implements Yieldable protocol so errors can be directly yielded in Fx.gen computations.
- *
- * @template Tag - The error tag (discriminator string)
- * @param tag - The error tag
- * @returns A class that can be extended with custom data
- *
- * @example
- * ```ts
- * // Error with data
- * class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
- * const err = new NotFoundError({ id: "123" })
- * err.id // "123"
- * err._tag // "NotFoundError"
- * err.stack // Error stack trace
- *
- * // Error without data
- * class UnauthorizedError extends TaggedError("UnauthorizedError") {}
- * const err2 = new UnauthorizedError()
- *
- * // Direct yielding in Fx.gen computation
- * const program = Fx.gen(function* () {
- *   yield* new NotFoundError({ id: "123" })  // Short-circuits with error
- * })
- *
- * // instanceof checks work
- * if (err instanceof NotFoundError) {
- *   console.log(err.id)
- * }
- * ```
- */
-declare function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<Tag>;
-/**
- * Create a type guard for a tagged error type.
- * Returns a curried function that checks if a value is the specified error type.
- *
- * @template E - The tagged error type to check for
- * @param tag - The error tag to match
- * @returns A type guard function
- *
- * @example
- * ```ts
- * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
- *
- * const error: unknown = getError()
- *
- * if (Err.is<NotFoundError>("NotFoundError")(error)) {
- *   console.log(error.id) // TypeScript knows error is NotFoundError
- * }
- *
- * // Works with union error types
- * type AppError = NotFoundError | ValidationError | DbError
- *
- * function handleError(error: AppError) {
- *   if (Err.is<NotFoundError>("NotFoundError")(error)) {
- *     // Handle not found
- *   } else if (Err.is<ValidationError>("ValidationError")(error)) {
- *     // Handle validation error
- *   }
- * }
- * ```
- */
-declare const is: <E extends TaggedError<string>>(tag: E["_tag"]) => ((error: unknown) => error is E);
-/**
- * Err namespace containing utilities for creating and checking tagged errors.
- *
- * Tagged errors are plain objects with a `_tag` discriminator field,
- * making them serializable and easy to pattern match.
- *
- * @example
- * ```ts
- * import { Err, Result, Fx, pipe } from "@nicolastoulemont/std"
- * import type { TaggedError } from "@nicolastoulemont/std"
- *
- * // Define error types
- * type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
- * type ValidationError = TaggedError<"ValidationError", { field: string; message: string }>
- *
- * // Create constructors
- * const NotFound = Err.tagged<NotFoundError>("NotFoundError")
- * const Validation = Err.tagged<ValidationError>("ValidationError")
- *
- * // Use with Result
- * function findUser(id: string): Result<User, NotFoundError> {
- *   const user = db.find(id)
- *   if (!user) return Result.err(NotFound({ resourceId: id }))
- *   return Result.ok(user)
- * }
- *
- * // Use with Fx.gen computation
- * const program = Fx.gen(function* () {
- *   const user = yield* findUser("123")
- *   return user
- * })
- *
- * // Pattern match on error types
- * pipe(
- *   program.run(),
- *   Result.match({
- *     Ok: (user) => console.log(user),
- *     Err: (error) => {
- *       if (Err.is<NotFoundError>("NotFoundError")(error)) {
- *         console.log(`Not found: ${error.resourceId}`)
- *       }
- *     }
- *   })
- * )
- * ```
- */
-declare const Err: {
-  readonly tagged: <E extends TaggedError<string>>(tag: E["_tag"]) => IsEmptyData<DataOf<E>> extends true ? () => E : (data: DataOf<E>) => E;
-  readonly is: <E extends TaggedError<string>>(tag: E["_tag"]) => ((error: unknown) => error is E);
-};
-//#endregion
-export { ErrorData as a, TaggedErrorFactory as c, tagged as i, TaggedErrorInstance as l, TaggedError as n, ErrorTag as o, is as r, TaggedError$1 as s, Err as t };
-//# sourceMappingURL=index-BsXtpnw-.d.mts.map

package/dist/index-BsXtpnw-.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BsXtpnw-.d.mts","names":[],"sources":["../src/err/err.types.ts","../src/err/err.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;;;;;;AAkBY,KAlBA,aAkBA,CAAA,YAAmB,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GAAA;EAAiE,SAAA,IAAA,EAjB/E,GAiB+E;EAAK,UAhBzF,QAAA,CAgByF,EAAA;IAAjB,SAAA,EAAA,EAAA,GAAA,GAAA,KAAA;IAAyB,SAAA,EAAA,EAAA,GAAA,GAdtF,aAcsF,CAd1E,GAc0E,EAdrE,IAcqE,CAAA;IAAK,SAAA,EAAA,EAAA,GAAA,GAAA,KAAA;EAQtG,CAAA;EAEO,CAAA,MAAA,CAAA,QAAA,GAAA,EArBI,SAqBJ,CArBc,aAqBd,CArB0B,GAqB1B,EArB+B,IAqB/B,CAAA,EAAA,KAAA,EAAA,OAAA,CAAA;CAAiC,GApBhD,QAoBgD,CApBvC,IAoBuC,CAAA;;;;;;AAgBpD;AAaA;;KAvCY,wEAAwE,cAAY,KAAK,QAAQ;;AClC3C;;;;;AAOrB,KDmCjC,kBCnCiC,CAAA,YAAA,MAAA,CAAA,GAAA;EAAI,IAAA,CAAA,aAAA,MAAA,GAAA,MAAA,CAAA,CAAA,GAAA,IAAA,EAAA,MDqC9B,ICrC8B,SAAA,KAAA,GAAA,EAAA,GAAA,CAAA,IAAA,EDqCG,ICrCH,CAAA,CAAA,EDsC5C,mBCtC4C,CDsCxB,GCtCwB,EDsCnB,ICtCmB,CAAA;EAK5C,SAAA,IAAA,EDkCY,GClCD;AA0BhB,CAAA;;;;;;;;;;;AAwCA;AAAqD,KDlBzC,QCkByC,CAAA,CAAA,CAAA,GDlB3B,CCkB2B,SDlBjB,aCkBiB,CAAA,KAAA,IAAA,CAAA,GAAA,GAAA,GAAA,KAAA;;;;AAwDrD;;;;;AAmDA;;;AAjJwB,KDiCZ,SCjCY,CAAA,CAAA,CAAA,GDiCG,CCjCH,SDiCa,aCjCb,CAAA,MAAA,EAAA,KAAA,KAAA,CAAA,GAAA,IAAA,GAAA,KAAA;;;;ADxBxB;;KCTK,MDa8B,CAAA,UCbb,WDaa,CAAA,MAAA,CAAA,CAAA,GCbU,IDaV,CCbe,CDaf,EAAA,MAAA,GAAA,OCbkC,QDalC,GAAA,OCboD,MAAA,CAAO,QDa3D,CAAA;;;;KCR9B,WDWwC,CAAA,IAAA,CAAA,GAAA,MCXd,IDWc,SAAA,KAAA,GAAA,IAAA,GAAA,KAAA;;;;;;;AAW7C;;;;;;AAQA;;;;;;;;AAkBA;AAaA;;;cCnCa,mBAAmB,0BACzB,cACF,YAAY,OAAO,yBAAyB,WAAW,OAAO,OAAO;AAxCR;;;;;;;AAOjB;AA+BjD;;;;;;;;;;;AAwCA;;;;;AAwDA;;;;;AAmDA;;;;;AAjJK,iBAsCW,WAtCX,CAAA,YAAA,MAAA,CAAA,CAAA,GAAA,EAsCgD,GAtChD,CAAA,EAsCsD,kBAtCtD,CAsCyE,GAtCzE,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8FQ,eAAgB,0BAA0B,4CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmDpF;8BAnJmB,0BACzB,cACF,YAAY,OAAO,yBAAyB,WAAW,OAAO,OAAO;0BA8F7C,0BAA0B,4CAA0C"}

package/dist/index-BzYtgdX0.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BzYtgdX0.d.mts","names":[],"sources":["../src/data/data.types.ts","../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":[],"mappings":"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"}