ts-data-forge 8.0.0 → 9.0.1

package/dist/functional/optional/impl/optional-or-else.mjs

@@ -1,19 +1,18 @@
 import { isNone } from './optional-is-none.mjs';
 
 function orElse(...args) {
-    switch (args.length) {
-        case 2: {
-            const [optional, alternative] = args;
-            return orElseImpl(optional, alternative);
-        }
-        case 1: {
-            // Curried version
-            const [alternative] = args;
-            return (optional) => orElseImpl(optional, alternative);
-        }
+  switch (args.length) {
+    case 2: {
+      const [optional, alternative] = args;
+      return orElseImpl(optional, alternative);
     }
+    case 1: {
+      const [alternative] = args;
+      return (optional) => orElseImpl(optional, alternative);
+    }
+  }
 }
-const orElseImpl = (optional, alternative) => (isNone(optional) ? alternative : optional);
+const orElseImpl = (optional, alternative) => isNone(optional) ? alternative : optional;
 
 export { orElse };
 //# sourceMappingURL=optional-or-else.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"optional-or-else.mjs","sources":["../../../../src/functional/optional/impl/optional-or-else.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAqDM,SAAU,MAAM,CAIpB,GAAG,IAA0E,EAAA;AAE7E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,IAAI;AAEpC,YAAA,OAAO,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC;QAC1C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI;YAE1B,OAAO,CAAC,QAA6B,KACnC,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC;QACrC;;AAEJ;AAEA,MAAM,UAAU,GAAG,CAIjB,QAAW,EACX,WAAe,MACH,MAAM,CAAC,QAAQ,CAAC,GAAG,WAAW,GAAG,QAAQ,CAAC;;;;"}
+{"version":3,"file":"optional-or-else.mjs","sources":["../../../../src/functional/optional/impl/optional-or-else.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isNone } from './optional-is-none.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Returns the `Optional` if it is `Some`, otherwise returns the alternative.\n *\n * Provides a way to chain Optional operations with fallback values. This is\n * particularly useful for implementing default behavior or cascading lookups.\n * Supports both direct usage and curried form for functional composition.\n *\n * @example\n *\n * ```ts\n * const preferred = Optional.some('primary');\n *\n * const fallback = Optional.some('secondary');\n *\n * const noneValue = Optional.none as Optional<string>;\n *\n * assert.deepStrictEqual(Optional.orElse(preferred, fallback), preferred);\n *\n * assert.deepStrictEqual(Optional.orElse(noneValue, fallback), fallback);\n *\n * const orElseFallback = Optional.orElse(Optional.some('default'));\n *\n * assert.deepStrictEqual(\n *   orElseFallback(Optional.none),\n *   Optional.some('default'),\n * );\n *\n * assert.deepStrictEqual(\n *   orElseFallback(Optional.some('value')),\n *   Optional.some('value'),\n * );\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @param optional The `Optional` to check.\n * @param alternative The alternative `Optional` to return if the first is\n *   `None`.\n * @returns The first `Optional` if `Some`, otherwise the alternative.\n */\nexport function orElse<\n  O extends UnknownOptional,\n  const O2 extends UnknownOptional,\n>(optional: O, alternative: O2): O | O2;\n\n// Curried version\nexport function orElse<O2>(\n  alternative: Optional<O2>,\n): <O>(optional: Optional<O>) => Optional<O> | Optional<O2>;\n\nexport function orElse<\n  O extends UnknownOptional,\n  const O2 extends UnknownOptional,\n>(\n  ...args: readonly [optional: O, alternative: O2] | readonly [alternative: O2]\n): (O | O2) | ((optional: Optional<Unwrap<O>>) => Optional<Unwrap<O>> | O2) {\n  switch (args.length) {\n    case 2: {\n      const [optional, alternative] = args;\n\n      return orElseImpl(optional, alternative);\n    }\n\n    case 1: {\n      // Curried version\n      const [alternative] = args;\n\n      return (optional: Optional<Unwrap<O>>) =>\n        orElseImpl(optional, alternative);\n    }\n  }\n}\n\nconst orElseImpl = <\n  O extends UnknownOptional,\n  const O2 extends UnknownOptional,\n>(\n  optional: O,\n  alternative: O2,\n): O | O2 => (isNone(optional) ? alternative : optional);\n"],"names":[],"mappings":";;AAqDO,SAAS,UAIX,IAAA,EACuE;AAC1E,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,WAAW,CAAA,GAAI,IAAA;AAEhC,MAAA,OAAO,UAAA,CAAW,UAAU,WAAW,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAW,CAAA,GAAI,IAAA;AAEtB,MAAA,OAAO,CAAC,QAAA,KACN,UAAA,CAAW,QAAA,EAAU,WAAW,CAAA;AAAA,IACpC;AAAA;AAEJ;AAEA,MAAM,aAAa,CAIjB,QAAA,EACA,gBACY,MAAA,CAAO,QAAQ,IAAI,WAAA,GAAc,QAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"optional-some.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-some.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,EAAG,OAAO,CAAC,KAAG,IAAI,CAAC,CAAC,CAInC,CAAC"}
+{"version":3,"file":"optional-some.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-some.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,IAAI,CAAC,CAAC,CAInC,CAAC"}

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

@@ -1,27 +1,8 @@
 import { SomeTypeTagName } from './tag.mjs';
 
-/**
- * Creates an {@link Some} containing the given value.
- *
- * @example
- *
- * ```ts
- * const someValue = Optional.some({ id: 1 });
- *
- * const noneValue = Optional.none;
- *
- * assert.isTrue(Optional.isSome(someValue));
- *
- * assert.isTrue(Optional.isNone(noneValue));
- * ```
- *
- * @template S The type of the value.
- * @param value The value to wrap in an {@link Some}.
- * @returns An {@link Some}<S> containing the value.
- */
 const some = (value) => ({
-    $$tag: SomeTypeTagName,
-    value,
+  $$tag: SomeTypeTagName,
+  value
 });
 
 export { some };

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

@@ -1 +1 @@
-{"version":3,"file":"optional-some.mjs","sources":["../../../../src/functional/optional/impl/optional-some.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,IAAI,GAAG,CAAW,KAAQ,MACpC;AACC,IAAA,KAAK,EAAE,eAAe;IACtB,KAAK;AACN,CAAA;;;;"}
+{"version":3,"file":"optional-some.mjs","sources":["../../../../src/functional/optional/impl/optional-some.mts"],"sourcesContent":["import { type Some } from '../../../types.mjs';\nimport { SomeTypeTagName } from './tag.mjs';\n\n/**\n * Creates an {@link Some} containing the given value.\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 *\n * @template S The type of the value.\n * @param value The value to wrap in an {@link Some}.\n * @returns An {@link Some}<S> containing the value.\n */\nexport const some = <const S,>(value: S): Some<S> =>\n  ({\n    $$tag: SomeTypeTagName,\n    value,\n  }) as const;\n"],"names":[],"mappings":";;AAsBO,MAAM,IAAA,GAAO,CAAW,KAAA,MAC5B;AAAA,EACC,KAAA,EAAO,eAAA;AAAA,EACP;AACF,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"optional-to-nullable.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-to-nullable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,eAAe,EAClD,UAAU,CAAC,KACV,MAAM,CAAC,CAAC,CAAC,GAAG,SAA8D,CAAC"}
+{"version":3,"file":"optional-to-nullable.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-to-nullable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,eAAe,YACxC,CAAC,KACV,MAAM,CAAC,CAAC,CAAC,GAAG,SAA8D,CAAC"}

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

@@ -1,33 +1,7 @@
 import { isSome } from './optional-is-some.mjs';
 import { unwrap } from './optional-unwrap.mjs';
 
-/**
- * Converts an `Optional` to a nullable value.
- *
- * This function extracts the value from an Optional, returning `undefined`
- * for empty Optionals. This is useful when interfacing with APIs or systems
- * that expect nullable values rather than Optional types.
- *
- * Note: This returns `undefined` (not `null`) for consistency with
- * JavaScript's undefined semantics and TypeScript's optional properties.
- *
- * @example
- *
- * ```ts
- * const someNumber = Optional.some(42);
- *
- * const noneNumber = Optional.none as Optional<number>;
- *
- * assert.isTrue(Optional.toNullable(someNumber) === 42);
- *
- * assert.isTrue(Optional.toNullable(noneNumber) === undefined);
- * ```
- *
- * @template O The `UnknownOptional` type to convert.
- * @param optional The `Optional` to convert.
- * @returns The contained value if `Some`, otherwise `undefined`.
- */
-const toNullable = (optional) => (isSome(optional) ? unwrap(optional) : undefined);
+const toNullable = (optional) => isSome(optional) ? unwrap(optional) : void 0;
 
 export { toNullable };
 //# sourceMappingURL=optional-to-nullable.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"optional-to-nullable.mjs","sources":["../../../../src/functional/optional/impl/optional-to-nullable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,UAAU,GAAG,CACxB,QAAW,MACgB,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS;;;;"}
+{"version":3,"file":"optional-to-nullable.mjs","sources":["../../../../src/functional/optional/impl/optional-to-nullable.mts"],"sourcesContent":["import { 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 * Converts an `Optional` to a nullable value.\n *\n * This function extracts the value from an Optional, returning `undefined`\n * for empty Optionals. This is useful when interfacing with APIs or systems\n * that expect nullable values rather than Optional types.\n *\n * Note: This returns `undefined` (not `null`) for consistency with\n * JavaScript's undefined semantics and TypeScript's optional properties.\n *\n * @example\n *\n * ```ts\n * const someNumber = Optional.some(42);\n *\n * const noneNumber = Optional.none as Optional<number>;\n *\n * assert.isTrue(Optional.toNullable(someNumber) === 42);\n *\n * assert.isTrue(Optional.toNullable(noneNumber) === undefined);\n * ```\n *\n * @template O The `UnknownOptional` type to convert.\n * @param optional The `Optional` to convert.\n * @returns The contained value if `Some`, otherwise `undefined`.\n */\nexport const toNullable = <O extends UnknownOptional>(\n  optional: O,\n): Unwrap<O> | undefined => (isSome(optional) ? unwrap(optional) : undefined);\n"],"names":[],"mappings":";;;AA+BO,MAAM,UAAA,GAAa,CACxB,QAAA,KAC2B,MAAA,CAAO,QAAQ,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,GAAI;;;;"}

package/dist/functional/optional/impl/optional-unwrap-or.mjs

@@ -1,17 +1,16 @@
 import { unwrap } from './optional-unwrap.mjs';
 
 function unwrapOr(...args) {
-    switch (args.length) {
-        case 2: {
-            const [optional, defaultValue] = args;
-            return unwrapOrImpl(optional, defaultValue);
-        }
-        case 1: {
-            // Curried version: first argument is default value
-            const [defaultValue] = args;
-            return (optional) => unwrapOrImpl(optional, defaultValue);
-        }
+  switch (args.length) {
+    case 2: {
+      const [optional, defaultValue] = args;
+      return unwrapOrImpl(optional, defaultValue);
     }
+    case 1: {
+      const [defaultValue] = args;
+      return (optional) => unwrapOrImpl(optional, defaultValue);
+    }
+  }
 }
 const unwrapOrImpl = (optional, defaultValue) => unwrap(optional) ?? defaultValue;
 

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

@@ -1 +1 @@
-{"version":3,"file":"optional-unwrap-or.mjs","sources":["../../../../src/functional/optional/impl/optional-unwrap-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA8CM,SAAU,QAAQ,CACtB,GAAG,IAA0E,EAAA;AAE7E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,GAAG,IAAI;AAErC,YAAA,OAAO,YAAY,CAAC,QAAQ,EAAE,YAAY,CAAC;QAC7C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,QAA6B,KACnC,YAAY,CAAC,QAAQ,EAAE,YAAY,CAAC;QACxC;;AAEJ;AAEA,MAAM,YAAY,GAAG,CACnB,QAAW,EACX,YAAe,KACG,MAAM,CAAC,QAAQ,CAAC,IAAI,YAAY;;;;"}
+{"version":3,"file":"optional-unwrap-or.mjs","sources":["../../../../src/functional/optional/impl/optional-unwrap-or.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Unwraps an `Optional`, returning the contained value or a default value if\n * it's `None`.\n *\n * Supports both direct usage and curried form for functional composition.\n * This is often preferred over `unwrap()` when you have a sensible fallback\n * value.\n *\n * @example\n *\n * ```ts\n * const withValue = Optional.some(5);\n *\n * const withoutValue = Optional.none as Optional<number>;\n *\n * assert.isTrue(Optional.unwrapOr(withValue, 0) === 5);\n *\n * assert.isTrue(Optional.unwrapOr(withoutValue, 0) === 0);\n *\n * const unwrapWithDefault = Optional.unwrapOr(10);\n *\n * assert.isTrue(unwrapWithDefault(Optional.some(3)) === 3);\n *\n * assert.isTrue(unwrapWithDefault(Optional.none) === 10);\n * ```\n *\n * @template O The `UnknownOptional` type to unwrap.\n * @template D The type of the default value.\n * @param optional The `Optional` to unwrap.\n * @param defaultValue The value to return if `optional` is `None`.\n * @returns The contained value if `Some`, otherwise `defaultValue`.\n */\nexport function unwrapOr<O extends UnknownOptional, D>(\n  optional: O,\n  defaultValue: D,\n): D | Unwrap<O>;\n\n// Curried version\nexport function unwrapOr<D>(\n  defaultValue: D,\n): <O>(optional: Optional<O>) => D | O;\n\nexport function unwrapOr<O extends UnknownOptional, D>(\n  ...args: readonly [optional: O, defaultValue: D] | readonly [defaultValue: D]\n): (D | Unwrap<O>) | ((optional: Optional<Unwrap<O>>) => D | Unwrap<O>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, defaultValue] = args;\n\n      return unwrapOrImpl(optional, defaultValue);\n    }\n\n    case 1: {\n      // Curried version: first argument is default value\n      const [defaultValue] = args;\n\n      return (optional: Optional<Unwrap<O>>) =>\n        unwrapOrImpl(optional, defaultValue);\n    }\n  }\n}\n\nconst unwrapOrImpl = <O extends UnknownOptional, D>(\n  optional: O,\n  defaultValue: D,\n): D | Unwrap<O> => unwrap(optional) ?? defaultValue;\n"],"names":[],"mappings":";;AA8CO,SAAS,YACX,IAAA,EACmE;AACtE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,YAAY,CAAA,GAAI,IAAA;AAEjC,MAAA,OAAO,YAAA,CAAa,UAAU,YAAY,CAAA;AAAA,IAC5C;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,YAAY,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,CAAC,QAAA,KACN,YAAA,CAAa,QAAA,EAAU,YAAY,CAAA;AAAA,IACvC;AAAA;AAEJ;AAEA,MAAM,eAAe,CACnB,QAAA,EACA,YAAA,KACkB,MAAA,CAAO,QAAQ,CAAA,IAAK,YAAA;;;;"}

package/dist/functional/optional/impl/optional-unwrap-throw.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-unwrap-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap-throw.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,eAAe,EACnD,UAAU,CAAC,KACV,MAAM,CAAC,CAAC,CAOV,CAAC"}
+{"version":3,"file":"optional-unwrap-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap-throw.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,eAAe,YACzC,CAAC,KACV,MAAM,CAAC,CAAC,CAOV,CAAC"}

package/dist/functional/optional/impl/optional-unwrap-throw.mjs

@@ -1,38 +1,10 @@
 import { isSome } from './optional-is-some.mjs';
 
-/**
- * Unwraps an `Optional`, returning the contained value. Throws an error if
- * the `Optional` is `None`.
- *
- * This is a safer alternative to direct value access when you know the
- * Optional should contain a value. Use this method when an empty Optional
- * represents a programming error or unexpected condition.
- *
- * @example
- *
- * ```ts
- * const present = Optional.some('available');
- *
- * assert.isTrue(Optional.unwrapThrow(present) === 'available');
- *
- * assert.throws(
- *   () => Optional.unwrapThrow(Optional.none),
- *   /has failed because it is `None`/u,
- * );
- * ```
- *
- * @template O The `UnknownOptional` type to unwrap.
- * @param optional The `Optional` to unwrap.
- * @returns The contained value if `Some`.
- * @throws {Error} Error with message "`unwrapThrow()` has failed because it
- *   is `None`" if the `Optional` is `None`.
- */
 const unwrapThrow = (optional) => {
-    if (isSome(optional)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return optional.value;
-    }
-    throw new Error('`unwrapThrow()` has failed because it is `None`');
+  if (isSome(optional)) {
+    return optional.value;
+  }
+  throw new Error("`unwrapThrow()` has failed because it is `None`");
 };
 
 export { unwrapThrow };

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

@@ -1 +1 @@
-{"version":3,"file":"optional-unwrap-throw.mjs","sources":["../../../../src/functional/optional/impl/optional-unwrap-throw.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,WAAW,GAAG,CACzB,QAAW,KACE;AACb,IAAA,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE;;QAEpB,OAAO,QAAQ,CAAC,KAAkB;IACpC;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC;AACpE;;;;"}
+{"version":3,"file":"optional-unwrap-throw.mjs","sources":["../../../../src/functional/optional/impl/optional-unwrap-throw.mts"],"sourcesContent":["import { type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Unwraps an `Optional`, returning the contained value. Throws an error if\n * the `Optional` is `None`.\n *\n * This is a safer alternative to direct value access when you know the\n * Optional should contain a value. Use this method when an empty Optional\n * represents a programming error or unexpected condition.\n *\n * @example\n *\n * ```ts\n * const present = Optional.some('available');\n *\n * assert.isTrue(Optional.unwrapThrow(present) === 'available');\n *\n * assert.throws(\n *   () => Optional.unwrapThrow(Optional.none),\n *   /has failed because it is `None`/u,\n * );\n * ```\n *\n * @template O The `UnknownOptional` type to unwrap.\n * @param optional The `Optional` to unwrap.\n * @returns The contained value if `Some`.\n * @throws {Error} Error with message \"`unwrapThrow()` has failed because it\n *   is `None`\" if the `Optional` is `None`.\n */\nexport const unwrapThrow = <O extends UnknownOptional>(\n  optional: O,\n): Unwrap<O> => {\n  if (isSome(optional)) {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return optional.value as Unwrap<O>;\n  }\n\n  throw new Error('`unwrapThrow()` has failed because it is `None`');\n};\n"],"names":[],"mappings":";;AA+BO,MAAM,WAAA,GAAc,CACzB,QAAA,KACc;AACd,EAAA,IAAI,MAAA,CAAO,QAAQ,CAAA,EAAG;AAEpB,IAAA,OAAO,QAAA,CAAS,KAAA;AAAA,EAClB;AAEA,EAAA,MAAM,IAAI,MAAM,iDAAiD,CAAA;AACnE;;;;"}

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

@@ -1,10 +1,10 @@
 import { isSome } from './optional-is-some.mjs';
 
 function unwrap(optional) {
-    return isSome(optional)
-        ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            optional.value
-        : undefined;
+  return isSome(optional) ? (
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    optional.value
+  ) : void 0;
 }
 
 export { unwrap };

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

@@ -1 +1 @@
-{"version":3,"file":"optional-unwrap.mjs","sources":["../../../../src/functional/optional/impl/optional-unwrap.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAqCM,SAAU,MAAM,CACpB,QAAW,EAAA;IAEX,OAAO,MAAM,CAAC,QAAQ;AACpB;AACG,YAAA,QAAQ,CAAC;UACV,SAAS;AACf;;;;"}
+{"version":3,"file":"optional-unwrap.mjs","sources":["../../../../src/functional/optional/impl/optional-unwrap.mts"],"sourcesContent":["import { type Some } from '../../../types.mjs';\nimport { type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Unwraps an `Optional`, returning the contained value or `undefined` if\n * empty.\n *\n * This function provides a safe way to extract values from Optionals without\n * throwing exceptions. It has overloaded behavior based on the type:\n *\n * - For `Some<T>`: Always returns `T` (guaranteed by type system)\n * - For general `Optional<T>`: Returns `T | undefined`\n *\n * @example\n *\n * ```ts\n * const someString = Optional.some('text');\n *\n * const noneString = Optional.none as Optional<string>;\n *\n * assert.isTrue(Optional.unwrap(someString) === 'text');\n *\n * assert.isTrue(Optional.unwrap(noneString) === undefined);\n * ```\n *\n * @template O The `UnknownOptional` type to unwrap.\n * @param optional The `Optional` to unwrap.\n * @returns The contained value if `Some`, otherwise `undefined`.\n */\nexport function unwrap<O extends Some<unknown>>(optional: O): Unwrap<O>;\n\nexport function unwrap<O extends UnknownOptional>(\n  optional: O,\n): Unwrap<O> | undefined;\n\nexport function unwrap<O extends UnknownOptional>(\n  optional: O,\n): Unwrap<O> | undefined {\n  return isSome(optional)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (optional.value as Unwrap<O>)\n    : undefined;\n}\n"],"names":[],"mappings":";;AAqCO,SAAS,OACd,QAAA,EACuB;AACvB,EAAA,OAAO,OAAO,QAAQ,CAAA;AAAA;AAAA,IAEjB,QAAA,CAAS;AAAA,MACV,MAAA;AACN;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"optional-zip.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-zip.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAKhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,KAAK,CAAC,CAAC,EAC5B,WAAW,QAAQ,CAAC,CAAC,CAAC,EACtB,WAAW,QAAQ,CAAC,CAAC,CAAC,KACrB,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAGjB,CAAC"}
+{"version":3,"file":"optional-zip.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-zip.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAKhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,KAAK,CAAC,CAAC,aACjB,QAAQ,CAAC,CAAC,CAAC,aACX,QAAQ,CAAC,CAAC,CAAC,KACrB,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAGjB,CAAC"}

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

@@ -2,41 +2,7 @@ import { isSome } from './optional-is-some.mjs';
 import { none } from './optional-none.mjs';
 import { some } from './optional-some.mjs';
 
-/**
- * Combines two `Optional` values into a single `Optional` containing a tuple.
- * If either `Optional` is `None`, returns `None`.
- *
- * @example
- *
- * ```ts
- * const zipped = Optional.zip(Optional.some('left'), Optional.some(1));
- *
- * assert.isTrue(Optional.isSome(zipped));
- *
- * if (Optional.isSome(zipped)) {
- *   const expected: readonly [string, number] = ['left', 1] as const;
- *
- *   assert.deepStrictEqual(zipped.value, expected);
- * }
- *
- * const missing = Optional.zip(
- *   Optional.some('value'),
- *   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
- *   Optional.none as Optional<number>,
- * );
- *
- * assert.deepStrictEqual(missing, Optional.none);
- * ```
- *
- * @template A The value type of the first `Optional`.
- * @template B The value type of the second `Optional`.
- * @param optionalA The first `Optional`.
- * @param optionalB The second `Optional`.
- * @returns An `Optional` containing a tuple of both values, or `None`.
- */
-const zip = (optionalA, optionalB) => isSome(optionalA) && isSome(optionalB)
-    ? some([optionalA.value, optionalB.value])
-    : none;
+const zip = (optionalA, optionalB) => isSome(optionalA) && isSome(optionalB) ? some([optionalA.value, optionalB.value]) : none;
 
 export { zip };
 //# sourceMappingURL=optional-zip.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"optional-zip.mjs","sources":["../../../../src/functional/optional/impl/optional-zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,GAAG,GAAG,CACjB,SAAsB,EACtB,SAAsB,KAEtB,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,SAAS;AACnC,MAAE,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAU;MAChD;;;;"}
+{"version":3,"file":"optional-zip.mjs","sources":["../../../../src/functional/optional/impl/optional-zip.mts"],"sourcesContent":["import { type Optional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\n\n/**\n * Combines two `Optional` values into a single `Optional` containing a tuple.\n * If either `Optional` is `None`, returns `None`.\n *\n * @example\n *\n * ```ts\n * const zipped = Optional.zip(Optional.some('left'), Optional.some(1));\n *\n * assert.isTrue(Optional.isSome(zipped));\n *\n * if (Optional.isSome(zipped)) {\n *   const expected: readonly [string, number] = ['left', 1] as const;\n *\n *   assert.deepStrictEqual(zipped.value, expected);\n * }\n *\n * const missing = Optional.zip(\n *   Optional.some('value'),\n *   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n *   Optional.none as Optional<number>,\n * );\n *\n * assert.deepStrictEqual(missing, Optional.none);\n * ```\n *\n * @template A The value type of the first `Optional`.\n * @template B The value type of the second `Optional`.\n * @param optionalA The first `Optional`.\n * @param optionalB The second `Optional`.\n * @returns An `Optional` containing a tuple of both values, or `None`.\n */\nexport const zip = <A, const B>(\n  optionalA: Optional<A>,\n  optionalB: Optional<B>,\n): Optional<readonly [A, B]> =>\n  isSome(optionalA) && isSome(optionalB)\n    ? some([optionalA.value, optionalB.value] as const)\n    : none;\n"],"names":[],"mappings":";;;;AAqCO,MAAM,MAAM,CACjB,SAAA,EACA,SAAA,KAEA,MAAA,CAAO,SAAS,CAAA,IAAK,MAAA,CAAO,SAAS,CAAA,GACjC,KAAK,CAAC,SAAA,CAAU,OAAO,SAAA,CAAU,KAAK,CAAU,CAAA,GAChD;;;;"}

package/dist/functional/optional/impl/tag.mjs

@@ -1,6 +1,5 @@
-const SomeTypeTagName = 'ts-data-forge::Optional.some';
-/** @internal String literal tag to identify the 'None' variant of Optional. */
-const NoneTypeTagName = 'ts-data-forge::Optional.none';
+const SomeTypeTagName = "ts-data-forge::Optional.some";
+const NoneTypeTagName = "ts-data-forge::Optional.none";
 
 export { NoneTypeTagName, SomeTypeTagName };
 //# sourceMappingURL=tag.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/optional/impl/tag.mts"],"sourcesContent":[null],"names":[],"mappings":"AAGO,MAAM,eAAe,GAC1B;AAEF;AACO,MAAM,eAAe,GAAkB;;;;"}
+{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/optional/impl/tag.mts"],"sourcesContent":["/** @internal String literal tag to identify the 'Some' variant of Optional. */\nimport { type None, type Some } from '../../../types.mjs';\n\nexport const SomeTypeTagName: Some<unknown>['$$tag'] =\n  'ts-data-forge::Optional.some';\n\n/** @internal String literal tag to identify the 'None' variant of Optional. */\nexport const NoneTypeTagName: None['$$tag'] = 'ts-data-forge::Optional.none';\n"],"names":[],"mappings":"AAGO,MAAM,eAAA,GACX;AAGK,MAAM,eAAA,GAAiC;;;;"}

package/dist/functional/pipe.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,EAAG,GAAG,CAAC,KAAG,IAAI,CAAC,CAAC,CAYI,CAAC;AAkBjD,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAC/B,eAAe,CAAC,CAAC,CAAC,GAClB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;AAgCjE,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;CACtC,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,IAAI,QAAQ,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,SAAS,eAAe,IAAI,QAAQ,CAAC;IACzD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CAAC"}
+{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,KAAM,CAAC,KAAG,IAAI,CAAC,CAAC,CAYI,CAAC;AAkBjD,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAC/B,eAAe,CAAC,CAAC,CAAC,GAClB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;AAgCjE,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;CACtC,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,IAAI,QAAQ,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,SAAS,eAAe,IAAI,QAAQ,CAAC;IACzD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CAAC"}

package/dist/functional/pipe.mjs

@@ -1,42 +1,17 @@
 import { isOptional } from './optional/impl/optional-is-optional.mjs';
 import { map } from './optional/impl/optional-map.mjs';
 
-/**
- * Creates a new pipe object that allows for chaining operations on a value.
- *
- * This function provides a fluent interface for applying transformations to
- * values, with intelligent method selection based on the input type:
- *
- * - For `Optional` values: Provides `mapOptional` for safe Optional
- *   transformations
- * - For other values: Provides `mapNullable` for null-safe transformations
- * - All types get the basic `map` method for general transformations
- *
- * The pipe maintains type safety throughout the chain, automatically selecting
- * the appropriate overload based on the current value type.
- *
- * @template A The type of the initial value to wrap in a pipe.
- * @param a The initial value to wrap in a pipe.
- * @returns A pipe object with chaining methods appropriate for the value type.
- */
-const pipe = (a) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-({
+const pipe = (a) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  {
     value: a,
     map: (fn) => pipe(fn(a)),
-    mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
-    ...(isOptional(a)
-        ? {
-            mapOptional: (fn) => pipe(map(a, fn)),
-        }
-        : {}),
-});
-// NOTE: 以下では 'typing when used with generics' test で型エラーが出る。
-// 詳細は documents/reports/pipe-typing.md の 「mapNullable を条件付きで含めるのがうまくいかない理由」を参照。
-// export type Pipe<A> = PipeBase<A> &
-//   ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown) &
-//   ([undefined] extends [A] ? PipeMapNullable<A> : unknown) &
-//   ([null] extends [A] ? PipeMapNullable<A> : unknown);
+    mapNullable: (fn) => pipe(a == null ? void 0 : fn(a)),
+    ...isOptional(a) ? {
+      mapOptional: (fn) => pipe(map(a, fn))
+    } : {}
+  }
+);
 
 export { pipe };
 //# sourceMappingURL=pipe.mjs.map

package/dist/functional/pipe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,IAAI,GAAG,CAAW,CAAI;AACjC;AACA,CAAC;AACC,IAAA,KAAK,EAAE,CAAC;AACR,IAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAExD,IAAA,IAAIA,UAAmB,CAAC,CAAC;AACvB,UAAE;AACE,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAACC,GAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC/C;UACD,EAAE,CAAC;AACR,CAAA;AAsBH;AACA;AACA;AACA;AACA;AACA;;;;"}
+{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":["import { expectType } from '../expect-type.mjs';\nimport { Optional, type UnknownOptional } from './optional/index.mjs';\n\n/**\n * Creates a new pipe object that allows for chaining operations on a value.\n *\n * This function provides a fluent interface for applying transformations to\n * values, with intelligent method selection based on the input type:\n *\n * - For `Optional` values: Provides `mapOptional` for safe Optional\n *   transformations\n * - For other values: Provides `mapNullable` for null-safe transformations\n * - All types get the basic `map` method for general transformations\n *\n * The pipe maintains type safety throughout the chain, automatically selecting\n * the appropriate overload based on the current value type.\n *\n * @template A The type of the initial value to wrap in a pipe.\n * @param a The initial value to wrap in a pipe.\n * @returns A pipe object with chaining methods appropriate for the value type.\n */\nexport const pipe = <const A,>(a: A): Pipe<A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ({\n    value: a,\n    map: (fn) => pipe(fn(a)),\n    mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),\n\n    ...(Optional.isOptional(a)\n      ? {\n          mapOptional: (fn) => pipe(Optional.map(a, fn)),\n        }\n      : {}),\n  }) satisfies PipeImpl<A> as unknown as Pipe<A>;\n\n// `PipeBase<A>` is always present; the conditional only *adds* `mapOptional`\n// for Optional values. Two subtleties motivate this shape:\n//\n//   1. The check is `[A] extends [UnknownOptional]` (a 1-tuple), not the bare\n//      `A extends UnknownOptional`. A bare check distributes over unions, so a\n//      piped union value such as `Result<D, E> | undefined` would expand into\n//      `Pipe<Ok<D>> | Pipe<Err<E>> | Pipe<undefined>`. Calling a chained method\n//      on that union of pipe objects forces TypeScript to synthesize a merged\n//      call signature, during which a branded member like `Ok<D>` is widened to\n//      its constraint (`Ok<number>`) — losing the brand `D`.\n//\n//   2. `value: A` lives on `PipeBase<A>`, *outside* the conditional. If `value`\n//      flowed through the conditional, then for a not-yet-resolved generic `A`\n//      the deferred true branch narrows `A` to `A & UnknownOptional`, so\n//      `.value` would surface as the noisy `(A & UnknownOptional) | A`. Keeping\n//      it on the unconditional base yields a clean `A`.\nexport type Pipe<A> = PipeBase<A> &\n  PipeMapNullable<A> &\n  ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown);\n\n// NOTE: 以下では 'typing when used with generics' test で型エラーが出る。\n// 詳細は documents/reports/pipe-typing.md の 「mapNullable を条件付きで含めるのがうまくいかない理由」を参照。\n// export type Pipe<A> = PipeBase<A> &\n//   ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown) &\n//   ([undefined] extends [A] ? PipeMapNullable<A> : unknown) &\n//   ([null] extends [A] ? PipeMapNullable<A> : unknown);\n\nexpectType<Optional<number>, UnknownOptional>('<=');\n\nexpectType<number | undefined, undefined>('>=');\n\nexpectType<keyof Pipe<number | undefined>, 'value' | 'map' | 'mapNullable'>(\n  '=',\n);\n\nexpectType<\n  keyof Pipe<Optional<number>>,\n  'value' | 'map' | 'mapNullable' | 'mapOptional'\n>('=');\n\nexpectType<\n  keyof Pipe<Optional<number | undefined>>,\n  'value' | 'map' | 'mapNullable' | 'mapOptional'\n>('=');\n\nexpectType<\n  keyof Pipe<Optional<number> | undefined>,\n  'value' | 'map' | 'mapNullable'\n>('=');\n\ntype PipeBase<A> = Readonly<{\n  /** The current value being piped. */\n  value: A;\n\n  /**\n   * Maps the current value to a new value using the provided function.\n   *\n   * @example\n   *\n   * ```ts\n   * const result = pipe(2)\n   *   .map((value) => value * 3)\n   *   .map((value) => `value: ${value}`);\n   *\n   * assert.deepStrictEqual(result.value, 'value: 6');\n   * ```\n   *\n   * @template B The type of the new value.\n   * @param fn Function to transform the current value.\n   * @returns A new pipe containing the transformed value.\n   */\n  map: <B>(fn: (a: A) => B) => Pipe<B>;\n}>;\n\ntype PipeMapNullable<A> = Readonly<{\n  /**\n   * Maps the current value only if it's not null or undefined. If the current\n   * value is null/undefined, the transformation is skipped and undefined is\n   * propagated through the pipe.\n   *\n   * @example\n   *\n   * ```ts\n   * const result = pipe<string | undefined>('hello')\n   *   .mapNullable((value) => value.toUpperCase())\n   *   .mapNullable((value) => value.slice(0, 2));\n   *\n   * assert.deepStrictEqual(result.value, 'HE');\n   *\n   * const empty = pipe<string | undefined>(undefined).mapNullable((value) =>\n   *   value.toUpperCase(),\n   * );\n   *\n   * assert.isTrue(empty.value === undefined);\n   * ```\n   *\n   * @template B The type of the transformed value.\n   * @param fn Function to transform the non-null value.\n   * @returns A new pipe containing the transformed value or undefined.\n   */\n  mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;\n}>;\n\ntype PipeMapOptional<A extends UnknownOptional> = Readonly<{\n  /**\n   * Maps the value inside an Optional using Optional.map semantics. If the\n   * Optional is None, the transformation is skipped and None is propagated.\n   * If the Optional is Some, the transformation is applied to the inner\n   * value.\n   *\n   * @example\n   *\n   * ```ts\n   * const result = pipe(Optional.some(10))\n   *   .mapOptional((value) => value * 2)\n   *   .mapOptional((value) => value + 5);\n   *\n   * assert.deepStrictEqual(result.value, Optional.some(25));\n   *\n   * const empty = pipe(Optional.none as Optional<number>).mapOptional(\n   *   (value) => value * 2,\n   * );\n   *\n   * assert.isTrue(Optional.isNone(empty.value));\n   * ```\n   *\n   * @template B The type of the transformed inner value.\n   * @param fn Function to transform the inner value of the Optional.\n   * @returns A new pipe containing an Optional with the transformed value.\n   */\n  mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;\n}>;\n\n/** @internal */\ntype Cast<T, U> = T & U;\n\n/** @internal */\ntype PipeImpl<A> = Readonly<{\n  value: A;\n  map: <B>(fn: (a: A) => B) => PipeImpl<B>;\n  mapNullable?: <B>(fn: (a: NonNullable<A>) => B) => PipeImpl<B | undefined>;\n  mapOptional?: <B>(\n    fn: (a: Optional.Unwrap<Cast<A, UnknownOptional>>) => B,\n  ) => PipeImpl<Optional<B>>;\n}>;\n"],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AAqBO,MAAM,OAAO,CAAW,CAAA;AAAA;AAAA,EAE5B;AAAA,IACC,KAAA,EAAO,CAAA;AAAA,IACP,KAAK,CAAC,EAAA,KAAO,IAAA,CAAK,EAAA,CAAG,CAAC,CAAC,CAAA;AAAA,IACvB,WAAA,EAAa,CAAC,EAAA,KAAO,IAAA,CAAK,KAAK,IAAA,GAAO,MAAA,GAAY,EAAA,CAAG,CAAC,CAAC,CAAA;AAAA,IAEvD,GAAIA,UAAS,CAAW,CAAC,CAAA,GACrB;AAAA,MACE,WAAA,EAAa,CAAC,EAAA,KAAO,IAAA,CAAKC,GAAS,CAAI,CAAA,EAAG,EAAE,CAAC;AAAA,QAE/C;AAAC;AACP;;;;"}

package/dist/functional/result/impl/result-err.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,EAAG,OAAO,CAAC,KAAG,GAAG,CAAC,CAAC,CAIjC,CAAC"}
+{"version":3,"file":"result-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,SAAU,CAAC,KAAG,GAAG,CAAC,CAAC,CAIjC,CAAC"}

package/dist/functional/result/impl/result-err.mjs

@@ -1,33 +1,8 @@
 import { ErrTypeTagName } from './tag.mjs';
 
-/**
- * Creates a `Result.Err` containing the given error value.
- *
- * Use this constructor when an operation fails and you want to wrap the error
- * information in a Result type for consistent error handling.
- *
- * @example
- *
- * ```ts
- * const success = Result.ok({ id: 1 });
- *
- * const failure = Result.err(new Error('missing data'));
- *
- * assert.deepStrictEqual(success, {
- *   $$tag: 'ts-data-forge::Result.ok',
- *   value: { id: 1 },
- * });
- *
- * assert.isTrue(Result.isErr(failure));
- * ```
- *
- * @template E The type of the error value.
- * @param value The error value.
- * @returns A `Result.Err<E>` containing the value.
- */
 const err = (value) => ({
-    $$tag: ErrTypeTagName,
-    value,
+  $$tag: ErrTypeTagName,
+  value
 });
 
 export { err };

package/dist/functional/result/impl/result-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-err.mjs","sources":["../../../../src/functional/result/impl/result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;MACU,GAAG,GAAG,CAAW,KAAQ,MACnC;AACC,IAAA,KAAK,EAAE,cAAc;IACrB,KAAK;AACN,CAAA;;;;"}
+{"version":3,"file":"result-err.mjs","sources":["../../../../src/functional/result/impl/result-err.mts"],"sourcesContent":["import { type Err } from '../../../types.mjs';\nimport { ErrTypeTagName } from './tag.mjs';\n\n/**\n * Creates a `Result.Err` containing the given error value.\n *\n * Use this constructor when an operation fails and you want to wrap the error\n * information in a Result type for consistent error handling.\n *\n * @example\n *\n * ```ts\n * const success = Result.ok({ id: 1 });\n *\n * const failure = Result.err(new Error('missing data'));\n *\n * assert.deepStrictEqual(success, {\n *   $$tag: 'ts-data-forge::Result.ok',\n *   value: { id: 1 },\n * });\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n *\n * @template E The type of the error value.\n * @param value The error value.\n * @returns A `Result.Err<E>` containing the value.\n */\nexport const err = <const E,>(value: E): Err<E> =>\n  ({\n    $$tag: ErrTypeTagName,\n    value,\n  }) as const;\n"],"names":[],"mappings":";;AA4BO,MAAM,GAAA,GAAM,CAAW,KAAA,MAC3B;AAAA,EACC,KAAA,EAAO,cAAA;AAAA,EACP;AACF,CAAA;;;;"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"result-expect-to-be.mjs","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AA2CM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;AAE9B,YAAA,OAAO,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI;YAEtB,OAAO,CAAC,MAAS,KAAkB,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACpE;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,OAAe,KACA;AACf,IAAA,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;AAChB,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC;IACzB;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;AAC1B,CAAC;;;;"}
+{"version":3,"file":"result-expect-to-be.mjs","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { unwrapOk } from './result-unwrap-ok.mjs';\nimport { type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the success value or throwing an error with\n * the provided message.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok('data');\n *\n * assert.isTrue(Result.expectToBe(okValue, 'should have value') === 'data');\n *\n * const expectResult = Result.expectToBe('missing result');\n *\n * const throwTest = (): void => {\n *   expectResult(Result.err('boom'));\n * };\n *\n * assert.throws(throwTest, /missing result/u);\n *\n * assert.isTrue(expectResult(Result.ok('value')) === 'value');\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @param result The `Result` to unwrap.\n * @param message The error message to throw if the `Result` is `Result.Err`.\n * @returns The success value if `Result.Ok`.\n * @throws Error with the provided message if the `Result` is `Result.Err`.\n */\nexport function expectToBe<R extends UnknownResult>(\n  result: R,\n  message: string,\n): UnwrapOk<R>;\n\n// Curried version\nexport function expectToBe(\n  message: string,\n): <R extends UnknownResult>(result: R) => UnwrapOk<R>;\n\nexport function expectToBe<R extends UnknownResult>(\n  ...args: readonly [result: R, message: string] | readonly [message: string]\n): UnwrapOk<R> | ((result: R) => UnwrapOk<R>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, message] = args;\n\n      return expectToBeImpl(result, message);\n    }\n\n    case 1: {\n      // Curried version: first argument is message\n      const [message] = args;\n\n      return (result: R): UnwrapOk<R> => expectToBeImpl(result, message);\n    }\n  }\n}\n\nconst expectToBeImpl = <R extends UnknownResult>(\n  result: R,\n  message: string,\n): UnwrapOk<R> => {\n  if (isOk(result)) {\n    return unwrapOk(result);\n  }\n\n  throw new Error(message);\n};\n"],"names":[],"mappings":";;;AA2CO,SAAS,cACX,IAAA,EACyC;AAC5C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,OAAO,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,cAAA,CAAe,QAAQ,OAAO,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,IAAA;AAElB,MAAA,OAAO,CAAC,MAAA,KAA2B,cAAA,CAAe,MAAA,EAAQ,OAAO,CAAA;AAAA,IACnE;AAAA;AAEJ;AAEA,MAAM,cAAA,GAAiB,CACrB,MAAA,EACA,OAAA,KACgB;AAChB,EAAA,IAAI,IAAA,CAAK,MAAM,CAAA,EAAG;AAChB,IAAA,OAAO,SAAS,MAAM,CAAA;AAAA,EACxB;AAEA,EAAA,MAAM,IAAI,MAAM,OAAO,CAAA;AACzB,CAAA;;;;"}

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

@@ -1,24 +1,24 @@
 import { isErr } from './result-is-err.mjs';
 
 function flatMap(...args) {
-    switch (args.length) {
-        case 2: {
-            // Direct version: first argument is result
-            const [result, flatMapFn] = args;
-            return flatMapImpl(result, flatMapFn);
-        }
-        case 1: {
-            // Curried version
-            const [flatMapFn] = args;
-            return (result) => flatMapImpl(result, flatMapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [result, flatMapFn] = args;
+      return flatMapImpl(result, flatMapFn);
     }
+    case 1: {
+      const [flatMapFn] = args;
+      return (result) => flatMapImpl(result, flatMapFn);
+    }
+  }
 }
-const flatMapImpl = (result, flatMapFn) => isErr(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        result
-    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        flatMapFn(result.value);
+const flatMapImpl = (result, flatMapFn) => isErr(result) ? (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  result
+) : (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  flatMapFn(result.value)
+);
 
 export { flatMap };
 //# sourceMappingURL=result-flat-map.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-flat-map.mjs","sources":["../../../../src/functional/result/impl/result-flat-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAuDM,SAAU,OAAO,CACrB,GAAG,IAE6D,EAAA;AAIhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI;AAEhC,YAAA,OAAO,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC;QACvC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,MAAS,KAAK,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC;QACtD;;AAEJ;AAEA,MAAM,WAAW,GAAG,CAClB,MAAS,EACT,SAAiD,KAEjD,KAAK,CAAC,MAAM;AACV;QACG;AACH;AACE,QAAA,SAAS,CAAC,MAAM,CAAC,KAAoB,CAAC;;;;"}
+{"version":3,"file":"result-flat-map.mjs","sources":["../../../../src/functional/result/impl/result-flat-map.mts"],"sourcesContent":["import { type Err } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Applies a function that returns a `Result` to the success value of a\n * `Result`. If the input is `Err`, returns the original `Err`. This is the\n * monadic bind operation for `Result`.\n *\n * @example\n *\n * ```ts\n * const parseNumber = (input: string): Result<number, string> => {\n *   const num = Num.safeParseInt(input);\n *\n *   return Result.mapErr(num, () => 'not a number');\n * };\n *\n * const parsed = Result.flatMap(Result.ok('42'), parseNumber);\n *\n * const failure = Result.flatMap(Result.ok('abc'), parseNumber);\n *\n * const passthrough = Result.flatMap(Result.err('fail'), parseNumber);\n *\n * assert.deepStrictEqual(parsed, Result.ok(42));\n *\n * assert.deepStrictEqual(failure, Result.err('not a number'));\n *\n * assert.deepStrictEqual(passthrough, Result.err('fail'));\n *\n * const parseThenDouble = Result.flatMap((input: string) =>\n *   Result.map(parseNumber(input), (value) => value * 2),\n * );\n *\n * assert.deepStrictEqual(parseThenDouble(Result.ok('10')), Result.ok(20));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The success type of the `Result` returned by the function.\n * @template E2 The error type of the `Result` returned by the function.\n * @param result The `Result` to flat map.\n * @param flatMapFn The function to apply that returns a `Result`.\n * @returns The result of applying the function, or the original `Err`.\n */\nexport function flatMap<R extends UnknownResult, S2, E2>(\n  result: R,\n  flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>,\n): Result<S2, E2 | UnwrapErr<R>>;\n\n// Curried version\nexport function flatMap<S, S2, E2>(\n  flatMapFn: (value: S) => Result<S2, E2>,\n): <E>(result: Result<S, E>) => Result<S2, E | E2>;\n\nexport function flatMap<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [result: R, flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>]\n    | readonly [flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>]\n):\n  | Result<S2, E2 | UnwrapErr<R>>\n  | ((result: R) => Result<S2, UnwrapErr<R> | E2>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, flatMapFn] = args;\n\n      return flatMapImpl(result, flatMapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [flatMapFn] = args;\n\n      return (result: R) => flatMapImpl(result, flatMapFn);\n    }\n  }\n}\n\nconst flatMapImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>,\n): Result<S2, E2 | UnwrapErr<R>> =>\n  isErr(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (result as Err<UnwrapErr<R>>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      flatMapFn(result.value as UnwrapOk<R>);\n"],"names":[],"mappings":";;AAuDO,SAAS,WACX,IAAA,EAK8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,SAAS,CAAA,GAAI,IAAA;AAE5B,MAAA,OAAO,WAAA,CAAY,QAAQ,SAAS,CAAA;AAAA,IACtC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,MAAA,KAAc,WAAA,CAAY,MAAA,EAAQ,SAAS,CAAA;AAAA,IACrD;AAAA;AAEJ;AAEA,MAAM,WAAA,GAAc,CAClB,MAAA,EACA,SAAA,KAEA,MAAM,MAAM,CAAA;AAAA;AAAA,EAEP;AAAA;AAAA;AAAA,EAED,SAAA,CAAU,OAAO,KAAoB;AAAA,CAAA;;;;"}