functype 0.8.80 → 0.8.82

package/dist/either/index.d.ts

@@ -1,2 +1,2 @@
-export { E as Either, c as Left, R as Right, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from '../Either-CfG7OVB-.js';
-import '../Valuable-BI2O7E9Q.js';
+export { E as Either, d as Left, R as Right, c as TestEither, g as TypeCheckLeft, f as TypeCheckRight, e as isLeft, i as isRight, t as tryCatch, h as tryCatchAsync } from '../Either-CncND8cm.js';
+import '../Typeable-BBXrKPTY.js';

package/dist/either/index.mjs

@@ -1,2 +1,2 @@
-export{p as Either,i as Left,h as Right,n as TypeCheckLeft,m as TypeCheckRight,k as isLeft,j as isRight,l as tryCatch,o as tryCatchAsync}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{p as Either,i as Left,h as Right,n as TypeCheckLeft,m as TypeCheckRight,k as isLeft,j as isRight,l as tryCatch,o as tryCatchAsync}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/fpromise/index.d.ts

@@ -1,5 +1,5 @@
-import { E as Either } from '../Either-CfG7OVB-.js';
-import { T as Type } from '../Valuable-BI2O7E9Q.js';
+import { E as Either } from '../Either-CncND8cm.js';
+import { T as Type } from '../Typeable-BBXrKPTY.js';
 
 /**
  * Error context information that provides additional metadata about errors.

package/dist/fpromise/index.mjs

@@ -1,2 +1,2 @@
-export{J as FPromise,I as FPromiseCompanion}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{J as FPromise,I as FPromiseCompanion}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.d.ts

@@ -1,15 +1,16 @@
 import { Brand } from './branded/index.js';
 export { BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unbrand, createBrander, hasBrand, unbrand } from './branded/index.js';
-import { O as Option, E as Either, F as Foldable, L as List, P as Pipe, S as Serializable, M as Matchable, T as Traversable } from './Either-CfG7OVB-.js';
-export { a as Collection, C as Converters, I as IterableType, c as Left, h as MatchableUtils, N as None, k as OptionConstructor, R as Right, l as SerializationMethods, m as Set, j as Some, b as TestEither, f as TypeCheckLeft, e as TypeCheckRight, d as isLeft, i as isRight, t as tryCatch, g as tryCatchAsync } from './Either-CfG7OVB-.js';
-import { T as Type, a as Typeable, F as Functor, A as AsyncFunctor, V as Valuable } from './Valuable-BI2O7E9Q.js';
-export { b as AbstractFunctor, c as ArrayFunctor, E as ExtractTag, d as TypeableParams, e as ValuableParams, i as isTypeable } from './Valuable-BI2O7E9Q.js';
+import { O as Option, E as Either, F as Foldable, L as List, A as AsyncMonad, T as Traversable, a as FunctypeBase, b as Extractable, P as Pipe, S as Serializable, M as Matchable } from './Either-CncND8cm.js';
+export { s as Applicative, C as Collection, q as CollectionOps, r as ContainerOps, u as Functor, j as Functype, k as FunctypeCollection, d as Left, l as MatchableUtils, v as Monad, N as None, n as OptionConstructor, R as Right, o as SerializationMethods, p as Set, m as Some, c as TestEither, g as TypeCheckLeft, f as TypeCheckRight, e as isLeft, i as isRight, t as tryCatch, h as tryCatchAsync } from './Either-CncND8cm.js';
+import { T as Type, a as Typeable } from './Typeable-BBXrKPTY.js';
+export { E as ExtractTag, b as TypeableParams, i as isTypeable } from './Typeable-BBXrKPTY.js';
 import { FPromise } from './fpromise/index.js';
 export { ErrorContext, FPromiseCompanion } from './fpromise/index.js';
 import { Try } from './try/index.js';
 export { TypeNames } from './try/index.js';
-export { a as ESMap, E as ESMapType, M as Map, S as SafeTraversable } from './Map-wkGSJvYa.js';
-export { Tuple } from './tuple/index.js';
+export { Map, SafeTraversable } from './map/index.js';
+import { V as Valuable } from './Tuple-ZYh96cGE.js';
+export { T as Tuple, a as ValuableParams } from './Tuple-ZYh96cGE.js';
 
 /**
  * A brand with runtime validation
@@ -825,6 +826,31 @@ type Identity<T> = {
 };
 declare function Identity<T>(value: T): Identity<T>;
 
+interface IterableType<A extends Type> extends Iterable<A>, AsyncMonad<A>, Traversable<A> {
+    count(p: (x: A) => boolean): number;
+    find(p: (a: A) => boolean): Option<A>;
+    forEach(f: (a: A) => void): void;
+    drop(n: number): IterableType<A>;
+    dropRight(n: number): IterableType<A>;
+    dropWhile(p: (a: A) => boolean): IterableType<A>;
+    exists(p: (a: A) => boolean): boolean;
+    filter(p: (a: A) => boolean): IterableType<A>;
+    filterNot(p: (a: A) => boolean): IterableType<A>;
+    flatten<B>(): IterableType<B>;
+    reduce(f: (b: A, a: A) => A): A;
+    reduceRight(f: (b: A, a: A) => A): A;
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+    get head(): A | undefined;
+    get headOption(): Option<A>;
+    get isEmpty(): boolean;
+    map<B extends Type>(f: (a: A) => B): IterableType<B>;
+    ap<B extends Type>(ff: IterableType<(value: A) => B>): IterableType<B>;
+    flatMap<B extends Type>(f: (a: A) => IterableType<B>): IterableType<B>;
+    get size(): number;
+    toArray<B = A>(): readonly B[];
+}
+
 /**
  * Lazy type module
  * @module Lazy
@@ -835,7 +861,7 @@ declare function 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
  */
-type Lazy<T extends Type> = {
+interface Lazy<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 */
@@ -871,6 +897,12 @@ type Lazy<T extends Type> = {
      * @returns A new Lazy containing the mapped value
      */
     map<U extends Type>(f: (value: T) => U): Lazy<U>;
+    /**
+     * Applies a wrapped function to a wrapped value (Applicative pattern)
+     * @param ff - A Lazy containing a function from T to U
+     * @returns A new Lazy containing the result
+     */
+    ap<U extends Type>(ff: Lazy<(value: T) => U>): Lazy<U>;
     /**
      * Maps the value inside the Lazy using an async function
      * @param f - The async mapping function
@@ -980,14 +1012,14 @@ type Lazy<T extends Type> = {
     toString(): string;
     /**
      * Converts the Lazy to a value object
-     * @returns Object representation of the Lazy
+     * @returns Object representation of the Lazy with evaluation state
      */
     toValue(): {
         _tag: "Lazy";
         evaluated: boolean;
         value?: T;
     };
-} & Functor<T> & AsyncFunctor<T> & Pipe<T> & Serializable<T> & Typeable<"Lazy"> & Foldable<T> & Matchable<T, "Lazy">;
+}
 /**
  * Creates a Lazy computation that defers evaluation until needed.
  * Results are memoized after first evaluation.
@@ -1203,6 +1235,20 @@ declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>)
     cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
 };
 
+/**
+ * Type alias for the native JavaScript Map
+ * @interface
+ * @module Map
+ * @category Collections
+ */
+type ESMapType<K, V> = Map<K, V>;
+/**
+ * Reference to the native JavaScript Map
+ * @module Map
+ * @category Collections
+ */
+declare const ESMap: MapConstructor;
+
 /**
  * Stack data structure - Last In, First Out (LIFO)
  * Implements the Traversable interface for working with ordered collections
@@ -1236,6 +1282,18 @@ type Stack<A extends Type> = {
      * @returns A new flattened Stack
      */
     flatMap<B extends Type>(f: (a: A) => Stack<B>): Stack<B>;
+    /**
+     * Applies a Stack of functions to this Stack
+     * @param ff - Stack of functions to apply
+     * @returns A new Stack with applied functions
+     */
+    ap<B extends Type>(ff: Stack<(value: A) => B>): Stack<B>;
+    /**
+     * Maps each element to an async Stack and flattens the result
+     * @param f - The async mapping function returning a Stack
+     * @returns A promise of the new flattened Stack
+     */
+    flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Stack<B>>): PromiseLike<Stack<B>>;
     /**
      * Convert the stack to a List
      * @returns A List containing all elements
@@ -1260,7 +1318,7 @@ type Stack<A extends Type> = {
         Empty: () => R;
         NonEmpty: (values: A[]) => R;
     }): R;
-} & Traversable<A> & Functor<A> & Typeable<"Stack"> & Valuable<"Stack", A[]> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
+} & Traversable<A> & Valuable<"Stack", A[]> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
 declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
     /**
      * Creates an empty stack
@@ -1293,4 +1351,4 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
     fromBinary: <A>(binary: string) => Stack<A>;
 };
 
-export { type Async, AsyncFunctor, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, Foldable, FoldableUtils, Functor, HKT, ISO8601Date, Identity, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, UUID, type UniversalContainer, UrlString, ValidatedBrand, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };
+export { type Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, Foldable, FoldableUtils, FunctypeBase, HKT, ISO8601Date, Identity, IntegerNumber, type IterableType, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, UUID, type UniversalContainer, UrlString, ValidatedBrand, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export{F as Base,A as BoundedNumber,B as BoundedString,a as Companion,D as Cond,_ as ESMap,p as Either,w as EmailAddress,J as FPromise,I as FPromiseCompanion,U as FoldableUtils,W as HKT,z as ISO8601Date,X as Identity,t as IntegerNumber,Y as Lazy,Z as LazyList,i as Left,g as List,$ as Map,E as Match,aa as MatchableUtils,G as NAME,v as NonEmptyString,s as NonNegativeNumber,c as None,e as Option,d as OptionConstructor,T as ParseError,C as PatternString,u as PositiveInteger,r as PositiveNumber,h as Right,f as Set,b as Some,ba as Stack,O as Task,L as TaskException,M as TaskResult,H as Throwable,V as Try,n as TypeCheckLeft,m as TypeCheckRight,y as UUID,x as UrlString,q as ValidatedBrand,N as createCancellationTokenSource,S as createErrorSerializer,R as formatError,Q as formatStackTrace,k as isLeft,j as isRight,K as isTaggedThrowable,P as safeStringify,l as tryCatch,o as tryCatchAsync}from'./chunk-JIVKCD74.mjs';export{d as Tuple,a as Typeable,c as Valuable,b as isTypeable}from'./chunk-7PQA3W7W.mjs';export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unbrand}from'./chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{F as Base,A as BoundedNumber,B as BoundedString,a as Companion,D as Cond,_ as ESMap,p as Either,w as EmailAddress,J as FPromise,I as FPromiseCompanion,U as FoldableUtils,W as HKT,z as ISO8601Date,X as Identity,t as IntegerNumber,Y as Lazy,Z as LazyList,i as Left,g as List,$ as Map,E as Match,aa as MatchableUtils,G as NAME,v as NonEmptyString,s as NonNegativeNumber,c as None,e as Option,d as OptionConstructor,T as ParseError,C as PatternString,u as PositiveInteger,r as PositiveNumber,h as Right,f as Set,b as Some,ba as Stack,O as Task,L as TaskException,M as TaskResult,H as Throwable,V as Try,n as TypeCheckLeft,m as TypeCheckRight,y as UUID,x as UrlString,q as ValidatedBrand,N as createCancellationTokenSource,S as createErrorSerializer,R as formatError,Q as formatStackTrace,k as isLeft,j as isRight,K as isTaggedThrowable,P as safeStringify,l as tryCatch,o as tryCatchAsync}from'./chunk-JMCOLAJY.mjs';export{d as Tuple,a as Typeable,c as Valuable,b as isTypeable}from'./chunk-B6FR572T.mjs';export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unbrand}from'./chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/list/index.d.ts

@@ -1,2 +1,2 @@
-export { L as List } from '../Either-CfG7OVB-.js';
-import '../Valuable-BI2O7E9Q.js';
+export { L as List } from '../Either-CncND8cm.js';
+import '../Typeable-BBXrKPTY.js';

package/dist/list/index.mjs

@@ -1,2 +1,2 @@
-export{g as List}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{g as List}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/map/index.d.ts

@@ -1,4 +1,58 @@
-import '../Either-CfG7OVB-.js';
-import '../Valuable-BI2O7E9Q.js';
-export { M as Map, S as SafeTraversable } from '../Map-wkGSJvYa.js';
-import '../tuple/index.js';
+import { T as Traversable, C as Collection, S as Serializable, P as Pipe, F as Foldable, O as Option } from '../Either-CncND8cm.js';
+import { a as Typeable, T as Type } from '../Typeable-BBXrKPTY.js';
+import { T as Tuple } from '../Tuple-ZYh96cGE.js';
+
+/**
+ * A traversable interface for map that excludes map and flatMap operations
+ */
+type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap" | "flatMapAsync" | "ap">;
+interface Map<K, V> extends SafeTraversable<K, V>, Collection<Tuple<[K, V]>>, Typeable<"Map">, Serializable<[K, V][]>, Pipe<[K, V][]>, Foldable<Tuple<[K, V]>>, Iterable<[K, V]> {
+    readonly _tag: "Map";
+    add(item: Tuple<[K, V]>): Map<K, V>;
+    remove(value: K): Map<K, V>;
+    map<U>(f: (value: V) => U): Map<K, U>;
+    ap<U>(ff: Map<K, (value: V) => U>): Map<K, U>;
+    flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map<K2, V2>;
+    flatMapAsync<U>(f: (value: V) => PromiseLike<Map<K, U>>): PromiseLike<Map<K, U>>;
+    get(key: K): Option<V>;
+    getOrElse(key: K, defaultValue: V): V;
+    orElse(key: K, alternative: Option<V>): Option<V>;
+    fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U;
+    foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B;
+    foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B;
+    /**
+     * Pattern matches over the Map, applying a handler function based on whether it's empty
+     * @param patterns - Object with handler functions for Empty and NonEmpty variants
+     * @returns The result of applying the matching handler function
+     */
+    match<R>(patterns: {
+        Empty: () => R;
+        NonEmpty: (entries: Array<Tuple<[K, V]>>) => R;
+    }): R;
+    toValue(): {
+        _tag: "Map";
+        value: [K, V][];
+    };
+}
+declare const Map: (<K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map<K, V>) & {
+    /**
+     * Creates a Map from JSON string
+     * @param json - The JSON string
+     * @returns Map instance
+     */
+    fromJSON: <K, V>(json: string) => Map<K, V>;
+    /**
+     * Creates a Map from YAML string
+     * @param yaml - The YAML string
+     * @returns Map instance
+     */
+    fromYAML: <K, V>(yaml: string) => Map<K, V>;
+    /**
+     * Creates a Map from binary string
+     * @param binary - The binary string
+     * @returns Map instance
+     */
+    fromBinary: <K, V>(binary: string) => Map<K, V>;
+};
+
+export { Map, type SafeTraversable };

