functype 0.8.67 → 0.8.69

package/dist/Either-BfXNbTHo.d.ts

@@ -0,0 +1,533 @@
+import { a as Type, F as Functor, T as Typeable, V as Valuable, b as AsyncFunctor, E as ExtractTag } from './Valuable-CtuVEKTZ.js';
+
+/**
+ * Foldable type class represents data structures that can be folded to a summary value.
+ *
+ * @typeParam A - The type of elements in the data structure
+ */
+type Foldable<A> = {
+    /**
+     * Pattern matches over the structure, applying specific handlers for each variant
+     * @param onEmpty - Function to apply if the structure is empty or has no value
+     * @param onValue - Function to apply if the structure has a value
+     * @returns The result of applying the appropriate function
+     */
+    fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
+    /**
+     * Left-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    /**
+     * Right-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+};
+
+/**
+ * Pattern matching interface for functional data types.
+ *
+ * @typeParam A - The type of elements in the data structure
+ * @typeParam Tags - The type of tags used for pattern matching
+ */
+type Matchable<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.
+     *
+     * The return type is inferred from the pattern handlers when not explicitly specified.
+     *
+     * @param patterns - An object containing handler functions for each variant
+     * @returns The result of applying the matching handler function
+     */
+    match<R>(patterns: Record<Tags, (value: A) => R>): R;
+};
+/**
+ * Utility functions for working with Matchable data structures
+ */
+declare const MatchableUtils: {
+    /**
+     * Helper function to create a default case for pattern matching
+     *
+     * @param handler - The default handler function to apply
+     * @returns A function that always applies the default handler
+     */
+    default: <A, R>(handler: (value: A) => R) => (value: A) => R;
+    /**
+     * Helper function to create a match pattern that guards based on a predicate
+     *
+     * @param predicate - The predicate function for guarding
+     * @param handler - The handler function to apply if the predicate passes
+     * @returns A function that applies the handler only if the predicate passes
+     */
+    when: <A, R>(predicate: (value: A) => boolean, handler: (value: A) => R) => (value: A) => R | undefined;
+};
+
+/**
+ * Pipe interface for functional data structures
+ * @typeParam T - The type of value to pipe
+ */
+type Pipe<T extends Type> = {
+    /**
+     * Pipes the value through the provided function
+     * @param f - The function to apply to the value
+     * @returns The result of applying the function to the value
+     * @typeParam U - The return type of the function
+     */
+    pipe<U extends Type>(f: (value: T) => U): U;
+};
+
+/**
+ * Methods for different serialization formats
+ */
+type SerializationMethods<T> = {
+    toJSON(): string;
+    toYAML(): string;
+    toBinary(): string;
+};
+type Serializable<T> = {
+    serialize(): SerializationMethods<T>;
+};
+
+/**
+ * Traversable typeclass for data structures that can be traversed through
+ */
+type Traversable<A extends Type> = Functor<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;
+};
+
+/**
+ * Creates a Some variant of Option containing a value.
+ * @param value - The value to wrap in Some
+ * @returns A new Some instance containing the value
+ * @typeParam T - The type of the value
+ */
+declare const Some: <T extends Type>(value: T) => Option<T>;
+/**
+ * Creates a None variant of Option representing absence of a value.
+ * @returns A new None instance
+ * @typeParam T - The type that would be contained if this was a Some
+ */
+declare const None: <T extends Type>() => Option<T>;
+/**
+ * Safely wraps a value that might be null or undefined in an Option.
+ * Creates Some if the value is defined, None otherwise.
+ * @param value - The value to wrap (might be null/undefined)
+ * @returns Some(value) if value is defined, None otherwise
+ * @typeParam T - The type of the value
+ */
+declare const OptionConstructor: <T extends Type>(value: T | null | undefined) => Option<T>;
+/**
+ * Option type module
+ * @module Option
+ * @category Core
+ */
+/**
+ * The Option type represents a value that may or may not exist.
+ * It's used to handle potentially null or undefined values in a type-safe way.
+ * @typeParam T - The type of the value contained in the Option
+ */
+type Option<T extends Type> = {
+    /** Tag identifying if this is a Some or None variant */
+    readonly _tag: "Some" | "None";
+    /** The contained value (undefined for None) */
+    readonly value: T | undefined;
+    /** Whether this Option contains no value */
+    isEmpty: boolean;
+    /**
+     * Extracts the value if present
+     * @throws Error if the Option is None
+     * @returns The contained value
+     */
+    get(): T;
+    /**
+     * Returns the contained value or a default value if None
+     * @param defaultValue - The value to return if this Option is None
+     * @returns The contained value or defaultValue
+     */
+    getOrElse(defaultValue: T): T;
+    /**
+     * Returns the contained value or throws a specified error if None
+     * @param error - The error to throw if this Option is None
+     * @returns The contained value
+     * @throws The specified error if the Option is None
+     */
+    getOrThrow(error: Error): T;
+    /**
+     * Returns this Option if it contains a value, otherwise returns the alternative
+     * @param alternative - The alternative Option to return if this is None
+     * @returns This Option or the alternative
+     */
+    orElse(alternative: Option<T>): Option<T>;
+    /**
+     * Returns the contained value or null if None
+     * @returns The contained value or null
+     */
+    orNull(): T | null;
+    /**
+     * Returns the contained value or undefined if None
+     * @returns The contained value or undefined
+     */
+    orUndefined(): T | undefined;
+    /**
+     * Maps the value inside the Option using the provided function
+     * @param f - The mapping function
+     * @returns A new Option containing the mapped value, or None if this Option is None
+     */
+    map<U extends Type>(f: (value: T) => U): Option<U>;
+    /**
+     * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
+     * @param predicate - The predicate function to test the value
+     * @returns This Option or None
+     */
+    filter(predicate: (value: T) => boolean): Option<T>;
+    /**
+     * Maps the value using a function that returns an Option
+     * @param f - The mapping function returning an Option
+     * @returns The result of applying f to the contained value, or None if this Option is None
+     */
+    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
+    /**
+     * Maps the value using an async function that returns an Option
+     * @param f - The async mapping function returning an Option
+     * @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
+     * @param onSome - Function to apply if the Option has a value
+     * @returns The result of applying the appropriate function
+     */
+    fold<U>(onNone: () => U, onSome: (value: T) => U): U;
+    /**
+     * Left-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
+    /**
+     * Right-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
+    /**
+     * Converts this Option to a List
+     * @returns A List containing the value if Some, or empty List if None
+     */
+    toList(): List<T>;
+    /**
+     * Checks if this Option contains the specified value
+     * @param value - The value to check for
+     * @returns true if this Option contains the value, false otherwise
+     */
+    contains(value: T): boolean;
+    /** The number of elements in this Option (0 or 1) */
+    size: number;
+    /**
+     * Converts this Option to an Either
+     * @param left - The value to use for Left if this Option is None
+     * @returns Either.Right with the contained value if Some, or Either.Left with left if None
+     */
+    toEither<E>(left: E): Either<E, T>;
+    /**
+     * Returns a string representation of this Option
+     * @returns A string representation
+     */
+    toString(): string;
+    /**
+     * Returns a simple object representation of this Option
+     * @returns An object with _tag and value properties
+     */
+    toValue(): {
+        _tag: "Some" | "None";
+        value: T;
+    };
+    /**
+     * Pattern matches over the Option, applying a handler function based on the variant
+     * @param patterns - Object with handler functions for Some and None variants
+     * @returns The result of applying the matching handler function
+     */
+    match<R>(patterns: {
+        Some: (value: T) => R;
+        None: () => R;
+    }): R;
+} & (Traversable<T> & Functor<T> & Typeable<"Some" | "None"> & Valuable<"Some" | "None", T> & AsyncFunctor<T> & Serializable<T> & Pipe<T> & Foldable<T> & Matchable<T, "Some" | "None">);
+declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
+    /**
+     * Creates an Option from any value. Alias for Option function.
+     * @param value - The value to wrap
+     * @returns Some(value) if value is defined, None otherwise
+     * @typeParam T - The type of the value
+     */
+    from: <T>(value: T) => Option<T>;
+    /**
+     * Returns a None instance. Alias for None function.
+     * @returns A None instance
+     * @typeParam T - The type that would be contained if this was a Some
+     */
+    none: <T>() => Option<T>;
+    /**
+     * Creates an Option from JSON string
+     * @param json - The JSON string
+     * @returns Option instance
+     */
+    fromJSON: <T>(json: string) => Option<T>;
+    /**
+     * Creates an Option from YAML string
+     * @param yaml - The YAML string
+     * @returns Option instance
+     */
+    fromYAML: <T>(yaml: string) => Option<T>;
+    /**
+     * Creates an Option from binary string
+     * @param binary - The binary string
+     * @returns Option instance
+     */
+    fromBinary: <T>(binary: string) => Option<T>;
+};
+
+type IterableType<A extends Type> = {
+    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>;
+    flatMap<B extends Type>(f: (a: A) => IterableType<B>): IterableType<B>;
+    get size(): number;
+    toArray<B = A>(): readonly B[];
+} & Iterable<A> & Functor<A> & AsyncFunctor<A> & Traversable<A>;
+
+type Set<A> = {
+    add: (value: A) => Set<A>;
+    remove: (value: A) => Set<A>;
+    contains: (value: A) => boolean;
+    has: (value: A) => boolean;
+    map: <B>(f: (a: A) => B) => Set<B>;
+    flatMap: <B>(f: (a: A) => IterableType<B>) => Set<B>;
+    fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
+    toList: () => List<A>;
+    toSet: () => Set<A>;
+    toString: () => string;
+} & IterableType<A> & Collection<A> & Typeable<"Set"> & Valuable<"Set", A[]> & Serializable<A[]> & Pipe<A[]> & Foldable<A>;
+declare const Set: (<A>(iterable?: Iterable<A> | IterableType<A>) => Set<A>) & {
+    /**
+     * Creates a Set from JSON string
+     * @param json - The JSON string
+     * @returns Set instance
+     */
+    fromJSON: <A>(json: string) => Set<A>;
+    /**
+     * Creates a Set from YAML string
+     * @param yaml - The YAML string
+     * @returns Set instance
+     */
+    fromYAML: <A>(yaml: string) => Set<A>;
+    /**
+     * Creates a Set from binary string
+     * @param binary - The binary string
+     * @returns Set instance
+     */
+    fromBinary: <A>(binary: string) => Set<A>;
+};
+
+type List<A> = {
+    readonly length: number;
+    readonly [Symbol.iterator]: () => Iterator<A>;
+    map: <B>(f: (a: A) => B) => List<B>;
+    flatMap: <B>(f: (a: A) => IterableType<B>) => List<B>;
+    flatMapAsync: <B>(f: (a: A) => PromiseLike<IterableType<B>>) => PromiseLike<List<B>>;
+    forEach: (f: (a: A) => void) => void;
+    count: (p: (x: A) => boolean) => number;
+    exists: (p: (a: A) => boolean) => boolean;
+    filter<S extends A>(predicate: (a: A) => a is S): List<S>;
+    filter(predicate: (a: A) => unknown): List<A>;
+    filterNot: (p: (a: A) => boolean) => List<A>;
+    filterType: <T extends Typeable<string, unknown>>(tag: string) => List<T & A>;
+    find: <T extends A = A>(predicate: (a: A) => boolean, tag?: ExtractTag<T>) => Option<T>;
+    readonly head: A | undefined;
+    readonly headOption: Option<A>;
+    readonly isEmpty: boolean;
+    toArray: <B = A>() => B[];
+    reduce: (f: (prev: A, curr: A) => A) => A;
+    reduceRight: (f: (prev: A, curr: 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;
+    remove: (value: A) => List<A>;
+    removeAt: (index: number) => List<A>;
+    add: (item: A) => List<A>;
+    get: (index: number) => Option<A>;
+    concat: (other: List<A>) => List<A>;
+    toList: () => List<A>;
+    toSet: () => Set<A>;
+    toString: () => string;
+    toValue: () => {
+        _tag: "List";
+        value: A[];
+    };
+    drop: (n: number) => List<A>;
+    dropRight: (n: number) => List<A>;
+    dropWhile: (p: (a: A) => boolean) => List<A>;
+    flatten: <B>() => List<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
+     * @returns The result of applying the matching handler function
+     */
+    match<R>(patterns: {
+        Empty: () => R;
+        NonEmpty: (values: A[]) => R;
+    }): R;
+} & IterableType<A> & AsyncFunctor<A> & Typeable<"List"> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
+declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
+    /**
+     * Creates a List from JSON string
+     * @param json - The JSON string
+     * @returns List instance
+     */
+    fromJSON: <A>(json: string) => List<A>;
+    /**
+     * Creates a List from YAML string
+     * @param yaml - The YAML string
+     * @returns List instance
+     */
+    fromYAML: <A>(yaml: string) => List<A>;
+    /**
+     * Creates a List from binary string
+     * @param binary - The binary string
+     * @returns List instance
+     */
+    fromBinary: <A>(binary: string) => List<A>;
+};
+
+/**
+ * Defines conversion methods for collection types
+ * @interface
+ * @module Collections
+ * @category Core
+ */
+type Converters<A> = {
+    toList(): List<A>;
+    toSet(): Set<A>;
+    toString(): string;
+};
+/**
+ * Represents a collection with conversion capabilities
+ * @interface
+ * @module Collections
+ * @category Core
+ */
+type Collection<A> = Converters<A>;
+
+type TestEither<L extends Type, R extends Type> = Either<L, R> & Functor<R> & AsyncFunctor<R>;
+declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
+declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
+declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+    value: R;
+};
+declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
+    value: L;
+};
+declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
+declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
+declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
+declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
+/**
+ * Either type module
+ * @module Either
+ * @category Core
+ */
+type Either<L extends Type, R extends Type> = {
+    readonly _tag: "Left" | "Right";
+    value: L | R;
+    isLeft: () => boolean;
+    isRight: () => boolean;
+    getOrElse: (defaultValue: R) => R;
+    getOrThrow: () => R;
+    map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
+    merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
+    mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
+    flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
+    flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
+    toOption: () => Option<R>;
+    toList: () => List<R>;
+    toString: () => string;
+    [Symbol.iterator]: () => Iterator<R>;
+    yield: () => Generator<R, void, unknown>;
+    traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
+    lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>;
+    tap: (f: (value: R) => void) => Either<L, R>;
+    tapLeft: (f: (value: L) => void) => Either<L, R>;
+    mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
+    bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>;
+    fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T;
+    swap: () => Either<R, L>;
+    /**
+     * Pipes the value through the provided function based on whether this is a Left or Right
+     * @param onLeft - The function to apply if this is a Left
+     * @param onRight - The function to apply if this is a Right
+     * @returns The result of applying the appropriate function
+     */
+    pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R) => U): U;
+    /**
+     * Pipes the Either value through the provided function
+     * @param f - The function to apply to the value
+     * @returns The result of applying the function to the value
+     */
+    pipe<U extends Type>(f: (value: L | R) => U): U;
+    /**
+     * Pattern matches over the Either, applying a handler function based on the variant
+     * @param patterns - Object with handler functions for Left and Right variants
+     * @returns The result of applying the matching handler function
+     */
+    match<T>(patterns: {
+        Left: (value: L) => T;
+        Right: (value: R) => T;
+    }): T;
+} & Typeable<"Left" | "Right"> & Valuable<"Left" | "Right", L | R> & PromiseLike<R> & AsyncFunctor<R> & Serializable<R> & Pipe<L | R> & Foldable<R> & Matchable<L | R, "Left" | "Right">;
+declare const Either: {
+    sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
+    traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
+    fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
+    fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
+    ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
+    fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
+    fromJSON: <L extends Type, R extends Type>(json: string) => Either<L, R>;
+    fromYAML: <L extends Type, R extends Type>(yaml: string) => Either<L, R>;
+    fromBinary: <L extends Type, R extends Type>(binary: string) => Either<L, R>;
+};
+
+export { type Converters as C, Either as E, type Foldable as F, type IterableType as I, List as L, type Matchable as M, None as N, Option as O, type Pipe as P, Right as R, type Serializable as S, type Traversable as T, type Collection as a, type TestEither as b, Left as c, isLeft as d, TypeCheckRight as e, TypeCheckLeft as f, tryCatchAsync as g, MatchableUtils as h, isRight as i, Some as j, OptionConstructor as k, type SerializationMethods as l, Set as m, tryCatch as t };

