@nicolastoulemont/std 0.2.0 → 0.4.0

package/dist/index-BFhV56qy.d.mts

@@ -1,105 +0,0 @@
-import { i as Result } from "./result.types-Bd8a43Fg.mjs";
-
-//#region src/brand/brand.types.d.ts
-
-/**
- * Unique symbol for brand keys to ensure true nominal typing.
- * Using a symbol prevents collision with actual property keys.
- */
-declare const BrandSymbol: unique symbol;
-/**
- * A brand type that adds nominal typing to TypeScript.
- * The brand exists only at the type level - no runtime cost.
- *
- * @template K - The brand key (typically a string literal type)
- */
-type Brand$1<K extends string> = {
-  readonly [BrandSymbol]: K;
-};
-/**
- * Create a branded type by intersecting a base type with a brand.
- * The resulting type is structurally compatible with T but nominally unique.
- *
- * @template T - The base type to brand
- * @template K - The brand key (string literal)
- *
- * @example
- * ```ts
- * type UserId = Branded<string, "UserId">
- * type OrderId = Branded<string, "OrderId">
- *
- * // UserId and OrderId are incompatible even though both are strings
- * declare const userId: UserId
- * declare const orderId: OrderId
- * userId = orderId // Type error!
- * ```
- */
-type Branded<T, K extends string> = T & Brand$1<K>;
-/**
- * Extract the base type from a branded type.
- * Useful for working with the underlying value.
- *
- * @template B - A branded type
- */
-type Unbrand<B> = B extends Branded<infer T, string> ? T : B;
-/**
- * Extract the brand key from a branded type.
- *
- * @template B - A branded type
- */
-type BrandKey<B> = B extends Brand$1<infer K> ? K : never;
-/**
- * A validation function that checks if a value can be branded.
- * Returns true if the value passes validation, false otherwise.
- *
- * @template T - The base type being validated
- */
-type Validator<T> = (value: T) => boolean;
-/**
- * Error type returned when brand validation fails.
- * Contains the original value and error message for debugging.
- *
- * @template T - The type of the value that failed validation
- */
-type BrandError<T = unknown> = {
-  readonly __typename: "BrandError";
-  readonly value: T;
-  readonly message: string;
-};
-//#endregion
-//#region src/brand/brand.d.ts
-
-/**
- * Brand namespace containing utilities for nominal typing in TypeScript.
- *
- * Brand types add type-level distinctiveness to primitive types without
- * any runtime overhead. This prevents accidental mixing of semantically
- * different values that share the same structural type.
- *
- * @example
- * ```ts
- * import { Brand } from "@repo/std"
- * import type { Branded } from "@repo/std"
- *
- * // Define branded types
- * type UserId = Branded<string, "UserId">
- * type Email = Branded<string, "Email">
- *
- * // Create values
- * const userId = Brand.make<UserId>("user-123")
- * const isValidEmail = Brand.is<Email>(s => s.includes("@"))
- *
- * // Type safety
- * function sendEmail(email: Email) { ... }
- * sendEmail(userId) // Type error! UserId is not Email
- * ```
- */
-declare const Brand: {
-  readonly make: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
-  readonly unsafeMake: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
-  readonly is: <T, K extends string>(validator: Validator<T>) => ((value: T) => value is Branded<T, K>);
-  readonly refine: <B extends Branded<unknown, string>>(validator: Validator<Unbrand<B>>, errorMessage?: string | ((value: Unbrand<B>) => string)) => ((value: Unbrand<B>) => Result<B, BrandError<Unbrand<B>>>);
-};
-//#endregion
-export { Branded as a, BrandKey as i, Brand$1 as n, Unbrand as o, BrandError as r, Validator as s, Brand as t };
-//# sourceMappingURL=index-BFhV56qy.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BFhV56qy.d.mts","names":[],"sources":["../src/brand/brand.types.ts","../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAYA,cARc,WAQG,EACS,OAAd,MAAA;AAqBZ;;;;;AAQA;AAAyB,KA9Bb,OA8Ba,CAAA,UAAA,MAAA,CAAA,GAAA;EAAU,UA7BvB,WAAA,CA6BuB,EA7BT,CA6BS;CAA+B;;AAOlE;AAQA;AAiBA;;;;ACqFA;;;;;;;;;;;AApF2E,KDzC/D,OCyC+D,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GDzChC,CCyCgC,GDzC5B,OCyC4B,CDzCtB,CCyCsB,CAAA;;;;;;;AA+C9D,KDhFD,OCgFC,CAAA,CAAA,CAAA,GDhFY,CCgFZ,SDhFsB,OCgFtB,CAAA,KAAA,EAAA,EAAA,MAAA,CAAA,GAAA,CAAA,GDhFqD,CCgFrD;;;;;;AAE+C,KD3EhD,QC2EgD,CAAA,CAAA,CAAA,GD3ElC,CC2EkC,SD3ExB,OC2EwB,CAAA,KAAA,EAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;;;;;;KDnEhD,uBAAuB;;;;;;;KAiBvB;;kBAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCmFL;4BAlIkB,iCAAiC,QAAQ,OAAK;kCAoBxC,iCAAiC,QAAQ,OAAK;gDA0BhC,UAAU,gBAAc,eAAe,QAAQ,GAAG;8BA8CpE,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}

