ts-data-forge 14.6.1 → 14.6.2

package/dist/functional/async-result/impl/async-result-from-promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async-result-from-promise.mjs","sources":["../../../../src/functional/async-result/impl/async-result-from-promise.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Converts a `Promise` into an `AsyncResult`. If the input Promise resolves,\n * the `AsyncResult` resolves to `Ok` with the resolved value. If the input\n * Promise rejects, the rejection reason is passed through `mapError` and the\n * `AsyncResult` resolves to `Err` with the mapped error.\n *\n * Passing `mapError` is what gives the error channel a concrete type `E`.\n * Omitting it carries the rejection reason through untouched, leaving the\n * error channel as `unknown` — the same contract as `Result.fromPromise`.\n *\n * @example\n *\n * ```ts\n * const resolved = await AsyncResult.fromPromise(\n *   Promise.resolve('ok'),\n *   (error) => `failed: ${String(error)}`,\n * );\n *\n * const rejected = await AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n *   (error) => (isError(error) ? error.message : 'unknown'),\n * );\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.deepStrictEqual(rejected, Result.err('boom'));\n *\n * // Without `mapError`, the rejection reason is carried as-is.\n * const untyped = await AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n * );\n *\n * assert.isTrue(Result.isErr(untyped));\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value.\n * @param promise The Promise to convert.\n * @param mapError The function applied to the rejection reason to produce the\n *   error value. Omit it to carry the rejection reason as `unknown`.\n * @returns An `AsyncResult<S, E>` that never rejects for the input Promise's\n *   failure.\n */\nexport function fromPromise<S>(promise: Promise<S>): AsyncResult<S, unknown>;\n\nexport function fromPromise<S, E>(\n  promise: Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E>;\n\nexport function fromPromise<S, E>(\n  promise: Promise<S>,\n  mapError?: (error: unknown) => E,\n): AsyncResult<S, E> | AsyncResult<S, unknown> {\n  return mapError === undefined\n    ? fromPromiseImpl(promise, (error: unknown) => error)\n    : fromPromiseImpl(promise, mapError);\n}\n\nconst fromPromiseImpl = <S, E>(\n  promise: Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E> =>\n  promise\n    .then((value) => Result.ok(value))\n    .catch((error: unknown) => Result.err(mapError(error)));\n"],"names":["Result.ok","Result.err"],"mappings":";;;;AAqDO,SAAS,WAAA,CACd,SACA,QAAA,EAC6C;AAC7C,EAAA,OAAO,QAAA,KAAa,MAAA,GAChB,eAAA,CAAgB,OAAA,EAAS,CAAC,UAAmB,KAAK,CAAA,GAClD,eAAA,CAAgB,OAAA,EAAS,QAAQ,CAAA;AACvC;AAEA,MAAM,eAAA,GAAkB,CACtB,OAAA,EACA,QAAA,KAEA,QACG,IAAA,CAAK,CAAC,UAAUA,EAAO,CAAG,KAAK,CAAC,CAAA,CAChC,MAAM,CAAC,KAAA,KAAmBC,GAAO,CAAI,QAAA,CAAS,KAAK,CAAC,CAAC,CAAA;;;;"}
+{"version":3,"file":"async-result-from-promise.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-from-promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAqDhD,MAAM,UAAU,WAAW,CACzB,OAAmB,EACnB,QAAgC;IAEhC,OAAO,QAAQ,KAAK,SAAS;QAC3B,CAAC,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,KAAK,CAAC;QACrD,CAAC,CAAC,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;AACzC,CAAC;AAED,MAAM,eAAe,GAAG,CACtB,OAAmB,EACnB,QAA+B,EACZ,EAAE,CACrB,OAAO;KACJ,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;KACjC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-from-throwable.mjs

@@ -1,17 +1,15 @@
-import { err } from '../../result/impl/result-err.mjs';
-import { ok } from '../../result/impl/result-ok.mjs';
-import '@sindresorhus/is';
-
-function fromThrowable(fn, mapError) {
-  return mapError === void 0 ? fromThrowableImpl(fn, (error) => error) : fromThrowableImpl(fn, mapError);
+import { Result } from '../../result/index.mjs';
+export function fromThrowable(fn, mapError) {
+    return mapError === undefined
+        ? fromThrowableImpl(fn, (error) => error)
+        : fromThrowableImpl(fn, mapError);
 }
 const fromThrowableImpl = async (fn, mapError) => {
-  try {
-    return ok(await fn());
-  } catch (error) {
-    return err(mapError(error));
-  }
+    try {
+        return Result.ok(await fn());
+    }
+    catch (error) {
+        return Result.err(mapError(error));
+    }
 };
-
-export { fromThrowable };
-//# sourceMappingURL=async-result-from-throwable.mjs.map
+//# sourceMappingURL=async-result-from-throwable.mjs.map

package/dist/functional/async-result/impl/async-result-from-throwable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async-result-from-throwable.mjs","sources":["../../../../src/functional/async-result/impl/async-result-from-throwable.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Wraps a function returning a `Promise` in an `AsyncResult`. Both a\n * synchronous `throw` while calling `fn` and an asynchronous rejection of the\n * returned Promise are caught, passed through `mapError`, and carried as\n * `Err`.\n *\n * Passing `mapError` is what gives the error channel a concrete type `E`.\n * Omitting it carries the thrown value through untouched, leaving the error\n * channel as `unknown`.\n *\n * @example\n *\n * ```ts\n * const success = await AsyncResult.fromThrowable(\n *   () => Promise.resolve(2),\n *   (error) => `failed: ${String(error)}`,\n * );\n *\n * const failure = await AsyncResult.fromThrowable(\n *   (): Promise<number> => {\n *     throw new Error('boom');\n *   },\n *   (error) => (isError(error) ? error.message : 'unknown'),\n * );\n *\n * assert.deepStrictEqual(success, Result.ok(2));\n *\n * assert.deepStrictEqual(failure, Result.err('boom'));\n *\n * // Without `mapError`, the thrown value is carried as-is.\n * const untyped = await AsyncResult.fromThrowable(\n *   (): Promise<number> => {\n *     throw new Error('boom');\n *   },\n * );\n *\n * assert.isTrue(Result.isErr(untyped));\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value.\n * @param fn The function to execute; it may throw synchronously or return a\n *   rejecting Promise.\n * @param mapError The function applied to the thrown value or rejection\n *   reason to produce the error value. Omit it to carry the thrown value as\n *   `unknown`.\n * @returns An `AsyncResult<S, E>` containing either the resolved value or the\n *   mapped error.\n */\nexport function fromThrowable<S>(fn: () => Promise<S>): AsyncResult<S, unknown>;\n\nexport function fromThrowable<S, E>(\n  fn: () => Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E>;\n\nexport function fromThrowable<S, E>(\n  fn: () => Promise<S>,\n  mapError?: (error: unknown) => E,\n): AsyncResult<S, E> | AsyncResult<S, unknown> {\n  return mapError === undefined\n    ? fromThrowableImpl(fn, (error: unknown) => error)\n    : fromThrowableImpl(fn, mapError);\n}\n\nconst fromThrowableImpl = async <S, E>(\n  fn: () => Promise<S>,\n  mapError: (error: unknown) => E,\n): AsyncResult<S, E> => {\n  try {\n    return Result.ok(await fn());\n  } catch (error) {\n    return Result.err(mapError(error));\n  }\n};\n"],"names":["Result.ok","Result.err"],"mappings":";;;;AA2DO,SAAS,aAAA,CACd,IACA,QAAA,EAC6C;AAC7C,EAAA,OAAO,QAAA,KAAa,MAAA,GAChB,iBAAA,CAAkB,EAAA,EAAI,CAAC,UAAmB,KAAK,CAAA,GAC/C,iBAAA,CAAkB,EAAA,EAAI,QAAQ,CAAA;AACpC;AAEA,MAAM,iBAAA,GAAoB,OACxB,EAAA,EACA,QAAA,KACsB;AACtB,EAAA,IAAI;AACF,IAAA,OAAOA,EAAO,CAAG,MAAM,EAAA,EAAI,CAAA;AAAA,EAC7B,SAAS,KAAA,EAAO;AACd,IAAA,OAAOC,GAAO,CAAI,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,EACnC;AACF,CAAA;;;;"}
+{"version":3,"file":"async-result-from-throwable.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-from-throwable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA2DhD,MAAM,UAAU,aAAa,CAC3B,EAAoB,EACpB,QAAgC;IAEhC,OAAO,QAAQ,KAAK,SAAS;QAC3B,CAAC,CAAC,iBAAiB,CAAC,EAAE,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,KAAK,CAAC;QAClD,CAAC,CAAC,iBAAiB,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,iBAAiB,GAAG,KAAK,EAC7B,EAAoB,EACpB,QAA+B,EACZ,EAAE;IACrB,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IACrC,CAAC;AACH,CAAC,CAAC"}

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