package/dist/map/index.mjs

@@ -1,2 +1,2 @@
-export{$ as Map}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{$ as Map}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/option/index.d.ts

@@ -1,2 +1,2 @@
-export { N as None, O as Option, k as OptionConstructor, j as Some } from '../Either-CfG7OVB-.js';
-import '../Valuable-BI2O7E9Q.js';
+export { N as None, O as Option, n as OptionConstructor, m as Some } from '../Either-CncND8cm.js';
+import '../Typeable-BBXrKPTY.js';

package/dist/option/index.mjs

@@ -1,2 +1,2 @@
-export{c as None,e as Option,d as OptionConstructor,b as Some}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{c as None,e as Option,d as OptionConstructor,b as Some}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-export { m as Set } from '../Either-CfG7OVB-.js';
-import '../Valuable-BI2O7E9Q.js';
+export { p as Set } from '../Either-CncND8cm.js';
+import '../Typeable-BBXrKPTY.js';

package/dist/set/index.mjs

@@ -1,2 +1,2 @@
-export{f as Set}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{f as Set}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/try/index.d.ts

@@ -1,22 +1,27 @@
-import { E as Either, S as Serializable, P as Pipe, F as Foldable, M as Matchable } from '../Either-CfG7OVB-.js';
-import { T as Type, a as Typeable, V as Valuable } from '../Valuable-BI2O7E9Q.js';
+import { a as FunctypeBase, b as Extractable, P as Pipe, E as Either } from '../Either-CncND8cm.js';
+import { T as Type } from '../Typeable-BBXrKPTY.js';
 
 /**
  * Possible types of Try instances
  */
 type TypeNames = "Success" | "Failure";
