functype 0.18.0 → 0.20.0

package/README.md

@@ -9,6 +9,17 @@ Functype is a lightweight functional programming library for TypeScript, drawing
 
 [API Documentation](https://jordanburke.github.io/functype/)
 
+### CLI Documentation
+
+Get LLM-optimized API reference directly in your terminal:
+
+```bash
+npx functype              # Overview of all types
+npx functype Option       # Detailed info for Option type
+npx functype interfaces   # All interface definitions
+npx functype --json       # JSON output for programmatic use
+```
+
 ## Core Principles
 
 - **Immutability**: All data structures are immutable, promoting predictable and side-effect-free code
@@ -597,12 +608,7 @@ All data structures implement the `Functype` hierarchy:
 ```typescript
 // Base interface for all data structures
 interface FunctypeBase<A, Tag>
-  extends AsyncMonad<A>,
-    Traversable<A>,
-    Serializable<A>,
-    Foldable<A>,
-    Typeable<Tag>,
-    ContainerOps<A> {
+  extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
   readonly _tag: Tag
 }
 
@@ -613,11 +619,7 @@ interface Functype<A, Tag> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>
 
 // For collections (List, Set, Map)
 interface FunctypeCollection<A, Tag>
-  extends FunctypeBase<A, Tag>,
-    Iterable<A>,
-    Pipe<A[]>,
-    Collection<A>,
-    CollectionOps<A, FunctypeCollection<A, Tag>> {
+  extends FunctypeBase<A, Tag>, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag>> {
   toValue(): { _tag: Tag; value: A[] }
   // Collections work with Iterable instead of Monad
   flatMap<B>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag>

package/README.processed.md

@@ -639,12 +639,7 @@ All data structures implement the `Functype` hierarchy:
 ```typescript
 // Base interface for all data structures
 interface FunctypeBase<A, Tag>
-  extends AsyncMonad<A>,
-    Traversable<A>,
-    Serializable<A>,
-    Foldable<A>,
-    Typeable<Tag>,
-    ContainerOps<A> {
+  extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
   readonly _tag: Tag
 }
 
@@ -655,11 +650,7 @@ interface Functype<A, Tag> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>
 
 // For collections (List, Set, Map)
 interface FunctypeCollection<A, Tag>
-  extends FunctypeBase<A, Tag>,
-    Iterable<A>,
-    Pipe<A[]>,
-    Collection<A>,
-    CollectionOps<A, FunctypeCollection<A, Tag>> {
+  extends FunctypeBase<A, Tag>, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag>> {
   toValue(): { _tag: Tag; value: A[] }
   // Collections work with Iterable instead of Monad
   flatMap<B>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag>

package/dist/Brand-B-0nKo7I.d.ts

@@ -0,0 +1,55 @@
+//#region src/branded/Brand.d.ts
+type Brand<K$1 extends string, T> = T & {
+  readonly __brand: K$1;
+};
+type Unwrap<T> = T extends Brand<string, infer U> ? U : T;
+type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
+/**
+ * Brand is a utility for creating nominal typing in TypeScript.
+ * It creates phantom types that exist only at compile time.
+ * At runtime, the branded value IS the primitive value.
+ *
+ * @param _brand
+ * @param value - The value to brand
+ * @returns The value with phantom type brand
+ */
+declare function Brand<K$1 extends string, T>(_brand: K$1, value: T): Brand<K$1, T>;
+/**
+ * Helper to unwrap a branded value to its underlying type
+ * Works with both Brand and ValidatedBrand
+ * @param branded - The branded value (can be null or undefined)
+ * @returns The original value without the brand
+ *
+ * Note: Also exported as 'unwrap' from 'functype/branded' for convenience
+ */
+declare function unwrapBrand<K$1 extends string, T>(branded: Brand<K$1, T>): T;
+declare function unwrapBrand<K$1 extends string, T>(branded: Brand<K$1, T> | null): T | null;
+declare function unwrapBrand<K$1 extends string, T>(branded: Brand<K$1, T> | undefined): T | undefined;
+declare function unwrapBrand<K$1 extends string, T>(branded: Brand<K$1, T> | null | undefined): T | null | undefined;
+/**
+ * Type guard for checking if a value has a specific brand
+ * @param value - The value to check
+ * @param _brand - The brand to check for (unused at runtime)
+ * @returns True if the value has the specified brand
+ *
+ * Note: Since brands are phantom types that exist only at compile time,
+ * this function can only provide a runtime approximation. It always returns true
+ * for non-null values, as we have no way to actually check the brand at runtime.
+ * This function is primarily for API consistency and documentation purposes.
+ */
+declare function hasBrand<K$1 extends string, T>(value: unknown, _brand: K$1): value is Brand<K$1, T>;
+/**
+ * Create a branded type constructor for a specific brand
+ * @param brand - The brand name
+ * @returns A function that brands values with the specified brand
+ */
+declare function createBrander<K$1 extends string, T>(brand: K$1): (value: T) => Brand<K$1, T>;
+type BrandedString<K$1 extends string> = Brand<K$1, string>;
+type BrandedNumber<K$1 extends string> = Brand<K$1, number>;
+type BrandedBoolean<K$1 extends string> = Brand<K$1, boolean>;
+declare const BrandedString: <K$1 extends string>(brand: K$1) => (value: string) => BrandedString<K$1>;
+declare const BrandedNumber: <K$1 extends string>(brand: K$1) => (value: number) => BrandedNumber<K$1>;
+declare const BrandedBoolean: <K$1 extends string>(brand: K$1) => (value: boolean) => BrandedBoolean<K$1>;
+//#endregion
+export { ExtractBrand as a, hasBrand as c, BrandedString as i, unwrapBrand as l, BrandedBoolean as n, Unwrap as o, BrandedNumber as r, createBrander as s, Brand as t };
+//# sourceMappingURL=Brand-B-0nKo7I.d.ts.map

package/dist/Brand-Cfr5zy8F.js

@@ -0,0 +1,2 @@
+function e(e,t){return t}function t(e){return e??e}function n(e,t){return e!=null}function r(t){return n=>e(t,n)}const i=t=>n=>e(t,n),a=t=>n=>e(t,n),o=t=>n=>e(t,n);export{r as a,i,o as n,n as o,a as r,t as s,e as t};
+//# sourceMappingURL=Brand-Cfr5zy8F.js.map

package/dist/Brand-Cfr5zy8F.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Brand-Cfr5zy8F.js","names":[],"sources":["../src/branded/Brand.ts"],"sourcesContent":["// Phantom type brand - exists only at compile time\n// Must use type alias (not interface) because we need intersection with primitives\nexport type Brand<K extends string, T> = T & {\n  readonly __brand: K\n}\n\n// Utility type to extract the underlying type from a branded type\n// Handles both Brand and ValidatedBrand\nexport type Unwrap<T> = T extends Brand<string, infer U> ? U : T\n\n// Utility type to extract the brand from a branded type\nexport type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never\n\n/**\n * Brand is a utility for creating nominal typing in TypeScript.\n * It creates phantom types that exist only at compile time.\n * At runtime, the branded value IS the primitive value.\n *\n * @param _brand\n * @param value - The value to brand\n * @returns The value with phantom type brand\n */\nexport function Brand<K extends string, T>(_brand: K, value: T): Brand<K, T> {\n  // Just return the value with a type assertion\n  // No runtime modification - the brand exists only in TypeScript\n  return value as Brand<K, T>\n}\n\n/**\n * Helper to unwrap a branded value to its underlying type\n * Works with both Brand and ValidatedBrand\n * @param branded - The branded value (can be null or undefined)\n * @returns The original value without the brand\n *\n * Note: Also exported as 'unwrap' from 'functype/branded' for convenience\n */\nexport function unwrapBrand<K extends string, T>(branded: Brand<K, T>): T\nexport function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null): T | null\nexport function unwrapBrand<K extends string, T>(branded: Brand<K, T> | undefined): T | undefined\nexport function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null | undefined): T | null | undefined\nexport function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null | undefined): T | null | undefined {\n  // Handle null/undefined\n  if (branded === null || branded === undefined) {\n    return branded\n  }\n  // Since branded values (both Brand and ValidatedBrand) ARE their primitives, just return as-is\n  return branded as unknown as T\n}\n\n// Convenience alias for branded module users\nexport { unwrapBrand as unwrap }\n\n/**\n * Type guard for checking if a value has a specific brand\n * @param value - The value to check\n * @param _brand - The brand to check for (unused at runtime)\n * @returns True if the value has the specified brand\n *\n * Note: Since brands are phantom types that exist only at compile time,\n * this function can only provide a runtime approximation. It always returns true\n * for non-null values, as we have no way to actually check the brand at runtime.\n * This function is primarily for API consistency and documentation purposes.\n */\nexport function hasBrand<K extends string, T>(value: unknown, _brand: K): value is Brand<K, T> {\n  // In a phantom type system, we can't actually check the brand at runtime\n  // We can only verify the value exists\n  return value !== null && value !== undefined\n}\n\n/**\n * Create a branded type constructor for a specific brand\n * @param brand - The brand name\n * @returns A function that brands values with the specified brand\n */\nexport function createBrander<K extends string, T>(brand: K) {\n  return (value: T): Brand<K, T> => Brand(brand, value)\n}\n\n// Common branded primitive types\nexport type BrandedString<K extends string> = Brand<K, string>\nexport type BrandedNumber<K extends string> = Brand<K, number>\nexport type BrandedBoolean<K extends string> = Brand<K, boolean>\n\n// Factory for common primitive branded types\nexport const BrandedString =\n  <K extends string>(brand: K) =>\n  (value: string): BrandedString<K> =>\n    Brand(brand, value)\n\nexport const BrandedNumber =\n  <K extends string>(brand: K) =>\n  (value: number): BrandedNumber<K> =>\n    Brand(brand, value)\n\nexport const BrandedBoolean =\n  <K extends string>(brand: K) =>\n  (value: boolean): BrandedBoolean<K> =>\n    Brand(brand, value)\n"],"mappings":"AAsBA,SAAgB,EAA2B,EAAW,EAAuB,CAG3E,OAAO,EAeT,SAAgB,EAAiC,EAA+D,CAM9G,OAJI,GACK,EAoBX,SAAgB,EAA8B,EAAgB,EAAiC,CAG7F,OAAO,GAAU,KAQnB,SAAgB,EAAmC,EAAU,CAC3D,MAAQ,IAA0B,EAAM,EAAO,EAAM,CASvD,MAAa,EACQ,GAClB,GACC,EAAM,EAAO,EAAM,CAEV,EACQ,GAClB,GACC,EAAM,EAAO,EAAM,CAEV,EACQ,GAClB,GACC,EAAM,EAAO,EAAM"}

package/dist/Tuple-CKxIyX7l.d.ts

@@ -0,0 +1,178 @@
+//#region src/types/index.d.ts
+type Type = unknown;
+//#endregion
+//#region src/foldable/Foldable.d.ts
+/**
+ * Foldable type class represents data structures that can be folded to a summary value.
+ *
+ * @typeParam A - The type of elements in the data structure
+ */
+interface 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;
+}
+//#endregion
+//#region src/pipe/index.d.ts
+/**
+ * Pipe interface for functional data structures
+ * @typeParam T - The type of value to pipe
+ */
+interface 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;
+}
+//#endregion
+//#region src/serializable/Serializable.d.ts
+/**
+ * Methods for different serialization formats
+ */
+interface SerializationMethods<T> {
+  toJSON(): string;
+  toYAML(): string;
+  toBinary(): string;
+}
+interface Serializable<T> {
+  serialize(): SerializationMethods<T>;
+}
+//#endregion
+//#region src/typeable/Typeable.d.ts
+/**
+ * Base interface for objects with a type tag
+ * @internal
+ */
+interface TypeableBase<Tag$1 extends string> {
+  readonly _tag: Tag$1;
+}
+type Typeable<Tag$1 extends string, T = object> = T & TypeableBase<Tag$1>;
+/**
+ * Parameters for creating a Typeable instance
+ * @internal
+ */
+type TypeableParams<Tag$1 extends string, T> = {
+  _tag: Tag$1;
+  impl: T;
+};
+/**
+ * Utility type to extract the Tag from a Typeable type
+ * @typeParam T - The Typeable type to extract the tag from
+ * @internal
+ */
+type ExtractTag<T> = T extends Typeable<infer Tag, unknown> ? Tag : never;
+/**
+ * Core utility for creating nominal typing in TypeScript by adding a type tag to any object.
+ * This allows for creating distinct types that are structurally identical but considered different by TypeScript's type system.
+ *
+ * @param params - The parameters containing the tag and implementation
+ * @returns A Typeable object with the specified tag
+ * @typeParam Tag - The string literal type used as the discriminator
+ * @typeParam T - The base type to extend with the tag
+ */
+declare function Typeable<Tag$1 extends string, T>({
+  _tag,
+  impl
+}: TypeableParams<Tag$1, T>): Typeable<Tag$1, T>;
+/**
+ * Type guard with automatic type inference using the full type
+ * @param value - The value to check
+ * @param tag - The tag to check for
+ * @returns Whether the value is a Typeable with the specified tag
+ */
+declare function isTypeable<T>(value: unknown, tag: string): value is T;
+//#endregion
+//#region src/tuple/Tuple.d.ts
+interface Tuple<T extends Type[]> extends Foldable<T[number]>, Pipe<Tuple<T>>, Serializable<Tuple<T>>, Typeable<"Tuple"> {
+  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;
+  length: number;
+  [Symbol.iterator](): Iterator<T[number]>;
+  toString(): string;
+  toValue(): {
+    _tag: "Tuple";
+    value: T;
+  };
+}
+/**
+ * Tuple provides a type-safe, fixed-length array with functional operations.
+ *
+ * @example
+ * // Creating tuples
+ * const t1 = Tuple([1, "hello", true])
+ * const t2 = Tuple.of(1, "hello", true)
+ * const pair = Tuple.pair("key", 42)
+ *
+ * @example
+ * // Type-safe access
+ * const triple = Tuple.triple("x", 10, true)
+ * const first = triple.get(0)  // string
+ * const second = triple.get(1) // number
+ * const third = triple.get(2)  // boolean
+ *
+ * @example
+ * // Functional operations
+ * const doubled = Tuple([1, 2, 3])
+ *   .map(arr => arr.map(x => x * 2))
+ *   .toArray() // [2, 4, 6]
+ */
+declare const Tuple: (<T extends Type[]>(values: T) => Tuple<T>) & {
+  /**
+   * Create a Tuple from multiple arguments
+   * @example
+   * const t = Tuple.of(1, "hello", true)
+   * // TypeScript infers: Tuple<[number, string, boolean]>
+   */
+  of: <T extends Type[]>(...values: T) => Tuple<T>;
+  /**
+   * Create a Tuple of size 2 (pair)
+   * @example
+   * const pair = Tuple.pair("key", 42)
+   * // TypeScript infers: Tuple<[string, number]>
+   */
+  pair: <A extends Type, B extends Type>(first: A, second: B) => Tuple<[A, B]>;
+  /**
+   * Create a Tuple of size 3 (triple)
+   * @example
+   * const triple = Tuple.triple("x", 10, true)
+   * // TypeScript infers: Tuple<[string, number, boolean]>
+   */
+  triple: <A extends Type, B extends Type, C extends Type>(first: A, second: B, third: C) => Tuple<[A, B, C]>;
+  /**
+   * Create an empty Tuple
+   * @example
+   * const empty = Tuple.empty()
+   * // TypeScript infers: Tuple<[]>
+   */
+  empty: () => Tuple<[]>;
+  /**
+   * Create a Tuple from an array (alias for constructor)
+   * @example
+   * const t = Tuple.from([1, 2, 3])
+   */
+  from: <T extends Type[]>(values: T) => Tuple<T>;
+};
+//#endregion
+export { isTypeable as a, Pipe as c, TypeableParams as i, Foldable as l, ExtractTag as n, Serializable as o, Typeable as r, SerializationMethods as s, Tuple as t, Type as u };
+//# sourceMappingURL=Tuple-CKxIyX7l.d.ts.map

package/dist/Tuple-CgX4p79w.js

@@ -0,0 +1,2 @@
+import e from"safe-stable-stringify";function t(e,t){return Object.assign(e,t)}const n=t=>{let n={_tag:`Tuple`,map:e=>r(e(t)),flatMap:e=>e(t),get:e=>t[e],toArray:()=>t,length:t.length,[Symbol.iterator](){let e=0;return{next:()=>e<t.length?{value:t[e++],done:!1}:{value:void 0,done:!0}}},fold:(e,n)=>t.length===0?e():n(t[0]),foldLeft:e=>n=>t.reduce(n,e),foldRight:e=>n=>t.reduceRight((e,t)=>n(t,e),e),pipe:e=>e(n),serialize:()=>({toJSON:()=>JSON.stringify({_tag:`Tuple`,value:t}),toYAML:()=>`_tag: Tuple\nvalue: ${e(t)}`,toBinary:()=>Buffer.from(JSON.stringify({_tag:`Tuple`,value:t})).toString(`base64`)}),toValue:()=>({_tag:`Tuple`,value:t}),toString:()=>`Tuple(${t.map(e=>String(e)).join(`, `)})`};return n},r=t(e=>n(e),{of:(...e)=>n(e),pair:(e,t)=>n([e,t]),triple:(e,t,r)=>n([e,t,r]),empty:()=>n([]),from:e=>n(e)});export{t as n,r as t};
+//# sourceMappingURL=Tuple-CgX4p79w.js.map

package/dist/Tuple-CgX4p79w.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tuple-CgX4p79w.js","names":["tuple: Tuple<T>"],"sources":["../src/companion/Companion.ts","../src/tuple/Tuple.ts"],"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]>, Pipe<Tuple<T>>, Serializable<Tuple<T>>, 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"],"mappings":"qCAsBA,SAAgB,EACd,EACA,EACsB,CAEtB,OAAO,OAAO,OAAO,EAAQ,EAAU,CCCzC,MAAM,EAAiC,GAAwB,CAC7D,IAAMA,EAAkB,CACtB,KAAM,QACN,IAAwB,GAEf,EADU,EAAE,EAAO,CACJ,CAGxB,QAA4B,GACnB,EAAE,EAAO,CAGlB,IAAwB,GACf,EAAO,GAGhB,YACS,EAGT,OAAQ,EAAO,OAEf,CAAC,OAAO,WAAiC,CACvC,IAAI,EAAQ,EACZ,MAAO,CACL,SACM,EAAQ,EAAO,OACV,CACL,MAAO,EAAO,KACd,KAAM,GACP,CAEM,CACL,MAAO,IAAA,GACP,KAAM,GACP,CAGN,EAIH,MAAU,EAAkB,IACnB,EAAO,SAAW,EAAI,GAAS,CAAG,EAAQ,EAAO,GAAI,CAG9D,SACM,GACH,GACQ,EAAO,OAAO,EAAI,EAAE,CAG/B,UACM,GACH,GACQ,EAAO,aAAgB,EAAK,IAAU,EAAG,EAAO,EAAI,CAAE,EAAE,CAInE,KAAU,GAAiC,EAAE,EAAM,CAGnD,eACS,CACL,WAAc,KAAK,UAAU,CAAE,KAAM,QAAS,MAAO,EAAQ,CAAC,CAC9D,WAAc,uBAAuB,EAAU,EAAO,GACtD,aAAgB,OAAO,KAAK,KAAK,UAAU,CAAE,KAAM,QAAS,MAAO,EAAQ,CAAC,CAAC,CAAC,SAAS,SAAS,CACjG,EAIH,aAAgB,CAAE,KAAM,QAAS,MAAO,EAAQ,EAEhD,aAAgB,SAAS,EAAO,IAAK,GAAM,OAAO,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,GAClE,CAED,OAAO,GAgFI,EAAQ,EA7EuB,GACnC,EAAY,EAAO,CAGL,CAOrB,IAAuB,GAAG,IACjB,EAAY,EAAO,CAS5B,MAAuC,EAAU,IACxC,EAAY,CAAC,EAAO,EAAO,CAAW,CAS/C,QAAyD,EAAU,EAAW,IACrE,EAAY,CAAC,EAAO,EAAQ,EAAM,CAAc,CASzD,UACS,EAAY,EAAE,CAAO,CAQ9B,KAAyB,GAChB,EAAY,EAAO,CAE7B,CAwB+D"}

