functype 0.8.67 → 0.8.69

package/dist/index.d.ts

@@ -1,3 +1,534 @@
-export { c as AbstractFunctor, d as ArrayFunctor, A as AsyncFunctor, E as ExtractTag, F as Functor, b as Tuple, a as Type, T as Typeable, e as TypeableParams, i as isTypeable } from './Tuple-DfdXAbL_.js';
 export { Brand, BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unbrand, createBrander, hasBrand, unbrand } from './branded/index.js';
-export { A as Async, B as Base, C as Companion, E as Either, u as EitherKind, f as ErrorContext, F as FPromise, g as FPromiseCompanion, H as HKT, I as Identity, w as IterableType, K as Kind, a as Left, L as List, s as ListKind, M as Map, None, Option, OptionConstructor, O as OptionKind, R as Right, S as Set, Some, o as Sync, p as Task, m as TaskException, l as TaskInfo, k as TaskParams, n as TaskResult, T as TestEither, r as Throwable, q as ThrowableType, j as Traversable, h as Try, v as TryKind, d as TypeCheckLeft, c as TypeCheckRight, U as UniversalContainer, b as isLeft, i as isRight, t as tryCatch, e as tryCatchAsync } from './option/index.js';
+import { E as Either, F as Foldable, O as Option, L as List, T as Traversable, S as Serializable, P as Pipe, M as Matchable } from './Either-BfXNbTHo.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-BfXNbTHo.js';
+import { T as Typeable, a as Type, F as Functor, V as Valuable } from './Valuable-CtuVEKTZ.js';
+export { A as AbstractFunctor, c as ArrayFunctor, b as AsyncFunctor, E as ExtractTag, d as TypeableParams, e as ValuableParams, i as isTypeable } from './Valuable-CtuVEKTZ.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-vivbm5n0.js';
+export { Tuple } from './tuple/index.js';
+
+/**
+ * Creates a function-object hybrid similar to Scala's companion objects.
+ * This utility allows creating TypeScript function objects with attached methods,
+ * mimicking Scala's class + companion object pattern without using classes.
+ *
+ * @param object The main function that will be invoked when the object is called
+ * @param companion Additional static methods to attach to the function
+ * @returns A function with the attached methods
+ *
+ * @example
+ * const greet = (name: string) => `Hello, ${name}!`;
+ * const methods = {
+ *   formal: (name: string) => `Good day, ${name}.`,
+ *   casual: (name: string) => `Hey ${name}!`
+ * };
+ * const Greeter = createCompanionObject(greet, methods);
+ *
+ * // Usage:
+ * Greeter("World"); // Hello, World!
+ * Greeter.formal("Sir"); // Good day, Sir.
+ * Greeter.casual("Friend"); // Hey Friend!
+ */
+declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
+
+/**
+ * Base Object from which most other objects inherit
+ * @param type - The type name for the object
+ * @param body - The implementation body
+ */
+declare function Base<T>(type: string, body: T): T & {
+    toString(): string;
+    _tag: string;
+};
+
+/**
+ * The identifier name for Throwable type
+ */
+declare const NAME: "Throwable";
+type ThrowableType = Error & Typeable<typeof NAME> & {
+    readonly data?: unknown;
+    readonly cause?: Error;
+    readonly taskInfo?: {
+        name: string;
+        description: string;
+    };
+};
+declare class Throwable extends Error implements ThrowableType {
+    readonly _tag: typeof NAME;
+    readonly data?: unknown;
+    readonly cause?: Error;
+    readonly taskInfo?: {
+        name: string;
+        description: string;
+    };
+    protected constructor(message: string, options?: {
+        data?: unknown | undefined;
+        cause?: Error | undefined;
+        stack?: string | undefined;
+        taskInfo?: {
+            name: string;
+            description: string;
+        } | undefined;
+    });
+    static apply(srcError: unknown, data?: unknown, taskInfo?: {
+        name: string;
+        description: string;
+    }): ThrowableType;
+}
+
+/**
+ * Type definition for errors with a _tag property that identifies them as Throwables
+ */
+type TaggedThrowable = Error & {
+    _tag: "Throwable";
+    cause?: Error;
+    taskInfo?: TaskInfo;
+};
+/**
+ * Type guard to check if an error is a TaggedThrowable
+ */
+declare function isTaggedThrowable(error: unknown): error is TaggedThrowable;
+type TaskParams = {
+    name?: string;
+    description?: string;
+};
+type TaskInfo = {
+    _task: TaskParams;
+    name?: string;
+    description?: string;
+};
+type TaskException<T> = Either<Throwable, T> & TaskInfo;
+/**
+ * TaskException factory function
+ * @param error - The error object
+ * @param data - Additional data related to the error
+ * @param _task - Task parameters
+ */
+declare const TaskException: <T>(error: unknown, data?: unknown, _task?: TaskParams) => TaskException<T>;
+type TaskResult<T> = Either<Throwable, T> & TaskInfo;
+declare const TaskResult: <T>(data: T, _task?: TaskParams) => TaskResult<T>;
+/**
+ * The CancellationToken is a control structure that allows long-running tasks to be cancelled
+ * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
+ */
+type CancellationToken = {
+    /** Whether the token has been cancelled */
+    readonly isCancelled: boolean;
+    /** Signal that can be used with fetch and other abortable APIs */
+    readonly signal: AbortSignal;
+    /** Register a callback to be called when cancellation occurs */
+    onCancel(callback: () => void): void;
+};
+/**
+ * Create a cancellation token and controller
+ * The controller can be used to cancel operations that use the token
+ */
+type CancellationTokenSource = {
+    /** The token to be passed to cancellable operations */
+    readonly token: CancellationToken;
+    /** Cancel all operations using this token */
+    cancel(): void;
+};
+/**
+ * Create a cancellation token source
+ * @returns A CancellationTokenSource that can be used to create and control cancellation tokens
+ */
+declare const createCancellationTokenSource: () => CancellationTokenSource;
+type Sync<T> = Either<Throwable, T>;
+type Async<T> = FPromise<Sync<T>>;
+declare const Task: (<T = unknown>(params?: TaskParams) => {
+    _type: string;
+    /**
+     * Run an async operation with explicit try/catch/finally semantics
+     * Returns a raw Promise that can interact with traditional Promise-based code
+     *
+     * @param t - The main operation function that returns a value or Promise
+     * @param e - Optional error handler function
+     * @param f - Optional finally handler function
+     * @param cancellationToken - Optional token for cancellation support
+     */
+    Async: <U = T>(t: () => U | Promise<U>, e?: (error: unknown) => unknown, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<U>;
+    /**
+     * Run a synchronous operation with explicit try/catch/finally semantics
+     * Returns an Either for functional error handling
+     *
+     * @param t - The main operation function that returns a value
+     * @param e - Optional error handler function
+     * @param f - Optional finally handler function
+     */
+    Sync: <U = T>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => Sync<U>;
+    /**
+     * Run an async operation with progress tracking capabilities
+     * Returns a Promise and provides progress updates via callback
+     *
+     * @param t - The main operation that receives a progress updater function
+     * @param onProgress - Callback that receives progress updates (0-100)
+     * @param e - Optional error handler function
+     * @param f - Optional finally handler function
+     * @param cancellationToken - Optional token for cancellation support
+     */
+    AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<U>;
+    toString(): string;
+    _tag: string;
+}) & {
+    /**
+     * Create a successful Task result
+     */
+    success: <T>(data: T, params?: TaskParams) => TaskResult<T>;
+    /**
+     * Create a failed Task result
+     */
+    fail: <T>(error: unknown, data?: unknown, params?: TaskParams) => TaskException<T>;
+    /**
+     * Extract the error chain from a Throwable error
+     * Returns an array of errors from outermost to innermost
+     *
+     * @param error - The error to extract the chain from
+     * @returns An array of errors in the chain, from outermost to innermost
+     */
+    getErrorChain: (error: Error | undefined) => Error[];
+    /**
+     * Format the error chain as a string with the option to include task details
+     *
+     * @param error - The error to format
+     * @param options - Formatting options
+     * @returns A formatted string representation of the error chain
+     */
+    formatErrorChain: (error: Error | undefined, options?: {
+        includeTasks?: boolean;
+        separator?: string;
+        includeStackTrace?: boolean;
+    }) => string;
+    /**
+     * 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<U>);
+    /**
+     * Convert a Task result to a Promise
+     */
+    toPromise: <U>(taskResult: TaskResult<U> | TaskException<U>) => Promise<U>;
+    /**
+     * 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 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>>, timeoutMs?: number, params?: TaskParams) => FPromise<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
+     */
+    fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<T>);
+    /**
+     * Create a cancellation token source
+     * @returns A cancellation token source that can be used to control task cancellation
+     */
+    createCancellationTokenSource: () => CancellationTokenSource;
+    /**
+     * Create a task that can be cancelled
+     *
+     * @param task - The task function to make cancellable
+     * @param params - Task parameters
+     * @returns An object with the task and a function to cancel it
+     */
+    cancellable: <T>(task: (token: CancellationToken) => Promise<T>, params?: TaskParams) => {
+        task: FPromise<T>;
+        cancel: () => void;
+    };
+    /**
+     * Creates a task with progress tracking
+     *
+     * @param task - The task function that accepts a progress updater
+     * @param onProgress - Callback function that receives progress updates
+     * @param params - Task parameters
+     * @returns An object with the task, cancel function, and current progress
+     */
+    withProgress: <T>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T>, onProgress?: (percent: number) => void, params?: TaskParams) => {
+        task: FPromise<T>;
+        cancel: () => void;
+        currentProgress: () => number;
+    };
+};
+type Task = ReturnType<typeof Task>;
+
+/**
+ * Type definition for task information that may be attached to errors
+ */
+type TaskErrorInfo = {
+    name?: string;
+    description?: string;
+    [key: string]: unknown;
+};
+/**
+ * Type definition for an error with potential task information
+ */
+type ErrorWithTaskInfo = Error & {
+    taskInfo?: TaskErrorInfo;
+    data?: unknown;
+};
+/**
+ * Type definition for a structured error chain element
+ */
+type ErrorChainElement = {
+    message?: string;
+    name?: string;
+    taskInfo?: TaskErrorInfo;
+    stack?: string;
+    [key: string]: unknown;
+};
+/**
+ * Options for formatting error chains
+ */
+type ErrorFormatterOptions = {
+    /** Include task names in the formatted output */
+    includeTasks?: boolean;
+    /** Include stack traces in the formatted output */
+    includeStackTrace?: boolean;
+    /** Separator between error lines (default: newline) */
+    separator?: string;
+    /** Include detailed error data in the output */
+    includeData?: boolean;
+    /** Maximum number of stack frames to include if stack trace is enabled */
+    maxStackFrames?: number;
+    /** Title to display at the start of the formatted error */
+    title?: string;
+    /** Format the output with colors for console display */
+    colors?: boolean;
+};
+/**
+ * Safely stringify data including BigInt values and circular references
+ */
+declare function safeStringify(obj: unknown): string;
+/**
+ * Format a stack trace string for better readability
+ */
+declare function formatStackTrace(stack: string | undefined): string;
+/**
+ * Create a formatted string representation of an error for better logging and display
+ *
+ * @example
+ * ```typescript
+ * const error = new Error("Something went wrong");
+ * console.error(formatError(error, { colors: true, includeData: true }));
+ * ```
+ */
+declare function formatError(error: unknown, options?: ErrorFormatterOptions): string;
+/**
+ * Create a serializer function for Pino or other JSON loggers
+ * to better represent errors with their full context
+ */
+declare function createErrorSerializer(): (err: unknown) => unknown;
+
+declare const ParseError: (message?: string) => Error & {
+    name: "ParseError";
+};
+type ParseError = Error & {
+    name: "ParseError";
+};
+
+/**
+ * Utility functions for working with Foldable data structures
+ */
+declare const FoldableUtils: {
+    /**
+     * Converts a Foldable to an Option
+     *
+     * @param foldable - The foldable structure to convert
+     * @returns An Option containing the value, or None if empty
+     */
+    toOption: <A extends Type>(foldable: Foldable<A>) => Option<A>;
+    /**
+     * Converts a Foldable to a List
+     *
+     * @param foldable - The foldable structure to convert
+     * @returns A List containing the value(s), or empty List if empty
+     */
+    toList: <A extends Type>(foldable: Foldable<A>) => List<A>;
+    /**
+     * Converts a Foldable to an Either
+     *
+     * @param foldable - The foldable structure to convert
+     * @param left - The value to use for Left if empty
+     * @returns Either.Right with the value if non-empty, or Either.Left with left if empty
+     */
+    toEither: <A extends Type, E>(foldable: Foldable<A>, left: E) => Either<E, A>;
+    /**
+     * Checks if the Foldable is empty
+     *
+     * @param foldable - The foldable structure to check
+     * @returns true if empty, false otherwise
+     */
+    isEmpty: <A extends Type>(foldable: Foldable<A>) => boolean;
+    /**
+     * Calculates the size of the Foldable
+     *
+     * @param foldable - The foldable structure to measure
+     * @returns The size (number of elements)
+     */
+    size: <A extends Type>(foldable: Foldable<A>) => number;
+};
+
+/**
+ * Type function for representing higher-kinded types
+ */
+type Kind<F, A> = F extends (arg: infer T) => infer R ? R : never;
+/**
+ * Type constructors for common Functype data types
+ */
+type OptionKind = <A>(a: A) => Option<A>;
+type ListKind = <A>(a: A) => List<A>;
+type EitherKind<E> = <A>(a: A) => Either<E, A>;
+type TryKind = <A>(a: A) => Try<A>;
+/**
+ * Generic container types for type-safe operations
+ */
+type Mappable<T> = {
+    map<U>(f: (value: T) => U): unknown;
+};
+type Flattenable = {
+    flatten(): unknown;
+};
+type FlatMappable<T> = {
+    flatMap<U>(f: (value: T) => unknown): unknown;
+};
+/**
+ * Universal type that includes all potential return types from the HKT functions
+ * Used to avoid 'any' usage which the linter prohibits
+ */
+type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
+/**
+ * HKT provides utilities for working with higher-kinded types
+ * This allows writing generic code that works across different
+ * container types like Option, List, Either, etc.
+ */
+declare const HKT: {
+    (): {
+        _type: string;
+        map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
+        flatten: <F, A>(ffa: unknown) => unknown;
+        flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+        ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
+        sequence: <F, G, A>(fga: unknown) => unknown;
+        traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+        toString(): string;
+        _tag: string;
+    };
+    map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
+    flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
+    flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+    ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
+    sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
+    traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+    isOption: <T extends Type>(value: unknown) => value is Option<T> & Mappable<T> & FlatMappable<T>;
+    isList: <T extends Type>(value: unknown) => value is List<T> & Mappable<T> & Flattenable & FlatMappable<T>;
+    isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A> & Mappable<A> & FlatMappable<A>;
+    isTry: <T extends Type>(value: unknown) => value is Try<T> & Mappable<T> & FlatMappable<T>;
+};
+
+type Identity<T> = {
+    id: T;
+    isSame?: (other: Identity<T>) => boolean;
+};
+declare function Identity<T>(value: T): Identity<T>;
+
+/**
+ * Stack data structure - Last In, First Out (LIFO)
+ * Implements the Traversable interface for working with ordered collections
+ */
+type Stack<A extends Type> = {
+    /**
+     * Push a value onto the top of the stack
+     * @param value - The value to push
+     * @returns A new Stack with the value added
+     */
+    push(value: A): Stack<A>;
+    /**
+     * Remove and return the top value from the stack
+     * @returns A tuple containing the new Stack and the value
+     */
+    pop(): [Stack<A>, Option<A>];
+    /**
+     * Return the top value without removing it
+     * @returns The top value wrapped in an Option
+     */
+    peek(): Option<A>;
+    /**
+     * Transforms each element in the stack using the provided function
+     * @param f - The mapping function
+     * @returns A new Stack with transformed elements
+     */
+    map<B extends Type>(f: (a: A) => B): Stack<B>;
+    /**
+     * Maps each element to a Stack and flattens the result
+     * @param f - The mapping function returning a Stack
+     * @returns A new flattened Stack
+     */
+    flatMap<B extends Type>(f: (a: A) => Stack<B>): Stack<B>;
+    /**
+     * Convert the stack to a List
+     * @returns A List containing all elements
+     */
+    toList(): List<A>;
+    /**
+     * Convert the stack to an array
+     * @returns An array of all elements
+     */
+    toArray(): A[];
+    /**
+     * Returns a string representation of the stack
+     * @returns A string representation
+     */
+    toString(): string;
+    /**
+     * Pattern matches over the Stack, 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;
+} & Traversable<A> & Functor<A> & Typeable<"Stack"> & 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
+     * @returns An empty Stack instance
+     */
+    empty: <A extends Type>() => Stack<A>;
+    /**
+     * Creates a Stack from a single value
+     * @param value - The value to create a stack with
+     * @returns A Stack with a single value
+     */
+    of: <A extends Type>(value: A) => Stack<A>;
+    /**
+     * Creates a Stack from JSON string
+     * @param json - The JSON string
+     * @returns Stack instance
+     */
+    fromJSON: <A>(json: string) => Stack<A>;
+    /**
+     * Creates a Stack from YAML string
+     * @param yaml - The YAML string
+     * @returns Stack instance
+     */
+    fromYAML: <A>(yaml: string) => Stack<A>;
+    /**
+     * Creates a Stack from binary string
+     * @param binary - The binary string
+     * @returns Stack instance
+     */
+    fromBinary: <A>(binary: string) => Stack<A>;
+};
+
+export { type Async, Base, type CancellationToken, type CancellationTokenSource, Companion, Either, type EitherKind, type ErrorChainElement, type ErrorFormatterOptions, type ErrorWithTaskInfo, FPromise, Foldable, FoldableUtils, Functor, HKT, Identity, type Kind, List, type ListKind, Matchable, NAME, Option, type OptionKind, ParseError, Pipe, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, TaskException, type TaskInfo, type TaskParams, TaskResult, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, type UniversalContainer, Valuable, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export{b as Base,a as Companion,r as Either,t as FPromise,s as FPromiseCompanion,y as HKT,z as Identity,k as Left,i as List,A as Map,e as None,g as Option,f as OptionConstructor,j as Right,h as Set,d as Some,w as Task,u as TaskException,v as TaskResult,c as Throwable,x as Try,p as TypeCheckLeft,o as TypeCheckRight,m as isLeft,l as isRight,n as tryCatch,q as tryCatchAsync}from'./chunk-NTL4HYMA.mjs';export{c as Tuple,a as Typeable,b as isTypeable}from'./chunk-PXFJPCM7.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{h as Base,a as Companion,J as ESMap,s as Either,u as FPromise,t as FPromiseCompanion,F as FoldableUtils,H as HKT,I as Identity,l as Left,g as List,K as Map,L as MatchableUtils,i as NAME,c as None,e as Option,d as OptionConstructor,E as ParseError,k as Right,f as Set,b as Some,M as Stack,z as Task,w as TaskException,x as TaskResult,j as Throwable,G as Try,q as TypeCheckLeft,p as TypeCheckRight,y as createCancellationTokenSource,D as createErrorSerializer,C as formatError,B as formatStackTrace,n as isLeft,m as isRight,v as isTaggedThrowable,A as safeStringify,o as tryCatch,r as tryCatchAsync}from'./chunk-5DWCHDSA.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
 //# sourceMappingURL=index.mjs.map

package/dist/list/index.d.ts

@@ -1,3 +1,2 @@
-import '../Tuple-DfdXAbL_.js';
-export { L as List } from '../option/index.js';
-import '../branded/index.js';
+export { L as List } from '../Either-BfXNbTHo.js';
+import '../Valuable-CtuVEKTZ.js';

package/dist/list/index.mjs

@@ -1,2 +1,2 @@
-export{i as List}from'../chunk-NTL4HYMA.mjs';import'../chunk-PXFJPCM7.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{g as List}from'../chunk-5DWCHDSA.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/map/index.d.ts

@@ -1,3 +1,4 @@
-export { M as Map } from '../option/index.js';
-import '../Tuple-DfdXAbL_.js';
-import '../branded/index.js';
+import '../Either-BfXNbTHo.js';
+import '../Valuable-CtuVEKTZ.js';
+export { M as Map, S as SafeTraversable } from '../Map-vivbm5n0.js';
+import '../tuple/index.js';

package/dist/map/index.mjs

@@ -1,2 +1,2 @@
-export{A as Map}from'../chunk-NTL4HYMA.mjs';import'../chunk-PXFJPCM7.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
+export{K as Map}from'../chunk-5DWCHDSA.mjs';import'../chunk-7PQA3W7W.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map