ts-data-forge 14.6.1 → 14.6.2

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

@@ -1,7 +1,28 @@
 import { none } from './optional-none.mjs';
 import { some } from './optional-some.mjs';
-
-const fromNullable = (value) => value == null ? none : some(value);
-
-export { fromNullable };
-//# sourceMappingURL=optional-from-nullable.mjs.map
+/**
+ * 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`.
+ */
+export const fromNullable = (value) => (value == null ? none : some(value));
+//# 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":["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;;;;"}
+{"version":3,"file":"optional-from-nullable.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-from-nullable.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,KAA2B,EACD,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC"}

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

@@ -1,6 +1,22 @@
 import { NoneTypeTagName } from './tag.mjs';
-
-const isNone = (optional) => optional.$$tag === NoneTypeTagName;
-
-export { isNone };
-//# sourceMappingURL=optional-is-none.mjs.map
+/**
+ * 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.
+ */
+export const isNone = (optional) => optional.$$tag === NoneTypeTagName;
+//# sourceMappingURL=optional-is-none.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-is-none.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-none.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CACpB,QAAW,EACkB,EAAE,CAAC,QAAQ,CAAC,KAAK,KAAK,eAAe,CAAC"}

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

@@ -1,8 +1,26 @@
-import { hasKey } from '../../../guard/has-key.mjs';
-import { isRecord } from '../../../guard/is-record.mjs';
-import { SomeTypeTagName, NoneTypeTagName } from './tag.mjs';
-
-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
+import { hasKey, isRecord } from '../../../guard/index.mjs';
+import { NoneTypeTagName, SomeTypeTagName } 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`.
+ */
+export const isOptional = (maybeOptional) => isRecord(maybeOptional) &&
+    hasKey(maybeOptional, '$$tag') &&
+    ((maybeOptional.$$tag === SomeTypeTagName &&
+        hasKey(maybeOptional, 'value')) ||
+        maybeOptional.$$tag === NoneTypeTagName);
+//# 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":["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;;;;"}
+{"version":3,"file":"optional-is-optional.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE7D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,aAAsB,EACc,EAAE,CACtC,QAAQ,CAAC,aAAa,CAAC;IACvB,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC;IAC9B,CAAC,CAAC,aAAa,CAAC,KAAK,KAAK,eAAe;QACvC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QAC/B,aAAa,CAAC,KAAK,KAAK,eAAe,CAAC,CAAC"}

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

@@ -1,6 +1,23 @@
 import { SomeTypeTagName } from './tag.mjs';
-
-const isSome = (optional) => optional.$$tag === SomeTypeTagName;
-
-export { isSome };
-//# sourceMappingURL=optional-is-some.mjs.map
+/**
+ * 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.
+ */
+export const isSome = (optional) => optional.$$tag === SomeTypeTagName;
+//# sourceMappingURL=optional-is-some.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-is-some.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-is-some.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CACpB,QAAW,EACkB,EAAE,CAAC,QAAQ,CAAC,KAAK,KAAK,eAAe,CAAC"}

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

@@ -2,23 +2,21 @@ import { isSome } from './optional-is-some.mjs';
 import { none } from './optional-none.mjs';
 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);
+export 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);
+        }
     }
-    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;
-
-export { map };
-//# sourceMappingURL=optional-map.mjs.map
+const mapImpl = (optional, mapFn) => isSome(optional)
+    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        some(mapFn(unwrap(optional)))
+    : none;
+//# 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":["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\n//\n// The returned function is generic over the *whole* optional, mirroring the\n// direct overload above, rather than fixing its parameter to `Optional<S>`.\n// Fixing it makes the curried form unusable from a caller that is itself\n// generic over the optional: with `S` bound to `Unwrap<O>` at currying time\n// the parameter becomes `Optional<Unwrap<O>>`, and TypeScript cannot show a\n// bare `O extends UnknownOptional` is assignable to that — although every\n// concrete instantiation of `O` is.\n//\n// The conditional is what keeps the check: `O` is inferred from the argument\n// and its value type still has to satisfy `S`, so mapping a `(s: string) =>\n// …` over an `Optional<number>` stays an error. The cost is the message it\n// produces — \"not assignable to `never`\" rather than naming the two optionals.\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): <O extends UnknownOptional>(\n  optional: Unwrap<O> extends S ? O : never,\n) => 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":";;;;;AA6DO,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;;;;"}
+{"version":3,"file":"optional-map.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAyD/C,MAAM,UAAU,GAAG,CACjB,GAAG,IAE2C;IAE9C,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE/B,OAAO,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,sDAAsD;YACtD,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,QAAW,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,OAAO,GAAG,CACd,QAAW,EACX,KAA+B,EACjB,EAAE,CAChB,MAAM,CAAC,QAAQ,CAAC;IACd,CAAC,CAAC,oEAAoE;QACpE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,CAAC;IAChC,CAAC,CAAC,IAAI,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"optional-match.mjs","sources":["../../../../src/functional/optional/impl/optional-match.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 * Folds an {@link Optional} into a plain value by applying one of two case\n * handlers: `some` if the {@link Optional} contains a value, `none`\n * otherwise. This is the function form of pattern matching on an\n * {@link Optional}.\n *\n * Unlike {@link Optional.map}, the result is not wrapped in an\n * {@link Optional} — both branches produce the final value directly.\n *\n * @example\n *\n * ```ts\n * const doubledOrZero = Optional.match(Optional.some(21), {\n *   some: (value) => value * 2,\n *   none: () => 0,\n * });\n *\n * assert.deepStrictEqual(doubledOrZero, 42);\n *\n * const matcher = Optional.match({\n *   some: (value: number) => `value: ${value}`,\n *   none: () => 'none',\n * });\n *\n * assert.deepStrictEqual(matcher(Optional.some(3)), 'value: 3');\n *\n * assert.deepStrictEqual(matcher(Optional.none), 'none');\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template S2 The type returned by the `some` case.\n * @template N2 The type returned by the `none` case.\n * @param optional The `Optional` to match on.\n * @param cases An object with a `some` handler receiving the contained value\n *   and a `none` handler receiving nothing.\n * @returns The value produced by whichever case handler was applied.\n */\nexport function match<O extends UnknownOptional, S2, N2>(\n  optional: O,\n  cases: Readonly<{\n    some: (value: Unwrap<O>) => S2;\n    none: () => N2;\n  }>,\n): N2 | S2;\n\n// Curried version\n//\n// The returned function is generic over the *whole* optional, mirroring the\n// direct overload above; see the comment on the curried overload of\n// `Optional.map` for why the parameter is a conditional type instead of a\n// plain `Optional<S>`.\nexport function match<S, S2, N2>(\n  cases: Readonly<{\n    some: (value: S) => S2;\n    none: () => N2;\n  }>,\n): <O extends UnknownOptional>(\n  optional: Unwrap<O> extends S ? O : never,\n) => N2 | S2;\n\nexport function match<O extends UnknownOptional, S2, N2>(\n  ...args:\n    | readonly [\n        optional: O,\n        cases: Readonly<{\n          some: (value: Unwrap<O>) => S2;\n          none: () => N2;\n        }>,\n      ]\n    | readonly [\n        cases: Readonly<{\n          some: (value: Unwrap<O>) => S2;\n          none: () => N2;\n        }>,\n      ]\n): N2 | S2 | ((optional: O) => N2 | S2) {\n  switch (args.length) {\n    case 2: {\n      const [optional, cases] = args;\n\n      return matchImpl(optional, cases);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the case handlers\n      const [cases] = args;\n\n      return (optional: O) => matchImpl(optional, cases);\n    }\n  }\n}\n\nconst matchImpl = <O extends UnknownOptional, S2, N2>(\n  optional: O,\n  cases: Readonly<{\n    some: (value: Unwrap<O>) => S2;\n    none: () => N2;\n  }>,\n): N2 | S2 =>\n  isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      cases.some(unwrap(optional)!)\n    : cases.none();\n"],"names":[],"mappings":";;;AAiEO,SAAS,SACX,IAAA,EAcmC;AACtC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,SAAA,CAAU,UAAU,KAAK,CAAA;AAAA,IAClC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,SAAA,CAAU,QAAA,EAAU,KAAK,CAAA;AAAA,IACnD;AAAA;AAEJ;AAEA,MAAM,SAAA,GAAY,CAChB,QAAA,EACA,KAAA,KAKA,OAAO,QAAQ,CAAA;AAAA;AAAA,EAEX,KAAA,CAAM,IAAA,CAAK,MAAA,CAAO,QAAQ,CAAE;AAAA,IAC5B,MAAM,IAAA,EAAK;;;;"}
+{"version":3,"file":"optional-match.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-match.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA+D/C,MAAM,UAAU,KAAK,CACnB,GAAG,IAaE;IAEL,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE/B,OAAO,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACpC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,0DAA0D;YAC1D,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,QAAW,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,SAAS,GAAG,CAChB,QAAW,EACX,KAGE,EACO,EAAE,CACX,MAAM,CAAC,QAAQ,CAAC;IACd,CAAC,CAAC,oEAAoE;QACpE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC;IAC/B,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC"}

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

@@ -1,6 +1,19 @@
 import { NoneTypeTagName } from './tag.mjs';
-
-const none = { $$tag: NoneTypeTagName };
-
-export { none };
-//# sourceMappingURL=optional-none.mjs.map
+/**
+ * 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));
+ * ```
+ */
+export const none = { $$tag: NoneTypeTagName };
+//# sourceMappingURL=optional-none.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-none.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-none.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,IAAI,GAAS,EAAE,KAAK,EAAE,eAAe,EAAW,CAAC"}

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

@@ -1,18 +1,16 @@
 import { isNone } from './optional-is-none.mjs';
-
-function orElse(...args) {
-  switch (args.length) {
-    case 2: {
-      const [optional, alternative] = args;
-      return orElseImpl(optional, alternative);
+export 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);
+        }
     }
-    case 1: {
-      const [alternative] = args;
-      return (optional) => orElseImpl(optional, alternative);
-    }
-  }
 }