@@ -1,23 +1,20 @@
-import { err } from '../../result/impl/result-err.mjs';
-import { isOk } from '../../result/impl/result-is-ok.mjs';
-import '@sindresorhus/is';
-
-function mapErr(...args) {
-  switch (args.length) {
-    case 2: {
-      const [asyncResult, mapFn] = args;
-      return mapErrImpl(asyncResult, mapFn);
+import { Result } from '../../result/index.mjs';
+export function mapErr(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is asyncResult
+            const [asyncResult, mapFn] = args;
+            return mapErrImpl(asyncResult, mapFn);
+        }
+        case 1: {
+            // Curried version: first argument is mapping function
+            const [mapFn] = args;
+            return (asyncResult) => mapErrImpl(asyncResult, mapFn);
+        }
     }
-    case 1: {
-      const [mapFn] = args;
-      return (asyncResult) => mapErrImpl(asyncResult, mapFn);
-    }
-  }
 }
 const mapErrImpl = async (asyncResult, mapFn) => {
-  const result = await asyncResult;
-  return isOk(result) ? result : err(await mapFn(result.value));
+    const result = await asyncResult;
+    return Result.isOk(result) ? result : Result.err(await mapFn(result.value));
 };
-
-export { mapErr };
-//# sourceMappingURL=async-result-map-err.mjs.map
+//# sourceMappingURL=async-result-map-err.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"async-result-map-err.mjs","sources":["../../../../src/functional/async-result/impl/async-result-map-err.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Maps an `AsyncResult<S, E>` to `AsyncResult<S, E2>` by applying a function\n * to the error value. The mapping function may be synchronous or return a\n * `Promise`; both are handled transparently. If the `AsyncResult` resolves to\n * `Ok`, the original `Ok` is passed through and the function is not called.\n *\n * If `mapFn` throws or returns a rejecting Promise, the rejection propagates\n * as-is — it is **not** caught and converted into an `Err`.\n *\n * @example\n *\n * ```ts\n * const errValue = AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n *   () => 'failure',\n * );\n *\n * const uppercased = await AsyncResult.mapErr(errValue, (error) =>\n *   error.toUpperCase(),\n * );\n *\n * assert.deepStrictEqual(uppercased, Result.err('FAILURE'));\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value of the input.\n * @template E2 The type of the error value returned by the mapping function.\n * @param asyncResult The `AsyncResult` to map.\n * @param mapFn The function to apply to the error value if present.\n * @returns A new `AsyncResult<S, E2>`.\n */\nexport function mapErr<S, E, E2>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (error: E) => E2 | Promise<E2>,\n): AsyncResult<S, E2>;\n\n// Curried version\n//\n// Unlike `Result.mapErr`, the returned function can simply be generic over\n// `S`: an `AsyncResult` is a `Promise`, not a discriminated union, so there\n// is no literal-narrowing problem that would require the whole-result\n// generic trick used by the synchronous combinators.\nexport function mapErr<E, E2>(\n  mapFn: (error: E) => E2 | Promise<E2>,\n): <S>(asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>;\n\nexport function mapErr<S, E, E2>(\n  ...args:\n    | readonly [\n        asyncResult: AsyncResult<S, E>,\n        mapFn: (error: E) => E2 | Promise<E2>,\n      ]\n    | readonly [mapFn: (error: E) => E2 | Promise<E2>]\n):\n  | AsyncResult<S, E2>\n  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is asyncResult\n      const [asyncResult, mapFn] = args;\n\n      return mapErrImpl(asyncResult, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (asyncResult: AsyncResult<S, E>) => mapErrImpl(asyncResult, mapFn);\n    }\n  }\n}\n\nconst mapErrImpl = async <S, E, E2>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (error: E) => E2 | Promise<E2>,\n): AsyncResult<S, E2> => {\n  const result = await asyncResult;\n\n  return Result.isOk(result) ? result : Result.err(await mapFn(result.value));\n};\n"],"names":["Result.isOk","Result.err"],"mappings":";;;;AAiDO,SAAS,UACX,IAAA,EAQwD;AAC3D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAA,EAAa,KAAK,CAAA,GAAI,IAAA;AAE7B,MAAA,OAAO,UAAA,CAAW,aAAa,KAAK,CAAA;AAAA,IACtC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,WAAA,KAAmC,UAAA,CAAW,WAAA,EAAa,KAAK,CAAA;AAAA,IAC1E;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,OACjB,WAAA,EACA,KAAA,KACuB;AACvB,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,IAAO,CAAK,MAAM,CAAA,GAAI,MAAA,GAASC,GAAO,CAAI,MAAM,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAA;AAC5E,CAAA;;;;"}
+{"version":3,"file":"async-result-map-err.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-map-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAiDhD,MAAM,UAAU,MAAM,CACpB,GAAG,IAKiD;IAIpD,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,gDAAgD;YAChD,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAElC,OAAO,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,sDAAsD;YACtD,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,WAA8B,EAAE,EAAE,CAAC,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAC5E,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,GAAG,KAAK,EACtB,WAA8B,EAC9B,KAAqC,EACjB,EAAE;IACtB,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;IAEjC,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9E,CAAC,CAAC"}

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