package/dist/index-BLG9B4bn.d.mts

@@ -1,116 +0,0 @@
-import { _ as GenGenerator, d as AsyncComputation, f as AsyncGenGenerator, v as SyncComputation, y as Yieldable } from "./result.types-Bd8a43Fg.mjs";
-
-//#region src/gen/gen.d.ts
-
-/**
- * Create a computation from a sync generator function.
- * Returns a SyncComputation where run() returns Result directly (no Promise).
- *
- * @template A - The success value type
- * @template E - The error type
- * @param generatorFn - A function that returns a sync generator
- * @returns SyncComputation<A, E>
- *
- * @see {@link run} for immediate execution without storing the computation
- *
- * @example
- * ```ts
- * const result = gen(function* () {
- *   const a = yield* Result.yield(divide(10, 2))
- *   const b = yield* Result.yield(divide(a, 2))
- *   return b
- * }).run()
- * // Type: Result<number, "DivisionByZero">
- * ```
- */
-declare function gen<A, E>(generatorFn: () => GenGenerator<A, E>): SyncComputation<A, E>;
-/**
- * Create a computation from an async generator function.
- * Returns an AsyncComputation where run() returns Promise<Result>.
- *
- * @template A - The success value type
- * @template E - The error type
- * @param generatorFn - A function that returns an async generator
- * @returns AsyncComputation<A, E>
- *
- * @see {@link run} for immediate execution without storing the computation
- *
- * @example
- * ```ts
- * const result = await gen(async function* () {
- *   const data = yield* Result.yield(await fetchData(1))
- *   return data
- * }).run()
- * // Type: Promise<Result<string, "NetworkError">>
- * ```
- */
-declare function gen<A, E>(generatorFn: () => AsyncGenGenerator<A, E>): AsyncComputation<A, E>;
-/**
- * Convert a sync predicate to a yieldable.
- * Use this to validate values within a gen computation.
- *
- * @template T - The value type to validate
- * @template E - The error type on failure
- * @param predicate - A sync predicate function
- * @param onFail - A function that creates an error from the failing value
- * @returns A function that takes a value and returns a Yieldable
- *
- * @example
- * ```ts
- * const isPositive = (n: number) => n > 0
- *
- * const result = gen(function* () {
- *   const value = yield* ensure(isPositive, n => `${n} must be positive`)(userInput)
- *   return value * 2
- * }).run()
- * ```
- */
-declare function ensure<T, E>(predicate: (value: T) => boolean, onFail: (value: T) => E): (value: T) => Yieldable<T, E>;
-/**
- * Convert an async predicate to an async yieldable.
- * Use this to validate values within an async gen computation.
- *
- * @template T - The value type to validate
- * @template E - The error type on failure
- * @param predicate - An async predicate function
- * @param onFail - A function that creates an error from the failing value
- * @returns A function that takes a value and returns a Promise<Yieldable>
- *
- * @example
- * ```ts
- * const isAvailable = async (id: number) => await checkAvailability(id)
- *
- * const result = await gen(async function* () {
- *   const id = yield* await ensure(isAvailable, id => `${id} not available`)(userId)
- *   return `user-${id}`
- * }).run()
- * ```
- */
-declare function ensure<T, E>(predicate: (value: T) => Promise<boolean>, onFail: (value: T) => E): (value: T) => Promise<Yieldable<T, E>>;
-/**
- * Convert a type refinement to a yieldable with type narrowing.
- * Use this to narrow types within a gen computation.
- *
- * Note: Refinements are inherently synchronous (TypeScript type guards).
- *
- * @template T - The input type
- * @template U - The narrowed type (must extend T)
- * @template E - The error type on failure
- * @param refinement - A type guard function
- * @param onFail - A function that creates an error from the failing value
- * @returns A function that takes a value and returns a Yieldable with narrowed type
- *
- * @example
- * ```ts
- * const isString = (v: unknown): v is string => typeof v === "string"
- *
- * const result = gen(function* () {
- *   const str = yield* ensureRefinement(isString, () => "Expected string")(unknownValue)
- *   return str.toUpperCase()  // str is typed as string
- * }).run()
- * ```
- */
-declare const ensureRefinement: <T, U extends T, E>(refinement: (value: T) => value is U, onFail: (value: T) => E) => (value: T) => Yieldable<U, E>;
-//#endregion
-export { ensureRefinement as n, gen as r, ensure as t };
-//# sourceMappingURL=index-BLG9B4bn.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BLG9B4bn.d.mts","names":[],"sources":["../src/gen/gen.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;AAsBA;;;;;;;;AA0GA;;;AAAqF,iBAhIrE,GAgIqE,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,WAAA,EAAA,GAAA,GAhIxC,YAgIwC,CAhI3B,CAgI2B,EAhIxB,CAgIwB,CAAA,CAAA,EAhInB,eAgImB,CAhIH,CAgIG,EAhIA,CAgIA,CAAA;;;;;;AAsBrF;;;;;;;;;;;AAuDA;;;;AAC4E,iBAxL5D,GAwL4D,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,WAAA,EAAA,GAAA,GAxL/B,iBAwL+B,CAxLb,CAwLa,EAxLV,CAwLU,CAAA,CAAA,EAxLL,gBAwLK,CAxLY,CAwLZ,EAxLe,CAwLf,CAAA;;;;;;;;;;;;;;;;;;;;;iBA9E5D,gCAAgC,+BAA+B,MAAM,YAAY,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;iBAsBpG,gCACK,MAAM,kCACT,MAAM,YACb,MAAM,QAAQ,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;cAoDzB,gCACG,0BAA0B,eAAe,mBAAmB,MAAM,cACxE,MAAI,UAAU,GAAG"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BR7takNf.d.mts","names":[],"sources":["../src/err/err.types.ts","../src/err/err.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;AAWA;;;;;;;;AAGyB,KAdb,aAca,CAAA,YAAA,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GAAA;EAAS,SAAA,UAAA,EAbX,GAaW;AASlC,CAAA,GArBI,QAqBQ,CArBC,IAqBD,CAAA;;;;;;;;AAkBA,KA9BA,mBA8BwB,CAAA,YAAW,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GA9BqC,KA8BrC,GA7B7C,QA6B6C,CA7BpC,IA6BoC,CAAA,GAAA;EAanC,SAAA,UAAS,EAzCI,GAyCE;uBAxCF,UAAU,oBAAoB,KAAK;;;AC5BM;;;;;AAU7D,KD2BO,kBC3BI,CAAA,YAAmB,MAAA,CAAA,GAAA;EAkEnB,IAAA,CAAA,aAAW,MAAA,GAAA,MAAA,CAAA,CAAA,GAAA,IAAA,EAAA,MDrCR,ICqCQ,SAAA,KAAA,GAAA,EAAA,GAAA,CAAA,IAAA,EDrCyB,ICqCzB,CAAA,CAAA,EDpCtB,mBCoCsB,CDpCF,GCoCE,EDpCG,ICoCH,CAAA;EAA0B,SAAA,UAAA,EDnC9B,GCmC8B;CAAyB;;;AAqG9E;;;;;;;;;AA3I0E,KDiB9D,QCjB8D,CAAA,CAAA,CAAA,GDiBhD,CCjBgD,SDiBtC,aCjBsC,CAAA,KAAA,IAAA,CAAA,GAAA,GAAA,GAAA,KAAA;;;;;;;;;;;;KD8B9D,eAAe,UAAU;;;AAtDrC;;;KCTK,MDWD,CAAA,UCXkB,WDWlB,CAAA,MAAA,CAAA,CAAA,GCXyC,IDWzC,CCX8C,CDW9C,EAAA,YAAA,CAAA;;AASJ;;KCfK,WDgBM,CAAA,IAAA,CAAA,GAAA,MChBoB,IDgBpB,SAAA,KAAA,GAAA,IAAA,GAAA,KAAA;;;;;;;;AAWX;;;;;;;;AAkBA;AAaA;;;;ACpEkE;;;;;AAKjB;AAuEjD;;;;;AAqGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArGgB,qCAAqC,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGjE;8BA7ImB,0BACzB,oBACF,YAAY,OAAO,yBAAyB,WAAW,OAAO,OAAO;0BAwF7C,0BAA0B,kDAAgD"}

