functype 0.44.0 → 0.45.0

package/dist/{index-DKAUrDCz.d.ts → index-DBg23xHh.d.ts}

@@ -1,5 +1,5 @@
-import { t as Brand } from "./Brand-BPeggBaO.js";
-import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-C4maYbiO.js";
+import { t as Brand } from "./Brand-B_uQBKwR.js";
+import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-35L0I92q.js";
 
 //#region src/error/ParseError.d.ts
 declare const ParseError: (message?: string) => Error & {
@@ -1192,376 +1192,6 @@ declare class Throwable extends Error implements ThrowableType {
   }): ThrowableType;
 }
 //#endregion
-//#region src/fpromise/FPromise.d.ts
-/**
- * Error context information that provides additional metadata about errors.
- * This context is passed to error mapping functions to provide more information
- * about the error that occurred.
- *
- * @property originalError - The original error that was thrown
- * @property stack - The stack trace of the error, if available
- * @property timestamp - The timestamp when the error occurred
- */
-type ErrorContext = {
-  originalError: unknown;
-  stack?: string;
-  timestamp: number;
-};
-/**
- * FPromise is a functional wrapper around JavaScript's Promise with enhanced error handling.
- * It implements the Functor and AsyncFunctor interfaces, providing map and flatMap operations
- * for functional composition.
- *
- * FPromise adds several features not available in standard Promises:
- * - Generic error typing for better type safety
- * - Error recovery mechanisms (recover, recoverWith, recoverWithF)
- * - Error filtering and categorization
- * - Side effect methods (tap, tapError)
- * - Error context preservation
- * - Conversion to/from Either for more functional error handling
- *
- * @template T - The type of the value that the FPromise resolves to
- * @template E - The type of the error that the FPromise may reject with (defaults to unknown)
- */
-/**
- * FPromise type that defines the function signature and methods
- */
-type FPromise<T extends Type, E extends Type = unknown> = PromiseLike<T> & {
-  readonly _tag: "FPromise";
-  tap: (f: (value: T) => void) => FPromise<T, E>;
-  mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T, E2>;
-  tapError: (f: (error: E) => void) => FPromise<T, E>;
-  recover: (fallback: T) => FPromise<T, never>;
-  recoverWith: (f: (error: E) => T) => FPromise<T, never>;
-  recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>) => FPromise<T, E2>;
-  filterError: <E2 extends E>(predicate: (error: E) => boolean, handler: (error: E) => FPromise<T, E2>) => FPromise<T, E>;
-  logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T, E>;
-  toPromise: () => Promise<T>;
-  toEither: () => Promise<Either<E, T>>;
-  fold: <R$1 extends Type>(onError: (error: E) => R$1, onSuccess: (value: T) => R$1) => FPromise<R$1, never>;
-  map: <U extends Type>(f: (value: T) => U) => FPromise<U, E>;
-  flatMap: <U extends Type>(f: (value: T) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>;
-  flatMapAsync: <U extends Type>(f: (value: T) => PromiseLike<U>) => Promise<U>;
-};
-/**
- * Static utility methods for FPromise using the Companion pattern.
- * These methods provide factory functions and utilities for working with FPromises.
- */
-declare const FPromiseCompanion: {
-  /**
-   * Creates an FPromise that resolves to the provided value.
-   *
-   * @template T - The type of the value
-   * @template E - The type of the error (defaults to never since this FPromise won't reject)
-   * @param value - The value to resolve with
-   * @returns An FPromise that resolves to the value
-   *
-   * @example
-   * const promise = FPromise.resolve(42)
-   * // promise resolves to 42
-   */
-  resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
-  /**
-   * Creates an FPromise that rejects with the provided reason.
-   *
-   * @template T - The type of the value (which will never be produced)
-   * @template E - The type of the error
-   * @param reason - The reason for rejection
-   * @returns An FPromise that rejects with the reason
-   *
-   * @example
-   * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
-   * // promise rejects with Error("Something went wrong")
-   */
-  reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
-  /**
-   * Creates an FPromise from a regular Promise.
-   *
-   * @template T - The type of the value
-   * @template E - The type of the error
-   * @param promise - The Promise to convert
-   * @returns An FPromise that resolves or rejects with the same value or error
-   *
-   * @example
-   * const promise = FPromise.from(fetch("https://api.example.com/data"))
-   * // promise is an FPromise that resolves or rejects based on the fetch result
-   */
-  from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
-  /**
-   * Creates an FPromise from an Either.
-   * If the Either is a Right, the FPromise resolves with the Right value.
-   * If the Either is a Left, the FPromise rejects with the Left value.
-   *
-   * @template L - The type of the Left value (error)
-   * @template R - The type of the Right value (success)
-   * @param either - The Either to convert
-   * @returns An FPromise that resolves or rejects based on the Either
-   *
-   * @example
-   * const either = Right<Error, number>(42)
-   * const promise = FPromise.fromEither(either)
-   * // promise resolves to 42
-   */
-  fromEither: <L, R$1>(either: Either<L, R$1>) => FPromise<R$1, L>;
-  /**
-   * Runs multiple FPromises in parallel and returns an array of results.
-   * Similar to Promise.all, this will reject if any of the promises reject.
-   *
-   * @template T - The type of the values
-   * @template E - The type of the error
-   * @param promises - An array of FPromises, Promises, or values
-   * @returns An FPromise that resolves to an array of results
-   *
-   * @example
-   * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
-   * const result = await FPromise.all(promises).toPromise()
-   * // result is [1, 2, 3]
-   */
-  all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
-  /**
-   * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
-   * This will always resolve, never reject.
-   *
-   * @template T - The type of the values
-   * @template E - The type of the errors
-   * @param promises - An array of FPromises or Promises
-   * @returns An FPromise that resolves to an array of Either results
-   *
-   * @example
-   * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
-   * const result = await FPromise.allSettled(promises).toPromise()
-   * // result is [Right(1), Left(Error("Failed"))]
-   */
-  allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
-  /**
-   * Like Promise.race, returns the first promise to settle (either resolve or reject).
-   *
-   * @template T - The type of the values
-   * @template E - The type of the errors
-   * @param promises - An array of FPromises or Promises
-   * @returns An FPromise that resolves or rejects with the result of the first promise to settle
-   *
-   * @example
-   * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
-   * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
-   * const result = await FPromise.race([slow, fast]).toPromise()
-   * // result is 2
-   */
-  race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-  /**
-   * Like Promise.any, returns the first promise to fulfill.
-   * This will only reject if all promises reject.
-   *
-   * @template T - The type of the values
-   * @template E - The type of the errors
-   * @param promises - An array of FPromises or Promises
-   * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
-   *
-   * @example
-   * const promises = [
-   *   FPromise.reject<number, Error>(new Error("First failed")),
-   *   FPromise.resolve(2),
-   *   FPromise.reject<number, Error>(new Error("Third failed"))
-   * ]
-   * const result = await FPromise.any(promises).toPromise()
-   * // result is 2
-   */
-  any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-  /**
-   * Retries an operation with exponential backoff.
-   * This is useful for operations that may fail temporarily, such as network requests.
-   *
-   * @template T - The type of the value
-   * @template E - The type of the error
-   * @param operation - A function that returns an FPromise
-   * @param options - Configuration options for the retry
-   * @param options.maxRetries - Maximum number of retry attempts
-   * @param options.baseDelay - Base delay in milliseconds (default: 100)
-   * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
-   * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
-   *
-   * @example
-   * const operation = () => {
-   *   if (Math.random() > 0.8) {
-   *     return FPromise.resolve("Success!")
-   *   }
-   *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
-   * }
-   *
-   * const result = await FPromise.retryWithBackoff(operation, {
-   *   maxRetries: 3,
-   *   baseDelay: 100,
-   *   shouldRetry: (error) => error.message === "Temporary failure"
-   * }).toPromise()
-   */
-  retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
-    maxRetries: number;
-    baseDelay?: number;
-    shouldRetry?: (error: E, attempt: number) => boolean;
-  }) => FPromise<T, E>;
-};
-/**
- * Creates an FPromise from an executor function.
- *
- * @template T - The type of the value that the FPromise resolves to
- * @template E - The type of the error that the FPromise may reject with
- * @param executor - A function that receives resolve and reject functions
- * @returns An FPromise instance
- */
-declare const FPromise: (<T extends Type, E = unknown>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: E) => void) => void) => FPromise<T, E>) & {
-  /**
-   * Creates an FPromise that resolves to the provided value.
-   *
-   * @template T - The type of the value
-   * @template E - The type of the error (defaults to never since this FPromise won't reject)
-   * @param value - The value to resolve with
-   * @returns An FPromise that resolves to the value
-   *
-   * @example
-   * const promise = FPromise.resolve(42)
-   * // promise resolves to 42
-   */
-  resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
-  /**
-   * Creates an FPromise that rejects with the provided reason.
-   *
-   * @template T - The type of the value (which will never be produced)
-   * @template E - The type of the error
-   * @param reason - The reason for rejection
-   * @returns An FPromise that rejects with the reason
-   *
-   * @example
-   * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
-   * // promise rejects with Error("Something went wrong")
-   */
-  reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
-  /**
-   * Creates an FPromise from a regular Promise.
-   *
-   * @template T - The type of the value
-   * @template E - The type of the error
-   * @param promise - The Promise to convert
-   * @returns An FPromise that resolves or rejects with the same value or error
-   *
-   * @example
-   * const promise = FPromise.from(fetch("https://api.example.com/data"))
-   * // promise is an FPromise that resolves or rejects based on the fetch result
-   */
-  from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
-  /**
-   * Creates an FPromise from an Either.
-   * If the Either is a Right, the FPromise resolves with the Right value.
-   * If the Either is a Left, the FPromise rejects with the Left value.
-   *
-   * @template L - The type of the Left value (error)
-   * @template R - The type of the Right value (success)
-   * @param either - The Either to convert
-   * @returns An FPromise that resolves or rejects based on the Either
-   *
-   * @example
-   * const either = Right<Error, number>(42)
-   * const promise = FPromise.fromEither(either)
-   * // promise resolves to 42
-   */
-  fromEither: <L, R$1>(either: Either<L, R$1>) => FPromise<R$1, L>;
-  /**
-   * Runs multiple FPromises in parallel and returns an array of results.
-   * Similar to Promise.all, this will reject if any of the promises reject.
-   *
-   * @template T - The type of the values
-   * @template E - The type of the error
-   * @param promises - An array of FPromises, Promises, or values
-   * @returns An FPromise that resolves to an array of results
-   *
-   * @example
-   * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
-   * const result = await FPromise.all(promises).toPromise()
-   * // result is [1, 2, 3]
-   */
-  all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
-  /**
-   * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
-   * This will always resolve, never reject.
-   *
-   * @template T - The type of the values
-   * @template E - The type of the errors
-   * @param promises - An array of FPromises or Promises
-   * @returns An FPromise that resolves to an array of Either results
-   *
-   * @example
-   * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
-   * const result = await FPromise.allSettled(promises).toPromise()
-   * // result is [Right(1), Left(Error("Failed"))]
-   */
-  allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
-  /**
-   * Like Promise.race, returns the first promise to settle (either resolve or reject).
-   *
-   * @template T - The type of the values
-   * @template E - The type of the errors
-   * @param promises - An array of FPromises or Promises
-   * @returns An FPromise that resolves or rejects with the result of the first promise to settle
-   *
-   * @example
-   * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
-   * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
-   * const result = await FPromise.race([slow, fast]).toPromise()
-   * // result is 2
-   */
-  race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-  /**
-   * Like Promise.any, returns the first promise to fulfill.
-   * This will only reject if all promises reject.
-   *
-   * @template T - The type of the values
-   * @template E - The type of the errors
-   * @param promises - An array of FPromises or Promises
-   * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
-   *
-   * @example
-   * const promises = [
-   *   FPromise.reject<number, Error>(new Error("First failed")),
-   *   FPromise.resolve(2),
-   *   FPromise.reject<number, Error>(new Error("Third failed"))
-   * ]
-   * const result = await FPromise.any(promises).toPromise()
-   * // result is 2
-   */
-  any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
-  /**
-   * Retries an operation with exponential backoff.
-   * This is useful for operations that may fail temporarily, such as network requests.
-   *
-   * @template T - The type of the value
-   * @template E - The type of the error
-   * @param operation - A function that returns an FPromise
-   * @param options - Configuration options for the retry
-   * @param options.maxRetries - Maximum number of retry attempts
-   * @param options.baseDelay - Base delay in milliseconds (default: 100)
-   * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
-   * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
-   *
-   * @example
-   * const operation = () => {
-   *   if (Math.random() > 0.8) {
-   *     return FPromise.resolve("Success!")
-   *   }
-   *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
-   * }
-   *
-   * const result = await FPromise.retryWithBackoff(operation, {
-   *   maxRetries: 3,
-   *   baseDelay: 100,
-   *   shouldRetry: (error) => error.message === "Temporary failure"
-   * }).toPromise()
-   */
-  retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
-    maxRetries: number;
-    baseDelay?: number;
-    shouldRetry?: (error: E, attempt: number) => boolean;
-  }) => FPromise<T, E>;
-};
-//#endregion
 //#region src/core/task/Task.d.ts
 /**
  * Type definition for errors with a _tag property that identifies them as Throwables
@@ -1679,7 +1309,7 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
    * @param f - Optional finally handler function
    * @param cancellationToken - Optional token for cancellation support
    */