@@ -1,23 +1,20 @@
-import { isErr } from '../../result/impl/result-is-err.mjs';
-import { ok } from '../../result/impl/result-ok.mjs';
-import '@sindresorhus/is';
-
-function map(...args) {
-  switch (args.length) {
-    case 2: {
-      const [asyncResult, mapFn] = args;
-      return mapImpl(asyncResult, mapFn);
+import { Result } from '../../result/index.mjs';
+export function map(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is asyncResult
+            const [asyncResult, mapFn] = args;
+            return mapImpl(asyncResult, mapFn);
+        }
+        case 1: {
+            // Curried version
+            const [mapFn] = args;
+            return (asyncResult) => mapImpl(asyncResult, mapFn);
+        }
     }
-    case 1: {
-      const [mapFn] = args;
-      return (asyncResult) => mapImpl(asyncResult, mapFn);
-    }
-  }
 }
 const mapImpl = async (asyncResult, mapFn) => {
-  const result = await asyncResult;
-  return isErr(result) ? result : ok(await mapFn(result.value));
+    const result = await asyncResult;
+    return Result.isErr(result) ? result : Result.ok(await mapFn(result.value));
 };
-
-export { map };
-//# sourceMappingURL=async-result-map.mjs.map
+//# sourceMappingURL=async-result-map.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"async-result-map.mjs","sources":["../../../../src/functional/async-result/impl/async-result-map.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Maps an `AsyncResult<S, E>` to `AsyncResult<S2, E>` by applying a function\n * to the success value. The mapping function may be synchronous or return a\n * `Promise`; both are handled transparently. If the `AsyncResult` resolves to\n * `Err`, the original `Err` is passed through and the function is not called.\n *\n * If `mapFn` throws or returns a rejecting Promise, the rejection propagates\n * as-is — it is **not** caught and converted into an `Err`. `map` performs no\n * implicit error conversion; write a fallible step as\n * `AsyncResult.flatMap` combined with `AsyncResult.fromThrowable` instead, so\n * that the error type stays explicit.\n *\n * @example\n *\n * ```ts\n * const okValue = AsyncResult.fromPromise(\n *   Promise.resolve(5),\n *   () => 'failed',\n * );\n *\n * const doubled = await AsyncResult.map(okValue, (value) => value * 2);\n *\n * assert.deepStrictEqual(doubled, Result.ok(10));\n *\n * const double = AsyncResult.map((value: number) => value * 2);\n *\n * const curried = await double(\n *   AsyncResult.fromPromise(Promise.resolve(21), () => 'failed'),\n * );\n *\n * assert.deepStrictEqual(curried, Result.ok(42));\n * ```\n *\n * @template S The type of the success value of the input.\n * @template S2 The type of the success value returned by the mapping\n *   function.\n * @template E The type of the error value.\n * @param asyncResult The `AsyncResult` to map.\n * @param mapFn The function to apply to the success value if present.\n * @returns A new `AsyncResult<S2, E>`.\n */\nexport function map<S, S2, E>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (value: S) => Promise<S2> | S2,\n): AsyncResult<S2, E>;\n\n// Curried version\n//\n// Unlike `Result.map`, the returned function can simply be generic over `E`:\n// an `AsyncResult` is a `Promise`, not a discriminated union, so there is no\n// literal-narrowing problem that would require the whole-result generic\n// trick used by the synchronous combinators.\nexport function map<S, S2>(\n  mapFn: (value: S) => Promise<S2> | S2,\n): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>;\n\nexport function map<S, S2, E>(\n  ...args:\n    | readonly [\n        asyncResult: AsyncResult<S, E>,\n        mapFn: (value: S) => Promise<S2> | S2,\n      ]\n    | readonly [mapFn: (value: S) => Promise<S2> | S2]\n):\n  | AsyncResult<S2, E>\n  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is asyncResult\n      const [asyncResult, mapFn] = args;\n\n      return mapImpl(asyncResult, mapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [mapFn] = args;\n\n      return (asyncResult: AsyncResult<S, E>) => mapImpl(asyncResult, mapFn);\n    }\n  }\n}\n\nconst mapImpl = async <S, S2, E>(\n  asyncResult: AsyncResult<S, E>,\n  mapFn: (value: S) => Promise<S2> | S2,\n): AsyncResult<S2, E> => {\n  const result = await asyncResult;\n\n  return Result.isErr(result) ? result : Result.ok(await mapFn(result.value));\n};\n"],"names":["Result.isErr","Result.ok"],"mappings":";;;;AA2DO,SAAS,OACX,IAAA,EAQwD;AAC3D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAA,EAAa,KAAK,CAAA,GAAI,IAAA;AAE7B,MAAA,OAAO,OAAA,CAAQ,aAAa,KAAK,CAAA;AAAA,IACnC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,WAAA,KAAmC,OAAA,CAAQ,WAAA,EAAa,KAAK,CAAA;AAAA,IACvE;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,OACd,WAAA,EACA,KAAA,KACuB;AACvB,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,KAAO,CAAM,MAAM,CAAA,GAAI,MAAA,GAASC,EAAO,CAAG,MAAM,KAAA,CAAM,MAAA,CAAO,KAAK,CAAC,CAAA;AAC5E,CAAA;;;;"}
+{"version":3,"file":"async-result-map.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA2DhD,MAAM,UAAU,GAAG,CACjB,GAAG,IAKiD;IAIpD,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,gDAAgD;YAChD,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAElC,OAAO,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QACrC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,WAA8B,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,OAAO,GAAG,KAAK,EACnB,WAA8B,EAC9B,KAAqC,EACjB,EAAE;IACtB,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;IAEjC,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9E,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-unwrap-or.mjs

@@ -1,10 +1,37 @@
-import { isOk } from '../../result/impl/result-is-ok.mjs';
-import '@sindresorhus/is';
-
-const unwrapOr = async (asyncResult, defaultValue) => {
-  const result = await asyncResult;
-  return isOk(result) ? result.value : defaultValue;
+import { Result } from '../../result/index.mjs';
+/**
+ * Unwraps an `AsyncResult`, resolving to the success value or a default value
+ * if it resolves to `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = AsyncResult.fromPromise(
+ *   Promise.resolve(10),
+ *   () => 'failed',
+ * );
+ *
+ * const errValue = AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   () => 'failed',
+ * );
+ *
+ * assert.isTrue((await AsyncResult.unwrapOr(okValue, 0)) === 10);
+ *
+ * assert.isTrue((await AsyncResult.unwrapOr(errValue, 0)) === 0);
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @template D The type of the default value.
+ * @param asyncResult The `AsyncResult` to unwrap.
+ * @param defaultValue The value to resolve to if `asyncResult` resolves to
+ *   `Err`.
+ * @returns A Promise of the success value if `Ok`, otherwise of
+ *   `defaultValue`.
+ */
+export const unwrapOr = async (asyncResult, defaultValue) => {
+    const result = await asyncResult;
+    return Result.isOk(result) ? result.value : defaultValue;
 };
-
-export { unwrapOr };
-//# sourceMappingURL=async-result-unwrap-or.mjs.map
+//# sourceMappingURL=async-result-unwrap-or.mjs.map

package/dist/functional/async-result/impl/async-result-unwrap-or.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async-result-unwrap-or.mjs","sources":["../../../../src/functional/async-result/impl/async-result-unwrap-or.mts"],"sourcesContent":["import { Result } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\n\n/**\n * Unwraps an `AsyncResult`, resolving to the success value or a default value\n * if it resolves to `Err`.\n *\n * @example\n *\n * ```ts\n * const okValue = AsyncResult.fromPromise(\n *   Promise.resolve(10),\n *   () => 'failed',\n * );\n *\n * const errValue = AsyncResult.fromPromise(\n *   Promise.reject(new Error('boom')),\n *   () => 'failed',\n * );\n *\n * assert.isTrue((await AsyncResult.unwrapOr(okValue, 0)) === 10);\n *\n * assert.isTrue((await AsyncResult.unwrapOr(errValue, 0)) === 0);\n * ```\n *\n * @template S The type of the success value.\n * @template E The type of the error value.\n * @template D The type of the default value.\n * @param asyncResult The `AsyncResult` to unwrap.\n * @param defaultValue The value to resolve to if `asyncResult` resolves to\n *   `Err`.\n * @returns A Promise of the success value if `Ok`, otherwise of\n *   `defaultValue`.\n */\nexport const unwrapOr = async <S, E, D>(\n  asyncResult: AsyncResult<S, E>,\n  defaultValue: D,\n): Promise<D | S> => {\n  const result = await asyncResult;\n\n  return Result.isOk(result) ? result.value : defaultValue;\n};\n"],"names":["Result.isOk"],"mappings":";;;AAkCO,MAAM,QAAA,GAAW,OACtB,WAAA,EACA,YAAA,KACmB;AACnB,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,IAAO,CAAK,MAAM,CAAA,GAAI,OAAO,KAAA,GAAQ,YAAA;AAC9C;;;;"}
+{"version":3,"file":"async-result-unwrap-or.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-unwrap-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,KAAK,EAC3B,WAA8B,EAC9B,YAAe,EACC,EAAE;IAClB,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;IAEjC,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC;AAC3D,CAAC,CAAC"}

package/dist/functional/async-result/impl/index.mjs

@@ -1,7 +1,8 @@
-export { flatMap } from './async-result-flat-map.mjs';
-export { fromPromise } from './async-result-from-promise.mjs';
-export { fromThrowable } from './async-result-from-throwable.mjs';
-export { mapErr } from './async-result-map-err.mjs';
-export { map } from './async-result-map.mjs';
-export { unwrapOr } from './async-result-unwrap-or.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './async-result-flat-map.mjs';
+export * from './async-result-from-promise.mjs';
+export * from './async-result-from-throwable.mjs';
+export * from './async-result-map-err.mjs';
+export * from './async-result-map.mjs';
+export * from './async-result-unwrap-or.mjs';
+export * from './types.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functional/async-result/impl/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC"}

package/dist/functional/async-result/impl/types.mjs

@@ -1,2 +1,2 @@
-
-//# sourceMappingURL=types.mjs.map
+export {};
+//# sourceMappingURL=types.mjs.map

package/dist/functional/async-result/impl/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/types.mts"],"names":[],"mappings":""}

package/dist/functional/async-result/index.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as AsyncResult };
-//# sourceMappingURL=index.mjs.map
+export * from './async-result.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functional/async-result/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/functional/async-result/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/functional/index.mjs

@@ -1,11 +1,7 @@
-import * as index from './async-result/impl/index.mjs';
-export { index as AsyncResult };
-export { match } from './match.mjs';
-import * as index$1 from './optional/impl/index.mjs';
-export { index$1 as Optional };
-export { pipe } from './pipe.mjs';
-import * as index$2 from './result/impl/index.mjs';
-export { index$2 as Result };
-import * as index$3 from './ternary-result/impl/index.mjs';
-export { index$3 as TernaryResult };
-//# sourceMappingURL=index.mjs.map
+export * from './async-result/index.mjs';
+export * from './match.mjs';
+export * from './optional/index.mjs';
+export * from './pipe.mjs';
+export * from './result/index.mjs';
+export * from './ternary-result/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functional/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}

package/dist/functional/match.mjs

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

package/dist/functional/match.mjs.map

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

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

@@ -1,18 +1,19 @@
-export { expectToBe } from './optional-expect-to-be.mjs';
-export { filter } from './optional-filter.mjs';
-export { flatMap } from './optional-flat-map.mjs';
-export { fromNullable } from './optional-from-nullable.mjs';
-export { isNone } from './optional-is-none.mjs';
-export { isOptional } from './optional-is-optional.mjs';
-export { isSome } from './optional-is-some.mjs';
-export { map } from './optional-map.mjs';
-export { match } from './optional-match.mjs';
-export { none } from './optional-none.mjs';
-export { orElse } from './optional-or-else.mjs';
-export { some } from './optional-some.mjs';
-export { toNullable } from './optional-to-nullable.mjs';
-export { unwrapOr } from './optional-unwrap-or.mjs';
-export { unwrapThrow } from './optional-unwrap-throw.mjs';
-export { unwrap } from './optional-unwrap.mjs';
-export { zip } from './optional-zip.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './optional-expect-to-be.mjs';
+export * from './optional-filter.mjs';
+export * from './optional-flat-map.mjs';
+export * from './optional-from-nullable.mjs';
+export * from './optional-is-none.mjs';
+export * from './optional-is-optional.mjs';
+export * from './optional-is-some.mjs';
+export * from './optional-map.mjs';
+export * from './optional-match.mjs';
+export * from './optional-none.mjs';
+export * from './optional-or-else.mjs';
+export * from './optional-some.mjs';
+export * from './optional-to-nullable.mjs';
+export * from './optional-unwrap-or.mjs';
+export * from './optional-unwrap-throw.mjs';
+export * from './optional-unwrap.mjs';
+export * from './optional-zip.mjs';
+export * from './types.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"optional-expect-to-be.mjs","sources":["../../../../src/functional/optional/impl/optional-expect-to-be.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Unwraps an `Optional`, returning the contained value or throwing an error\n * with the provided message.\n *\n * @example\n *\n * ```ts\n * const optionalValue = Optional.some('data');\n *\n * assert.isTrue(\n *   Optional.expectToBe(optionalValue, 'value expected') === 'data',\n * );\n *\n * const expectValue = Optional.expectToBe('missing optional');\n *\n * const throwTest = (): void => {\n *   expectValue(Optional.none);\n * };\n *\n * assert.throws(throwTest, /missing optional/u);\n *\n * assert.isTrue(expectValue(Optional.some('present')) === 'present');\n * ```\n *\n * @template O The `UnknownOptional` type to unwrap.\n * @param optional The `Optional` to unwrap.\n * @param message The error message to throw if the `Optional` is\n *   `None`.\n * @returns The contained value if `Some`.\n * @throws Error with the provided message if the `Optional` is\n *   `None`.\n */\nexport function expectToBe<O extends UnknownOptional>(\n  optional: O,\n  message: string,\n): Unwrap<O>;\n\n// Curried version\nexport function expectToBe(message: string): <O>(optional: Optional<O>) => O;\n\nexport function expectToBe<O extends UnknownOptional>(\n  ...args: readonly [optional: O, message: string] | readonly [message: string]\n): Unwrap<O> | ((optional: Optional<Unwrap<O>>) => Unwrap<O>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, message] = args;\n\n      return expectToBeImpl(optional, message);\n    }\n\n    case 1: {\n      // Curried version: first argument is message\n      const [message] = args;\n\n      return (optional: Optional<Unwrap<O>>): Unwrap<O> =>\n        expectToBeImpl(optional, message);\n    }\n  }\n}\n\nconst expectToBeImpl = <O extends UnknownOptional>(\n  optional: O,\n  message: string,\n): Unwrap<O> => {\n  if (isSome(optional)) {\n    return unwrap(optional);\n  }\n\n  throw new Error(message);\n};\n"],"names":[],"mappings":";;;AA6CO,SAAS,cACX,IAAA,EACyD;AAC5D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,OAAO,CAAA,GAAI,IAAA;AAE5B,MAAA,OAAO,cAAA,CAAe,UAAU,OAAO,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,IAAA;AAElB,MAAA,OAAO,CAAC,QAAA,KACN,cAAA,CAAe,QAAA,EAAU,OAAO,CAAA;AAAA,IACpC;AAAA;AAEJ;AAEA,MAAM,cAAA,GAAiB,CACrB,QAAA,EACA,OAAA,KACc;AACd,EAAA,IAAI,MAAA,CAAO,QAAQ,CAAA,EAAG;AACpB,IAAA,OAAO,OAAO,QAAQ,CAAA;AAAA,EACxB;AAEA,EAAA,MAAM,IAAI,MAAM,OAAO,CAAA;AACzB,CAAA;;;;"}
+{"version":3,"file":"optional-expect-to-be.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-expect-to-be.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA2C/C,MAAM,UAAU,UAAU,CACxB,GAAG,IAA0E;IAE7E,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;YAEjC,OAAO,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC3C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,6CAA6C;YAC7C,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;YAEvB,OAAO,CAAC,QAA6B,EAAa,EAAE,CAClD,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,cAAc,GAAG,CACrB,QAAW,EACX,OAAe,EACJ,EAAE;IACb,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACrB,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC1B,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC3B,CAAC,CAAC"}

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

@@ -2,26 +2,24 @@ 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 filter(...args) {
-  switch (args.length) {
-    case 2: {
-      const [optional, predicate] = args;
-      return filterImpl(optional, predicate);
+export function filter(...args) {
+    switch (args.length) {
+        case 2: {
+            const [optional, predicate] = args;
+            return filterImpl(optional, predicate);
+        }
+        case 1: {
+            // Curried version: first argument is predicate function
+            const [predicate] = args;
+            return (optional) => filterImpl(optional, predicate);
+        }
     }
-    case 1: {
-      const [predicate] = args;
-      return (optional) => filterImpl(optional, predicate);
-    }
-  }
 }
 const filterImpl = (optional, predicate) => {
-  if (isSome(optional)) {
-    const value = unwrap(optional);
-    return predicate(value) ? some(value) : none;
-  }
-  return none;
+    if (isSome(optional)) {
+        const value = unwrap(optional);
+        return predicate(value) ? some(value) : none;
+    }
+    return none;
 };
-
-export { filter };
-//# sourceMappingURL=optional-filter.mjs.map
+//# sourceMappingURL=optional-filter.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"optional-filter.mjs","sources":["../../../../src/functional/optional/impl/optional-filter.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Filters an `Optional` based on a predicate. If the `Optional` is `Some` and\n * the predicate returns true, returns the original `Optional`. Otherwise\n * returns `None`.\n *\n * @example\n *\n * ```ts\n * const even = Optional.filter(Optional.some(4), (value) => value % 2 === 0);\n *\n * const odd = Optional.filter(Optional.some(3), (value) => value % 2 === 0);\n *\n * assert.deepStrictEqual(even, Optional.some(4));\n *\n * assert.deepStrictEqual(odd, Optional.none);\n *\n * const filterEven = Optional.filter((value: number) => value % 2 === 0);\n *\n * assert.deepStrictEqual(filterEven(Optional.some(6)), Optional.some(6));\n *\n * assert.deepStrictEqual(filterEven(Optional.some(5)), Optional.none);\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @param optional The `Optional` to filter.\n * @param predicate The predicate function.\n * @returns The filtered `Optional`.\n */\nexport function filter<O extends UnknownOptional>(\n  optional: O,\n  predicate: (value: Unwrap<O>) => boolean,\n): Optional<Unwrap<O>>;\n\n// Curried version\nexport function filter<S>(\n  predicate: (value: S) => boolean,\n): (optional: Optional<S>) => Optional<S>;\n\nexport function filter<O extends UnknownOptional>(\n  ...args:\n    | readonly [optional: O, predicate: (value: Unwrap<O>) => boolean]\n    | readonly [predicate: (value: Unwrap<O>) => boolean]\n): Optional<Unwrap<O>> | ((optional: O) => Optional<Unwrap<O>>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, predicate] = args;\n\n      return filterImpl(optional, predicate);\n    }\n\n    case 1: {\n      // Curried version: first argument is predicate function\n      const [predicate] = args;\n\n      return (optional: O) => filterImpl(optional, predicate);\n    }\n  }\n}\n\nconst filterImpl = <O extends UnknownOptional>(\n  optional: O,\n  predicate: (value: Unwrap<O>) => boolean,\n): Optional<Unwrap<O>> => {\n  if (isSome(optional)) {\n    const value = unwrap(optional);\n\n    return predicate(value) ? some(value) : none;\n  }\n\n  return none;\n};\n"],"names":[],"mappings":";;;;;AA6CO,SAAS,UACX,IAAA,EAG2D;AAC9D,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,SAAS,CAAA,GAAI,IAAA;AAE9B,MAAA,OAAO,UAAA,CAAW,UAAU,SAAS,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,QAAA,KAAgB,UAAA,CAAW,QAAA,EAAU,SAAS,CAAA;AAAA,IACxD;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,CACjB,QAAA,EACA,SAAA,KACwB;AACxB,EAAA,IAAI,MAAA,CAAO,QAAQ,CAAA,EAAG;AACpB,IAAA,MAAM,KAAA,GAAQ,OAAO,QAAQ,CAAA;AAE7B,IAAA,OAAO,SAAA,CAAU,KAAK,CAAA,GAAI,IAAA,CAAK,KAAK,CAAA,GAAI,IAAA;AAAA,EAC1C;AAEA,EAAA,OAAO,IAAA;AACT,CAAA;;;;"}
+{"version":3,"file":"optional-filter.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-filter.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;AAyC/C,MAAM,UAAU,MAAM,CACpB,GAAG,IAEoD;IAEvD,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;YAEnC,OAAO,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,wDAAwD;YACxD,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;YAEzB,OAAO,CAAC,QAAW,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,GAAG,CACjB,QAAW,EACX,SAAwC,EACnB,EAAE;IACvB,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACrB,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE/B,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/C,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}

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

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

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

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