ts-data-forge 9.0.0 → 9.0.1

package/dist/collections/stack.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"stack.mjs","sources":["../../src/collections/stack.mts"],"sourcesContent":[null],"names":["Optional.none","Optional.some"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6LA;;;;;;;;;;;AAWG;AACH,MAAM,UAAU,CAAA;;AAEd,IAAA,OAAgB,iBAAiB,GAAG,CAAC;;AAGrC,IAAA,WAAW;;AAGX,IAAA,SAAS;;AAGT,IAAA,aAAa;AAEb;;;;AAIG;AACH,IAAA,WAAA,CAAY,gBAA8B,EAAE,EAAA;AAC1C,QAAA,MAAM,eAAe,GAAG,QAAQ,CAC9B,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,iBAAiB,EAAE,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CACjE;AAED,QAAA,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,CAC3B,EAAE,MAAM,EAAE,eAAe,EAAE,EAC3B,MAAM,SAAS,CAChB;AAED,QAAA,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC;AAE5B,QAAA,IAAI,CAAC,aAAa,GAAG,eAAe;;AAGpC,QAAA,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE;AACjC,YAAA,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;QAClB;IACF;AAEA;;;;AAIG;IACH,OAAO,GAAA;QACL,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;AAEpD,QAAA,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAC1B,EAAE,MAAM,EAAE,WAAW,EAAE,EACvB,MAAM,SAAS,CAChB;;QAGD,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;YACrC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACpC;AAEA,QAAA,IAAI,CAAC,WAAW,GAAG,SAAS;AAE5B,QAAA,IAAI,CAAC,aAAa,GAAG,WAAW;IAClC;;AAGA,IAAA,IAAI,OAAO,GAAA;AACT,QAAA,OAAO,IAAI,CAAC,SAAS,KAAK,CAAC;IAC7B;;AAGA,IAAA,IAAI,IAAI,GAAA;AACN,QAAA,OAAO,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC;IACjC;AAEA;;;;;;;;;;;;;AAaG;IACH,GAAG,GAAA;AACD,QAAA,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,OAAOA,IAAa;QACtB;AAEA,QAAA,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;;QAG9C,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAE;QAEjD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;AAE7C,QAAA,OAAOC,IAAa,CAAC,OAAO,CAAC;IAC/B;AAEA;;;;;;;;;;;;;;;;AAgBG;AACH,IAAA,IAAI,CAAC,KAAQ,EAAA;;QAEX,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,aAAa,EAAE;YACzC,IAAI,CAAC,OAAO,EAAE;QAChB;QAEA,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK;AAExC,QAAA,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IAChD;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DG;AACI,MAAM,WAAW,GAAG,CAAK,aAA4B,KAC1D,IAAI,UAAU,CAAI,aAAa;;;;"}
+{"version":3,"file":"stack.mjs","sources":["../../src/collections/stack.mts"],"sourcesContent":["import { Optional } from '../functional/index.mjs';\nimport { range } from '../iterator/index.mjs';\nimport { asUint32, Uint32 } from '../number/index.mjs';\nimport { type SizeType } from '../types.mjs';\n\n/**\n * Interface for a high-performance stack with LIFO (Last-In, First-Out)\n * behavior.\n *\n * This interface defines a mutable stack data structure where elements are\n * added to and removed from the top, following the Last-In, First-Out\n * principle. The implementation uses a dynamic array for optimal performance,\n * providing O(1) operations for both push and pop operations.\n *\n * **LIFO Behavior:**\n *\n * - **push**: Adds elements to the top of the stack\n * - **pop**: Removes and returns elements from the top of the stack\n * - The last element added is the first element to be removed\n *\n * **Performance Characteristics:**\n *\n * - Push: O(1) amortized (O(n) when buffer needs resizing)\n * - Pop: O(1) always\n * - Size/isEmpty: O(1) always\n * - Memory efficient with automatic garbage collection of removed elements\n *\n * **Use Cases:**\n *\n * - Function call management and recursion\n * - Undo/redo functionality\n * - Expression evaluation and parsing\n * - Depth-first search algorithms\n * - Backtracking algorithms\n * - Browser history management\n *\n * @template T The type of elements stored in the stack.\n */\nexport type Stack<T> = Readonly<{\n  /**\n   * Checks if the stack is empty.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * // eslint-disable-next-line unicorn/prefer-single-call\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   */\n  isEmpty: boolean;\n\n  /**\n   * The number of elements in the stack.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * // eslint-disable-next-line unicorn/prefer-single-call\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   */\n  size: SizeType.Arr;\n\n  /**\n   * Removes and returns the element at the top of the stack.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * // eslint-disable-next-line unicorn/prefer-single-call\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   *\n   * @returns The element at the top of the stack, or `Optional.none` if the\n   *   stack is empty.\n   */\n  pop: () => Optional<T>;\n\n  /**\n   * Adds an element to the top of the stack.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * // eslint-disable-next-line unicorn/prefer-single-call\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   *\n   * @param value The element to add.\n   */\n  push: (value: T) => void;\n}>;\n\n/**\n * Class implementation for a stack with LIFO (Last-In, First-Out) behavior\n * using a dynamic array. This implementation provides O(1) amortized push and\n * O(1) pop operations by using a resizable buffer that grows as needed.\n *\n * The underlying array automatically resizes when it becomes full, ensuring\n * that the stack can grow to accommodate any number of elements while\n * maintaining efficient operations.\n *\n * @template T The type of elements in the stack.\n * @implements Stack\n */\nclass StackClass<T> implements Stack<T> {\n  /** @internal Initial capacity for new stacks. */\n  static readonly #INITIAL_CAPACITY = 8;\n\n  /** @internal Dynamic array to store stack elements. */\n  #mut_buffer: (T | undefined)[];\n\n  /** @internal Current number of elements in the stack. */\n  #mut_size: Uint32;\n\n  /** @internal Current capacity of the buffer. */\n  #mut_capacity: Uint32;\n\n  /**\n   * Constructs a new StackClass instance.\n   *\n   * @param initialValues Optional initial values to populate the stack.\n   */\n  constructor(initialValues: readonly T[] = []) {\n    const initialCapacity = asUint32(\n      Math.max(StackClass.#INITIAL_CAPACITY, initialValues.length * 2),\n    );\n\n    this.#mut_buffer = Array.from<unknown, T | undefined>(\n      { length: initialCapacity },\n      () => undefined,\n    );\n\n    this.#mut_size = asUint32(0);\n\n    this.#mut_capacity = initialCapacity;\n\n    // Add initial values\n    for (const value of initialValues) {\n      this.push(value);\n    }\n  }\n\n  /**\n   * @internal\n   * Resizes the buffer when it becomes full.\n   * Doubles the capacity while preserving all elements.\n   */\n  #resize(): void {\n    const newCapacity = asUint32(this.#mut_capacity * 2);\n\n    const newBuffer = Array.from<unknown, T | undefined>(\n      { length: newCapacity },\n      () => undefined,\n    );\n\n    // Copy existing elements\n    for (const i of range(this.#mut_size)) {\n      newBuffer[i] = this.#mut_buffer[i];\n    }\n\n    this.#mut_buffer = newBuffer;\n\n    this.#mut_capacity = newCapacity;\n  }\n\n  /** @inheritdoc */\n  get isEmpty(): boolean {\n    return this.#mut_size === 0;\n  }\n\n  /** @inheritdoc */\n  get size(): SizeType.Arr {\n    return asUint32(this.#mut_size);\n  }\n\n  /**\n   * Removes and returns the element at the top of the stack (LIFO).\n   *\n   * This operation removes the element that was added most recently (last-in)\n   * and returns it. If the stack is empty, returns `Optional.none`. The\n   * operation is guaranteed to be O(1) and does not require any array resizing\n   * or memory reallocation.\n   *\n   * **Time Complexity:** O(1) - constant time operation **Space Complexity:**\n   * O(1) - no additional memory allocation\n   *\n   * @returns An Optional containing the removed element, or `Optional.none` if\n   *   the stack is empty.\n   */\n  pop(): Optional<T> {\n    if (this.isEmpty) {\n      return Optional.none;\n    }\n\n    this.#mut_size = Uint32.sub(this.#mut_size, 1);\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const element = this.#mut_buffer[this.#mut_size]!;\n\n    this.#mut_buffer[this.#mut_size] = undefined; // Clear reference for garbage collection\n\n    return Optional.some(element);\n  }\n\n  /**\n   * Adds an element to the top of the stack (LIFO).\n   *\n   * This operation adds the element to the top of the stack, where it will be\n   * the first to be popped (last-in, first-out ordering). The operation is\n   * amortized O(1), meaning it's O(1) for most operations with occasional O(n)\n   * when the buffer needs resizing.\n   *\n   * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is\n   * needed **Space Complexity:** O(1) - constant additional memory per element\n   *\n   * **Buffer Resizing:** When the internal buffer becomes full, it\n   * automatically doubles in size and copies existing elements to maintain the\n   * stack structure.\n   *\n   * @param value The element to add to the top of the stack.\n   */\n  push(value: T): void {\n    // Resize if buffer is full\n    if (this.#mut_size === this.#mut_capacity) {\n      this.#resize();\n    }\n\n    this.#mut_buffer[this.#mut_size] = value;\n\n    this.#mut_size = Uint32.add(this.#mut_size, 1);\n  }\n}\n\n/**\n * Creates a new Stack instance with LIFO (Last-In, First-Out) behavior using a\n * high-performance dynamic array.\n *\n * This factory function creates an optimized stack implementation that\n * maintains excellent performance characteristics for both push and pop\n * operations. The underlying dynamic array automatically resizes to accommodate\n * growing workloads while providing predictable O(1) operations.\n *\n * **Implementation Features:**\n *\n * - **O(1) push operations** (amortized - occasionally O(n) when resizing)\n * - **O(1) pop operations** (always)\n * - **Automatic buffer resizing** - starts at 8 elements, doubles when full\n * - **Memory efficient** - garbage collects removed elements immediately\n * - **Dynamic array design** - eliminates need for complex memory management\n *\n * **Performance Benefits:**\n *\n * - No array shifting required for stack operations\n * - Minimal memory allocation overhead\n * - Predictable performance under high load\n * - Efficient memory usage with automatic cleanup\n *\n * @example\n *\n * ```ts\n * const stack = createStack<string>();\n *\n * assert.isTrue(stack.isEmpty);\n *\n * assert.isTrue(stack.size === 0);\n *\n * stack.push('first');\n *\n * // eslint-disable-next-line unicorn/prefer-single-call\n * stack.push('second');\n *\n * assert.isFalse(stack.isEmpty);\n *\n * assert.isTrue(stack.size === 2);\n *\n * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n *\n * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n *\n * assert.deepStrictEqual(stack.pop(), Optional.none);\n *\n * const seededStack = createStack([10, 20, 30]);\n *\n * assert.isTrue(seededStack.size === 3);\n *\n * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n * ```\n *\n * @template T The type of elements stored in the stack.\n * @param initialValues Optional array of initial elements to populate the\n *   stack. Elements will be popped in reverse order of how they appear in the\n *   array (last array element will be popped first). If provided, the initial\n *   buffer capacity will be at least twice the array length.\n * @returns A new Stack instance optimized for high-performance LIFO operations.\n */\nexport const createStack = <T,>(initialValues?: readonly T[]): Stack<T> =>\n  new StackClass<T>(initialValues);\n"],"names":["Optional.none","Optional.some"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyMA,MAAM,UAAA,CAAkC;AAAA;AAAA,EAEtC,OAAgB,iBAAA,GAAoB,CAAA;AAAA;AAAA,EAGpC,WAAA;AAAA;AAAA,EAGA,SAAA;AAAA;AAAA,EAGA,aAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,WAAA,CAAY,aAAA,GAA8B,EAAC,EAAG;AAC5C,IAAA,MAAM,eAAA,GAAkB,QAAA;AAAA,MACtB,KAAK,GAAA,CAAI,UAAA,CAAW,iBAAA,EAAmB,aAAA,CAAc,SAAS,CAAC;AAAA,KACjE;AAEA,IAAA,IAAA,CAAK,cAAc,KAAA,CAAM,IAAA;AAAA,MACvB,EAAE,QAAQ,eAAA,EAAgB;AAAA,MAC1B,MAAM;AAAA,KACR;AAEA,IAAA,IAAA,CAAK,SAAA,GAAY,SAAS,CAAC,CAAA;AAE3B,IAAA,IAAA,CAAK,aAAA,GAAgB,eAAA;AAGrB,IAAA,KAAA,MAAW,SAAS,aAAA,EAAe;AACjC,MAAA,IAAA,CAAK,KAAK,KAAK,CAAA;AAAA,IACjB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAA,GAAgB;AACd,IAAA,MAAM,WAAA,GAAc,QAAA,CAAS,IAAA,CAAK,aAAA,GAAgB,CAAC,CAAA;AAEnD,IAAA,MAAM,YAAY,KAAA,CAAM,IAAA;AAAA,MACtB,EAAE,QAAQ,WAAA,EAAY;AAAA,MACtB,MAAM;AAAA,KACR;AAGA,IAAA,KAAA,MAAW,CAAA,IAAK,KAAA,CAAM,IAAA,CAAK,SAAS,CAAA,EAAG;AACrC,MAAA,SAAA,CAAU,CAAC,CAAA,GAAI,IAAA,CAAK,WAAA,CAAY,CAAC,CAAA;AAAA,IACnC;AAEA,IAAA,IAAA,CAAK,WAAA,GAAc,SAAA;AAEnB,IAAA,IAAA,CAAK,aAAA,GAAgB,WAAA;AAAA,EACvB;AAAA;AAAA,EAGA,IAAI,OAAA,GAAmB;AACrB,IAAA,OAAO,KAAK,SAAA,KAAc,CAAA;AAAA,EAC5B;AAAA;AAAA,EAGA,IAAI,IAAA,GAAqB;AACvB,IAAA,OAAO,QAAA,CAAS,KAAK,SAAS,CAAA;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,GAAA,GAAmB;AACjB,IAAA,IAAI,KAAK,OAAA,EAAS;AAChB,MAAA,OAAOA,IAAS;AAAA,IAClB;AAEA,IAAA,IAAA,CAAK,SAAA,GAAY,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,WAAW,CAAC,CAAA;AAG7C,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,WAAA,CAAY,IAAA,CAAK,SAAS,CAAA;AAE/C,IAAA,IAAA,CAAK,WAAA,CAAY,IAAA,CAAK,SAAS,CAAA,GAAI,MAAA;AAEnC,IAAA,OAAOC,KAAc,OAAO,CAAA;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,KAAK,KAAA,EAAgB;AAEnB,IAAA,IAAI,IAAA,CAAK,SAAA,KAAc,IAAA,CAAK,aAAA,EAAe;AACzC,MAAA,IAAA,CAAK,OAAA,EAAQ;AAAA,IACf;AAEA,IAAA,IAAA,CAAK,WAAA,CAAY,IAAA,CAAK,SAAS,CAAA,GAAI,KAAA;AAEnC,IAAA,IAAA,CAAK,SAAA,GAAY,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,WAAW,CAAC,CAAA;AAAA,EAC/C;AACF;AAgEO,MAAM,WAAA,GAAc,CAAK,aAAA,KAC9B,IAAI,WAAc,aAAa;;;;"}

package/dist/expect-type.d.mts

@@ -67,5 +67,5 @@ import { type TypeEq, type TypeExtends } from 'ts-type-forge';
  *   - **Performance**: Has zero runtime overhead as it's purely a compile-time
  *       construct.
  */
-export declare const expectType: <A, B>(_relation: TypeEq<A, B> extends true ? "<=" | "=" | ">=" | "~=" : "!=" | (TypeExtends<A, B> extends true ? "<=" | (TypeExtends<B, A> extends true ? ">=" | "~=" : "!>=") : "!<=" | (TypeExtends<B, A> extends true ? ">=" : "!>="))) => void;
+export declare const expectType: <A, B>(_relation: TypeEq<A, B> extends true ? '<=' | '=' | '>=' | '~=' : '!=' | (TypeExtends<A, B> extends true ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=') : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>='))) => void;
 //# sourceMappingURL=expect-type.d.mts.map

package/dist/expect-type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"expect-type.d.mts","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAC7B,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GACtB,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAC7D,KAAK,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,KACjE,IAAiB,CAAC"}
+{"version":3,"file":"expect-type.d.mts","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,aAClB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GACtB,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAC7D,KAAK,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,KACjE,IAAiB,CAAC"}

package/dist/expect-type.mjs

@@ -1,72 +1,4 @@
-/**
- * Compile-time type assertion utility for TypeScript type testing.
- *
- * This function performs static type relationship checking at compile-time and
- * has no runtime effect. It is primarily used in test files to verify that
- * TypeScript's type inference and type relationships work as expected. The
- * function will cause TypeScript compilation errors if the specified type
- * relationship does not hold.
- *
- * ## Supported Type Relations
- *
- * ### Equality Relations
- *
- * - **`"="` (strict equality)**: Asserts that types `A` and `B` are exactly the
- *   same type. Uses TypeScript's internal type equality checking.
- * - **`"!="` (strict inequality)**: Asserts that types `A` and `B` are not
- *   exactly the same type.
- *
- * ### Assignability Relations
- *
- * - **`"~="` (mutual assignability)**: Asserts that `A` extends `B` AND `B`
- *   extends `A`. Types are structurally equivalent and mutually assignable.
- * - **`"<="` (subtype relation)**: Asserts that type `A` extends (is assignable
- *   to) type `B`. Type `A` is a subtype of `B`.
- * - **`">="` (supertype relation)**: Asserts that type `B` extends (is assignable
- *   to) type `A`. Type `A` is a supertype of `B`.
- *
- * ### Negative Assignability Relations
- *
- * - **`"!<="` (not subtype)**: Asserts that type `A` does NOT extend type `B`.
- * - **`"!>="` (not supertype)**: Asserts that type `B` does NOT extend type `A`.
- *
- * ## Type Parameter Constraints
- *
- * @since 1.0.0
- * @template A - The first type for comparison. Can be any TypeScript type
- *   including:
- *
- *   - Primitive types (string, number, boolean, etc.)
- *   - Object types and interfaces
- *   - Union and intersection types
- *   - Generic types and type parameters
- *   - Literal types and branded types
- *   - Function types and return types
- *
- * @template B - The second type for comparison. Same constraints as type `A`.
- * @param _relation - A string literal representing the expected type
- *   relationship. TypeScript's type system automatically infers and restricts
- *   the available operators based on the actual relationship between types `A`
- *   and `B`. If an invalid relationship is specified, TypeScript will show a
- *   compilation error.
- *
- *   Combine `expectType` with runtime assertions for comprehensive testing:
- *
- *   ## Important Notes
- *
- *   - **Compile-time only**: This function has no runtime behavior and will be
- *       optimized away.
- *   - **Type inference**: The available relation operators are automatically
- *       inferred by TypeScript based on the actual type relationship between
- *       `A` and `B`.
- *   - **Error feedback**: Invalid type relationships will cause clear TypeScript
- *       compilation errors.
- *   - **Test organization**: Typically used in `.test.mts` files alongside runtime
- *       assertions.
- *   - **Performance**: Has zero runtime overhead as it's purely a compile-time
- *       construct.
- */
-const expectType = (_relation) => undefined;
+const expectType = (_relation) => void 0;
 
 export { expectType };
 //# sourceMappingURL=expect-type.mjs.map

package/dist/expect-type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"expect-type.mjs","sources":["../src/expect-type.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEG;AACI,MAAM,UAAU,GAAG,CACxB,SAKkE,KACzD;;;;"}
+{"version":3,"file":"expect-type.mjs","sources":["../src/expect-type.mts"],"sourcesContent":["import { type TypeEq, type TypeExtends } from 'ts-type-forge';\n\n/**\n * Compile-time type assertion utility for TypeScript type testing.\n *\n * This function performs static type relationship checking at compile-time and\n * has no runtime effect. It is primarily used in test files to verify that\n * TypeScript's type inference and type relationships work as expected. The\n * function will cause TypeScript compilation errors if the specified type\n * relationship does not hold.\n *\n * ## Supported Type Relations\n *\n * ### Equality Relations\n *\n * - **`\"=\"` (strict equality)**: Asserts that types `A` and `B` are exactly the\n *   same type. Uses TypeScript's internal type equality checking.\n * - **`\"!=\"` (strict inequality)**: Asserts that types `A` and `B` are not\n *   exactly the same type.\n *\n * ### Assignability Relations\n *\n * - **`\"~=\"` (mutual assignability)**: Asserts that `A` extends `B` AND `B`\n *   extends `A`. Types are structurally equivalent and mutually assignable.\n * - **`\"<=\"` (subtype relation)**: Asserts that type `A` extends (is assignable\n *   to) type `B`. Type `A` is a subtype of `B`.\n * - **`\">=\"` (supertype relation)**: Asserts that type `B` extends (is assignable\n *   to) type `A`. Type `A` is a supertype of `B`.\n *\n * ### Negative Assignability Relations\n *\n * - **`\"!<=\"` (not subtype)**: Asserts that type `A` does NOT extend type `B`.\n * - **`\"!>=\"` (not supertype)**: Asserts that type `B` does NOT extend type `A`.\n *\n * ## Type Parameter Constraints\n *\n * @since 1.0.0\n * @template A - The first type for comparison. Can be any TypeScript type\n *   including:\n *\n *   - Primitive types (string, number, boolean, etc.)\n *   - Object types and interfaces\n *   - Union and intersection types\n *   - Generic types and type parameters\n *   - Literal types and branded types\n *   - Function types and return types\n *\n * @template B - The second type for comparison. Same constraints as type `A`.\n * @param _relation - A string literal representing the expected type\n *   relationship. TypeScript's type system automatically infers and restricts\n *   the available operators based on the actual relationship between types `A`\n *   and `B`. If an invalid relationship is specified, TypeScript will show a\n *   compilation error.\n *\n *   Combine `expectType` with runtime assertions for comprehensive testing:\n *\n *   ## Important Notes\n *\n *   - **Compile-time only**: This function has no runtime behavior and will be\n *       optimized away.\n *   - **Type inference**: The available relation operators are automatically\n *       inferred by TypeScript based on the actual type relationship between\n *       `A` and `B`.\n *   - **Error feedback**: Invalid type relationships will cause clear TypeScript\n *       compilation errors.\n *   - **Test organization**: Typically used in `.test.mts` files alongside runtime\n *       assertions.\n *   - **Performance**: Has zero runtime overhead as it's purely a compile-time\n *       construct.\n */\nexport const expectType = <A, B>(\n  _relation: TypeEq<A, B> extends true\n    ? '<=' | '=' | '>=' | '~='\n    : | '!='\n      | (TypeExtends<A, B> extends true\n          ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=')\n          : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>=')),\n): void => undefined;\n"],"names":[],"mappings":"AAsEO,MAAM,UAAA,GAAa,CACxB,SAAA,KAMS;;;;"}

package/dist/functional/match.mjs

@@ -1,16 +1,16 @@
 import { keyIsIn } from '../guard/key-is-in.mjs';
 
 function match(...args) {
-    switch (args.length) {
-        case 2: {
-            const [target, cases] = args;
-            return cases[target];
-        }
-        case 3: {
-            const [target, cases, defaultValue] = args;
-            return keyIsIn(target, cases) ? cases[target] : defaultValue;
-        }
+  switch (args.length) {
+    case 2: {
+      const [target, cases] = args;
+      return cases[target];
     }
+    case 3: {
+      const [target, cases, defaultValue] = args;
+      return keyIsIn(target, cases) ? cases[target] : defaultValue;
+    }
+  }
 }
 
 export { match };

package/dist/functional/match.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"match.mjs","sources":["../../src/functional/match.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAmEM,SAAU,KAAK,CAKnB,GAAG,IAEmD,EAAA;AAEtD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI;AAE5B,YAAA,OAAO,KAAK,CAAC,MAAM,CAAC;;QAGtB,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,IAAI;AAE1C,YAAA,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,YAAY;;;AAGlE;;;;"}
+{"version":3,"file":"match.mjs","sources":["../../src/functional/match.mts"],"sourcesContent":["import {\n  type ReadonlyRecord,\n  type RelaxedExclude,\n  type TypeEq,\n  type UnknownRecord,\n  type ValueOf,\n} from 'ts-type-forge';\nimport { expectType } from '../expect-type.mjs';\nimport { keyIsIn } from '../guard/index.mjs';\n\n/**\n * Type-safe pattern matching function for string-based discriminated unions.\n *\n * Provides compile-time guarantees for exhaustive case handling when working\n * with literal string unions. Automatically enforces completeness checking when\n * all cases are covered, and requires a default value when cases are\n * incomplete.\n *\n * ## Key Features:\n *\n * - **Exhaustive Matching**: When all cases of a literal union are handled, no\n *   default value is needed\n * - **Partial Matching**: When cases are incomplete or working with general\n *   string types, a default value is required\n * - **Type Safety**: Prevents extra cases and ensures only valid keys are used\n * - **Strict Property Checking**: Rejects objects with unexpected properties\n *\n * @example\n *\n * ```ts\n * type Status = 'draft' | 'review' | 'published';\n *\n * const status: Status = 'draft';\n *\n * const message = match<\n *   Status,\n *   Readonly<{ draft: string; review: string; published: string }>\n * >(status, {\n *   draft: 'Work in progress',\n *   review: 'Awaiting feedback',\n *   published: 'Complete',\n * });\n *\n * assert.isTrue(message === 'Work in progress');\n * ```\n *\n * @param target - The value to match against\n * @param cases - Object mapping possible values to their corresponding results\n * @param defaultValue - Fallback value (required when not all cases are\n *   covered)\n * @returns The matched result or default value\n */\nexport function match<\n  const Case extends string,\n  const R extends ReadonlyRecord<Case, unknown>,\n>(target: Case, cases: StrictPropertyCheck<R, Case>): R[Case];\n\nexport function match<\n  const Case extends string,\n  const R extends UnknownRecord,\n  const D,\n>(\n  target: Case,\n  cases: StrictPropertyCheck<R, Case>,\n  defaultValue: IsLiteralUnionFullyCovered<Case, R> extends true ? never : D,\n): ValueOf<R> | D;\n\nexport function match<\n  const Case extends string,\n  const R extends UnknownRecord,\n  const D,\n>(\n  ...args:\n    | readonly [target: Case, cases: R]\n    | readonly [target: Case, cases: R, defaultValue: D]\n): ValueOf<R> | D {\n  switch (args.length) {\n    case 2: {\n      const [target, cases] = args;\n\n      return cases[target];\n    }\n\n    case 3: {\n      const [target, cases, defaultValue] = args;\n\n      return keyIsIn(target, cases) ? cases[target] : defaultValue;\n    }\n  }\n}\n\n/**\n * @template T The object type to check.\n * @template ExpectedKeys The union of string literal types representing the\n *   allowed keys.\n * @internal\n * Helper type to ensure that an object `T` only contains keys specified in `ExpectedKeys`.\n * If `T` has any keys not in `ExpectedKeys`, this type resolves to `never`.\n */\ntype StrictPropertyCheck<T, ExpectedKeys extends PropertyKey> =\n  RelaxedExclude<keyof T, ExpectedKeys> extends never ? T : never;\n\n/**\n * @template Case A union of string literal types representing the possible\n *   cases.\n * @template R A record type.\n * @internal\n * Helper type to check if all cases in `Case` union are fully covered by keys in `R`.\n * This checks bidirectional coverage: all Case members are in R, and no extra keys.\n */\ntype AllCasesCovered<Case extends PropertyKey, R> =\n  TypeEq<Case, keyof R> extends true ? true : false;\n\nexpectType<AllCasesCovered<'a' | 'b', Readonly<{ a: 1; b: 2 }>>, true>('=');\n\nexpectType<AllCasesCovered<'a' | 'b' | 'c', Readonly<{ a: 1; b: 2 }>>, false>(\n  '=',\n);\n\nexpectType<AllCasesCovered<'a' | 'b', Readonly<{ a: 1; b: 2; c: 3 }>>, false>(\n  '=',\n);\n\nexpectType<AllCasesCovered<string, Record<string, string>>, true>('=');\n\n/**\n * @template Case A union of string literal types.\n * @template R A record type.\n * @internal\n * Helper type to check if Case is a literal union type and all cases are covered.\n */\ntype IsLiteralUnionFullyCovered<\n  Case extends PropertyKey,\n  R extends UnknownRecord,\n> =\n  TypeEq<IsLiteralType<Case>, true> extends true\n    ? AllCasesCovered<Case, R>\n    : false;\n\nexpectType<\n  IsLiteralUnionFullyCovered<'a' | 'b', Readonly<{ a: 1; b: 2 }>>,\n  true\n>('=');\n\nexpectType<\n  IsLiteralUnionFullyCovered<'a' | 'b' | 'c', Readonly<{ a: 1; b: 2 }>>,\n  false\n>('=');\n\nexpectType<\n  IsLiteralUnionFullyCovered<'a' | 'b', Readonly<{ a: 1; b: 2; c: 3 }>>,\n  false\n>('=');\n\nexpectType<IsLiteralUnionFullyCovered<string, Record<string, string>>, false>(\n  '=',\n);\n\nexpectType<\n  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\n  IsLiteralUnionFullyCovered<'a' | 'b' | string, Readonly<{ a: 1; b: 2 }>>,\n  false\n>('=');\n\n/**\n * @template T The PropertyKey type to check.\n * @returns `true` if `T` is a literal type, `false` otherwise.\n * @internal\n * Helper type to determine if a given PropertyKey `T` is a literal type (e.g., 'a', 1)\n * or a general type (e.g., string, number).\n */\ntype IsLiteralType<T extends PropertyKey> = string extends T\n  ? false\n  : number extends T\n    ? false\n    : symbol extends T\n      ? false\n      : true;\n\nexpectType<IsLiteralType<'a' | 'b'>, true>('=');\n\nexpectType<IsLiteralType<'a'>, true>('=');\n\nexpectType<IsLiteralType<string>, false>('=');\n\nexpectType<IsLiteralType<number>, false>('=');\n\nexpectType<IsLiteralType<1>, true>('=');\n\nexpectType<IsLiteralType<number | 'aa'>, false>('=');\n\nexpectType<IsLiteralType<'aa' | 32>, true>('=');\n"],"names":[],"mappings":";;AAmEO,SAAS,SAKX,IAAA,EAGa;AAChB,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,MAAM,MAAM,CAAA;AAAA,IAAA;AACrB,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAA,EAAO,YAAY,CAAA,GAAI,IAAA;AAEtC,MAAA,OAAO,QAAQ,MAAA,EAAQ,KAAK,CAAA,GAAI,KAAA,CAAM,MAAM,CAAA,GAAI,YAAA;AAAA,IAAA;AAClD;AAEJ;;;;"}

package/dist/functional/optional/impl/optional-expect-to-be.mjs

@@ -2,23 +2,22 @@ import { isSome } from './optional-is-some.mjs';
 import { unwrap } from './optional-unwrap.mjs';
 
 function expectToBe(...args) {
-    switch (args.length) {
-        case 2: {
-            const [optional, message] = args;
-            return expectToBeImpl(optional, message);
-        }
-        case 1: {
-            // Curried version: first argument is message
-            const [message] = args;
-            return (optional) => expectToBeImpl(optional, message);
-        }
+  switch (args.length) {
+    case 2: {
+      const [optional, message] = args;
+      return expectToBeImpl(optional, message);
     }
+    case 1: {
+      const [message] = args;
+      return (optional) => expectToBeImpl(optional, message);
+    }
+  }
 }
 const expectToBeImpl = (optional, message) => {
-    if (isSome(optional)) {
-        return unwrap(optional);
-    }
-    throw new Error(message);
+  if (isSome(optional)) {
+    return unwrap(optional);
+  }
+  throw new Error(message);
 };
 
 export { expectToBe };

package/dist/functional/optional/impl/optional-expect-to-be.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-expect-to-be.mjs","sources":["../../../../src/functional/optional/impl/optional-expect-to-be.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AA6CM,SAAU,UAAU,CACxB,GAAG,IAA0E,EAAA;AAE7E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,IAAI;AAEhC,YAAA,OAAO,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC1C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI;YAEtB,OAAO,CAAC,QAA6B,KACnC,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC;QACrC;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,QAAW,EACX,OAAe,KACF;AACb,IAAA,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE;AACpB,QAAA,OAAO,MAAM,CAAC,QAAQ,CAAC;IACzB;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;AAC1B,CAAC;;;;"}
+{"version":3,"file":"optional-expect-to-be.mjs","sources":["../../../../src/functional/optional/impl/optional-expect-to-be.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Unwraps an `Optional`, returning the contained value or throwing an error\n * with the provided message.\n *\n * @example\n *\n * ```ts\n * const optionalValue = Optional.some('data');\n *\n * assert.isTrue(\n *   Optional.expectToBe(optionalValue, 'value expected') === 'data',\n * );\n *\n * const expectValue = Optional.expectToBe('missing optional');\n *\n * const throwTest = (): void => {\n *   expectValue(Optional.none);\n * };\n *\n * assert.throws(throwTest, /missing optional/u);\n *\n * assert.isTrue(expectValue(Optional.some('present')) === 'present');\n * ```\n *\n * @template O The `UnknownOptional` type to unwrap.\n * @param optional The `Optional` to unwrap.\n * @param message The error message to throw if the `Optional` is\n *   `None`.\n * @returns The contained value if `Some`.\n * @throws Error with the provided message if the `Optional` is\n *   `None`.\n */\nexport function expectToBe<O extends UnknownOptional>(\n  optional: O,\n  message: string,\n): Unwrap<O>;\n\n// Curried version\nexport function expectToBe(message: string): <O>(optional: Optional<O>) => O;\n\nexport function expectToBe<O extends UnknownOptional>(\n  ...args: readonly [optional: O, message: string] | readonly [message: string]\n): Unwrap<O> | ((optional: Optional<Unwrap<O>>) => Unwrap<O>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, message] = args;\n\n      return expectToBeImpl(optional, message);\n    }\n\n    case 1: {\n      // Curried version: first argument is message\n      const [message] = args;\n\n      return (optional: Optional<Unwrap<O>>): Unwrap<O> =>\n        expectToBeImpl(optional, message);\n    }\n  }\n}\n\nconst expectToBeImpl = <O extends UnknownOptional>(\n  optional: O,\n  message: string,\n): Unwrap<O> => {\n  if (isSome(optional)) {\n    return unwrap(optional);\n  }\n\n  throw new Error(message);\n};\n"],"names":[],"mappings":";;;AA6CO,SAAS,cACX,IAAA,EACyD;AAC5D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,OAAO,CAAA,GAAI,IAAA;AAE5B,MAAA,OAAO,cAAA,CAAe,UAAU,OAAO,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,IAAA;AAElB,MAAA,OAAO,CAAC,QAAA,KACN,cAAA,CAAe,QAAA,EAAU,OAAO,CAAA;AAAA,IACpC;AAAA;AAEJ;AAEA,MAAM,cAAA,GAAiB,CACrB,QAAA,EACA,OAAA,KACc;AACd,EAAA,IAAI,MAAA,CAAO,QAAQ,CAAA,EAAG;AACpB,IAAA,OAAO,OAAO,QAAQ,CAAA;AAAA,EACxB;AAEA,EAAA,MAAM,IAAI,MAAM,OAAO,CAAA;AACzB,CAAA;;;;"}

package/dist/functional/optional/impl/optional-filter.mjs

@@ -4,24 +4,23 @@ import { some } from './optional-some.mjs';
 import { unwrap } from './optional-unwrap.mjs';
 
 function filter(...args) {
-    switch (args.length) {
-        case 2: {
-            const [optional, predicate] = args;
-            return filterImpl(optional, predicate);
-        }
-        case 1: {
-            // Curried version: first argument is predicate function
-            const [predicate] = args;
-            return (optional) => filterImpl(optional, predicate);
-        }
+  switch (args.length) {
+    case 2: {
+      const [optional, predicate] = args;
+      return filterImpl(optional, predicate);
     }
+    case 1: {
+      const [predicate] = args;
+      return (optional) => filterImpl(optional, predicate);
+    }
+  }
 }
 const filterImpl = (optional, predicate) => {
-    if (isSome(optional)) {
-        const value = unwrap(optional);
-        return predicate(value) ? some(value) : none;
-    }
-    return none;
+  if (isSome(optional)) {
+    const value = unwrap(optional);
+    return predicate(value) ? some(value) : none;
+  }
+  return none;
 };
 
 export { filter };

package/dist/functional/optional/impl/optional-filter.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-filter.mjs","sources":["../../../../src/functional/optional/impl/optional-filter.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AA6CM,SAAU,MAAM,CACpB,GAAG,IAEoD,EAAA;AAEvD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,IAAI;AAElC,YAAA,OAAO,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,QAAW,KAAK,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC;QACzD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CACjB,QAAW,EACX,SAAwC,KACjB;AACvB,IAAA,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE;AACpB,QAAA,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC;AAE9B,QAAA,OAAO,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI;IAC9C;AAEA,IAAA,OAAO,IAAI;AACb,CAAC;;;;"}
+{"version":3,"file":"optional-filter.mjs","sources":["../../../../src/functional/optional/impl/optional-filter.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Filters an `Optional` based on a predicate. If the `Optional` is `Some` and\n * the predicate returns true, returns the original `Optional`. Otherwise\n * returns `None`.\n *\n * @example\n *\n * ```ts\n * const even = Optional.filter(Optional.some(4), (value) => value % 2 === 0);\n *\n * const odd = Optional.filter(Optional.some(3), (value) => value % 2 === 0);\n *\n * assert.deepStrictEqual(even, Optional.some(4));\n *\n * assert.deepStrictEqual(odd, Optional.none);\n *\n * const filterEven = Optional.filter((value: number) => value % 2 === 0);\n *\n * assert.deepStrictEqual(filterEven(Optional.some(6)), Optional.some(6));\n *\n * assert.deepStrictEqual(filterEven(Optional.some(5)), Optional.none);\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @param optional The `Optional` to filter.\n * @param predicate The predicate function.\n * @returns The filtered `Optional`.\n */\nexport function filter<O extends UnknownOptional>(\n  optional: O,\n  predicate: (value: Unwrap<O>) => boolean,\n): Optional<Unwrap<O>>;\n\n// Curried version\nexport function filter<S>(\n  predicate: (value: S) => boolean,\n): (optional: Optional<S>) => Optional<S>;\n\nexport function filter<O extends UnknownOptional>(\n  ...args:\n    | readonly [optional: O, predicate: (value: Unwrap<O>) => boolean]\n    | readonly [predicate: (value: Unwrap<O>) => boolean]\n): Optional<Unwrap<O>> | ((optional: O) => Optional<Unwrap<O>>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, predicate] = args;\n\n      return filterImpl(optional, predicate);\n    }\n\n    case 1: {\n      // Curried version: first argument is predicate function\n      const [predicate] = args;\n\n      return (optional: O) => filterImpl(optional, predicate);\n    }\n  }\n}\n\nconst filterImpl = <O extends UnknownOptional>(\n  optional: O,\n  predicate: (value: Unwrap<O>) => boolean,\n): Optional<Unwrap<O>> => {\n  if (isSome(optional)) {\n    const value = unwrap(optional);\n\n    return predicate(value) ? some(value) : none;\n  }\n\n  return none;\n};\n"],"names":[],"mappings":";;;;;AA6CO,SAAS,UACX,IAAA,EAG2D;AAC9D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,SAAS,CAAA,GAAI,IAAA;AAE9B,MAAA,OAAO,UAAA,CAAW,UAAU,SAAS,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,QAAA,KAAgB,UAAA,CAAW,QAAA,EAAU,SAAS,CAAA;AAAA,IACxD;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,CACjB,QAAA,EACA,SAAA,KACwB;AACxB,EAAA,IAAI,MAAA,CAAO,QAAQ,CAAA,EAAG;AACpB,IAAA,MAAM,KAAA,GAAQ,OAAO,QAAQ,CAAA;AAE7B,IAAA,OAAO,SAAA,CAAU,KAAK,CAAA,GAAI,IAAA,CAAK,KAAK,CAAA,GAAI,IAAA;AAAA,EAC1C;AAEA,EAAA,OAAO,IAAA;AACT,CAAA;;;;"}

package/dist/functional/optional/impl/optional-flat-map.mjs

@@ -3,19 +3,18 @@ import { none } from './optional-none.mjs';
 import { unwrap } from './optional-unwrap.mjs';
 
 function flatMap(...args) {
-    switch (args.length) {
-        case 2: {
-            const [optional, flatMapFn] = args;
-            return flatMapImpl(optional, flatMapFn);
-        }
-        case 1: {
-            // Curried version
-            const [flatMapFn] = args;
-            return (optional) => flatMapImpl(optional, flatMapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [optional, flatMapFn] = args;
+      return flatMapImpl(optional, flatMapFn);
     }
+    case 1: {
+      const [flatMapFn] = args;
+      return (optional) => flatMapImpl(optional, flatMapFn);
+    }
+  }
 }
-const flatMapImpl = (optional, flatMapFn) => (isSome(optional) ? flatMapFn(unwrap(optional)) : none);
+const flatMapImpl = (optional, flatMapFn) => isSome(optional) ? flatMapFn(unwrap(optional)) : none;
 
 export { flatMap };
 //# sourceMappingURL=optional-flat-map.mjs.map

package/dist/functional/optional/impl/optional-flat-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-flat-map.mjs","sources":["../../../../src/functional/optional/impl/optional-flat-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkDM,SAAU,OAAO,CACrB,GAAG,IAEyD,EAAA;AAE5D,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,IAAI;AAElC,YAAA,OAAO,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC;QACzC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,QAAW,KAAK,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC;QAC1D;;AAEJ;AAEA,MAAM,WAAW,GAAG,CAClB,QAAW,EACX,SAA6C,MAC3B,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC;;;;"}
+{"version":3,"file":"optional-flat-map.mjs","sources":["../../../../src/functional/optional/impl/optional-flat-map.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Applies a function that returns an `Optional` to the value in an\n * `Some`. If the input is `None`, returns `None`.\n * This is the monadic bind operation for `Optional`.\n *\n * @example\n *\n * ```ts\n * const parseNumber = (input: string): Optional<number> => {\n *   const num = Num.safeParseInt(input);\n *\n *   return Result.isErr(num) ? Optional.none : Optional.some(num.value);\n * };\n *\n * const parsed = Optional.flatMap(Optional.some('10'), parseNumber);\n *\n * assert.deepStrictEqual(parsed, Optional.some(10));\n *\n * const flatMapParse = Optional.flatMap(parseNumber);\n *\n * assert.deepStrictEqual(flatMapParse(Optional.some('5')), Optional.some(5));\n *\n * assert.deepStrictEqual(\n *   flatMapParse(Optional.some('invalid')),\n *   Optional.none,\n * );\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template S2 The value type of the `Optional` returned by the function.\n * @param optional The `Optional` to flat map.\n * @param flatMapFn The function to apply that returns an `Optional`.\n * @returns The result of applying the function, or `None`.\n */\nexport function flatMap<O extends UnknownOptional, S2>(\n  optional: O,\n  flatMapFn: (value: Unwrap<O>) => Optional<S2>,\n): Optional<S2>;\n\n// Curried version\nexport function flatMap<S, S2>(\n  flatMapFn: (value: S) => Optional<S2>,\n): (optional: Optional<S>) => Optional<S2>;\n\nexport function flatMap<O extends UnknownOptional, S2>(\n  ...args:\n    | readonly [optional: O, flatMapFn: (value: Unwrap<O>) => Optional<S2>]\n    | readonly [flatMapFn: (value: Unwrap<O>) => Optional<S2>]\n): Optional<S2> | ((optional: O) => Optional<S2>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, flatMapFn] = args;\n\n      return flatMapImpl(optional, flatMapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [flatMapFn] = args;\n\n      return (optional: O) => flatMapImpl(optional, flatMapFn);\n    }\n  }\n}\n\nconst flatMapImpl = <O extends UnknownOptional, S2>(\n  optional: O,\n  flatMapFn: (value: Unwrap<O>) => Optional<S2>,\n): Optional<S2> => (isSome(optional) ? flatMapFn(unwrap(optional)) : none);\n"],"names":[],"mappings":";;;;AAkDO,SAAS,WACX,IAAA,EAG6C;AAChD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,SAAS,CAAA,GAAI,IAAA;AAE9B,MAAA,OAAO,WAAA,CAAY,UAAU,SAAS,CAAA;AAAA,IACxC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,QAAA,KAAgB,WAAA,CAAY,QAAA,EAAU,SAAS,CAAA;AAAA,IACzD;AAAA;AAEJ;AAEA,MAAM,WAAA,GAAc,CAClB,QAAA,EACA,SAAA,KACkB,MAAA,CAAO,QAAQ,CAAA,GAAI,SAAA,CAAU,MAAA,CAAO,QAAQ,CAAC,CAAA,GAAI,IAAA;;;;"}

package/dist/functional/optional/impl/optional-from-nullable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-from-nullable.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-from-nullable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAC5B,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,KAC1B,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAyC,CAAC"}
+{"version":3,"file":"optional-from-nullable.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-from-nullable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SACrB,CAAC,GAAG,IAAI,GAAG,SAAS,KAC1B,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAyC,CAAC"}

package/dist/functional/optional/impl/optional-from-nullable.mjs

@@ -1,31 +1,7 @@
 import { none } from './optional-none.mjs';
 import { some } from './optional-some.mjs';
 
-/**
- * Converts a nullable value to an `Optional`.
- *
- * This is the primary way to lift nullable values (null or undefined) into
- * the Optional type system. The function treats both `null` and `undefined`
- * as empty values, converting them to `None`.
- *
- * @example
- *
- * ```ts
- * const present = Optional.fromNullable('hello');
- *
- * const absent = Optional.fromNullable<string | null>(null);
- *
- * assert.deepStrictEqual(present, Optional.some('hello'));
- *
- * assert.deepStrictEqual(absent, Optional.none);
- * ```
- *
- * @template T The type of the nullable value.
- * @param value The nullable value to convert.
- * @returns `Some<NonNullable<T>>` if the value is not null or
- *   undefined, otherwise `None`.
- */
-const fromNullable = (value) => (value == null ? none : some(value));
+const fromNullable = (value) => value == null ? none : some(value);
 
 export { fromNullable };
 //# sourceMappingURL=optional-from-nullable.mjs.map

package/dist/functional/optional/impl/optional-from-nullable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-from-nullable.mjs","sources":["../../../../src/functional/optional/impl/optional-from-nullable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,YAAY,GAAG,CAC1B,KAA2B,MACG,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;;;;"}
+{"version":3,"file":"optional-from-nullable.mjs","sources":["../../../../src/functional/optional/impl/optional-from-nullable.mts"],"sourcesContent":["import { type Optional } from '../optional.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\n\n/**\n * Converts a nullable value to an `Optional`.\n *\n * This is the primary way to lift nullable values (null or undefined) into\n * the Optional type system. The function treats both `null` and `undefined`\n * as empty values, converting them to `None`.\n *\n * @example\n *\n * ```ts\n * const present = Optional.fromNullable('hello');\n *\n * const absent = Optional.fromNullable<string | null>(null);\n *\n * assert.deepStrictEqual(present, Optional.some('hello'));\n *\n * assert.deepStrictEqual(absent, Optional.none);\n * ```\n *\n * @template T The type of the nullable value.\n * @param value The nullable value to convert.\n * @returns `Some<NonNullable<T>>` if the value is not null or\n *   undefined, otherwise `None`.\n */\nexport const fromNullable = <T,>(\n  value: T | null | undefined,\n): Optional<NonNullable<T>> => (value == null ? none : some(value));\n"],"names":[],"mappings":";;;AA4BO,MAAM,eAAe,CAC1B,KAAA,KAC8B,SAAS,IAAA,GAAO,IAAA,GAAO,KAAK,KAAK;;;;"}

package/dist/functional/optional/impl/optional-is-none.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-is-none.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-none.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,eAAe,EAC9C,UAAU,CAAC,KACV,QAAQ,IAAI,YAAY,CAAC,CAAC,CAAuC,CAAC"}
+{"version":3,"file":"optional-is-none.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-none.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,eAAe,YACpC,CAAC,KACV,QAAQ,IAAI,YAAY,CAAC,CAAC,CAAuC,CAAC"}

package/dist/functional/optional/impl/optional-is-none.mjs

@@ -1,24 +1,5 @@
 import { NoneTypeTagName } from './tag.mjs';
 
-/**
- * Checks if an {@link Optional} is {@link None}. Acts as a type guard.
- *
- * @example
- *
- * ```ts
- * const optionalValue = Optional.none as Optional<number>;
- *
- * if (Optional.isNone(optionalValue)) {
- *   // Type narrowed to None
- *   expectType<typeof optionalValue, None>('=');
- * }
- * ```
- *
- * @template O The {@link UnknownOptional} type to check.
- * @param optional The {@link Optional} to check.
- * @returns `true` if the {@link Optional} is {@link None}, `false`
- *   otherwise.
- */
 const isNone = (optional) => optional.$$tag === NoneTypeTagName;
 
 export { isNone };

package/dist/functional/optional/impl/optional-is-none.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-is-none.mjs","sources":["../../../../src/functional/optional/impl/optional-is-none.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,MAAM,GAAG,CACpB,QAAW,KACqB,QAAQ,CAAC,KAAK,KAAK;;;;"}
+{"version":3,"file":"optional-is-none.mjs","sources":["../../../../src/functional/optional/impl/optional-is-none.mts"],"sourcesContent":["import { type UnknownOptional } from '../optional.mjs';\nimport { NoneTypeTagName } from './tag.mjs';\nimport { type NarrowToNone } from './types.mjs';\n\n/**\n * Checks if an {@link Optional} is {@link None}. Acts as a type guard.\n *\n * @example\n *\n * ```ts\n * const optionalValue = Optional.none as Optional<number>;\n *\n * if (Optional.isNone(optionalValue)) {\n *   // Type narrowed to None\n *   expectType<typeof optionalValue, None>('=');\n * }\n * ```\n *\n * @template O The {@link UnknownOptional} type to check.\n * @param optional The {@link Optional} to check.\n * @returns `true` if the {@link Optional} is {@link None}, `false`\n *   otherwise.\n */\nexport const isNone = <O extends UnknownOptional>(\n  optional: O,\n): optional is NarrowToNone<O> => optional.$$tag === NoneTypeTagName;\n"],"names":[],"mappings":";;AAuBO,MAAM,MAAA,GAAS,CACpB,QAAA,KACgC,QAAA,CAAS,KAAA,KAAU;;;;"}

package/dist/functional/optional/impl/optional-is-optional.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-is-optional.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-optional.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GACrB,eAAe,OAAO,KACrB,aAAa,IAAI,QAAQ,CAAC,OAAO,CAKQ,CAAC"}
+{"version":3,"file":"optional-is-optional.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-optional.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,kBACN,OAAO,KACrB,aAAa,IAAI,QAAQ,CAAC,OAAO,CAKQ,CAAC"}

package/dist/functional/optional/impl/optional-is-optional.mjs

@@ -2,29 +2,7 @@ import { hasKey } from '../../../guard/has-key.mjs';
 import { isRecord } from '../../../guard/is-record.mjs';
 import { SomeTypeTagName, NoneTypeTagName } from './tag.mjs';
 
-/**
- * Checks if the given value is an {@link Optional}.
- *
- * @example
- *
- * ```ts
- * const maybeOptional = Optional.some('value');
- *
- * const notOptional = { $$tag: 'ts-data-forge::Optional.some' } as const;
- *
- * assert.isTrue(Optional.isOptional(maybeOptional));
- *
- * assert.isFalse(Optional.isOptional(notOptional));
- * ```
- *
- * @param maybeOptional The value to check.
- * @returns `true` if the value is an {@link Optional}, otherwise `false`.
- */
-const isOptional = (maybeOptional) => isRecord(maybeOptional) &&
-    hasKey(maybeOptional, '$$tag') &&
-    ((maybeOptional.$$tag === SomeTypeTagName &&
-        hasKey(maybeOptional, 'value')) ||
-        maybeOptional.$$tag === NoneTypeTagName);
+const isOptional = (maybeOptional) => isRecord(maybeOptional) && hasKey(maybeOptional, "$$tag") && (maybeOptional.$$tag === SomeTypeTagName && hasKey(maybeOptional, "value") || maybeOptional.$$tag === NoneTypeTagName);
 
 export { isOptional };
 //# sourceMappingURL=optional-is-optional.mjs.map

package/dist/functional/optional/impl/optional-is-optional.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-is-optional.mjs","sources":["../../../../src/functional/optional/impl/optional-is-optional.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,UAAU,GAAG,CACxB,aAAsB,KAEtB,QAAQ,CAAC,aAAa,CAAC;AACvB,IAAA,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC;AAC9B,KAAC,CAAC,aAAa,CAAC,KAAK,KAAK,eAAe;AACvC,QAAA,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC;AAC9B,QAAA,aAAa,CAAC,KAAK,KAAK,eAAe;;;;"}
+{"version":3,"file":"optional-is-optional.mjs","sources":["../../../../src/functional/optional/impl/optional-is-optional.mts"],"sourcesContent":["import { hasKey, isRecord } from '../../../guard/index.mjs';\nimport { type Optional } from '../optional.mjs';\nimport { NoneTypeTagName, SomeTypeTagName } from './tag.mjs';\n\n/**\n * Checks if the given value is an {@link Optional}.\n *\n * @example\n *\n * ```ts\n * const maybeOptional = Optional.some('value');\n *\n * const notOptional = { $$tag: 'ts-data-forge::Optional.some' } as const;\n *\n * assert.isTrue(Optional.isOptional(maybeOptional));\n *\n * assert.isFalse(Optional.isOptional(notOptional));\n * ```\n *\n * @param maybeOptional The value to check.\n * @returns `true` if the value is an {@link Optional}, otherwise `false`.\n */\nexport const isOptional = (\n  maybeOptional: unknown,\n): maybeOptional is Optional<unknown> =>\n  isRecord(maybeOptional) &&\n  hasKey(maybeOptional, '$$tag') &&\n  ((maybeOptional.$$tag === SomeTypeTagName &&\n    hasKey(maybeOptional, 'value')) ||\n    maybeOptional.$$tag === NoneTypeTagName);\n"],"names":[],"mappings":";;;;AAsBO,MAAM,aAAa,CACxB,aAAA,KAEA,SAAS,aAAa,CAAA,IACtB,OAAO,aAAA,EAAe,OAAO,CAAA,KAC3B,aAAA,CAAc,UAAU,eAAA,IACxB,MAAA,CAAO,eAAe,OAAO,CAAA,IAC7B,cAAc,KAAA,KAAU,eAAA;;;;"}

package/dist/functional/optional/impl/optional-is-some.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-is-some.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-some.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,eAAe,EAC9C,UAAU,CAAC,KACV,QAAQ,IAAI,YAAY,CAAC,CAAC,CAAuC,CAAC"}
+{"version":3,"file":"optional-is-some.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-some.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,eAAe,YACpC,CAAC,KACV,QAAQ,IAAI,YAAY,CAAC,CAAC,CAAuC,CAAC"}

package/dist/functional/optional/impl/optional-is-some.mjs

@@ -1,25 +1,5 @@
 import { SomeTypeTagName } from './tag.mjs';
 
-/**
- * Checks if an {@link Optional} is {@link Some}. Acts as a type guard.
- *
- * @example
- *
- * ```ts
- * const optionalNumber = Optional.some(42);
- *
- * if (Optional.isSome(optionalNumber)) {
- *   const value: number = optionalNumber.value;
- *
- *   assert.isTrue(value === 42);
- * }
- * ```
- *
- * @template O The {@link UnknownOptional} type to check.
- * @param optional The {@link Optional} to check.
- * @returns `true` if the {@link Optional} is {@link Some}, `false`
- *   otherwise.
- */
 const isSome = (optional) => optional.$$tag === SomeTypeTagName;
 
 export { isSome };

package/dist/functional/optional/impl/optional-is-some.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-is-some.mjs","sources":["../../../../src/functional/optional/impl/optional-is-some.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,MAAM,GAAG,CACpB,QAAW,KACqB,QAAQ,CAAC,KAAK,KAAK;;;;"}
+{"version":3,"file":"optional-is-some.mjs","sources":["../../../../src/functional/optional/impl/optional-is-some.mts"],"sourcesContent":["import { type UnknownOptional } from '../optional.mjs';\nimport { SomeTypeTagName } from './tag.mjs';\nimport { type NarrowToSome } from './types.mjs';\n\n/**\n * Checks if an {@link Optional} is {@link Some}. Acts as a type guard.\n *\n * @example\n *\n * ```ts\n * const optionalNumber = Optional.some(42);\n *\n * if (Optional.isSome(optionalNumber)) {\n *   const value: number = optionalNumber.value;\n *\n *   assert.isTrue(value === 42);\n * }\n * ```\n *\n * @template O The {@link UnknownOptional} type to check.\n * @param optional The {@link Optional} to check.\n * @returns `true` if the {@link Optional} is {@link Some}, `false`\n *   otherwise.\n */\nexport const isSome = <O extends UnknownOptional>(\n  optional: O,\n): optional is NarrowToSome<O> => optional.$$tag === SomeTypeTagName;\n"],"names":[],"mappings":";;AAwBO,MAAM,MAAA,GAAS,CACpB,QAAA,KACgC,QAAA,CAAS,KAAA,KAAU;;;;"}

package/dist/functional/optional/impl/optional-map.mjs

@@ -4,22 +4,21 @@ import { some } from './optional-some.mjs';
 import { unwrap } from './optional-unwrap.mjs';
 
 function map(...args) {
-    switch (args.length) {
-        case 2: {
-            const [optional, mapFn] = args;
-            return mapImpl(optional, mapFn);
-        }
-        case 1: {
-            // Curried version: first argument is mapping function
-            const [mapFn] = args;
-            return (optional) => mapImpl(optional, mapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [optional, mapFn] = args;
+      return mapImpl(optional, mapFn);
     }
+    case 1: {
+      const [mapFn] = args;
+      return (optional) => mapImpl(optional, mapFn);
+    }
+  }
 }
-const mapImpl = (optional, mapFn) => isSome(optional)
-    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        some(mapFn(unwrap(optional)))
-    : none;
+const mapImpl = (optional, mapFn) => isSome(optional) ? (
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  some(mapFn(unwrap(optional)))
+) : none;
 
 export { map };
 //# sourceMappingURL=optional-map.mjs.map

package/dist/functional/optional/impl/optional-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-map.mjs","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AA8CM,SAAU,GAAG,CACjB,GAAG,IAE2C,EAAA;AAE9C,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,IAAI;AAE9B,YAAA,OAAO,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC;QACjC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YAEpB,OAAO,CAAC,QAAW,KAAK,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC;QAClD;;AAEJ;AAEA,MAAM,OAAO,GAAG,CACd,QAAW,EACX,KAA+B,KAE/B,MAAM,CAAC,QAAQ;AACb;QACE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC;MAC7B,IAAI;;;;"}
+{"version":3,"file":"optional-map.mjs","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Maps an {@link Optional}<S> to {@link Optional}<S2> by applying a function to\n * a contained value. If the {@link Optional} is {@link None}, it\n * returns {@link Optional.none}. Otherwise, it applies the `mapFn` to the\n * value in `Some` and returns a new `Some` with the result.\n *\n * @example\n *\n * ```ts\n * const numberOptional = Optional.some(21);\n *\n * const mapped = Optional.map(numberOptional, (value) => value * 2);\n *\n * assert.deepStrictEqual(mapped, Optional.some(42));\n *\n * const mapToLength = Optional.map((text: string) => text.length);\n *\n * assert.deepStrictEqual(mapToLength(Optional.some('abc')), Optional.some(3));\n *\n * assert.deepStrictEqual(mapToLength(Optional.none), Optional.none);\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template S2 The type of the value returned by the mapping function.\n * @param optional The `Optional` to map.\n * @param mapFn The function to apply to the value if it exists.\n * @returns A new `Optional<S2>` resulting from the mapping, or\n *   `None` if the input was `None`.\n */\nexport function map<O extends UnknownOptional, S2>(\n  optional: O,\n  mapFn: (value: Unwrap<O>) => S2,\n): Optional<S2>;\n\n// Curried version\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): (optional: Optional<S>) => Optional<S2>;\n\nexport function map<O extends UnknownOptional, S2>(\n  ...args:\n    | readonly [optional: O, mapFn: (value: Unwrap<O>) => S2]\n    | readonly [mapFn: (value: Unwrap<O>) => S2]\n): Optional<S2> | ((optional: O) => Optional<S2>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, mapFn] = args;\n\n      return mapImpl(optional, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (optional: O) => mapImpl(optional, mapFn);\n    }\n  }\n}\n\nconst mapImpl = <O extends UnknownOptional, S2>(\n  optional: O,\n  mapFn: (value: Unwrap<O>) => S2,\n): Optional<S2> =>\n  isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      some(mapFn(unwrap(optional)!))\n    : none;\n"],"names":[],"mappings":";;;;;AA8CO,SAAS,OACX,IAAA,EAG6C;AAChD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,OAAA,CAAQ,UAAU,KAAK,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,OAAA,CAAQ,QAAA,EAAU,KAAK,CAAA;AAAA,IACjD;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,CACd,QAAA,EACA,KAAA,KAEA,OAAO,QAAQ,CAAA;AAAA;AAAA,EAEX,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,QAAQ,CAAE,CAAC;AAAA,IAC7B,IAAA;;;;"}

package/dist/functional/optional/impl/optional-none.mjs

@@ -1,21 +1,5 @@
 import { NoneTypeTagName } from './tag.mjs';
 
-/**
- * The singleton instance representing {@link None} (an empty
- * Optional).
- *
- * @example
- *
- * ```ts
- * const someValue = Optional.some({ id: 1 });
- *
- * const noneValue = Optional.none;
- *
- * assert.isTrue(Optional.isSome(someValue));
- *
- * assert.isTrue(Optional.isNone(noneValue));
- * ```
- */
 const none = { $$tag: NoneTypeTagName };
 
 export { none };

package/dist/functional/optional/impl/optional-none.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-none.mjs","sources":["../../../../src/functional/optional/impl/optional-none.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;MACU,IAAI,GAAS,EAAE,KAAK,EAAE,eAAe;;;;"}
+{"version":3,"file":"optional-none.mjs","sources":["../../../../src/functional/optional/impl/optional-none.mts"],"sourcesContent":["import { type None } from '../../../types.mjs';\nimport { NoneTypeTagName } from './tag.mjs';\n\n/**\n * The singleton instance representing {@link None} (an empty\n * Optional).\n *\n * @example\n *\n * ```ts\n * const someValue = Optional.some({ id: 1 });\n *\n * const noneValue = Optional.none;\n *\n * assert.isTrue(Optional.isSome(someValue));\n *\n * assert.isTrue(Optional.isNone(noneValue));\n * ```\n */\nexport const none: None = { $$tag: NoneTypeTagName } as const;\n"],"names":[],"mappings":";;AAmBO,MAAM,IAAA,GAAa,EAAE,KAAA,EAAO,eAAA;;;;"}