package/dist/index-BiFc2xWF.d.mts

@@ -1,211 +0,0 @@
-import { i as Result, y as Yieldable } from "./result.types-Bd8a43Fg.mjs";
-import { a as Option } from "./option.types-eqVODMIy.mjs";
-
-//#region src/either/either.types.d.ts
-
-/**
- * A discriminated union representing a choice between two alternatives.
- * By convention: Right = correct/preferred, Left = alternative.
- *
- * Unlike Result, neither side has inherent error semantics. Use Either when
- * both outcomes are valid alternatives (e.g., cached vs fresh data).
- *
- * Use Result when modeling success/failure with error semantics.
- *
- * Implements Yieldable protocol for use in Do computations with yield*.
- *
- * @example
- * ```ts
- * // Either: Valid alternatives
- * type DataSource = Either<CachedData, FreshData>
- *
- * // Result: Success/failure
- * type ApiResult = Result<User, ApiError>
- * ```
- */
-type Either$1<L, R> = Yieldable<R, L> & ({
-  readonly right: true;
-  readonly value: R;
-} | {
-  readonly right: false;
-  readonly value: L;
-});
-/**
- * Extract the left type from an Either
- */
-type LeftValue<E> = E extends {
-  readonly right: false;
-  readonly value: infer L;
-} ? L : never;
-/**
- * Extract the right type from an Either
- */
-type RightValue<E> = E extends {
-  readonly right: true;
-  readonly value: infer R;
-} ? R : never;
-/**
- * Return type for all() with array input - preserves tuple structure
- */
-type AllArrayReturn<T extends readonly Either$1<unknown, unknown>[]> = Either$1<LeftValue<T[number]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
-/**
- * Return type for all() with object input - preserves object structure
- */
-type AllObjectReturn<T extends Record<string, Either$1<unknown, unknown>>> = Either$1<LeftValue<T[keyof T]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
-/**
- * Type-safe interface for map() with async detection
- * Async overload must come first for proper type inference
- */
-type EitherMap = {
-  <A, B>(fn: (value: A) => Promise<B>): <L>(either: Either$1<L, A>) => Promise<Either$1<L, B>>;
-  <A, B>(fn: (value: A) => B): <L>(either: Either$1<L, A>) => Either$1<L, B>;
-};
-/**
- * Type-safe interface for mapLeft() with async detection
- */
-type EitherMapLeft = {
-  <L1, L2$1>(fn: (value: L1) => Promise<L2$1>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2$1, R>>;
-  <L1, L2$1>(fn: (value: L1) => L2$1): <R>(either: Either$1<L1, R>) => Either$1<L2$1, R>;
-};
-/**
- * Type-safe interface for bimap() with async detection
- */
-type EitherBimap = {
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => Promise<R2$1>): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => R2$1): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => Promise<R2$1>): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => R2$1): (either: Either$1<L1, R1>) => Either$1<L2$1, R2$1>;
-};
-/**
- * Type-safe interface for flatMap() with async detection and left union
- */
-type EitherFlatMap = {
-  <A, B, L2$1>(fn: (value: A) => Promise<Either$1<L2$1, B>>): <L>(either: Either$1<L, A>) => Promise<Either$1<L | L2$1, B>>;
-  <A, B, L2$1>(fn: (value: A) => Either$1<L2$1, B>): <L>(either: Either$1<L, A>) => Either$1<L | L2$1, B>;
-};
-/**
- * Type-safe interface for tap() with async detection
- */
-type EitherTap = {
-  <A>(fn: (value: A) => Promise<void>): <L>(either: Either$1<L, A>) => Promise<Either$1<L, A>>;
-  <A>(fn: (value: A) => void): <L>(either: Either$1<L, A>) => Either$1<L, A>;
-};
-/**
- * Type-safe interface for tapLeft() with async detection
- */
-type EitherTapLeft = {
-  <L>(fn: (value: L) => Promise<void>): <R>(either: Either$1<L, R>) => Promise<Either$1<L, R>>;
-  <L>(fn: (value: L) => void): <R>(either: Either$1<L, R>) => Either$1<L, R>;
-};
-/**
- * Type-safe interface for orElse() with async detection and right union
- */
-type EitherOrElse = {
-  <L1, L2$1, R2$1>(fn: (left: L1) => Promise<Either$1<L2$1, R2$1>>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2$1, R | R2$1>>;
-  <L1, L2$1, R2$1>(fn: (left: L1) => Either$1<L2$1, R2$1>): <R>(either: Either$1<L1, R>) => Either$1<L2$1, R | R2$1>;
-};
-/**
- * Type-safe interface for filter()
- */
-type EitherFilter = {
-  <R, L2$1>(predicate: (value: R) => boolean, onFail: (value: R) => L2$1): <L>(either: Either$1<L, R>) => Either$1<L | L2$1, R>;
-};
-//#endregion
-//#region src/either/either.d.ts
-
-/**
- * Combine multiple Eithers into a single Either.
- * Short-circuits on the first left value.
- *
- * Supports both array and object inputs with full type preservation.
- *
- * @param eithers - Array or object of Eithers to combine
- * @returns Either with all right values or first left
- *
- * @example
- * ```ts
- * // Array form (with const assertion for tuple typing)
- * all([right(1), right("hello")] as const)
- * // => right([1, "hello"])
- *
- * all([right(1), left("error"), right(3)])
- * // => left("error")
- *
- * // Object form
- * all({ a: right(1), b: right("hello") })
- * // => right({ a: 1, b: "hello" })
- * ```
- */
-declare function all<const T extends readonly Either$1<unknown, unknown>[]>(eithers: T): AllArrayReturn<T>;
-declare function all<const T extends Record<string, Either$1<unknown, unknown>>>(eithers: T): AllObjectReturn<T>;
-/**
- * Either namespace containing all utility functions for working with Either types.
- *
- * Either represents a value that can be one of two types: Left<L> or Right<R>.
- * By convention, Right is the "success" or preferred path, while Left represents
- * an alternative outcome (not necessarily an error, unlike Result).
- *
- * Use Either when both outcomes are valid and meaningful, not just success/failure.
- * For error handling, prefer Result instead.
- *
- * @see {@link Result} for success/error semantics
- * @see {@link Option} for presence/absence semantics
- *
- * @example
- * ```ts
- * import { Either, pipe } from '@repo/std'
- * import type { Either as EitherType } from '@repo/std'
- *
- * // Either for branching logic (cache vs fresh data)
- * const fetchOrCache = (id: number): EitherType<CachedData, FreshData> =>
- *   cache.has(id) ? Either.left(cache.get(id)) : Either.right(fetch(id))
- *
- * const result = pipe(
- *   fetchOrCache(1),
- *   Either.map(data => data.value),
- *   Either.unwrapOr(defaultValue)
- * )
- *
- * // Async example
- * const processed = await pipe(
- *   Either.right(userId),
- *   Either.map(async id => await fetchUser(id)),
- *   Either.flatMap(async user => Either.right(await enrichUser(user)))
- * )
- * ```
- */
-declare const Either: {
-  readonly left: <L>(value: L) => Either$1<L, never>;
-  readonly right: <R>(value: R) => Either$1<never, R>;
-  readonly isLeft: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
-    right: false;
-  }>;
-  readonly isRight: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
-    right: true;
-  }>;
-  readonly map: EitherMap;
-  readonly mapLeft: EitherMapLeft;
-  readonly bimap: EitherBimap;
-  readonly flatMap: EitherFlatMap;
-  readonly tap: EitherTap;
-  readonly tapLeft: EitherTapLeft;
-  readonly orElse: EitherOrElse;
-  readonly swap: <L, R>() => (either: Either$1<L, R>) => Either$1<R, L>;
-  readonly filter: EitherFilter;
-  readonly all: typeof all;
-  readonly unwrapOr: <R>(defaultValue: R) => <L>(either: Either$1<L, R>) => R;
-  readonly unwrapOrElse: <L, R>(fn: (left: L) => R) => (either: Either$1<L, R>) => R;
-  readonly match: <L, R, U$1>(handlers: {
-    left: (value: L) => U$1;
-    right: (value: R) => U$1;
-  }) => (either: Either$1<L, R>) => U$1;
-  readonly fromResult: <R, E>(result: Result<R, E>) => Either$1<E, R>;
-  readonly toResult: <L, R>(either: Either$1<L, R>) => Result<R, L>;
-  readonly fromOption: <R, L>(option: Option<R>, onNone: () => L) => Either$1<L, R>;
-  readonly toOption: <L, R>(either: Either$1<L, R>) => Option<R>;
-  readonly fromNullable: <R, L>(value: R | null | undefined, onNull: () => L) => Either$1<L, R>;
-  readonly fromPredicate: <R, L>(value: R, predicate: (value: R) => boolean, onFail: (value: R) => L) => Either$1<L, R>;
-};
-//#endregion
-export { EitherFilter as a, EitherMapLeft as c, EitherTapLeft as d, EitherBimap as i, EitherOrElse as l, all as n, EitherFlatMap as o, Either$1 as r, EitherMap as s, Either as t, EitherTap as u };
-//# sourceMappingURL=index-BiFc2xWF.d.mts.map

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

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