-const orElseImpl = (optional, alternative) => isNone(optional) ? alternative : optional;
-
-export { orElse };
-//# sourceMappingURL=optional-or-else.mjs.map
+const orElseImpl = (optional, alternative) => (isNone(optional) ? alternative : optional);
+//# 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":["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;;;;"}
+{"version":3,"file":"optional-or-else.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-or-else.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAoDhD,MAAM,UAAU,MAAM,CAIpB,GAAG,IAA0E;IAE7E,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC;YAErC,OAAO,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC3C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;YAE3B,OAAO,CAAC,QAA6B,EAAE,EAAE,CACvC,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,GAAG,CAIjB,QAAW,EACX,WAAe,EACP,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC"}

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

@@ -1,9 +1,25 @@
 import { SomeTypeTagName } from './tag.mjs';
-
-const some = (value) => ({
-  $$tag: SomeTypeTagName,
-  value
+/**
+ * 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.
+ */
+export const some = (value) => ({
+    $$tag: SomeTypeTagName,
+    value,
 });
-
-export { some };
-//# sourceMappingURL=optional-some.mjs.map
+//# sourceMappingURL=optional-some.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-some.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-some.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAW,KAAQ,EAAW,EAAE,CAClD,CAAC;IACC,KAAK,EAAE,eAAe;IACtB,KAAK;CACN,CAAU,CAAC"}

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

@@ -1,7 +1,30 @@
 import { isSome } from './optional-is-some.mjs';
 import { unwrap } from './optional-unwrap.mjs';
-
-const toNullable = (optional) => isSome(optional) ? unwrap(optional) : void 0;
-
-export { toNullable };
-//# sourceMappingURL=optional-to-nullable.mjs.map
+/**
+ * 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`.
+ */
+export const toNullable = (optional) => (isSome(optional) ? unwrap(optional) : undefined);
+//# 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":["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;;;;"}
+{"version":3,"file":"optional-to-nullable.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-to-nullable.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,QAAW,EACY,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC"}

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

@@ -1,18 +1,16 @@
 import { unwrap } from './optional-unwrap.mjs';
-
-function unwrapOr(...args) {
-  switch (args.length) {
-    case 2: {
-      const [optional, defaultValue] = args;
-      return unwrapOrImpl(optional, defaultValue);
+export 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);
+        }
     }
-    case 1: {
-      const [defaultValue] = args;
-      return (optional) => unwrapOrImpl(optional, defaultValue);
-    }
-  }
 }
 const unwrapOrImpl = (optional, defaultValue) => unwrap(optional) ?? defaultValue;