-  Async: <U = T>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
+  Async: <U = T>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => Promise<TaskOutcome<U>>;
   /**
    * Run a synchronous operation with explicit try/catch/finally semantics
    * Returns a TaskOutcome for functional error handling
@@ -1699,7 +1329,7 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
    * @param f - Optional finally handler function
    * @param cancellationToken - Optional token for cancellation support
    */
-  AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
+  AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => Promise<TaskOutcome<U>>;
   toString(): string;
   doUnwrap(): DoResult<unknown>;
   _tag: string;
@@ -1757,7 +1387,7 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
   /**
    * Convert a Promise-returning function to a Task-compatible function
    */
-  fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<U>>);
+  fromPromise: <U, Args extends unknown[]>(promiseFn: (...args: Args) => Promise<U>, params?: TaskParams) => ((...args: Args) => Promise<TaskOutcome<U>>);
   /**
    * Convert a Task result to a Promise
    */
@@ -1766,21 +1396,21 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
    * Race multiple tasks and return the result of the first one to complete
    * Optionally specify a timeout after which the race will fail
    *
-   * @param tasks - Array of tasks to race (as FPromises)
+   * @param tasks - Array of tasks to race (as Promises)
    * @param timeoutMs - Optional timeout in milliseconds
    * @param params - Task parameters for the race operation
    * @returns A promise that resolves with the first task to complete or rejects if all tasks fail
    */