package/dist/branded/index.d.ts

@@ -1,54 +1,2 @@
-type Unwrap<T> = T extends Brand<string, infer U> ? U : T;
-type ExtractBrand<T> = T extends Brand<infer K, unknown> ? K : never;
-type Brand<K extends string, T> = T & {
-    readonly __brand: K;
-};
-/**
- * Brand is a utility for creating nominal typing in TypeScript.
- * It creates phantom types that exist only at compile time.
- * At runtime, the branded value IS the primitive value.
- *
- * @param _brand
- * @param value - The value to brand
- * @returns The value with phantom type brand
- */
-declare function Brand<K extends string, T>(_brand: K, value: T): Brand<K, T>;
-/**
- * Helper to unwrap a branded value to its underlying type
- * Works with both Brand and ValidatedBrand
- * @param branded - The branded value (can be null or undefined)
- * @returns The original value without the brand
- *
- * Note: Also exported as 'unwrap' from 'functype/branded' for convenience
- */
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T>): T;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null): T | null;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | undefined): T | undefined;
-declare function unwrapBrand<K extends string, T>(branded: Brand<K, T> | null | undefined): T | null | undefined;
-
-/**
- * Type guard for checking if a value has a specific brand
- * @param value - The value to check
- * @param _brand - The brand to check for (unused at runtime)
- * @returns True if the value has the specified brand
- *
- * Note: Since brands are phantom types that exist only at compile time,
- * this function can only provide a runtime approximation. It always returns true
- * for non-null values, as we have no way to actually check the brand at runtime.
- * This function is primarily for API consistency and documentation purposes.
- */
-declare function hasBrand<K extends string, T>(value: unknown, _brand: K): value is Brand<K, T>;
-/**
- * Create a branded type constructor for a specific brand
- * @param brand - The brand name
- * @returns A function that brands values with the specified brand
- */
-declare function createBrander<K extends string, T>(brand: K): (value: T) => Brand<K, T>;
-type BrandedString<K extends string> = Brand<K, string>;
-declare const BrandedString: <K extends string>(brand: K) => (value: string) => BrandedString<K>;
-type BrandedNumber<K extends string> = Brand<K, number>;
-declare const BrandedNumber: <K extends string>(brand: K) => (value: number) => BrandedNumber<K>;
-type BrandedBoolean<K extends string> = Brand<K, boolean>;
-declare const BrandedBoolean: <K extends string>(brand: K) => (value: boolean) => BrandedBoolean<K>;
-
-export { Brand, BrandedBoolean, BrandedNumber, BrandedString, type ExtractBrand, type Unwrap, createBrander, hasBrand, unwrapBrand as unwrap, unwrapBrand };
+import { a as ExtractBrand, c as hasBrand, i as BrandedString, l as unwrapBrand, n as BrandedBoolean, o as Unwrap, r as BrandedNumber, s as createBrander, t as Brand } from "../Brand-B-0nKo7I.js";
+export { Brand, BrandedBoolean, BrandedNumber, BrandedString, ExtractBrand, Unwrap, createBrander, hasBrand, unwrapBrand as unwrap, unwrapBrand };

package/dist/branded/index.js

@@ -0,0 +1 @@
+import{a as e,i as t,n,o as r,r as i,s as a,t as o}from"../Brand-Cfr5zy8F.js";export{o as Brand,n as BrandedBoolean,i as BrandedNumber,t as BrandedString,e as createBrander,r as hasBrand,a as unwrap,a as unwrapBrand};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export { };