functype 0.17.0 → 0.18.0

package/dist/{chunk-BQJB6CCW.mjs → chunk-7JJIUQXK.mjs}

@@ -1,3 +1,3 @@
 import u from'safe-stable-stringify';function T(e,r){return Object.assign(e,r)}var p=e=>{let r={_tag:"Tuple",map:t=>{let n=t(e);return m(n)},flatMap:t=>t(e),get:t=>e[t],toArray:()=>e,length:e.length,[Symbol.iterator](){let t=0;return {next:()=>t<e.length?{value:e[t++],done:false}:{value:void 0,done:true}}},fold:(t,n)=>e.length===0?t():n(e[0]),foldLeft:t=>n=>e.reduce(n,t),foldRight:t=>n=>e.reduceRight((l,o)=>n(o,l),t),pipe:t=>t(r),serialize:()=>({toJSON:()=>JSON.stringify({_tag:"Tuple",value:e}),toYAML:()=>`_tag: Tuple
-value: ${u(e)}`,toBinary:()=>Buffer.from(JSON.stringify({_tag:"Tuple",value:e})).toString("base64")}),toValue:()=>({_tag:"Tuple",value:e}),toString:()=>`Tuple(${e.map(t=>String(t)).join(", ")})`};return r},a=e=>p(e),i={of:(...e)=>p(e),pair:(e,r)=>p([e,r]),triple:(e,r,t)=>p([e,r,t]),empty:()=>p([]),from:e=>p(e)},m=T(a,i);export{T as a,m as b};//# sourceMappingURL=chunk-BQJB6CCW.mjs.map
-//# sourceMappingURL=chunk-BQJB6CCW.mjs.map
+value: ${u(e)}`,toBinary:()=>Buffer.from(JSON.stringify({_tag:"Tuple",value:e})).toString("base64")}),toValue:()=>({_tag:"Tuple",value:e}),toString:()=>`Tuple(${e.map(t=>String(t)).join(", ")})`};return r},a=e=>p(e),i={of:(...e)=>p(e),pair:(e,r)=>p([e,r]),triple:(e,r,t)=>p([e,r,t]),empty:()=>p([]),from:e=>p(e)},m=T(a,i);export{T as a,m as b};//# sourceMappingURL=chunk-7JJIUQXK.mjs.map
+//# sourceMappingURL=chunk-7JJIUQXK.mjs.map

package/dist/chunk-7JJIUQXK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/companion/Companion.ts","../src/tuple/Tuple.ts"],"names":["Companion","object","companion","TupleObject","values","tuple","f","mapValue","Tuple","index","onEmpty","onValue","z","op","acc","value","stringify","v","TupleConstructor","TupleCompanion","first","second","third"],"mappings":"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","file":"chunk-7JJIUQXK.mjs","sourcesContent":["/**\n * Creates a function-object hybrid similar to Scala's companion objects.\n * This utility allows creating TypeScript function objects with attached methods,\n * mimicking Scala's class + companion object pattern without using classes.\n *\n * @param object The main function that will be invoked when the object is called\n * @param companion Additional static methods to attach to the function\n * @returns A function with the attached methods\n *\n * @example\n * const greet = (name: string) => `Hello, ${name}!`;\n * const methods = {\n *   formal: (name: string) => `Good day, ${name}.`,\n *   casual: (name: string) => `Hey ${name}!`\n * };\n * const Greeter = createCompanionObject(greet, methods);\n *\n * // Usage:\n * Greeter(\"World\"); // Hello, World!\n * Greeter.formal(\"Sir\"); // Good day, Sir.\n * Greeter.casual(\"Friend\"); // Hey Friend!\n */\nexport function Companion<ObjectF extends object, CompanionF extends object>(\n  object: ObjectF,\n  companion: CompanionF,\n): ObjectF & CompanionF {\n  // eslint-disable-next-line functional/immutable-data\n  return Object.assign(object, companion)\n}\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport type { Foldable } from \"@/foldable/Foldable\"\nimport type { Pipe } from \"@/pipe\"\nimport type { Serializable } from \"@/serializable/Serializable\"\nimport type { Typeable } from \"@/typeable/Typeable\"\nimport type { Type } from \"@/types\"\n\nexport interface Tuple<T extends Type[]>\n  extends Foldable<T[number]>,\n    Pipe<Tuple<T>>,\n    Serializable<Tuple<T>>,\n    Typeable<\"Tuple\"> {\n  get<K extends number>(index: K): T[K]\n\n  map<U extends Type[]>(f: (value: T) => U): Tuple<U>\n\n  flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>\n\n  toArray(): T\n\n  length: number\n\n  [Symbol.iterator](): Iterator<T[number]>\n\n  toString(): string\n\n  toValue(): { _tag: \"Tuple\"; value: T }\n}\n\nconst TupleObject = <T extends Type[]>(values: T): Tuple<T> => {\n  const tuple: Tuple<T> = {\n    _tag: \"Tuple\",\n    map: <U extends Type[]>(f: (value: T) => U): Tuple<U> => {\n      const mapValue = f(values)\n      return Tuple(mapValue)\n    },\n\n    flatMap: <U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U> => {\n      return f(values)\n    },\n\n    get: <K extends number>(index: K): T[K] => {\n      return values[index]\n    },\n\n    toArray: (): T => {\n      return values\n    },\n\n    length: values.length,\n\n    [Symbol.iterator](): Iterator<T[number]> {\n      let index = 0\n      return {\n        next: (): IteratorResult<T[number]> => {\n          if (index < values.length) {\n            return {\n              value: values[index++],\n              done: false,\n            }\n          } else {\n            return {\n              value: undefined,\n              done: true,\n            }\n          }\n        },\n      }\n    },\n\n    // Foldable implementation\n    fold: <B>(onEmpty: () => B, onValue: (value: T[number]) => B): B => {\n      return values.length === 0 ? onEmpty() : onValue(values[0]!)\n    },\n\n    foldLeft:\n      <B>(z: B) =>\n      (op: (b: B, a: T[number]) => B) => {\n        return values.reduce(op, z)\n      },\n\n    foldRight:\n      <B>(z: B) =>\n      (op: (a: T[number], b: B) => B): B => {\n        return values.reduceRight<B>((acc, value) => op(value, acc), z)\n      },\n\n    // Pipe implementation\n    pipe: <U>(f: (value: Tuple<T>) => U): U => f(tuple),\n\n    // Serializable implementation\n    serialize: () => {\n      return {\n        toJSON: () => JSON.stringify({ _tag: \"Tuple\", value: values }),\n        toYAML: () => `_tag: Tuple\\nvalue: ${stringify(values)}`,\n        toBinary: () => Buffer.from(JSON.stringify({ _tag: \"Tuple\", value: values })).toString(\"base64\"),\n      }\n    },\n\n    // Valuable implementation\n    toValue: () => ({ _tag: \"Tuple\", value: values }),\n\n    toString: () => `Tuple(${values.map((v) => String(v)).join(\", \")})`,\n  }\n\n  return tuple\n}\n\nconst TupleConstructor = <T extends Type[]>(values: T): Tuple<T> => {\n  return TupleObject(values)\n}\n\nconst TupleCompanion = {\n  /**\n   * Create a Tuple from multiple arguments\n   * @example\n   * const t = Tuple.of(1, \"hello\", true)\n   * // TypeScript infers: Tuple<[number, string, boolean]>\n   */\n  of: <T extends Type[]>(...values: T): Tuple<T> => {\n    return TupleObject(values)\n  },\n\n  /**\n   * Create a Tuple of size 2 (pair)\n   * @example\n   * const pair = Tuple.pair(\"key\", 42)\n   * // TypeScript infers: Tuple<[string, number]>\n   */\n  pair: <A extends Type, B extends Type>(first: A, second: B): Tuple<[A, B]> => {\n    return TupleObject([first, second] as [A, B])\n  },\n\n  /**\n   * Create a Tuple of size 3 (triple)\n   * @example\n   * const triple = Tuple.triple(\"x\", 10, true)\n   * // TypeScript infers: Tuple<[string, number, boolean]>\n   */\n  triple: <A extends Type, B extends Type, C extends Type>(first: A, second: B, third: C): Tuple<[A, B, C]> => {\n    return TupleObject([first, second, third] as [A, B, C])\n  },\n\n  /**\n   * Create an empty Tuple\n   * @example\n   * const empty = Tuple.empty()\n   * // TypeScript infers: Tuple<[]>\n   */\n  empty: (): Tuple<[]> => {\n    return TupleObject([] as [])\n  },\n\n  /**\n   * Create a Tuple from an array (alias for constructor)\n   * @example\n   * const t = Tuple.from([1, 2, 3])\n   */\n  from: <T extends Type[]>(values: T): Tuple<T> => {\n    return TupleObject(values)\n  },\n}\n\n/**\n * Tuple provides a type-safe, fixed-length array with functional operations.\n *\n * @example\n * // Creating tuples\n * const t1 = Tuple([1, \"hello\", true])\n * const t2 = Tuple.of(1, \"hello\", true)\n * const pair = Tuple.pair(\"key\", 42)\n *\n * @example\n * // Type-safe access\n * const triple = Tuple.triple(\"x\", 10, true)\n * const first = triple.get(0)  // string\n * const second = triple.get(1) // number\n * const third = triple.get(2)  // boolean\n *\n * @example\n * // Functional operations\n * const doubled = Tuple([1, 2, 3])\n *   .map(arr => arr.map(x => x * 2))\n *   .toArray() // [2, 4, 6]\n */\nexport const Tuple = Companion(TupleConstructor, TupleCompanion)\n"]}

package/dist/do/index.d.ts

@@ -1,5 +1,5 @@
-import { O as Option, E as Either, L as List, T as Try, x as Reshapeable, b as Doable } from '../Either-CM1xSzLl.js';
-export { D as DoResult } from '../Either-CM1xSzLl.js';
+import { O as Option, E as Either, L as List, T as Try, x as Reshapeable, b as Doable } from '../Either-Ccg0S1uS.js';
+export { D as DoResult } from '../Either-Ccg0S1uS.js';
 import '../Typeable-DiGVtDnq.js';
 
 /**

package/dist/do/index.mjs

@@ -1,2 +1,2 @@
-export{X as $,T as Do,U as DoAsync,_ as EmptyListError,$ as FailureError,Z as LeftError,Y as NoneError,V as isDoCapable,W as unwrap}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{ca as $,_ as Do,$ as DoAsync,fa as EmptyListError,ga as FailureError,ea as LeftError,da as NoneError,aa as isDoCapable,ba as unwrap}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/either/index.d.ts

@@ -1,2 +1,2 @@
-export { E as Either, e as Left, R as Right, d as TestEither, h as TypeCheckLeft, g as TypeCheckRight, f as isLeft, i as isRight, t as tryCatch, j as tryCatchAsync } from '../Either-CM1xSzLl.js';
+export { E as Either, e as Left, R as Right, d as TestEither, h as TypeCheckLeft, g as TypeCheckRight, f as isLeft, i as isRight, t as tryCatch, j as tryCatchAsync } from '../Either-Ccg0S1uS.js';
 import '../Typeable-DiGVtDnq.js';

package/dist/either/index.mjs

@@ -1,2 +1,2 @@
-export{t as Either,m as Left,l as Right,r as TypeCheckLeft,q as TypeCheckRight,o as isLeft,n as isRight,p as tryCatch,s as tryCatchAsync}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{z as Either,s as Left,r as Right,x as TypeCheckLeft,w as TypeCheckRight,u as isLeft,t as isRight,v as tryCatch,y as tryCatchAsync}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/fpromise/index.d.ts

@@ -1,4 +1,4 @@
-import { E as Either } from '../Either-CM1xSzLl.js';
+import { E as Either } from '../Either-Ccg0S1uS.js';
 import { T as Type } from '../Typeable-DiGVtDnq.js';
 
 /**

package/dist/fpromise/index.mjs

@@ -1,2 +1,2 @@
-export{N as FPromise,M as FPromiseCompanion}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{U as FPromise,T as FPromiseCompanion}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Brand } from './branded/index.js';
 export { BrandedBoolean, BrandedBoolean as BrandedBooleanType, BrandedNumber, BrandedNumber as BrandedNumberType, BrandedString, BrandedString as BrandedStringType, ExtractBrand, Unwrap, createBrander, hasBrand, unwrap as unwrapBrand } from './branded/index.js';
-import { L as List, O as Option, E as Either, D as DoResult, F as FunctypeBase, a as Extractable, A as AsyncMonad, P as Promisable, b as Doable, T as Try, c as Traversable, M as Matchable } from './Either-CM1xSzLl.js';
-export { u as Applicative, C as Collection, r as CollectionOps, s as ContainerOps, v as Functor, l as Functype, m as FunctypeCollection, e as Left, n as MatchableUtils, w as Monad, N as None, o as OptionConstructor, R as Right, p as Set, S as Some, d as TestEither, h as TypeCheckLeft, g as TypeCheckRight, q as TypeNames, k as isExtractable, f as isLeft, i as isRight, t as tryCatch, j as tryCatchAsync } from './Either-CM1xSzLl.js';
+import { L as List, O as Option, E as Either, D as DoResult, F as FunctypeBase, a as Extractable, A as AsyncMonad, P as Promisable, b as Doable, T as Try, c as Traversable, M as Matchable } from './Either-Ccg0S1uS.js';
+export { u as Applicative, C as Collection, r as CollectionOps, s as ContainerOps, v as Functor, l as Functype, m as FunctypeCollection, e as Left, n as MatchableUtils, w as Monad, N as None, o as OptionConstructor, R as Right, p as Set, S as Some, d as TestEither, h as TypeCheckLeft, g as TypeCheckRight, q as TypeNames, k as isExtractable, f as isLeft, i as isRight, t as tryCatch, j as tryCatchAsync } from './Either-Ccg0S1uS.js';
 import { T as Type, F as Foldable, P as Pipe, S as Serializable, a as Typeable } from './Typeable-DiGVtDnq.js';
 export { E as ExtractTag, b as SerializationMethods, c as TypeableParams, i as isTypeable } from './Typeable-DiGVtDnq.js';
 import { FPromise } from './fpromise/index.js';
@@ -285,6 +285,37 @@ declare function PatternString(brand: string, pattern: RegExp): ValidatedBrandCo
  */
 declare function Companion<ObjectF extends object, CompanionF extends object>(object: ObjectF, companion: CompanionF): ObjectF & CompanionF;
 
+/**
+ * Helper types for working with the Companion pattern
+ * @module CompanionTypes
+ */
+/**
+ * Extracts the companion methods type from a Companion object
+ * @typeParam T - The Companion type
+ * @example
+ * ```typescript
+ * type OptionCompanionMethods = CompanionMethods<typeof Option>
+ * // { from: ..., none: ..., fromJSON: ..., etc. }
+ * ```
+ */
+type CompanionMethods<T> = T extends ((...args: never[]) => unknown) & infer C ? C : never;
+/**
+ * Extracts the instance type from a constructor function
+ * @typeParam T - The constructor function type
+ * @example
+ * ```typescript
+ * type OptionInstance = InstanceType<typeof Option>
+ * // Option<T>
+ * ```
+ */
+type InstanceType<T> = T extends (...args: infer Args) => infer R ? R extends (...args: unknown[]) => unknown ? ReturnType<R> : R : never;
+/**
+ * Type guard to check if a value is a Companion object (has both constructor and companion methods)
+ * @param value - The value to check
+ * @returns True if value is a Companion object
+ */
+declare const isCompanion: (value: unknown) => value is ((...args: never[]) => unknown) & Record<string, unknown>;
+
 /** @internal */
 type LazyCondChain<T> = {
     when: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
@@ -1365,7 +1396,20 @@ type Identity<T> = {
     id: T;
     isSame?: (other: Identity<T>) => boolean;
 };
-declare function Identity<T>(value: T): Identity<T>;
+declare const Identity: (<T>(value: T) => Identity<T>) & {
+    /**
+     * Creates an Identity. Alias for Identity constructor.
+     * @param value - The value to wrap
+     * @returns Identity instance
+     */
+    of: <T>(value: T) => Identity<T>;
+    /**
+     * Creates an Identity. Same as of.
+     * @param value - The value to wrap
+     * @returns Identity instance
+     */
+    pure: <T>(value: T) => Identity<T>;
+};
 
 /**
  * Lazy type module
@@ -1680,13 +1724,82 @@ interface Ref<A> {
      */
     modify<B>(f: (current: A) => [A, B]): B;
 }
+declare const Ref: (<A extends Type>(initial: A) => Ref<A>) & {
+    /**
+     * Creates a Ref. Alias for Ref constructor.
+     * @param initial - The initial value
+     * @returns Ref instance
+     */
+    of: <A extends Type>(initial: A) => Ref<A>;
+};
+
 /**
- * Creates a new mutable reference containing the given value
+ * Serialization result containing methods for different formats
  */
-declare function Ref<A extends Type>(initial: A): Ref<A>;
-declare namespace Ref {
-    var of: typeof Ref;
+interface SerializationResult {
+    /** Serializes to JSON string */
+    toJSON: () => string;
+    /** Serializes to YAML string */
+    toYAML: () => string;
+    /** Serializes to base64-encoded binary string */
+    toBinary: () => string;
 }
+/**
+ * Creates a serializer for a simple tagged value
+ * @param tag - The type tag (e.g., "Some", "List", "Success")
+ * @param value - The value to serialize
+ * @returns Serialization methods
+ */
+declare const createSerializer: (tag: string, value: unknown) => SerializationResult;
+/**
+ * Creates a serializer for complex objects with custom serialization logic
+ * @param data - The data object to serialize (should include _tag)
+ * @returns Serialization methods
+ */
+declare const createCustomSerializer: (data: Record<string, unknown>) => SerializationResult;
+/**
+ * Generic deserializer from JSON
+ * @param json - The JSON string to parse
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromJSON: <T>(json: string, reconstructor: (parsed: {
+    _tag: string;
+    [key: string]: unknown;
+}) => T) => T;
+/**
+ * Generic deserializer from YAML (simple format)
+ * @param yaml - The YAML string to parse
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromYAML: <T>(yaml: string, reconstructor: (parsed: {
+    _tag: string;
+    [key: string]: unknown;
+}) => T) => T;
+/**
+ * Generic deserializer from binary (base64-encoded JSON)
+ * @param binary - The base64-encoded binary string
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromBinary: <T>(binary: string, reconstructor: (parsed: {
+    _tag: string;
+    [key: string]: unknown;
+}) => T) => T;
+/**
+ * Creates companion serialization methods for a type
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Companion methods object with fromJSON, fromYAML, and fromBinary
+ */
+declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
+    _tag: string;
+    [key: string]: unknown;
+}) => T) => {
+    fromJSON: (json: string) => T;
+    fromYAML: (yaml: string) => T;
+    fromBinary: (binary: string) => T;
+};
 
 /**
  * Parameters for creating a Valuable instance
@@ -1818,4 +1931,4 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
     fromBinary: <A>(binary: string) => Stack<A>;
 };
 
-export { type Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, Cond, DoResult, Doable, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, Err, type ErrorChainElement, type ErrorCode, type ErrorFormatterOptions, type ErrorMessage, type ErrorStatus, type ErrorWithTaskInfo, Extractable, FPromise, type FieldValidation, Foldable, FoldableUtils, type FormValidation, FunctypeBase, HKT, ISO8601Date, Identity, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Ok, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, Ref, Ref as RefType, Serializable, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, type TaskFailure, type TaskMetadata, type TaskOutcome, type TaskParams, type TaskResult, type TaskSuccess, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, type ValidatedBrandCompanion, ValidatedBrand as ValidatedBrandType, Validation, type ValidationRule, type Validator, Valuable, type ValuableParams, createCancellationTokenSource, createErrorSerializer, formatError, formatStackTrace, isTaggedThrowable, safeStringify };
+export { type Async, AsyncMonad, Base, BoundedNumber, BoundedString, Brand, type CancellationToken, type CancellationTokenSource, Companion, type CompanionMethods, Cond, DoResult, Doable, ESMap, type ESMapType, Either, type EitherKind, EmailAddress, Err, type ErrorChainElement, type ErrorCode, type ErrorFormatterOptions, type ErrorMessage, type ErrorStatus, type ErrorWithTaskInfo, Extractable, FPromise, type FieldValidation, Foldable, FoldableUtils, type FormValidation, FunctypeBase, HKT, ISO8601Date, Identity, type InstanceType, IntegerNumber, type Kind, Lazy, LazyList, Lazy as LazyType, List, type ListKind, Match, Matchable, NAME, NonEmptyString, NonNegativeNumber, Ok, Option, type OptionKind, ParseError, PatternString, Pipe, PositiveInteger, PositiveNumber, Promisable, Ref, Ref as RefType, Serializable, type SerializationResult, Stack, type Sync, type TaggedThrowable, Task, type TaskErrorInfo, type TaskFailure, type TaskMetadata, type TaskOutcome, type TaskParams, type TaskResult, type TaskSuccess, Throwable, type ThrowableType, Traversable, Try, type TryKind, Type, Typeable, TypedError, type TypedErrorContext, UUID, type UniversalContainer, UrlString, ValidatedBrand, type ValidatedBrandCompanion, ValidatedBrand as ValidatedBrandType, Validation, type ValidationRule, type Validator, Valuable, type ValuableParams, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, isCompanion, isTaggedThrowable, safeStringify };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export{X as $,J as Base,E as BoundedNumber,F as BoundedString,H as Cond,T as Do,U as DoAsync,ma as ESMap,t as Either,A as EmailAddress,_ as EmptyListError,P as Err,N as FPromise,M as FPromiseCompanion,$ as FailureError,ia as FoldableUtils,ja as HKT,D as ISO8601Date,ka as Identity,x as IntegerNumber,la as Lazy,g as LazyList,m as Left,Z as LeftError,k as List,na as Map,I as Match,oa as MatchableUtils,K as NAME,z as NonEmptyString,w as NonNegativeNumber,b as None,Y as NoneError,Q as Ok,d as Option,c as OptionConstructor,ea as ParseError,G as PatternString,y as PositiveInteger,v as PositiveNumber,f as Ref,l as Right,e as Set,a as Some,pa as Stack,S as Task,L as Throwable,h as Try,r as TypeCheckLeft,q as TypeCheckRight,i as Typeable,fa as TypedError,C as UUID,B as UrlString,u as ValidatedBrand,ga as Validation,qa as Valuable,R as createCancellationTokenSource,da as createErrorSerializer,ca as formatError,ba as formatStackTrace,V as isDoCapable,ha as isExtractable,o as isLeft,n as isRight,O as isTaggedThrowable,j as isTypeable,aa as safeStringify,p as tryCatch,s as tryCatchAsync,W as unwrap}from'./chunk-LW2YTB56.mjs';export{a as Companion,b as Tuple}from'./chunk-BQJB6CCW.mjs';export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unwrapBrand}from'./chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{ca as $,Q as Base,K as BoundedNumber,L as BoundedString,O as Cond,_ as Do,$ as DoAsync,ta as ESMap,z as Either,G as EmailAddress,fa as EmptyListError,W as Err,U as FPromise,T as FPromiseCompanion,ga as FailureError,pa as FoldableUtils,qa as HKT,J as ISO8601Date,ra as Identity,D as IntegerNumber,sa as Lazy,m as LazyList,s as Left,ea as LeftError,q as List,ua as Map,P as Match,va as MatchableUtils,R as NAME,F as NonEmptyString,C as NonNegativeNumber,h as None,da as NoneError,X as Ok,j as Option,i as OptionConstructor,la as ParseError,M as PatternString,E as PositiveInteger,B as PositiveNumber,l as Ref,r as Right,k as Set,g as Some,wa as Stack,Z as Task,S as Throwable,n as Try,x as TypeCheckLeft,w as TypeCheckRight,o as Typeable,ma as TypedError,I as UUID,H as UrlString,A as ValidatedBrand,na as Validation,xa as Valuable,Y as createCancellationTokenSource,b as createCustomSerializer,ka as createErrorSerializer,f as createSerializationCompanion,a as createSerializer,ja as formatError,ia as formatStackTrace,e as fromBinary,c as fromJSON,d as fromYAML,N as isCompanion,aa as isDoCapable,oa as isExtractable,u as isLeft,t as isRight,V as isTaggedThrowable,p as isTypeable,ha as safeStringify,v as tryCatch,y as tryCatchAsync,ba as unwrap}from'./chunk-6ZIR6EKC.mjs';export{a as Companion,b as Tuple}from'./chunk-7JJIUQXK.mjs';export{a as Brand,g as BrandedBoolean,f as BrandedNumber,e as BrandedString,d as createBrander,c as hasBrand,b as unwrapBrand}from'./chunk-OR6V4TCO.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-CM1xSzLl.js';
+export { L as List } from '../Either-Ccg0S1uS.js';
 import '../Typeable-DiGVtDnq.js';

package/dist/list/index.mjs

@@ -1,2 +1,2 @@
-export{k as List}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{q as List}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/map/index.d.ts

@@ -1,4 +1,4 @@
-import { c as Traversable, C as Collection, O as Option } from '../Either-CM1xSzLl.js';
+import { c as Traversable, C as Collection, O as Option } from '../Either-Ccg0S1uS.js';
 import { a as Typeable, S as Serializable, P as Pipe, F as Foldable, T as Type } from '../Typeable-DiGVtDnq.js';
 import { Tuple } from '../tuple/index.js';
 

package/dist/map/index.mjs

@@ -1,2 +1,2 @@
-export{na as Map}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{ua as Map}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.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, o as OptionConstructor, S as Some } from '../Either-CM1xSzLl.js';
+export { N as None, O as Option, o as OptionConstructor, S as Some } from '../Either-Ccg0S1uS.js';
 import '../Typeable-DiGVtDnq.js';

package/dist/option/index.mjs

@@ -1,2 +1,2 @@
-export{b as None,d as Option,c as OptionConstructor,a as Some}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{h as None,j as Option,i as OptionConstructor,g as Some}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-export { p as Set } from '../Either-CM1xSzLl.js';
+export { p as Set } from '../Either-Ccg0S1uS.js';
 import '../Typeable-DiGVtDnq.js';

package/dist/set/index.mjs

@@ -1,2 +1,2 @@
-export{e as Set}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{k as Set}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/try/index.d.ts

@@ -1,2 +1,2 @@
-export { T as Try, q as TypeNames } from '../Either-CM1xSzLl.js';
+export { T as Try, q as TypeNames } from '../Either-Ccg0S1uS.js';
 import '../Typeable-DiGVtDnq.js';

package/dist/try/index.mjs

@@ -1,2 +1,2 @@
-export{h as Try}from'../chunk-LW2YTB56.mjs';import'../chunk-BQJB6CCW.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
+export{n as Try}from'../chunk-6ZIR6EKC.mjs';import'../chunk-7JJIUQXK.mjs';import'../chunk-OR6V4TCO.mjs';//# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/tuple/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functype",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "description": "A functional programming library for TypeScript, using immutable data structures and type classes",
   "author": "jordan.burke@gmail.com",
@@ -12,36 +12,36 @@
   "homepage": "https://functype.org/",
   "url": "https://github.com/jordanburke/functype",
   "devDependencies": {
-    "@eslint/compat": "^1.4.0",
+    "@eslint/compat": "^1.4.1",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.38.0",
+    "@eslint/js": "^9.39.1",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/github": "^11.0.6",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.1.0",
-    "@types/node": "^22.18.11",
-    "@typescript-eslint/eslint-plugin": "^8.46.1",
-    "@typescript-eslint/parser": "^8.46.1",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
+    "@types/node": "^22.19.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
+    "@typescript-eslint/parser": "^8.46.4",
+    "@vitest/coverage-v8": "^4.0.9",
+    "@vitest/ui": "^4.0.9",
     "cross-env": "^10.1.0",
-    "eslint": "^9.38.0",
+    "eslint": "^9.39.1",
     "eslint-config-functype": "1.3.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-functional": "^9.0.2",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "fast-check": "^4.3.0",
-    "globals": "^16.4.0",
+    "globals": "^16.5.0",
     "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
+    "rimraf": "^6.1.0",
     "semantic-release": "^24.2.9",
     "ts-node": "^10.9.2",
-    "tsup": "^8.5.0",
+    "tsup": "^8.5.1",
     "tsx": "^4.20.6",
     "typedoc": "^0.28.14",
     "typescript": "5.9.2",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.9"
   },
   "types": "./dist/index.d.ts",
   "module": "./dist/index.mjs",
@@ -141,6 +141,18 @@
         "types": "./dist/branded/index.d.ts",
         "default": "./dist/branded/index.mjs"
       }
+    },
+    "./companion": {
+      "import": {
+        "types": "./dist/companion/index.d.ts",
+        "default": "./dist/companion/index.mjs"
+      }
+    },
+    "./serialization": {
+      "import": {
+        "types": "./dist/serialization/index.d.ts",
+        "default": "./dist/serialization/index.mjs"
+      }
     }
   },
   "files": [
@@ -152,7 +164,7 @@
   "sideEffects": false,
   "scripts": {
     "validate": "pnpm validate:core && pnpm validate:landing",
-    "validate:core": "pnpm format && pnpm lint && pnpm test && pnpm build",
+    "validate:core": "pnpm format && pnpm lint && pnpm test && pnpm docs:validate && pnpm build",
     "validate:landing": "cd landing && pnpm validate",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -172,8 +184,8 @@
     "docs:preprocess": "tsx scripts/preprocess-docs.ts",
     "docs": "pnpm docs:preprocess && typedoc",
     "docs:watch": "typedoc --watch",
-    "docs:validate": "tsx scripts/validate-docs.ts",
-    "postdocs": "node -e \"console.log('Documentation generated in ./typedocs')\"",
+    "docs:sync": "tsx scripts/sync-docs.ts",
+    "docs:validate": "tsx scripts/validate-docs.ts && tsx scripts/sync-docs.ts",
     "analyze:size": "pnpm build && node ./scripts/analyze-bundle-size.js",
     "landing:dev": "cd landing && pnpm dev",
     "landing:build": "cd landing && pnpm build",

package/dist/chunk-BQJB6CCW.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/companion/Companion.ts","../src/tuple/Tuple.ts"],"names":["Companion","object","companion","TupleObject","values","tuple","f","mapValue","Tuple","index","onEmpty","onValue","z","op","acc","value","stringify","v","TupleConstructor","TupleCompanion","first","second","third"],"mappings":"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","file":"chunk-BQJB6CCW.mjs","sourcesContent":["/**\n * Creates a function-object hybrid similar to Scala's companion objects.\n * This utility allows creating TypeScript function objects with attached methods,\n * mimicking Scala's class + companion object pattern without using classes.\n *\n * @param object The main function that will be invoked when the object is called\n * @param companion Additional static methods to attach to the function\n * @returns A function with the attached methods\n *\n * @example\n * const greet = (name: string) => `Hello, ${name}!`;\n * const methods = {\n *   formal: (name: string) => `Good day, ${name}.`,\n *   casual: (name: string) => `Hey ${name}!`\n * };\n * const Greeter = createCompanionObject(greet, methods);\n *\n * // Usage:\n * Greeter(\"World\"); // Hello, World!\n * Greeter.formal(\"Sir\"); // Good day, Sir.\n * Greeter.casual(\"Friend\"); // Hey Friend!\n */\nexport function Companion<ObjectF extends object, CompanionF extends object>(\n  object: ObjectF,\n  companion: CompanionF,\n): ObjectF & CompanionF {\n  return Object.assign(object, companion)\n}\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport type { Foldable } from \"@/foldable/Foldable\"\nimport type { Pipe } from \"@/pipe\"\nimport type { Serializable } from \"@/serializable/Serializable\"\nimport type { Typeable } from \"@/typeable/Typeable\"\nimport type { Type } from \"@/types\"\n\nexport interface Tuple<T extends Type[]>\n  extends Foldable<T[number]>,\n    Pipe<Tuple<T>>,\n    Serializable<Tuple<T>>,\n    Typeable<\"Tuple\"> {\n  get<K extends number>(index: K): T[K]\n\n  map<U extends Type[]>(f: (value: T) => U): Tuple<U>\n\n  flatMap<U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U>\n\n  toArray(): T\n\n  length: number\n\n  [Symbol.iterator](): Iterator<T[number]>\n\n  toString(): string\n\n  toValue(): { _tag: \"Tuple\"; value: T }\n}\n\nconst TupleObject = <T extends Type[]>(values: T): Tuple<T> => {\n  const tuple: Tuple<T> = {\n    _tag: \"Tuple\",\n    map: <U extends Type[]>(f: (value: T) => U): Tuple<U> => {\n      const mapValue = f(values)\n      return Tuple(mapValue)\n    },\n\n    flatMap: <U extends Type[]>(f: (value: T) => Tuple<U>): Tuple<U> => {\n      return f(values)\n    },\n\n    get: <K extends number>(index: K): T[K] => {\n      return values[index]\n    },\n\n    toArray: (): T => {\n      return values\n    },\n\n    length: values.length,\n\n    [Symbol.iterator](): Iterator<T[number]> {\n      let index = 0\n      return {\n        next: (): IteratorResult<T[number]> => {\n          if (index < values.length) {\n            return {\n              value: values[index++],\n              done: false,\n            }\n          } else {\n            return {\n              value: undefined,\n              done: true,\n            }\n          }\n        },\n      }\n    },\n\n    // Foldable implementation\n    fold: <B>(onEmpty: () => B, onValue: (value: T[number]) => B): B => {\n      return values.length === 0 ? onEmpty() : onValue(values[0]!)\n    },\n\n    foldLeft:\n      <B>(z: B) =>\n      (op: (b: B, a: T[number]) => B) => {\n        return values.reduce(op, z)\n      },\n\n    foldRight:\n      <B>(z: B) =>\n      (op: (a: T[number], b: B) => B): B => {\n        return values.reduceRight<B>((acc, value) => op(value, acc), z)\n      },\n\n    // Pipe implementation\n    pipe: <U>(f: (value: Tuple<T>) => U): U => f(tuple),\n\n    // Serializable implementation\n    serialize: () => {\n      return {\n        toJSON: () => JSON.stringify({ _tag: \"Tuple\", value: values }),\n        toYAML: () => `_tag: Tuple\\nvalue: ${stringify(values)}`,\n        toBinary: () => Buffer.from(JSON.stringify({ _tag: \"Tuple\", value: values })).toString(\"base64\"),\n      }\n    },\n\n    // Valuable implementation\n    toValue: () => ({ _tag: \"Tuple\", value: values }),\n\n    toString: () => `Tuple(${values.map((v) => String(v)).join(\", \")})`,\n  }\n\n  return tuple\n}\n\nconst TupleConstructor = <T extends Type[]>(values: T): Tuple<T> => {\n  return TupleObject(values)\n}\n\nconst TupleCompanion = {\n  /**\n   * Create a Tuple from multiple arguments\n   * @example\n   * const t = Tuple.of(1, \"hello\", true)\n   * // TypeScript infers: Tuple<[number, string, boolean]>\n   */\n  of: <T extends Type[]>(...values: T): Tuple<T> => {\n    return TupleObject(values)\n  },\n\n  /**\n   * Create a Tuple of size 2 (pair)\n   * @example\n   * const pair = Tuple.pair(\"key\", 42)\n   * // TypeScript infers: Tuple<[string, number]>\n   */\n  pair: <A extends Type, B extends Type>(first: A, second: B): Tuple<[A, B]> => {\n    return TupleObject([first, second] as [A, B])\n  },\n\n  /**\n   * Create a Tuple of size 3 (triple)\n   * @example\n   * const triple = Tuple.triple(\"x\", 10, true)\n   * // TypeScript infers: Tuple<[string, number, boolean]>\n   */\n  triple: <A extends Type, B extends Type, C extends Type>(first: A, second: B, third: C): Tuple<[A, B, C]> => {\n    return TupleObject([first, second, third] as [A, B, C])\n  },\n\n  /**\n   * Create an empty Tuple\n   * @example\n   * const empty = Tuple.empty()\n   * // TypeScript infers: Tuple<[]>\n   */\n  empty: (): Tuple<[]> => {\n    return TupleObject([] as [])\n  },\n\n  /**\n   * Create a Tuple from an array (alias for constructor)\n   * @example\n   * const t = Tuple.from([1, 2, 3])\n   */\n  from: <T extends Type[]>(values: T): Tuple<T> => {\n    return TupleObject(values)\n  },\n}\n\n/**\n * Tuple provides a type-safe, fixed-length array with functional operations.\n *\n * @example\n * // Creating tuples\n * const t1 = Tuple([1, \"hello\", true])\n * const t2 = Tuple.of(1, \"hello\", true)\n * const pair = Tuple.pair(\"key\", 42)\n *\n * @example\n * // Type-safe access\n * const triple = Tuple.triple(\"x\", 10, true)\n * const first = triple.get(0)  // string\n * const second = triple.get(1) // number\n * const third = triple.get(2)  // boolean\n *\n * @example\n * // Functional operations\n * const doubled = Tuple([1, 2, 3])\n *   .map(arr => arr.map(x => x * 2))\n *   .toArray() // [2, 4, 6]\n */\nexport const Tuple = Companion(TupleConstructor, TupleCompanion)\n"]}