package/dist/Map-vivbm5n0.d.ts

@@ -0,0 +1,65 @@
+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-BfXNbTHo.js';
+import { a as Type, T as Typeable, V as Valuable } from './Valuable-CtuVEKTZ.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/{Tuple-DfdXAbL_.d.ts → Valuable-CtuVEKTZ.d.ts}

@@ -1,4 +1,5 @@
 type Type = unknown;
+
 type AbstractFunctor<A extends Type> = {
     map(f: (value: A) => Type): AbstractFunctor<Type>;
     flatMap(f: (value: A) => AbstractFunctor<Type>): AbstractFunctor<Type>;
@@ -26,11 +27,20 @@ type Typeable<Tag extends string, T = object> = T & {
 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;
@@ -38,15 +48,12 @@ declare function Valuable<Tag extends string, V, T = object>(params: ValuablePar
     };
     _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>>;
 
-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 { type AsyncFunctor as A, type ExtractTag as E, type Functor as F, Typeable as T, Valuable as V, type Type as a, Tuple as b, type AbstractFunctor as c, type ArrayFunctor as d, type TypeableParams as e, isTypeable as i };
+export { type AbstractFunctor as A, type ExtractTag as E, type Functor as F, Typeable as T, Valuable as V, type Type as a, type AsyncFunctor as b, type ArrayFunctor as c, type TypeableParams as d, type ValuableParams as e, isTypeable as i };