package/dist/index-BwVaI5d0.d.mts

@@ -1,79 +0,0 @@
-import { a as ResultFilter, c as ResultMapErr, i as Result$1, l as ResultOrElse, n as AllObjectReturn, o as ResultFlatMap, r as FromTryReturn, s as ResultMap, t as AllArrayReturn, u as ResultTap } from "./result.types-Bd8a43Fg.mjs";
-
-//#region src/result/result.d.ts
-
-/**
- * Combine multiple Results into a single Result.
- * Supports both array and object inputs.
- *
- * - If all Results are ok, returns ok with all values
- * - If any Result is an error, returns the first error (short-circuits)
- *
- * @example
- * ```ts
- * // Array form (use `as const` for tuple types) - returns Result<[number, string], E>
- * const [num, str] = pipe(
- *   Result.all([parseNumber(input), parseString(other)] as const),
- *   Result.unwrapOr([0, ''])
- * )
- *
- * // Object form - returns Result<{ user: User, config: Config }, E>
- * pipe(
- *   Result.all({ user: fetchUser(id), config: loadConfig() }),
- *   Result.tap(({ user, config }) => console.log(user.name, config.theme))
- * )
- * ```
- */
-declare function all<T extends readonly Result$1<unknown, unknown>[]>(results: T): AllArrayReturn<T>;
-declare function all<T extends Record<string, Result$1<unknown, unknown>>>(results: T): AllObjectReturn<T>;
-/**
- * Result namespace containing all utility functions for working with Result types.
- *
- * Result represents either success (ok) or failure (err). Use this for operations
- * that can fail with typed errors.
- *
- * @see {@link Option} for presence/absence semantics (no error information)
- * @see {@link Either} for two valid outcomes (not just success/failure)
- *
- * @example
- * ```ts
- * import { Result, pipe } from '@repo/std'
- * import type { Result as ResultType } from '@repo/std'
- *
- * const divide = (a: number, b: number): ResultType<number, string> =>
- *   b === 0 ? Result.err('division by zero') : Result.ok(a / b)
- *
- * const result = pipe(
- *   divide(10, 2),
- *   Result.map(n => n * 2),
- *   Result.unwrapOr(0)
- * )
- * ```
- */
-declare const Result: {
-  readonly ok: <T>(value: T) => Result$1<T, never>;
-  readonly err: <E>(error: E) => Result$1<never, E>;
-  readonly isOk: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
-    ok: true;
-  }>;
-  readonly isErr: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
-    ok: false;
-  }>;
-  readonly map: ResultMap;
-  readonly mapErr: ResultMapErr;
-  readonly flatMap: ResultFlatMap;
-  readonly tap: ResultTap;
-  readonly orElse: ResultOrElse;
-  readonly filter: ResultFilter;
-  readonly all: typeof all;
-  readonly unwrapOr: <T>(defaultValue: T) => <E>(result: Result$1<T, E>) => T;
-  readonly unwrapOrElse: <E, T>(fn: (error: E) => T) => (result: Result$1<T, E>) => T;
-  readonly match: <T, E, U>(handlers: {
-    ok: (value: T) => U;
-    err: (error: E) => U;
-  }) => (result: Result$1<T, E>) => U;
-  readonly fromTry: <T>(fn: () => T) => FromTryReturn<T>;
-};
-//#endregion
-export { all as n, Result as t };
-//# sourceMappingURL=index-BwVaI5d0.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BwVaI5d0.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;iBAqVgB,uBAAuB,uCAAyC,IAAI,eAAe;iBACnF,cAAc,eAAe,sCAAwC,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;cA2K5F;0BApegB,MAAI,SAAW;2BAoBd,MAAI,gBAAkB;gCA2BjB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;iCAgBlD,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;uCAiSnE,kBACN,SAAW,GAAG,OAAK;4CAkBZ,MAAM,eAChB,SAAW,GAAG,OAAK;;gBAqBM,MAAM;iBAAgB,MAAM;iBACrD,SAAW,GAAG,OAAK;kCA+CO,MAAI,cAAc"}