-type Try<T> = {
+interface Try<T> extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T> {
     readonly _tag: TypeNames;
     readonly error: Error | undefined;
     isSuccess: () => boolean;
     isFailure: () => boolean;
     get: () => T;
     getOrElse: (defaultValue: T) => T;
+    getOrThrow: (error?: Error) => T;
     orElse: (alternative: Try<T>) => Try<T>;
+    orNull: () => T | null;
+    orUndefined: () => T | undefined;
     orThrow: (error: Error) => T;
     toEither: () => Either<Error, T>;
     map: <U>(f: (value: T) => U) => Try<U>;
+    ap: <U>(ff: Try<(value: T) => U>) => Try<U>;
     flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
+    flatMapAsync: <U>(f: (value: T) => Promise<Try<U>>) => Promise<Try<U>>;
     /**
      * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success
      * @param onFailure - Function to apply if the Try is Failure
@@ -34,7 +39,11 @@ type Try<T> = {
         Success: (value: T) => R;
         Failure: (error: Error) => R;
     }): R;
-} & Typeable<TypeNames> & Valuable<TypeNames, T | Error> & Serializable<T> & Pipe<T> & Foldable<T> & Matchable<T | Error, "Success" | "Failure">;
+    toValue(): {
+        _tag: TypeNames;
+        value: T | Error;
+    };
+}
 declare const Try: (<T>(f: () => T) => Try<T>) & {
     /**
      * Creates a Try from JSON string

package/dist/try/index.mjs

@@ -1,2 +1,2 @@
-export{V as Try}from'../chunk-JIVKCD74.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{V as Try}from'../chunk-JMCOLAJY.mjs';import'../chunk-B6FR572T.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/tuple/index.d.ts

@@ -1,12 +1,2 @@
-import { T as Type, c as ArrayFunctor, a as Typeable, V as Valuable } from '../Valuable-BI2O7E9Q.js';
-
-type Tuple<T extends Type[]> = {
-    get<K extends number>(index: K): T[K];
-    map<U extends Type[]>(f: (value: T) => U): Tuple<U>;
-    flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>;
-    toArray(): T;
-    [Symbol.iterator](): Iterator<T[number]>;
-} & ArrayFunctor<T> & Typeable<"Tuple"> & Valuable<"Tuple", T>;
-declare const Tuple: <T extends Type[]>(values: T) => Tuple<T>;
-
-export { Tuple };
+import '../Typeable-BBXrKPTY.js';
+export { T as Tuple } from '../Tuple-ZYh96cGE.js';

package/dist/tuple/index.mjs

@@ -1,2 +1,2 @@
-export{d as Tuple}from'../chunk-7PQA3W7W.mjs';//# sourceMappingURL=index.mjs.map
+export{d as Tuple}from'../chunk-B6FR572T.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functype",
-  "version": "0.8.80",
+  "version": "0.8.82",
   "type": "module",
   "description": "A smallish functional library for TypeScript",
   "author": "jordan.burke@gmail.com",
@@ -139,12 +139,12 @@
   },
   "sideEffects": false,
   "scripts": {
+    "clean": "rimraf dist",
     "compile": "tsc --noEmit",
     "build": "pnpm compile && pnpm lint && pnpm test",
     "build:dev": "tsup --watch",
-    "build:prod": "pnpm compile && pnpm test && cross-env NODE_ENV=production tsup",
+    "build:prod": "pnpm clean && pnpm compile && pnpm test && cross-env NODE_ENV=production tsup",
     "build:watch": "tsup --watch",
-    "build:publish": "pnpm build:prod && pnpm publish --access public",
     "lint:fix": "eslint ./src --quiet --fix",
     "lint:format": "prettier --loglevel warn --write \"./**/*.{ts,tsx,css,md,json}\" ",
     "lint": "pnpm lint:format && pnpm lint:fix ",

package/dist/Map-wkGSJvYa.d.ts

@@ -1,65 +0,0 @@
-import { T as Traversable, I as IterableType, O as Option, a as Collection, S as Serializable, P as Pipe, F as Foldable, M as Matchable } from './Either-CfG7OVB-.js';
-import { T as Type, a as Typeable, V as Valuable } from './Valuable-BI2O7E9Q.js';
-import { Tuple } from './tuple/index.js';
-
-/**
- * Type alias for the native JavaScript Map
- * @interface
- * @module Map
- * @category Collections
- */
-type ESMapType<K, V> = Map<K, V>;
-/**
- * Reference to the native JavaScript Map
- * @module Map
- * @category Collections
- */
-declare const ESMap: MapConstructor;
-
-/**
- * A traversable interface for map that excludes map and flatMap operations
- */
-type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap">;
-type Map$1<K, V> = {
-    add(item: Tuple<[K, V]>): Map$1<K, V>;
-    remove(value: K): Map$1<K, V>;
-    map<U>(f: (value: V) => U): Map$1<K, U>;
-    flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map$1<K2, V2>;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-    fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U;
-    foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B;
-    foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B;
-    /**
-     * Pattern matches over the Map, applying a handler function based on whether it's empty
-     * @param patterns - Object with handler functions for Empty and NonEmpty variants
-     * @returns The result of applying the matching handler function
-     */
-    match<R>(patterns: {
-        Empty: () => R;
-        NonEmpty: (entries: Array<Tuple<[K, V]>>) => R;
-    }): R;
-} & SafeTraversable<K, V> & Collection<Tuple<[K, V]>> & Typeable<"Map"> & Valuable<"Map", ESMapType<K, V>> & Serializable<[K, V][]> & Pipe<[K, V][]> & Foldable<Tuple<[K, V]>> & Matchable<Array<Tuple<[K, V]>>, "Empty" | "NonEmpty">;
-declare const Map$1: (<K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map$1<K, V>) & {
-    /**
-     * Creates a Map from JSON string
-     * @param json - The JSON string
-     * @returns Map instance
-     */
-    fromJSON: <K, V>(json: string) => Map$1<K, V>;
-    /**
-     * Creates a Map from YAML string
-     * @param yaml - The YAML string
-     * @returns Map instance
-     */
-    fromYAML: <K, V>(yaml: string) => Map$1<K, V>;
-    /**
-     * Creates a Map from binary string
-     * @param binary - The binary string
-     * @returns Map instance
-     */
-    fromBinary: <K, V>(binary: string) => Map$1<K, V>;
-};
-
-export { type ESMapType as E, Map$1 as M, type SafeTraversable as S, ESMap as a };

package/dist/Valuable-BI2O7E9Q.d.ts

@@ -1,59 +0,0 @@
-type Type = unknown;
-
-type AbstractFunctor<A extends Type> = {
-    map(f: (value: A) => Type): AbstractFunctor<Type>;
-    flatMap(f: (value: A) => AbstractFunctor<Type>): AbstractFunctor<Type>;
-};
-type Functor<A extends Type> = AbstractFunctor<A> & {
-    map<B extends Type>(f: (value: A) => B): Functor<B>;
-    flatMap<B extends Type>(f: (value: A) => Functor<B>): Functor<B>;
-};
-type AsyncFunctor<A extends Type> = {
-    flatMapAsync(f: (value: A) => PromiseLike<AsyncFunctor<A>>): PromiseLike<AsyncFunctor<A>>;
-};
-type ArrayFunctor<A extends Type[]> = AbstractFunctor<A> & {
-    map<U extends Type[]>(f: (value: A) => U): ArrayFunctor<U>;
-    flatMap<U extends Type[]>(f: (value: A) => ArrayFunctor<U>): ArrayFunctor<U>;
-};
-
-type TypeableParams<Tag extends string, T> = {
-    _tag: Tag;
-    impl: T;
-};
-type ExtractTag<T> = T extends Typeable<infer Tag, unknown> ? Tag : never;
-type Typeable<Tag extends string, T = object> = T & {
-    readonly _tag: Tag;
-};
-declare function Typeable<Tag extends string, T>({ _tag, impl }: TypeableParams<Tag, T>): Typeable<Tag, T>;
-declare function isTypeable<T>(value: unknown, tag: string): value is T;
-
-/**
- * Parameters for creating a Valuable instance
- */
-type ValuableParams<Tag extends string, T, V> = {
-    _tag: Tag;
-    impl: T;
-    value: V;
-};
-/**
- * Creates a Valuable wrapper that adds value extraction capabilities
- * @param params - Configuration parameters
- * @module Valuable
- * @category Utilities
- */
-declare function Valuable<Tag extends string, V, T = object>(params: ValuableParams<Tag, T, V>): T & {
-    toValue: () => {
-        _tag: Tag;
-        value: V;
-    };
-    _tag: Tag;
-};
-/**
- * Represents a type that can extract its inner value
- * @interface
- * @module Valuable
- * @category Utilities
- */
-type Valuable<Tag extends string, V, T = object> = ReturnType<typeof Valuable<Tag, V, T>>;
-
-export { type AsyncFunctor as A, type ExtractTag as E, type Functor as F, type Type as T, Valuable as V, Typeable as a, type AbstractFunctor as b, type ArrayFunctor as c, type TypeableParams as d, type ValuableParams as e, isTypeable as i };

package/dist/chunk-7PQA3W7W.mjs

@@ -1,2 +0,0 @@
-function r({_tag:e,impl:t}){return {...t,_tag:e}}function n(e,t){return !e||typeof e!="object"||!("_tag"in e)?false:t?e._tag===t:true}function u(e){let t=r({_tag:e._tag,impl:e.impl});return {...t,toValue:()=>({_tag:t._tag,value:e.value})}}var a=e=>({_tag:"Tuple",map:t=>{let T=t(e);return a(T)},flatMap:t=>t(e),get:t=>e[t],toArray:()=>e,[Symbol.iterator](){let t=0;return {next:()=>t<e.length?{value:e[t++],done:false}:{value:void 0,done:true}}},toValue:()=>({_tag:"Tuple",value:e})});export{r as a,n as b,u as c,a as d};//# sourceMappingURL=chunk-7PQA3W7W.mjs.map
-//# sourceMappingURL=chunk-7PQA3W7W.mjs.map