functype 0.58.1 → 0.59.1

package/dist/{index-VSAy-IRN.d.ts → index-BPe5pcCH.d.ts}

@@ -1,5 +1,5 @@
 import { t as Brand } from "./Brand-BJIRbUKB.js";
-import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-DwyoW0ZP.js";
+import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-De-FhPDq.js";
 
 //#region src/error/ParseError.d.ts
 declare const ParseError: (message?: string) => Error & {
@@ -36,7 +36,7 @@ type DoResult<T> = {
  * The doUnwrap method should return a DoResult indicating success/failure
  * and the contained value or error information
  */
-interface Doable<T> {
+interface Doable<out T> {
   doUnwrap(): DoResult<T>;
 }
 //#endregion
@@ -48,7 +48,7 @@ interface Doable<T> {
  * @interface Unsafe
  * @template T The type of value that can be extracted
  */
-interface Unsafe<T extends Type> {
+interface Unsafe<out T extends Type> {
   /**
    * Extract the value or throw an error
    * @param error Optional custom error to throw. If not provided, uses type-appropriate default error
@@ -61,24 +61,30 @@ interface Unsafe<T extends Type> {
  * Extractable type class for data structures that can extract their values
  * with various fallback strategies.
  *
- * This interface is implemented by Option, Either, and other types that
- * wrap values and need both safe and fallible extraction methods.
+ * Covariance: T is declared `<out T>`. The fallback methods `orElse` and `or`
+ * widen the result via `<T2>`, matching Scala's `getOrElse[B1 >: B](default: => B1): B1`
+ * shape — when the caller passes a T-typed default the result is just T, and when
+ * they pass a wider T2 the result union widens accordingly.
  *
- * Extends Unsafe to provide exception-throwing operations alongside safe alternatives.
+ * Implementers that previously overrode `or`/`orElse` with widened signatures
+ * (Option, Either, Try) can inherit from this base directly; their 0.58-era
+ * `Omit<Extractable<T>, "or" | "orElse">` workarounds are no longer needed.
  */
-interface Extractable<T extends Type> extends Unsafe<T> {
+interface Extractable<out T extends Type> extends Unsafe<T> {
   /**
-   * Returns the contained value or a default value
+   * Returns the contained value or a default value. The default may be of a
+   * different type; the result widens to `T | T2`.
    * @param defaultValue - The value to return if extraction fails
    * @returns The contained value or defaultValue
    */
-  orElse(defaultValue: T): T;
+  orElse<T2 extends Type>(defaultValue: T2): T | T2;
   /**
-   * Returns this container if it has a value, otherwise returns the alternative container
+   * Returns this container if it has a value, otherwise returns the alternative container.
+   * The alternative may carry a different type; the result widens to `Extractable<T | T2>`.
    * @param alternative - The alternative container
    * @returns This container or the alternative
    */
-  or(alternative: Extractable<T>): Extractable<T>;
+  or<T2 extends Type>(alternative: Extractable<T2>): Extractable<T | T2>;
   /**
    * Returns the contained value or null
    * @returns The contained value or null
@@ -114,7 +120,7 @@ declare function isExtractable<T extends Type>(value: unknown): value is Extract
  *   .take(10)
  *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
  */
-interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
+interface LazyList<out A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<"LazyList"> {
   readonly [Symbol.toStringTag]: string;
   [Symbol.iterator](): Iterator<A>;
   map<B extends Type>(f: (a: A) => B): LazyList<B>;
@@ -124,7 +130,8 @@ interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Seria
   drop(n: number): LazyList<A>;
   takeWhile(predicate: (a: A) => boolean): LazyList<A>;
   dropWhile(predicate: (a: A) => boolean): LazyList<A>;
-  concat(other: LazyList<A>): LazyList<A>;
+  /** Concatenate with another lazy list, possibly widening (Scala: `++[B >: A]`). */
+  concat<B extends Type>(other: LazyList<B>): LazyList<A | B>;
   zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
   takeRight(n: number): LazyList<A>;
   reverse(): LazyList<A>;
@@ -244,7 +251,7 @@ declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>)
  *
  * @typeParam A - The type of value(s) in the container
  */
-interface ContainerOps<A extends Type> {
+interface ContainerOps<out A extends Type> {
   /**
    * Counts elements that satisfy the predicate.
    * For single-value containers: returns 0 or 1
@@ -277,7 +284,7 @@ interface ContainerOps<A extends Type> {
  * @typeParam A - The element type
  * @typeParam Self - The collection type itself for proper return types
  */
-interface CollectionOps<A extends Type, Self> {
+interface CollectionOps<out A extends Type, Self> {
   /**
    * Left-associative fold over all elements using an initial value and combining function.
    * Unlike foldLeft (which is curried), this provides a convenient uncurried signature.
@@ -358,7 +365,7 @@ interface CollectionOps<A extends Type, Self> {
  * - Identity: fa.map(x => x) ≡ fa
  * - Composition: fa.map(f).map(g) ≡ fa.map(x => g(f(x)))
  */
-interface Functor<A extends Type> {
+interface Functor<out A extends Type> {
   map<B extends Type>(f: (value: A) => B): Functor<B>;
 }
 /**
@@ -370,7 +377,7 @@ interface Functor<A extends Type> {
  * - Homomorphism: pure(f).ap(pure(x)) ≡ pure(f(x))
  * - Interchange: u.ap(pure(y)) ≡ pure(f => f(y)).ap(u)
  */
-interface Applicative<A extends Type> extends Functor<A> {
+interface Applicative<out A extends Type> extends Functor<A> {
   ap<B extends Type>(ff: Applicative<(value: A) => B>): Applicative<B>;
 }
 /**
@@ -381,14 +388,14 @@ interface Applicative<A extends Type> extends Functor<A> {
  * - Right identity: m.flatMap(pure) ≡ m
  * - Associativity: m.flatMap(f).flatMap(g) ≡ m.flatMap(x => f(x).flatMap(g))
  */
-interface Monad<A extends Type> extends Applicative<A> {
+interface Monad<out A extends Type> extends Applicative<A> {
   flatMap<B extends Type>(f: (value: A) => Monad<B>): Monad<B>;
 }
 /**
  * Async monad - supports asynchronous monadic operations
  * Extends Monad so it has map, ap, and flatMap in addition to flatMapAsync
  */
-interface AsyncMonad<A extends Type> extends Monad<A> {
+interface AsyncMonad<out A extends Type> extends Monad<A> {
   flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<AsyncMonad<B>>): PromiseLike<AsyncMonad<B>>;
 }
 //#endregion
@@ -413,7 +420,7 @@ interface AsyncMonad<A extends Type> extends Monad<A> {
  * // Promise rejects with "error"
  * ```
  */
-interface Promisable<A extends Type> {
+interface Promisable<out A extends Type> {
   /**
    * Converts this container to a Promise
    *
@@ -426,12 +433,68 @@ interface Promisable<A extends Type> {
   toPromise(): Promise<A>;
 }
 //#endregion
+//#region src/typeclass/variance.d.ts
+/**
+ * Variance helpers — small utilities for expressing covariance-safe signatures
+ * when TypeScript's type system doesn't offer the exact constraint we need.
+ *
+ * Motivation: Scala has lower-bound type parameters like `def reduce[B >: A](op: (B, B) => B): B`
+ * — B must be a supertype of A. TypeScript lacks lower bounds, so a naive port
+ * (`reduce<B = A>(op: (b: B, a: B) => B): B`) lets the caller pick ANY B, including
+ * unrelated types. At runtime that's a footgun: `List<number>.reduce<string>(...)` would
+ * compile but run as number addition typed as string.
+ *
+ * `Widen<A, B>` closes that gap using a conditional type. When B is truly a supertype
+ * of A (including the default case B = A), `Widen<A, B>` is B. When B is unrelated,
+ * it resolves to `never`, which makes the callback uncallable and produces a compile
+ * error at the call site.
+ *
+ * @module typeclass/variance
+ */
+/**
+ * The TypeScript equivalent of Scala's `B >: A` (B is a supertype of A).
+ *
+ * Resolves to `B` when `A extends B` (i.e., B is a legitimate supertype of A, or B = A).
+ * Resolves to `never` otherwise, which renders any callback position using Widen
+ * uncallable — the user gets a compile-time error rather than a runtime type lie.
+ *
+ * @example
+ * ```ts
+ * // Inside a container interface:
+ * reduce<B = A>(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>
+ *
+ * // Callers:
+ * list.reduce((a, b) => a + b)          // B defaults to A, Widen<A,A> = A, fine
+ * list.reduce<A | "extra">(...)         // A extends A | "extra", Widen = B, fine
+ * list.reduce<UnrelatedType>(...)       // A doesn't extend Unrelated, Widen = never, compile error
+ * ```
+ */
+type Widen<A, B> = A extends B ? B : never;
+/**
+ * Runtime-safe `reduce` over an array whose element type `A` may be narrower than
+ * the accumulator type `B`. Centralizes the single `as unknown as B` cast that's
+ * otherwise spread across every container's implementation.
+ *
+ * Safety: the cast is sound because the `Widen<A, B>` type-level constraint at the
+ * public API layer guarantees `A <: B`. When that holds, A values flowing into the
+ * callback are valid B values at runtime — exactly what Scala's `[B >: A]` provides.
+ *
+ * @param arr - source array of A values
+ * @param op - accumulator operation typed over B (where B is A or a supertype)
+ * @returns the folded value, typed as B
+ */
+declare const reduceWiden: <A, B>(arr: readonly A[], op: (b: B, a: B) => B) => B;
+/**
+ * Right-associative variant of {@link reduceWiden}. Same safety argument.
+ */
+declare const reduceRightWiden: <A, B>(arr: readonly A[], op: (b: B, a: B) => B) => B;
+//#endregion
 //#region src/try/Try.d.ts
 /**
  * Possible types of Try instances
  */
 type TypeNames = "Success" | "Failure";
-interface Try<out T> extends FunctypeSum<T, TypeNames>, Omit<Extractable<T>, "or" | "orElse">, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {
+interface Try<out T> extends FunctypeSum<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {
   readonly _tag: TypeNames;
   readonly error: Error | undefined;
   isSuccess(): this is Try<T> & {
@@ -583,7 +646,7 @@ declare const Try: (<T>(f: () => T) => Try<T>) & {
  * const asOption = result.toOption()
  * asOption.map(x => x * 2).orElse(0)
  */
-interface Reshapeable<T extends Type> {
+interface Reshapeable<out T extends Type> {
   /**
    * Converts this monad to an Option.
    *
@@ -1301,7 +1364,7 @@ interface TaskMetadata {
   readonly name: string;
   readonly description: string;
 }
-interface TaskOutcome<T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>, AsyncMonad<T>, Promisable<T>, Doable<T> {
+interface TaskOutcome<out T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>, AsyncMonad<T>, Promisable<T>, Doable<T> {
   readonly _tag: "Ok" | "Err";
   readonly _meta: TaskMetadata;
   readonly value?: T;
@@ -1312,8 +1375,8 @@ interface TaskOutcome<T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>,
   readonly mapAsync: <U>(f: (value: T) => Promise<U>) => Promise<TaskOutcome<U>>;
   readonly flatMapAsync: <U>(f: (value: T) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>;
   readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>;
-  readonly recover: (value: T) => Ok<T>;
-  readonly recoverWith: (f: (error: Throwable) => T) => Ok<T>;
+  recover<U extends Type>(value: U): Ok<T | U>;
+  recoverWith<U extends Type>(f: (error: Throwable) => U): Ok<T | U>;
   readonly isSuccess: () => this is Ok<T>;
   readonly isFailure: () => this is Err<T>;
   readonly isOk: () => this is Ok<T>;
@@ -1328,12 +1391,12 @@ interface TaskOutcome<T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>,
     Err: (error: Throwable) => U;
   }) => U;
 }
-interface Ok<T> extends TaskOutcome<T> {
+interface Ok<out T> extends TaskOutcome<T> {
   readonly _tag: "Ok";
   readonly value: T;
   readonly error: undefined;
 }
-interface Err<T> extends TaskOutcome<T> {
+interface Err<out T> extends TaskOutcome<T> {
   readonly _tag: "Err";
   readonly value: undefined;
   readonly error: Throwable;
@@ -3394,9 +3457,16 @@ declare const HKT: {
 };
 //#endregion
 //#region src/identity/Identity.d.ts
-type Identity<T> = {
-  id: T;
-  isSame?: (other: Identity<T>) => boolean;
+/**
+ * Identity — a trivial container carrying a single tagged value.
+ * Covariant in T (`<out T>`). `isSame` takes `Identity<unknown>` so that
+ * cross-type equality checks (semantically always `false` for unrelated types)
+ * don't block variance — mirroring the `contains(unknown)` pattern used on
+ * List/Set/Map.
+ */
+type Identity<out T> = {
+  readonly id: T;
+  isSame?: (other: Identity<unknown>) => boolean;
 };
 declare const Identity: (<T>(value: T) => Identity<T>) & {
   /**
@@ -3424,17 +3494,16 @@ declare const Identity: (<T>(value: T) => Identity<T>) & {
  * It provides memoization and safe evaluation with integration to Option, Either, and Try.
  * @typeParam T - The type of the value to be computed
  */
-interface Lazy<T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>, Pipe<T> {
+interface Lazy<out T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>, Pipe<T> {
   /** Tag identifying this as a Lazy type */
   readonly _tag: "Lazy";
   /** Whether the computation has been evaluated */
   readonly isEvaluated: boolean;
   /**
-   * Returns the computed value or a default value if computation fails
-   * @param defaultValue - The value to return if computation fails
-   * @returns The computed value or defaultValue
+   * Returns the computed value or a default value if computation fails.
+   * Result widens to `T | T2` (Scala: `getOrElse[B >: A](default: B): B`).
    */
-  orElse(defaultValue: T): T;
+  orElse<T2 extends Type>(defaultValue: T2): T | T2;
   /**
    * Returns the computed value or null if computation fails
    * @returns The computed value or null
@@ -3448,11 +3517,10 @@ interface Lazy<T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>,
    */
   orThrow(error?: Error): T;
   /**
-   * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy
-   * @param alternative - The alternative Lazy to use if computation fails
-   * @returns This Lazy or the alternative
+   * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy.
+   * The alternative may carry a different type; result is `Lazy<T | T2>`.
    */
-  or(alternative: Lazy<T>): Lazy<T>;
+  or<T2 extends Type>(alternative: Lazy<T2>): Lazy<T | T2>;
   /**
    * Maps the value inside the Lazy using the provided function
    * @param f - The mapping function
@@ -3669,14 +3737,24 @@ declare const Lazy: (<T extends Type>(thunk: () => T) => Lazy<T>) & {
 //#endregion
 //#region src/traversable/Traversable.d.ts
 /**
- * Traversable typeclass for data structures that can be traversed through
+ * Traversable typeclass for data structures that can be traversed through.
+ *
+ * Covariance: A is declared `<out A>`. Query (`contains`) accepts `unknown` —
+ * mirroring Scala's `contains(elem: Any)` — so an unrelated-type arg is a
+ * sound `false` rather than a type error. Aggregations (`reduce`, `reduceRight`)
+ * widen the accumulator via `<B = A>`, matching Scala's `reduce[B >: A]`; when
+ * called without an explicit type arg the behavior is identical to the pre-0.59
+ * signature, so existing call sites compile unchanged.
+ *
+ * Implementers that previously overrode these methods with the widened shape
+ * (List, Set) can inherit from this base without a per-type override.
  */
-interface Traversable<A extends Type> extends AsyncMonad<A> {
+interface Traversable<out A extends Type> extends AsyncMonad<A> {
   get size(): number;
   get isEmpty(): boolean;
-  contains(value: A): boolean;
-  reduce(f: (b: A, a: A) => A): A;
-  reduceRight(f: (b: A, a: A) => A): A;
+  contains(value: unknown): boolean;
+  reduce<B = A>(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>;
+  reduceRight<B = A>(op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>): Widen<A, B>;
 }
 //#endregion
 //#region src/traversable/KVTraversable.d.ts
@@ -3694,7 +3772,7 @@ interface Traversable<A extends Type> extends AsyncMonad<A> {
 type KVTraversable<A> = Omit<Traversable<A>, "map" | "flatMap" | "flatMapAsync" | "ap">;
 //#endregion
 //#region src/map/Map.d.ts
-interface Map$1<K, V> extends KVTraversable<Tuple<[K, V]>>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
+interface Map$1<K, out V> extends KVTraversable<Tuple<[K, V]>>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
   readonly [Symbol.toStringTag]: string;
   readonly _tag: "Map";
   add(item: Tuple<[K, V]>): Map$1<K, V>;
@@ -3778,7 +3856,7 @@ declare const ESMap: MapConstructor;
  * @typeParam A - The type of elements in the data structure
  * @typeParam Tags - The type of tags used for pattern matching
  */
-interface Matchable<A, Tags extends string = string> {
+interface Matchable<out A, Tags extends string = string> {
   /**
    * Pattern matches against this data structure, applying handlers for each variant based on tag.
    * Similar to fold but with stronger type safety for tag-based variants.
@@ -4001,6 +4079,14 @@ declare const Obj: (<T extends Record<string, Type>>(data: T) => Obj<T>) & {
  * A mutable reference container that holds a value of type A.
  * This provides controlled mutability in a functional context.
  *
+ * **Variance: invariant in A by design.** Ref is a mutable cell — `set(A)`
+ * writes A (contravariant) and `get(): A` reads A (covariant), so A is
+ * genuinely invariant. Unlike the other containers in functype, Ref has no
+ * `<out A>` annotation and cannot be widened via subtyping. This mirrors
+ * Scala's `scala.concurrent.stm.Ref` and reflects the fundamental nature of
+ * mutable state: you can't safely treat a `Ref[Narrow]` as a `Ref[Wide]`
+ * because someone could `set` a Wide value that isn't a Narrow.
+ *
  * @example
  * const counter = Ref(0)
  * counter.get() // 0
@@ -4131,15 +4217,12 @@ declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
 interface Set<out A> extends FunctypeCollection<A, "Set">, Collection<A> {
   add<B>(value: B): Set<A | B>;
   remove: (value: unknown) => Set<A>;
-  contains(value: unknown): boolean;
   has(value: unknown): boolean;
   map: <B>(f: (a: A) => B) => Set<B>;
   flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>;
   filter: (p: (a: A) => boolean) => Set<A>;
   filterNot: (p: (a: A) => boolean) => Set<A>;
   fold: <B>(initial: B, fn: (acc: B, a: A) => B) => B;
-  reduce<B = A>(op: (b: B, a: B) => B): B;
-  reduceRight<B = A>(op: (b: B, a: B) => B): B;
   toList: () => List<A>;
   toSet: () => Set<A>;
   toArray: <B = A>() => B[];
@@ -4215,11 +4298,12 @@ type Valuable<Tag extends string, V, T = object> = Typeable<Tag, T> & {
 type Stack<A extends Type> = {
   readonly [Symbol.toStringTag]: string;
   /**
-   * Push a value onto the top of the stack
+   * Push a value onto the top of the stack. The value may be a wider type;
+   * the result widens to `Stack<A | B>` (Scala: `:+[B >: A]`).
    * @param value - The value to push
    * @returns A new Stack with the value added
    */
-  push(value: A): Stack<A>;
+  push<B extends Type>(value: B): Stack<A | B>;
   /**
    * Remove and return the top value from the stack
    * @returns A tuple containing the new Stack and the value
@@ -4408,18 +4492,6 @@ interface Option<out T extends Type> extends Functype<T, "Some" | "None">, Promi
    * @returns Promise of the result of applying f to the contained value, or None if this Option is None
    */
   flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>;
-  /**
-   * Applies a binary operator to a start value and the contained value
-   * @param f - The binary operator
-   * @returns The result of the reduction
-   */
-  reduce<U>(f: (acc: U, value: T) => U): U;
-  /**
-   * Applies a binary operator to the contained value and a start value
-   * @param f - The binary operator
-   * @returns The result of the reduction
-   */
-  reduceRight<U>(f: (acc: U, value: T) => U): U;
   /**
    * Pattern matches over the Option, applying onNone if None and onSome if Some
    * @param onNone - Function to apply if the Option is None
@@ -4614,11 +4686,6 @@ interface List<out A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapea
   partition: (p: (a: A) => boolean) => [List<A>, List<A>];
   span: (p: (a: A) => boolean) => [List<A>, List<A>];
   slice: (start: number, end: number) => List<A>;
-  /** Contains check. Accepts `unknown` (Scala: `contains(elem: Any)`). */
-  contains(value: unknown): boolean;
-  /** Reduce with a possibly-wider accumulator type (Scala: `reduce[B >: A]`). Defaults to `B = A`. */
-  reduce<B = A>(op: (b: B, a: B) => B): B;
-  reduceRight<B = A>(op: (b: B, a: B) => B): B;
   /**
    * Pattern matches over the List, applying a handler function based on whether it's empty
    * @param patterns - Object with handler functions for Empty and NonEmpty variants
@@ -4768,7 +4835,7 @@ interface FunctypeSum<A extends Type, Tag extends string = string> extends Async
  * union. After `if (e.isLeft())`, the else branch narrows `e` to RightOf<L,R> and
  * `e.value` narrows to R without a cast.
  */
-interface EitherBase<out L extends Type, out R extends Type> extends FunctypeSum<R, "Left" | "Right">, Promisable<R>, Doable<R>, Reshapeable<R>, Omit<Extractable<R>, "or" | "orElse"> {
+interface EitherBase<out L extends Type, out R extends Type> extends FunctypeSum<R, "Left" | "Right">, Promisable<R>, Doable<R>, Reshapeable<R>, Extractable<R> {
   isLeft(): this is LeftOf<L, R>;
   isRight(): this is RightOf<L, R>;
   orElse<R2 extends Type>(defaultValue: R2): R | R2;
@@ -5128,4 +5195,4 @@ interface FailureErrorType extends Error {
 }
 declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-export { Map$1 as $, AsyncMonad as $n, TypedErrorContext as $t, Collection as A, Cond as An, Task as At, SerializationResult as B, NonEmptyString as Bn, ContextServices as Bt, isRight as C, isTaggedThrowable as Cn, HttpClientConfig as Ct, Functype as D, Base as Dn, IO as Dt, FunctypeSum as E, ThrowableType as En, TestContext as Et, Some as F, BoundedNumber as Fn, LayerInput as Ft, fromJSON as G, UUID as Gn, FormValidation as Gt, createSerializationCompanion as H, PatternString as Hn, Tag as Ht, Stack as I, BoundedString as In, LayerOutput as It, Obj as J, ValidatedBrandCompanion as Jn, Validator as Jt, fromYAML as K, UrlString as Kn, Validation as Kt, Valuable as L, EmailAddress as Ln, Exit as Lt, None as M, InstanceType as Mn, UIO as Mt, Option as N, isCompanion as Nn, Layer as Nt, FunctypeBase as O, Match as On, InterruptedError as Ot, OptionConstructor as P, Companion as Pn, LayerError as Pt, ESMapType as Q, Applicative as Qn, TypedError as Qt, ValuableParams as R, ISO8601Date as Rn, ExitTag as Rt, isLeft as S, createCancellationTokenSource as Sn, HttpClient as St, tryCatchAsync as T, Throwable as Tn, TestClockTag as Tt, createSerializer as U, PositiveInteger as Un, TagService as Ut, createCustomSerializer as V, NonNegativeNumber as Vn, HasService as Vt, fromBinary as W, PositiveNumber as Wn, FieldValidation as Wt, MatchableUtils as X, TypeNames as Xn, ErrorMessage as Xt, Matchable as Y, Try as Yn, ErrorCode as Yt, ESMap as Z, Promisable as Zn, ErrorStatus as Zt, Right as _, TaskMetadata as _n, DecodeError as _t, EmptyListError as a, formatError as an, Extractable as ar, HKT as at, TypeCheckLeft as b, TaskResult as bn, HttpStatusError as bt, LeftError as c, Async as cn, Doable as cr, OptionKind as ct, isDoCapable as d, Err as dn, FoldableUtils as dt, ErrorChainElement as en, Functor as er, KVTraversable as et, unwrap as f, Ok as fn, Http as ft, LeftOf as g, TaskFailure as gn, ParseMode as gt, Left as h, Task$1 as hn, HttpResponse as ht, DoGenerator as i, createErrorSerializer as in, LazyList as ir, EitherKind as it, List as j, CompanionMethods as jn, TimeoutError as jt, FunctypeCollection as k, UntypedMatch as kn, RIO as kt, LeftErrorType as l, CancellationToken as ln, ParseError as lr, TryKind as lt, EitherBase as m, TaggedThrowable as mn, HttpRequestOptions as mt, Do as n, ErrorWithTaskInfo as nn, CollectionOps as nr, Lazy as nt, FailureError as o, formatStackTrace as on, isExtractable as or, Kind as ot, Either as p, Sync as pn, HttpMethodOptions as pt, Ref as q, ValidatedBrand as qn, ValidationRule as qt, DoAsync as r, TaskErrorInfo as rn, ContainerOps as rr, Identity as rt, FailureErrorType as s, safeStringify as sn, DoResult as sr, ListKind as st, $ as t, ErrorFormatterOptions as tn, Monad as tr, Traversable as tt, NoneError as u, CancellationTokenSource as un, UniversalContainer as ut, RightOf as v, TaskOutcome as vn, HttpError as vt, tryCatch as w, NAME as wn, TestClock as wt, TypeCheckRight as x, TaskSuccess as xn, NetworkError as xt, TestEither as y, TaskParams as yn, HttpMethod as yt, Set as z, IntegerNumber as zn, Context as zt };
+export { Map$1 as $, reduceWiden as $n, TypedErrorContext as $t, Collection as A, Cond as An, Task as At, SerializationResult as B, NonEmptyString as Bn, ContextServices as Bt, isRight as C, isTaggedThrowable as Cn, HttpClientConfig as Ct, Functype as D, Base as Dn, IO as Dt, FunctypeSum as E, ThrowableType as En, TestContext as Et, Some as F, BoundedNumber as Fn, LayerInput as Ft, fromJSON as G, UUID as Gn, FormValidation as Gt, createSerializationCompanion as H, PatternString as Hn, Tag as Ht, Stack as I, BoundedString as In, LayerOutput as It, Obj as J, ValidatedBrandCompanion as Jn, Validator as Jt, fromYAML as K, UrlString as Kn, Validation as Kt, Valuable as L, EmailAddress as Ln, Exit as Lt, None as M, InstanceType as Mn, UIO as Mt, Option as N, isCompanion as Nn, Layer as Nt, FunctypeBase as O, Match as On, InterruptedError as Ot, OptionConstructor as P, Companion as Pn, LayerError as Pt, ESMapType as Q, reduceRightWiden as Qn, TypedError as Qt, ValuableParams as R, ISO8601Date as Rn, ExitTag as Rt, isLeft as S, createCancellationTokenSource as Sn, HttpClient as St, tryCatchAsync as T, Throwable as Tn, TestClockTag as Tt, createSerializer as U, PositiveInteger as Un, TagService as Ut, createCustomSerializer as V, NonNegativeNumber as Vn, HasService as Vt, fromBinary as W, PositiveNumber as Wn, FieldValidation as Wt, MatchableUtils as X, TypeNames as Xn, ErrorMessage as Xt, Matchable as Y, Try as Yn, ErrorCode as Yt, ESMap as Z, Widen as Zn, ErrorStatus as Zt, Right as _, TaskMetadata as _n, DecodeError as _t, EmptyListError as a, formatError as an, CollectionOps as ar, HKT as at, TypeCheckLeft as b, TaskResult as bn, HttpStatusError as bt, LeftError as c, Async as cn, Extractable as cr, OptionKind as ct, isDoCapable as d, Err as dn, Doable as dr, FoldableUtils as dt, ErrorChainElement as en, Promisable as er, KVTraversable as et, unwrap as f, Ok as fn, ParseError as fr, Http as ft, LeftOf as g, TaskFailure as gn, ParseMode as gt, Left as h, Task$1 as hn, HttpResponse as ht, DoGenerator as i, createErrorSerializer as in, Monad as ir, EitherKind as it, List as j, CompanionMethods as jn, TimeoutError as jt, FunctypeCollection as k, UntypedMatch as kn, RIO as kt, LeftErrorType as l, CancellationToken as ln, isExtractable as lr, TryKind as lt, EitherBase as m, TaggedThrowable as mn, HttpRequestOptions as mt, Do as n, ErrorWithTaskInfo as nn, AsyncMonad as nr, Lazy as nt, FailureError as o, formatStackTrace as on, ContainerOps as or, Kind as ot, Either as p, Sync as pn, HttpMethodOptions as pt, Ref as q, ValidatedBrand as qn, ValidationRule as qt, DoAsync as r, TaskErrorInfo as rn, Functor as rr, Identity as rt, FailureErrorType as s, safeStringify as sn, LazyList as sr, ListKind as st, $ as t, ErrorFormatterOptions as tn, Applicative as tr, Traversable as tt, NoneError as u, CancellationTokenSource as un, DoResult as ur, UniversalContainer as ut, RightOf as v, TaskOutcome as vn, HttpError as vt, tryCatch as w, NAME as wn, TestClock as wt, TypeCheckRight as x, TaskSuccess as xn, NetworkError as xt, TestEither as y, TaskParams as yn, HttpMethod as yt, Set as z, IntegerNumber as zn, Context as zt };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import { a as ExtractBrand, c as hasBrand, i as BrandedString, l as unwrapBrand, n as BrandedBoolean, o as Unwrap, r as BrandedNumber, s as createBrander, t as Brand } from "./Brand-BJIRbUKB.js";
-import { $ as Map, $n as AsyncMonad, $t as TypedErrorContext, A as Collection, An as Cond, At as Task, B as SerializationResult, Bn as NonEmptyString, Bt as ContextServices, C as isRight, Cn as isTaggedThrowable, Ct as HttpClientConfig, D as Functype, Dn as Base, Dt as IO, E as FunctypeSum, En as ThrowableType, Et as TestContext, F as Some, Fn as BoundedNumber, Ft as LayerInput, G as fromJSON, Gn as UUID, Gt as FormValidation, H as createSerializationCompanion, Hn as PatternString, Ht as Tag, I as Stack, In as BoundedString, It as LayerOutput, J as Obj, Jn as ValidatedBrandCompanion, Jt as Validator, K as fromYAML, Kn as UrlString, Kt as Validation, L as Valuable, Ln as EmailAddress, Lt as Exit, M as None, Mn as InstanceType, Mt as UIO, N as Option, Nn as isCompanion, Nt as Layer, O as FunctypeBase, On as Match, Ot as InterruptedError, P as OptionConstructor, Pn as Companion, Pt as LayerError, Q as ESMapType, Qn as Applicative, Qt as TypedError, R as ValuableParams, Rn as ISO8601Date, Rt as ExitTag, S as isLeft, Sn as createCancellationTokenSource, St as HttpClient, T as tryCatchAsync, Tn as Throwable, Tt as TestClockTag, U as createSerializer, Un as PositiveInteger, Ut as TagService, V as createCustomSerializer, Vn as NonNegativeNumber, Vt as HasService, W as fromBinary, Wn as PositiveNumber, Wt as FieldValidation, X as MatchableUtils, Xn as TypeNames, Xt as ErrorMessage, Y as Matchable, Yn as Try, Yt as ErrorCode, Z as ESMap, Zn as Promisable, Zt as ErrorStatus, _ as Right, _n as TaskMetadata, _t as DecodeError, a as EmptyListError, an as formatError, ar as Extractable, at as HKT, b as TypeCheckLeft, bn as TaskResult, bt as HttpStatusError, c as LeftError, cn as Async, cr as Doable, ct as OptionKind, d as isDoCapable, dn as Err, dt as FoldableUtils, en as ErrorChainElement, er as Functor, et as KVTraversable, f as unwrap, fn as Ok, ft as Http, g as LeftOf, gn as TaskFailure, gt as ParseMode, h as Left, hn as Task$1, ht as HttpResponse, i as DoGenerator, in as createErrorSerializer, ir as LazyList, it as EitherKind, j as List, jn as CompanionMethods, jt as TimeoutError, k as FunctypeCollection, kn as UntypedMatch, kt as RIO, l as LeftErrorType, ln as CancellationToken, lr as ParseError, lt as TryKind, m as EitherBase, mn as TaggedThrowable, mt as HttpRequestOptions, n as Do, nn as ErrorWithTaskInfo, nr as CollectionOps, nt as Lazy, o as FailureError, on as formatStackTrace, or as isExtractable, ot as Kind, p as Either, pn as Sync, pt as HttpMethodOptions, q as Ref, qn as ValidatedBrand, qt as ValidationRule, r as DoAsync, rn as TaskErrorInfo, rr as ContainerOps, rt as Identity, s as FailureErrorType, sn as safeStringify, sr as DoResult, st as ListKind, t as $, tn as ErrorFormatterOptions, tr as Monad, tt as Traversable, u as NoneError, un as CancellationTokenSource, ut as UniversalContainer, v as RightOf, vn as TaskOutcome, vt as HttpError, w as tryCatch, wn as NAME, wt as TestClock, x as TypeCheckRight, xn as TaskSuccess, xt as NetworkError, y as TestEither, yn as TaskParams, yt as HttpMethod, z as Set, zn as IntegerNumber, zt as Context } from "./index-VSAy-IRN.js";
-import { a as isTypeable, c as Pipe, i as TypeableParams, l as Foldable, n as ExtractTag, o as Serializable, r as Typeable, s as SerializationMethods, t as Tuple, u as Type } from "./Tuple-DwyoW0ZP.js";
-export { $, Applicative, Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, BrandedBoolean as BrandedBooleanType, BrandedNumber, BrandedNumber as BrandedNumberType, BrandedString, BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, CollectionOps, Companion, CompanionMethods, Cond, ContainerOps, Context, Context as ContextType, ContextServices, DecodeError, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherBase, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, ExtractBrand, ExtractTag, Extractable, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, FunctypeSum, HKT, HasService, Http, HttpClient, HttpClientConfig, HttpError, HttpError as HttpErrors, HttpMethod, HttpMethodOptions, HttpRequestOptions, HttpResponse, HttpStatusError, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, KVTraversable, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, LeftOf, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NetworkError, NonEmptyString, NonNegativeNumber, None, NoneError, Obj, Ok, Option, OptionConstructor, OptionKind, ParseError, ParseMode, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, RightOf, Serializable, SerializationMethods, SerializationResult, Set, Some, Stack, Sync, Tag, Tag as TagType, TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, TestClock as TestClockType, TestClockTag, TestContext, TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, UIO, UUID, UniversalContainer, UntypedMatch, Unwrap, UrlString, ValidatedBrand, ValidatedBrand as ValidatedBrandType, ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, safeStringify, tryCatch, tryCatchAsync, unwrap, unwrapBrand };
+import { $ as Map, $n as reduceWiden, $t as TypedErrorContext, A as Collection, An as Cond, At as Task, B as SerializationResult, Bn as NonEmptyString, Bt as ContextServices, C as isRight, Cn as isTaggedThrowable, Ct as HttpClientConfig, D as Functype, Dn as Base, Dt as IO, E as FunctypeSum, En as ThrowableType, Et as TestContext, F as Some, Fn as BoundedNumber, Ft as LayerInput, G as fromJSON, Gn as UUID, Gt as FormValidation, H as createSerializationCompanion, Hn as PatternString, Ht as Tag, I as Stack, In as BoundedString, It as LayerOutput, J as Obj, Jn as ValidatedBrandCompanion, Jt as Validator, K as fromYAML, Kn as UrlString, Kt as Validation, L as Valuable, Ln as EmailAddress, Lt as Exit, M as None, Mn as InstanceType, Mt as UIO, N as Option, Nn as isCompanion, Nt as Layer, O as FunctypeBase, On as Match, Ot as InterruptedError, P as OptionConstructor, Pn as Companion, Pt as LayerError, Q as ESMapType, Qn as reduceRightWiden, Qt as TypedError, R as ValuableParams, Rn as ISO8601Date, Rt as ExitTag, S as isLeft, Sn as createCancellationTokenSource, St as HttpClient, T as tryCatchAsync, Tn as Throwable, Tt as TestClockTag, U as createSerializer, Un as PositiveInteger, Ut as TagService, V as createCustomSerializer, Vn as NonNegativeNumber, Vt as HasService, W as fromBinary, Wn as PositiveNumber, Wt as FieldValidation, X as MatchableUtils, Xn as TypeNames, Xt as ErrorMessage, Y as Matchable, Yn as Try, Yt as ErrorCode, Z as ESMap, Zn as Widen, Zt as ErrorStatus, _ as Right, _n as TaskMetadata, _t as DecodeError, a as EmptyListError, an as formatError, ar as CollectionOps, at as HKT, b as TypeCheckLeft, bn as TaskResult, bt as HttpStatusError, c as LeftError, cn as Async, cr as Extractable, ct as OptionKind, d as isDoCapable, dn as Err, dr as Doable, dt as FoldableUtils, en as ErrorChainElement, er as Promisable, et as KVTraversable, f as unwrap, fn as Ok, fr as ParseError, ft as Http, g as LeftOf, gn as TaskFailure, gt as ParseMode, h as Left, hn as Task$1, ht as HttpResponse, i as DoGenerator, in as createErrorSerializer, ir as Monad, it as EitherKind, j as List, jn as CompanionMethods, jt as TimeoutError, k as FunctypeCollection, kn as UntypedMatch, kt as RIO, l as LeftErrorType, ln as CancellationToken, lr as isExtractable, lt as TryKind, m as EitherBase, mn as TaggedThrowable, mt as HttpRequestOptions, n as Do, nn as ErrorWithTaskInfo, nr as AsyncMonad, nt as Lazy, o as FailureError, on as formatStackTrace, or as ContainerOps, ot as Kind, p as Either, pn as Sync, pt as HttpMethodOptions, q as Ref, qn as ValidatedBrand, qt as ValidationRule, r as DoAsync, rn as TaskErrorInfo, rr as Functor, rt as Identity, s as FailureErrorType, sn as safeStringify, sr as LazyList, st as ListKind, t as $, tn as ErrorFormatterOptions, tr as Applicative, tt as Traversable, u as NoneError, un as CancellationTokenSource, ur as DoResult, ut as UniversalContainer, v as RightOf, vn as TaskOutcome, vt as HttpError, w as tryCatch, wn as NAME, wt as TestClock, x as TypeCheckRight, xn as TaskSuccess, xt as NetworkError, y as TestEither, yn as TaskParams, yt as HttpMethod, z as Set, zn as IntegerNumber, zt as Context } from "./index-BPe5pcCH.js";
+import { a as isTypeable, c as Pipe, i as TypeableParams, l as Foldable, n as ExtractTag, o as Serializable, r as Typeable, s as SerializationMethods, t as Tuple, u as Type } from "./Tuple-De-FhPDq.js";
+export { $, Applicative, Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, BrandedBoolean as BrandedBooleanType, BrandedNumber, BrandedNumber as BrandedNumberType, BrandedString, BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, CollectionOps, Companion, CompanionMethods, Cond, ContainerOps, Context, Context as ContextType, ContextServices, DecodeError, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherBase, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, ExtractBrand, ExtractTag, Extractable, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, FunctypeSum, HKT, HasService, Http, HttpClient, HttpClientConfig, HttpError, HttpError as HttpErrors, HttpMethod, HttpMethodOptions, HttpRequestOptions, HttpResponse, HttpStatusError, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, KVTraversable, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, LeftOf, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NetworkError, NonEmptyString, NonNegativeNumber, None, NoneError, Obj, Ok, Option, OptionConstructor, OptionKind, ParseError, ParseMode, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, RightOf, Serializable, SerializationMethods, SerializationResult, Set, Some, Stack, Sync, Tag, Tag as TagType, TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, TestClock as TestClockType, TestClockTag, TestContext, TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, UIO, UUID, UniversalContainer, UntypedMatch, Unwrap, UrlString, ValidatedBrand, ValidatedBrand as ValidatedBrandType, ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, Widen, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, reduceRightWiden, reduceWiden, safeStringify, tryCatch, tryCatchAsync, unwrap, unwrapBrand };

package/dist/index.js

@@ -1 +1 @@
-import{Brand as e,BrandedBoolean as t,BrandedNumber as n,BrandedString as r,createBrander as i,hasBrand as a,unwrap as o}from"./branded/index.js";import{$ as s,A as c,At as l,B as u,C as d,Ct as f,D as p,Dt as m,E as h,Et as g,F as _,Ft as v,G as y,H as b,I as x,It as S,J as C,K as w,L as T,M as E,Mt as D,N as O,Nt as k,O as A,Ot as j,P as M,Pt as N,Q as P,R as F,S as I,St as L,T as R,Tt as z,U as B,V,W as H,X as U,Y as W,Z as G,_ as K,_t as q,a as J,at as Y,b as X,bt as Z,c as Q,ct as $,d as ee,dt as te,et as ne,f as re,ft as ie,g as ae,gt as oe,h as se,ht as ce,i as le,it as ue,j as de,jt as fe,k as pe,kt as me,l as he,lt as ge,m as _e,mt as ve,n as ye,nt as be,o as xe,ot as Se,p as Ce,pt as we,q as Te,r as Ee,rt as De,s as Oe,st as ke,t as Ae,tt as je,u as Me,ut as Ne,v as Pe,vt as Fe,w as Ie,wt as Le,x as Re,xt as ze,y as Be,yt as Ve,z as He}from"./src-CmTVH4Yo.js";import{r as Ue,t as We}from"./Tuple-DY00RBep.js";export{de as $,Te as Base,G as BoundedNumber,P as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,Ue as Companion,W as Cond,d as Context,E as Do,O as DoAsync,xe as ESMap,Ne as Either,s as EmailAddress,M as EmptyListError,u as Err,I as Exit,_ as FailureError,Me as FoldableUtils,he as HKT,ee as Http,Ce as HttpClient,re as HttpErrors,Be as IO,ne as ISO8601Date,Q as Identity,je as IntegerNumber,X as InterruptedError,Pe as Layer,Oe as Lazy,f as LazyList,te as Left,x as LeftError,Ve as List,J as Map,C as Match,le as MatchableUtils,y as NAME,be as NonEmptyString,De as NonNegativeNumber,g as None,T as NoneError,Ee as Obj,V as Ok,m as Option,j as OptionConstructor,S as ParseError,ue as PatternString,Y as PositiveInteger,Se as PositiveNumber,Le as Ref,ie as Right,z as Set,me as Some,ye as Stack,K as Tag,b as Task,_e as TestClock,se as TestClockTag,ae as TestContext,w as Throwable,Re as TimeoutError,L as Try,We as Tuple,we as TypeCheckLeft,ve as TypeCheckRight,Z as Typeable,h as TypedError,ke as UUID,$ as UrlString,ge as ValidatedBrand,R as Validation,Ae as Valuable,i as createBrander,B as createCancellationTokenSource,l as createCustomSerializer,p as createErrorSerializer,fe as createSerializationCompanion,D as createSerializer,A as formatError,pe as formatStackTrace,k as fromBinary,N as fromJSON,v as fromYAML,a as hasBrand,U as isCompanion,F as isDoCapable,Ie as isExtractable,ce as isLeft,oe as isRight,H as isTaggedThrowable,ze as isTypeable,c as safeStringify,q as tryCatch,Fe as tryCatchAsync,He as unwrap,o as unwrapBrand};
+import{Brand as e,BrandedBoolean as t,BrandedNumber as n,BrandedString as r,createBrander as i,hasBrand as a,unwrap as o}from"./branded/index.js";import{$ as s,A as c,At as l,B as u,C as d,Ct as f,D as p,Dt as m,E as h,Et as g,F as _,Ft as v,G as y,H as b,I as x,It as S,J as C,K as w,L as T,Lt as E,M as D,Mt as O,N as k,Nt as A,O as j,Ot as M,P as N,Pt as P,Q as F,R as I,Rt as L,S as R,St as z,T as B,Tt as V,U as H,V as U,W,X as G,Y as K,Z as q,_ as J,_t as Y,a as X,at as Z,b as Q,bt as $,c as ee,ct as te,d as ne,dt as re,et as ie,f as ae,ft as oe,g as se,gt as ce,h as le,ht as ue,i as de,it as fe,j as pe,jt as me,k as he,kt as ge,l as _e,lt as ve,m as ye,mt as be,n as xe,nt as Se,o as Ce,ot as we,p as Te,pt as Ee,q as De,r as Oe,rt as ke,s as Ae,st as je,t as Me,tt as Ne,u as Pe,ut as Fe,v as Ie,vt as Le,w as Re,wt as ze,x as Be,xt as Ve,y as He,yt as Ue,z as We}from"./src-Co3npRp-.js";import{r as Ge,t as Ke}from"./Tuple-DY00RBep.js";export{pe as $,De as Base,q as BoundedNumber,F as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,Ge as Companion,K as Cond,d as Context,D as Do,k as DoAsync,Ce as ESMap,Fe as Either,s as EmailAddress,N as EmptyListError,u as Err,R as Exit,_ as FailureError,Pe as FoldableUtils,_e as HKT,ne as Http,Te as HttpClient,ae as HttpErrors,He as IO,ie as ISO8601Date,ee as Identity,Ne as IntegerNumber,Q as InterruptedError,Ie as Layer,Ae as Lazy,f as LazyList,re as Left,x as LeftError,Ue as List,X as Map,C as Match,de as MatchableUtils,y as NAME,Se as NonEmptyString,ke as NonNegativeNumber,M as None,T as NoneError,Oe as Obj,U as Ok,ge as Option,l as OptionConstructor,L as ParseError,fe as PatternString,Z as PositiveInteger,we as PositiveNumber,ze as Ref,oe as Right,V as Set,me as Some,xe as Stack,J as Tag,b as Task,ye as TestClock,le as TestClockTag,se as TestContext,w as Throwable,Be as TimeoutError,z as Try,Ke as Tuple,Ee as TypeCheckLeft,be as TypeCheckRight,$ as Typeable,h as TypedError,je as UUID,te as UrlString,ve as ValidatedBrand,B as Validation,Me as Valuable,i as createBrander,H as createCancellationTokenSource,O as createCustomSerializer,p as createErrorSerializer,A as createSerializationCompanion,P as createSerializer,j as formatError,he as formatStackTrace,v as fromBinary,S as fromJSON,E as fromYAML,a as hasBrand,G as isCompanion,I as isDoCapable,Re as isExtractable,ue as isLeft,ce as isRight,W as isTaggedThrowable,Ve as isTypeable,g as reduceRightWiden,m as reduceWiden,c as safeStringify,Y as tryCatch,Le as tryCatchAsync,We as unwrap,o as unwrapBrand};

package/dist/list/index.d.ts

@@ -1,2 +1,2 @@
-import { j as List } from "../index-VSAy-IRN.js";
+import { j as List } from "../index-BPe5pcCH.js";
 export { List };

package/dist/list/index.js

@@ -1 +1 @@
-import{yt as e}from"../src-CmTVH4Yo.js";export{e as List};
+import{yt as e}from"../src-Co3npRp-.js";export{e as List};

package/dist/map/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as Map } from "../index-VSAy-IRN.js";
+import { $ as Map } from "../index-BPe5pcCH.js";
 export { Map };

package/dist/map/index.js

@@ -1 +1 @@
-import{a as e}from"../src-CmTVH4Yo.js";export{e as Map};
+import{a as e}from"../src-Co3npRp-.js";export{e as Map};

package/dist/option/index.d.ts

@@ -1,2 +1,2 @@
-import { F as Some, M as None, N as Option, P as OptionConstructor } from "../index-VSAy-IRN.js";
+import { F as Some, M as None, N as Option, P as OptionConstructor } from "../index-BPe5pcCH.js";
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

@@ -1 +1 @@
-import{Dt as e,Et as t,Ot as n,kt as r}from"../src-CmTVH4Yo.js";export{t as None,e as Option,n as OptionConstructor,r as Some};
+import{At as e,Ot as t,jt as n,kt as r}from"../src-Co3npRp-.js";export{t as None,r as Option,e as OptionConstructor,n as Some};

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-import { z as Set } from "../index-VSAy-IRN.js";
+import { z as Set } from "../index-BPe5pcCH.js";
 export { Set };

package/dist/set/index.js

@@ -1 +1 @@
-import{Tt as e}from"../src-CmTVH4Yo.js";export{e as Set};
+import{Tt as e}from"../src-Co3npRp-.js";export{e as Set};