-  race: <T>(tasks: Array<FPromise<T> | FPromise<TaskOutcome<T>>>, timeoutMs?: number, params?: TaskParams) => FPromise<TaskOutcome<T>>;
+  race: <T>(tasks: Array<Promise<T> | Promise<TaskOutcome<T>>>, timeoutMs?: number, params?: TaskParams) => Promise<TaskOutcome<T>>;
   /**
    * Convert a Node.js style callback function to a Task-compatible function
    * Node.js callbacks typically have the signature (error, result) => void
    *
    * @param nodeFn - Function that accepts a Node.js style callback
    * @param params - Task parameters
-   * @returns A function that returns an FPromise
+   * @returns A function that returns a Promise
    */
-  fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<T>>);
+  fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => Promise<TaskOutcome<T>>);
   /**
    * Create a cancellation token source
    * @returns A cancellation token source that can be used to control task cancellation
@@ -1794,7 +1424,7 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
    * @returns An object with the task and a function to cancel it
    */
   cancellable: <T>(task: (token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, params?: TaskParams) => {
-    task: FPromise<TaskOutcome<T>>;
+    task: Promise<TaskOutcome<T>>;
     cancel: () => void;
   };
   /**
@@ -1806,7 +1436,7 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
    * @returns An object with the task, cancel function, and current progress
    */
   withProgress: <T>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, onProgress?: (percent: number) => void, params?: TaskParams) => {
-    task: FPromise<TaskOutcome<T>>;
+    task: Promise<TaskOutcome<T>>;
     cancel: () => void;
     currentProgress: () => number;
   };