package/dist/index-CckxkaUd.d.mts

@@ -1,80 +0,0 @@
-import { a as Option$1, c as OptionMap, l as OptionOrElse, n as AllObjectReturn, o as OptionFilter, r as FromTryReturn, s as OptionFlatMap, t as AllArrayReturn, u as OptionTap } from "./option.types-eqVODMIy.mjs";
-
-//#region src/option/option.d.ts
-
-/**
- * Combine multiple Options into a single Option.
- * Supports both array and object inputs.
- *
- * - If all Options are some, returns some with all values
- * - If any Option is none, returns none (short-circuits)
- *
- * @example
- * ```ts
- * // Array form (use `as const` for tuple types) - returns Option<[number, string]>
- * const [num, str] = pipe(
- *   Option.all([parseNumber(input), parseString(other)] as const),
- *   Option.unwrapOr([0, ''])
- * )
- *
- * // Object form - returns Option<{ user: User, config: Config }>
- * pipe(
- *   Option.all({ user: findUser(id), config: loadConfig() }),
- *   Option.tap(({ user, config }) => console.log(user.name, config.theme))
- * )
- * ```
- */
-declare function all<T extends readonly Option$1<unknown>[]>(options: T): AllArrayReturn<T>;
-declare function all<T extends Record<string, Option$1<unknown>>>(options: T): AllObjectReturn<T>;
-/**
- * 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')
- * )
- * ```
- */
-declare const Option: {
-  readonly some: <T>(value: T) => Option$1<T>;
-  readonly none: <T>() => Option$1<T>;
-  readonly isSome: <T>(option: Option$1<T>) => option is Extract<Option$1<T>, {
-    some: true;
-  }>;
-  readonly isNone: <T>(option: Option$1<T>) => option is Extract<Option$1<T>, {
-    some: false;
-  }>;
-  readonly map: OptionMap;
-  readonly flatMap: OptionFlatMap;
-  readonly tap: OptionTap;
-  readonly orElse: OptionOrElse;
-  readonly filter: OptionFilter;
-  readonly all: typeof all;
-  readonly unwrapOr: <T>(defaultValue: T) => (option: Option$1<T>) => T;
-  readonly unwrapOrElse: <T>(fn: () => T) => (option: Option$1<T>) => T;
-  readonly match: <T, U>(handlers: {
-    some: (value: T) => U;
-    none: () => U;
-  }) => (option: Option$1<T>) => U;
-  readonly fromNullable: <T>(value: T | null | undefined) => Option$1<T>;
-  readonly fromTry: <T>(fn: () => T) => FromTryReturn<T>;
-};
-//#endregion
-export { all as n, Option as t };
-//# sourceMappingURL=index-CckxkaUd.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-CckxkaUd.d.mts","names":[],"sources":["../src/option/option.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;iBA6SgB,uBAAuB,8BAAgC,IAAI,eAAe;iBAC1E,cAAc,eAAe,6BAA+B,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;cA0LnF;4BA1ckB,MAAI,SAAW;0BAmBnB,SAAW;+BA0BJ,SAAW,iBAAe,QAAQ,SAAW;;;+BAgB7C,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;uCA0P3D,eACT,SAAW,OAAK;uCAkBX,eACL,SAAW,OAAK;;kBAqBQ,MAAM;gBAAe;iBAC7C,SAAW,OAAK;oCAqBY,yBAAuB,SAAW;kCA2CpC,MAAI,cAAc"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-Cp_4sFun.d.mts","names":[],"sources":["../src/adt/adt.types.ts","../src/adt/adt.record.ts","../src/adt/adt.data.ts","../src/adt/adt.match.ts","../src/adt/adt.codec.ts"],"sourcesContent":[],"mappings":"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OoB,SDmOV,GCnOU,CAAA,KAAA,EAAA,CAAA,GDoOhB,QCpOgB,CDoOP,aCpOO,CDoOO,CCpOP,CAAA,CAAA,GDqOhB,CCrOgB,SDqON,YCrOM,CAAA,KAAA,SAAA,EAAA,KAAA,EAAA,CAAA,GDsOd,QCtOc,CDsOL,WCtOK,CDsOO,CCtOP,CAAA,GDsOY,aCtOZ,CDsO0B,QCtO1B,CAAA,CAAA,GAAA,KAAA;;;;;;;;;;KDsPV,kBAAkB,UAAU,qBAAqB;AErQ7D;;;;;;;;;;AC7CY,KH8TA,SG9Ta,CAAA,CAAA,EAAA,YAAA,MAAA,CAAA,GH+TvB,CG/TuB,SH+Tb,GG/Ta,CAAA,KAAA,EAAA,CAAA,GHgUnB,GGhUmB,SAAA,MHgUH,CGhUG,GHiUjB,QGjUiB,CHiUR,WGjUQ,CHiUI,aGjUJ,CHiUkB,CGjUlB,CHiUoB,GGjUpB,CAAA,CAAA,CAAA,GHiU2B,aGjU3B,CHiUyC,GGjUzC,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;;;;;;AHLoC;;;;;AAkB7D;;;;;AAiBA;;;;;;AAqBA;;;;;;;;AAcA;AAeA;;;;;AAMA;;;;;AAAoG;AAWzE;AAe3B;;;;;;;;;;AAKmC,iBChEnB,MDgEmB,CAAA,mBAAA,MAAA,EAAA,YC9DvB,gBD8DuB,EAAA,eC7DlB,eD6DkB,CC7DF,UD6DE,EC7DQ,GD6DR,CAAA,CAAA,CAAA,UAAA,EC5DrB,UD4DqB,EAAA,MAAA,EC5DH,GD4DG,EAAA,MAAA,EC5DQ,MD4DR,CAAA,EC5DiB,YD4DjB,CC5D8B,UD4D9B,EC5DwC,GD4DxC,EC5D2C,MD4D3C,CAAA;AAAyC,iBCzD5D,MDyD4D,CAAA,mBAAA,MAAA,EAAA,YCzDlB,gBDyDkB,CAAA,CAAA,UAAA,ECxD9D,UDwD8D,EAAA,MAAA,ECvDlE,GDuDkE,CAAA,ECtDzE,YDsDyE,CCtD5D,UDsD4D,ECtDlD,GDsDkD,CAAA;;;;;;;AA1Hf;;;;;AAkB7D;;;;;AAiBA;;;;;;AAqBA;;;;;;;;AAcA;AAeA;;;;;AAMA;;;;;AAAoG;AAWzE;AAe3B;;;;;AACkC,iBEpElB,IFoEkB,CAAA,YEpEH,MFoEG,CAAA,MAAA,EEpEY,SFoEZ,CAAA,CAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EEpE+C,GFoE/C,CAAA,EEpEmD,GFoEnD,CEpEuD,GFoEvD,CAAA;;;;;;;;AAtH2B;;AAO3C,KGFN,aHEM,CAAA,UAAA;EAAE,SAAA,UAAA,EAAA,MAAA;CAAC,EAAA,OAAA,CAAA,GAAA,QGDb,CHYI,CAAA,YAAe,CAAA,GAAA,CAAA,KAAA,EGZO,OHYP,CGZe,CHYf,EAAA;EAGO,SAAA,UAAA,EGfkC,CHelC;AAAd,CAAA,CAAA,EAAA,GGfyD,OHezD,EAFD;;AAgBnB;;;;;;AAqBA;;;;;;;;AAcA;AAeA;;;;;AAMA;;;;;AAAoG;AAWzE;AAe3B;AAAgC,iBG/EhB,KH+EgB,CAAA,UAAA;EACL,SAAA,UAAA,EAAA,MAAA;CAAX,EAAA,OAAA,EAAA,iBG7EG,aH6EH,CG7EiB,CH6EjB,EG7EoB,OH6EpB,CAAA,GG7E+B,aH6E/B,CG7E6C,CH6E7C,EG7EgD,OH6EhD,CAAA,CAAA,CAAA,KAAA,EG5EP,CH4EO,EAAA,QAAA,EG5EM,QH4EN,CAAA,EG5EiB,OH4EjB;;;;;AAtH6C;AAO/C,iBIUE,gBAAA,CJVF,IAAA,EIWN,UJXM,CAAA,MAAA,CAAA,EAAA,OAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAAA,OAAA,EAAA,gBAAA,CAAA,EIcO,eJdP,CAAA,QAAA,CAAA,CAAA,EIeX,UJfW"}