-
-export { unwrapOr };
-//# sourceMappingURL=optional-unwrap-or.mjs.map
+//# sourceMappingURL=optional-unwrap-or.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-unwrap-or.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap-or.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA6C/C,MAAM,UAAU,QAAQ,CACtB,GAAG,IAA0E;IAE7E,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,GAAG,IAAI,CAAC;YAEtC,OAAO,YAAY,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC9C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,mDAAmD;YACnD,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;YAE5B,OAAO,CAAC,QAA6B,EAAE,EAAE,CACvC,YAAY,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG,CACnB,QAAW,EACX,YAAe,EACA,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,YAAY,CAAC"}

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

@@ -1,11 +1,36 @@
 import { isSome } from './optional-is-some.mjs';
-
-const unwrapThrow = (optional) => {
-  if (isSome(optional)) {
-    return optional.value;
-  }
-  throw new Error("`unwrapThrow()` has failed because it is `None`");
+/**
+ * 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`.
+ */
+export 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`');
 };
-
-export { unwrapThrow };
-//# sourceMappingURL=optional-unwrap-throw.mjs.map
+//# sourceMappingURL=optional-unwrap-throw.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-unwrap-throw.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap-throw.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,QAAW,EACA,EAAE;IACb,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACrB,oEAAoE;QACpE,OAAO,QAAQ,CAAC,KAAkB,CAAC;IACrC,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;AACrE,CAAC,CAAC"}

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

@@ -1,11 +1,8 @@
 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
-  ) : void 0;
+export function unwrap(optional) {
+    return isSome(optional)
+        ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            optional.value
+        : undefined;
 }
-
-export { unwrap };
-//# sourceMappingURL=optional-unwrap.mjs.map
+//# sourceMappingURL=optional-unwrap.mjs.map

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":["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;;;;"}
+{"version":3,"file":"optional-unwrap.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAmChD,MAAM,UAAU,MAAM,CACpB,QAAW;IAEX,OAAO,MAAM,CAAC,QAAQ,CAAC;QACrB,CAAC,CAAC,oEAAoE;YACnE,QAAQ,CAAC,KAAmB;QAC/B,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC"}

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

@@ -1,8 +1,39 @@
 import { isSome } from './optional-is-some.mjs';
 import { none } from './optional-none.mjs';
 import { some } from './optional-some.mjs';
-
-const zip = (optionalA, optionalB) => isSome(optionalA) && isSome(optionalB) ? some([optionalA.value, optionalB.value]) : none;
-
-export { zip };
-//# sourceMappingURL=optional-zip.mjs.map
+/**
+ * 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`.
+ */
+export const zip = (optionalA, optionalB) => isSome(optionalA) && isSome(optionalB)
+    ? some([optionalA.value, optionalB.value])
+    : none;
+//# sourceMappingURL=optional-zip.mjs.map