@@ -3897,6 +3527,18 @@ interface Map$1<K$1, V> extends SafeTraversable<K$1, V>, Collection<Tuple<[K$1,
   };
 }
 declare const Map$1: (<K$1, V>(entries?: readonly (readonly [K$1, V])[] | IterableIterator<[K$1, V]> | null) => Map$1<K$1, V>) & {
+  /**
+   * Creates an empty Map
+   * Returns a singleton instance for efficiency
+   * @returns An empty Map instance
+   */
+  empty: <K$1, V>() => Map$1<K$1, V>;
+  /**
+   * Creates a Map from variadic key-value pair arguments
+   * @param entries - Key-value pairs to create map from
+   * @returns A Map containing the entries
+   */
+  of: <K$1, V>(...entries: [K$1, V][]) => Map$1<K$1, V>;
   /**
    * Creates a Map from JSON string
    * @param json - The JSON string
@@ -4114,6 +3756,18 @@ interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
   toString: () => string;
 }
 declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
+  /**
+   * Creates an empty Set
+   * Returns a singleton instance for efficiency
+   * @returns An empty Set instance
+   */
+  empty: <A extends Type>() => Set<A>;
+  /**
+   * Creates a Set from variadic arguments
+   * @param values - Values to create set from
+   * @returns A Set containing the unique values
+   */
+  of: <A extends Type>(...values: A[]) => Set<A>;
   /**
    * Creates a Set from JSON string
    * @param json - The JSON string
@@ -4532,6 +4186,18 @@ interface List<A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapeable<
   }): R$1;
 }
 declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
+  /**
+   * Creates an empty List
+   * Returns a singleton instance for efficiency
+   * @returns An empty List instance
+   */
+  empty: <A extends Type>() => List<A>;
+  /**
+   * Creates a List from variadic arguments
+   * @param values - Values to create list from
+   * @returns A List containing the values
+   */
+  of: <A extends Type>(...values: A[]) => List<A>;
   /**
    * Creates a List from JSON string
    * @param json - The JSON string
@@ -4972,4 +4638,4 @@ interface FailureErrorType extends Error {
 }
 declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-export { TestClockTag as $, TaskFailure as $t, OptionConstructor as A, PositiveNumber as An, ValidationRule as At, fromBinary as B, Functor as Bn, TaskErrorInfo as Bt, Functype as C, EmailAddress as Cn, OptionKind as Ct, List as D, NonNegativeNumber as Dn, FieldValidation as Dt, Collection as E, NonEmptyString as En, FoldableUtils as Et, Set as F, Try as Fn, TypedError as Ft, MatchableUtils as G, Extractable as Gn, Async as Gt, fromYAML as H, CollectionOps as Hn, formatError as Ht, SerializationResult as I, TypeNames as In, TypedErrorContext as It, Map$1 as J, Doable as Jn, Err as Jt, ESMap as K, isExtractable as Kn, CancellationToken as Kt, createCustomSerializer as L, Promisable as Ln, ErrorChainElement as Lt, Stack as M, UrlString as Mn, ErrorCode as Mt, Valuable as N, ValidatedBrand as Nn, ErrorMessage as Nt, None as O, PatternString as On, FormValidation as Ot, ValuableParams as P, ValidatedBrandCompanion as Pn, ErrorStatus as Pt, TestClock as Q, Task$1 as Qt, createSerializationCompanion as R, Applicative as Rn, ErrorFormatterOptions as Rt, tryCatchAsync as S, BoundedString as Sn, ListKind as St, FunctypeCollection as T, IntegerNumber as Tn, UniversalContainer as Tt, Ref as U, ContainerOps as Un, formatStackTrace as Ut, fromJSON as V, Monad as Vn, createErrorSerializer as Vt, Matchable as W, LazyList as Wn, safeStringify as Wt, Traversable as X, Sync as Xt, SafeTraversable as Y, ParseError as Yn, Ok as Yt, Lazy as Z, TaggedThrowable as Zt, TypeCheckLeft as _, CompanionMethods as _n, TagService as _t, EmptyListError as a, createCancellationTokenSource as an, TimeoutError as at, isRight as b, Companion as bn, HKT as bt, LeftError as c, FPromise as cn, LayerError as ct, isDoCapable as d, Throwable as dn, Exit as dt, TaskMetadata as en, TestContext as et, unwrap as f, ThrowableType as fn, ExitTag as ft, TestEither as g, Cond as gn, Tag as gt, Right as h, UntypedMatch as hn, HasService as ht, DoGenerator as i, TaskSuccess as in, Task as it, Some as j, UUID as jn, Validator as jt, Option as k, PositiveInteger as kn, Validation as kt, LeftErrorType as l, FPromiseCompanion as ln, LayerInput as lt, Left as m, Match as mn, ContextServices as mt, Do as n, TaskParams as nn, InterruptedError as nt, FailureError as o, isTaggedThrowable as on, UIO as ot, Either as p, Base as pn, Context as pt, ESMapType as q, DoResult as qn, CancellationTokenSource as qt, DoAsync as r, TaskResult as rn, RIO as rt, FailureErrorType as s, ErrorContext as sn, Layer as st, $ as t, TaskOutcome as tn, IO as tt, NoneError as u, NAME as un, LayerOutput as ut, TypeCheckRight as v, InstanceType as vn, Identity as vt, FunctypeBase as w, ISO8601Date as wn, TryKind as wt, tryCatch as x, BoundedNumber as xn, Kind as xt, isLeft as y, isCompanion as yn, EitherKind as yt, createSerializer as z, AsyncMonad as zn, ErrorWithTaskInfo as zt };
+export { TestClockTag as $, TaskFailure as $t, OptionConstructor as A, ValidatedBrand as An, ValidationRule as At, fromBinary as B, ContainerOps as Bn, TaskErrorInfo as Bt, Functype as C, NonEmptyString as Cn, OptionKind as Ct, List as D, PositiveNumber as Dn, FieldValidation as Dt, Collection as E, PositiveInteger as En, FoldableUtils as Et, Set as F, Applicative as Fn, TypedError as Ft, MatchableUtils as G, Doable as Gn, Async as Gt, fromYAML as H, Extractable as Hn, formatError as Ht, SerializationResult as I, AsyncMonad as In, TypedErrorContext as It, Map$1 as J, Err as Jt, ESMap as K, ParseError as Kn, CancellationToken as Kt, createCustomSerializer as L, Functor as Ln, ErrorChainElement as Lt, Stack as M, Try as Mn, ErrorCode as Mt, Valuable as N, TypeNames as Nn, ErrorMessage as Nt, None as O, UUID as On, FormValidation as Ot, ValuableParams as P, Promisable as Pn, ErrorStatus as Pt, TestClock as Q, Task$1 as Qt, createSerializationCompanion as R, Monad as Rn, ErrorFormatterOptions as Rt, tryCatchAsync as S, IntegerNumber as Sn, ListKind as St, FunctypeCollection as T, PatternString as Tn, UniversalContainer as Tt, Ref as U, isExtractable as Un, formatStackTrace as Ut, fromJSON as V, LazyList as Vn, createErrorSerializer as Vt, Matchable as W, DoResult as Wn, safeStringify as Wt, Traversable as X, Sync as Xt, SafeTraversable as Y, Ok as Yt, Lazy as Z, TaggedThrowable as Zt, TypeCheckLeft as _, Companion as _n, TagService as _t, EmptyListError as a, createCancellationTokenSource as an, TimeoutError as at, isRight as b, EmailAddress as bn, HKT as bt, LeftError as c, Throwable as cn, LayerError as ct, isDoCapable as d, Match as dn, Exit as dt, TaskMetadata as en, TestContext as et, unwrap as f, UntypedMatch as fn, ExitTag as ft, TestEither as g, isCompanion as gn, Tag as gt, Right as h, InstanceType as hn, HasService as ht, DoGenerator as i, TaskSuccess as in, Task as it, Some as j, ValidatedBrandCompanion as jn, Validator as jt, Option as k, UrlString as kn, Validation as kt, LeftErrorType as l, ThrowableType as ln, LayerInput as lt, Left as m, CompanionMethods as mn, ContextServices as mt, Do as n, TaskParams as nn, InterruptedError as nt, FailureError as o, isTaggedThrowable as on, UIO as ot, Either as p, Cond as pn, Context as pt, ESMapType as q, CancellationTokenSource as qt, DoAsync as r, TaskResult as rn, RIO as rt, FailureErrorType as s, NAME as sn, Layer as st, $ as t, TaskOutcome as tn, IO as tt, NoneError as u, Base as un, LayerOutput as ut, TypeCheckRight as v, BoundedNumber as vn, Identity as vt, FunctypeBase as w, NonNegativeNumber as wn, TryKind as wt, tryCatch as x, ISO8601Date as xn, Kind as xt, isLeft as y, BoundedString as yn, EitherKind as yt, createSerializer as z, CollectionOps as zn, ErrorWithTaskInfo 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-BPeggBaO.js";
-import { $ as TestClockTag, $t as TaskFailure, A as OptionConstructor, An as PositiveNumber, At as ValidationRule, B as fromBinary, Bn as Functor, Bt as TaskErrorInfo, C as Functype, Cn as EmailAddress, Ct as OptionKind, D as List, Dn as NonNegativeNumber, Dt as FieldValidation, E as Collection, En as NonEmptyString, Et as FoldableUtils, F as Set, Fn as Try, Ft as TypedError, G as MatchableUtils, Gn as Extractable, Gt as Async, H as fromYAML, Hn as CollectionOps, Ht as formatError, I as SerializationResult, In as TypeNames, It as TypedErrorContext, J as Map, Jn as Doable, Jt as Err, K as ESMap, Kn as isExtractable, Kt as CancellationToken, L as createCustomSerializer, Ln as Promisable, Lt as ErrorChainElement, M as Stack, Mn as UrlString, Mt as ErrorCode, N as Valuable, Nn as ValidatedBrand, Nt as ErrorMessage, O as None, On as PatternString, Ot as FormValidation, P as ValuableParams, Pn as ValidatedBrandCompanion, Pt as ErrorStatus, Q as TestClock, Qt as Task$1, R as createSerializationCompanion, Rn as Applicative, Rt as ErrorFormatterOptions, S as tryCatchAsync, Sn as BoundedString, St as ListKind, T as FunctypeCollection, Tn as IntegerNumber, Tt as UniversalContainer, U as Ref, Un as ContainerOps, Ut as formatStackTrace, V as fromJSON, Vn as Monad, Vt as createErrorSerializer, W as Matchable, Wn as LazyList, Wt as safeStringify, X as Traversable, Xt as Sync, Y as SafeTraversable, Yn as ParseError, Yt as Ok, Z as Lazy, Zt as TaggedThrowable, _ as TypeCheckLeft, _n as CompanionMethods, _t as TagService, a as EmptyListError, an as createCancellationTokenSource, at as TimeoutError, b as isRight, bn as Companion, bt as HKT, c as LeftError, cn as FPromise, ct as LayerError, d as isDoCapable, dn as Throwable, dt as Exit, en as TaskMetadata, et as TestContext, f as unwrap, fn as ThrowableType, ft as ExitTag, g as TestEither, gn as Cond, gt as Tag, h as Right, hn as UntypedMatch, ht as HasService, i as DoGenerator, in as TaskSuccess, it as Task, j as Some, jn as UUID, jt as Validator, k as Option, kn as PositiveInteger, kt as Validation, l as LeftErrorType, ln as FPromiseCompanion, lt as LayerInput, m as Left, mn as Match, mt as ContextServices, n as Do, nn as TaskParams, nt as InterruptedError, o as FailureError, on as isTaggedThrowable, ot as UIO, p as Either, pn as Base, pt as Context, q as ESMapType, qn as DoResult, qt as CancellationTokenSource, r as DoAsync, rn as TaskResult, rt as RIO, s as FailureErrorType, sn as ErrorContext, st as Layer, t as $, tn as TaskOutcome, tt as IO, u as NoneError, un as NAME, ut as LayerOutput, v as TypeCheckRight, vn as InstanceType, vt as Identity, w as FunctypeBase, wn as ISO8601Date, wt as TryKind, x as tryCatch, xn as BoundedNumber, xt as Kind, y as isLeft, yn as isCompanion, yt as EitherKind, z as createSerializer, zn as AsyncMonad, zt as ErrorWithTaskInfo } from "./index-DKAUrDCz.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-C4maYbiO.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, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorContext, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, Exit as ExitType, ExitTag, ExtractBrand, ExtractTag, Extractable, FPromise, FPromiseCompanion, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, Functor, Functype, FunctypeBase, FunctypeCollection, HKT, HasService, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NonEmptyString, NonNegativeNumber, None, NoneError, Ok, Option, OptionConstructor, OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, SafeTraversable, 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 { 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-B_uQBKwR.js";
+import { $ as TestClockTag, $t as TaskFailure, A as OptionConstructor, An as ValidatedBrand, At as ValidationRule, B as fromBinary, Bn as ContainerOps, Bt as TaskErrorInfo, C as Functype, Cn as NonEmptyString, Ct as OptionKind, D as List, Dn as PositiveNumber, Dt as FieldValidation, E as Collection, En as PositiveInteger, Et as FoldableUtils, F as Set, Fn as Applicative, Ft as TypedError, G as MatchableUtils, Gn as Doable, Gt as Async, H as fromYAML, Hn as Extractable, Ht as formatError, I as SerializationResult, In as AsyncMonad, It as TypedErrorContext, J as Map, Jt as Err, K as ESMap, Kn as ParseError, Kt as CancellationToken, L as createCustomSerializer, Ln as Functor, Lt as ErrorChainElement, M as Stack, Mn as Try, Mt as ErrorCode, N as Valuable, Nn as TypeNames, Nt as ErrorMessage, O as None, On as UUID, Ot as FormValidation, P as ValuableParams, Pn as Promisable, Pt as ErrorStatus, Q as TestClock, Qt as Task$1, R as createSerializationCompanion, Rn as Monad, Rt as ErrorFormatterOptions, S as tryCatchAsync, Sn as IntegerNumber, St as ListKind, T as FunctypeCollection, Tn as PatternString, Tt as UniversalContainer, U as Ref, Un as isExtractable, Ut as formatStackTrace, V as fromJSON, Vn as LazyList, Vt as createErrorSerializer, W as Matchable, Wn as DoResult, Wt as safeStringify, X as Traversable, Xt as Sync, Y as SafeTraversable, Yt as Ok, Z as Lazy, Zt as TaggedThrowable, _ as TypeCheckLeft, _n as Companion, _t as TagService, a as EmptyListError, an as createCancellationTokenSource, at as TimeoutError, b as isRight, bn as EmailAddress, bt as HKT, c as LeftError, cn as Throwable, ct as LayerError, d as isDoCapable, dn as Match, dt as Exit, en as TaskMetadata, et as TestContext, f as unwrap, fn as UntypedMatch, ft as ExitTag, g as TestEither, gn as isCompanion, gt as Tag, h as Right, hn as InstanceType, ht as HasService, i as DoGenerator, in as TaskSuccess, it as Task, j as Some, jn as ValidatedBrandCompanion, jt as Validator, k as Option, kn as UrlString, kt as Validation, l as LeftErrorType, ln as ThrowableType, lt as LayerInput, m as Left, mn as CompanionMethods, mt as ContextServices, n as Do, nn as TaskParams, nt as InterruptedError, o as FailureError, on as isTaggedThrowable, ot as UIO, p as Either, pn as Cond, pt as Context, q as ESMapType, qt as CancellationTokenSource, r as DoAsync, rn as TaskResult, rt as RIO, s as FailureErrorType, sn as NAME, st as Layer, t as $, tn as TaskOutcome, tt as IO, u as NoneError, un as Base, ut as LayerOutput, v as TypeCheckRight, vn as BoundedNumber, vt as Identity, w as FunctypeBase, wn as NonNegativeNumber, wt as TryKind, x as tryCatch, xn as ISO8601Date, xt as Kind, y as isLeft, yn as BoundedString, yt as EitherKind, z as createSerializer, zn as CollectionOps, zt as ErrorWithTaskInfo } from "./index-DBg23xHh.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-35L0I92q.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, Do, DoAsync, DoGenerator, DoResult, Doable, ESMap, ESMapType, Either, 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, HKT, HasService, IO, IO as IOType, Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, Kind, Layer, Layer as LayerType, LayerError, LayerInput, LayerOutput, Lazy, Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, List, ListKind, Map, Match, Matchable, MatchableUtils, Monad, NAME, NonEmptyString, NonNegativeNumber, None, NoneError, Ok, Option, OptionConstructor, OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, RIO, Ref, Ref as RefType, Right, SafeTraversable, 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 };

package/dist/index.js

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

package/dist/list/index.d.ts

@@ -1,2 +1,2 @@
-import { D as List } from "../index-DKAUrDCz.js";
+import { D as List } from "../index-DBg23xHh.js";
 export { List };

package/dist/list/index.js

@@ -1 +1 @@
-import{_t as e}from"../src-BuPnddUO.js";export{e as List};
+import{ht as e}from"../src-Bl2PmAVK.js";export{e as List};

package/dist/map/index.d.ts

@@ -1,2 +1,2 @@
-import { J as Map, Y as SafeTraversable } from "../index-DKAUrDCz.js";
+import { J as Map, Y as SafeTraversable } from "../index-DBg23xHh.js";
 export { Map, SafeTraversable };

package/dist/map/index.js

@@ -1 +1 @@
-import{i as e}from"../src-BuPnddUO.js";export{e as Map};
+import{i as e}from"../src-Bl2PmAVK.js";export{e as Map};

package/dist/option/index.d.ts

@@ -1,2 +1,2 @@
-import { A as OptionConstructor, O as None, j as Some, k as Option } from "../index-DKAUrDCz.js";
+import { A as OptionConstructor, O as None, j as Some, k as Option } from "../index-DBg23xHh.js";
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

@@ -1 +1 @@
-import{Dt as e,Et as t,Tt as n,wt as r}from"../src-BuPnddUO.js";export{r as None,n as Option,t as OptionConstructor,e as Some};
+import{Ct as e,St as t,Tt as n,wt as r}from"../src-Bl2PmAVK.js";export{t as None,e as Option,r as OptionConstructor,n as Some};

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-import { F as Set } from "../index-DKAUrDCz.js";
+import { F as Set } from "../index-DBg23xHh.js";
 export { Set };

package/dist/set/index.js

@@ -1 +1 @@
-import{Ct as e}from"../src-BuPnddUO.js";export{e as Set};
+import{xt as e}from"../src-Bl2PmAVK.js";export{e as Set};