ts-data-forge 14.5.0 → 14.6.1

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

@@ -0,0 +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;;;;"}

package/dist/functional/async-result/impl/async-result-from-throwable.d.mts

@@ -0,0 +1,53 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Wraps a function returning a `Promise` in an `AsyncResult`. Both a
+ * synchronous `throw` while calling `fn` and an asynchronous rejection of the
+ * returned Promise are caught, passed through `mapError`, and carried as
+ * `Err`.
+ *
+ * Passing `mapError` is what gives the error channel a concrete type `E`.
+ * Omitting it carries the thrown value through untouched, leaving the error
+ * channel as `unknown`.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = await AsyncResult.fromThrowable(
+ *   () => Promise.resolve(2),
+ *   (error) => `failed: ${String(error)}`,
+ * );
+ *
+ * const failure = await AsyncResult.fromThrowable(
+ *   (): Promise<number> => {
+ *     throw new Error('boom');
+ *   },
+ *   (error) => (isError(error) ? error.message : 'unknown'),
+ * );
+ *
+ * assert.deepStrictEqual(success, Result.ok(2));
+ *
+ * assert.deepStrictEqual(failure, Result.err('boom'));
+ *
+ * // Without `mapError`, the thrown value is carried as-is.
+ * const untyped = await AsyncResult.fromThrowable(
+ *   (): Promise<number> => {
+ *     throw new Error('boom');
+ *   },
+ * );
+ *
+ * assert.isTrue(Result.isErr(untyped));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @param fn The function to execute; it may throw synchronously or return a
+ *   rejecting Promise.
+ * @param mapError The function applied to the thrown value or rejection
+ *   reason to produce the error value. Omit it to carry the thrown value as
+ *   `unknown`.
+ * @returns An `AsyncResult<S, E>` containing either the resolved value or the
+ *   mapped error.
+ */
+export declare function fromThrowable<S>(fn: () => Promise<S>): AsyncResult<S, unknown>;
+export declare function fromThrowable<S, E>(fn: () => Promise<S>, mapError: (error: unknown) => E): AsyncResult<S, E>;
+//# sourceMappingURL=async-result-from-throwable.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-from-throwable.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-from-throwable.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAEhF,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAChC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,GAC9B,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,17 @@
+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);
+}
+const fromThrowableImpl = async (fn, mapError) => {
+  try {
+    return ok(await fn());
+  } catch (error) {
+    return err(mapError(error));
+  }
+};
+
+export { fromThrowable };
+//# sourceMappingURL=async-result-from-throwable.mjs.map

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

@@ -0,0 +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;;;;"}

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

@@ -0,0 +1,35 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Maps an `AsyncResult<S, E>` to `AsyncResult<S, E2>` by applying a function
+ * to the error value. The mapping function may be synchronous or return a
+ * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
+ * `Ok`, the original `Ok` is passed through and the function is not called.
+ *
+ * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
+ * as-is — it is **not** caught and converted into an `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const errValue = AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   () => 'failure',
+ * );
+ *
+ * const uppercased = await AsyncResult.mapErr(errValue, (error) =>
+ *   error.toUpperCase(),
+ * );
+ *
+ * assert.deepStrictEqual(uppercased, Result.err('FAILURE'));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value of the input.
+ * @template E2 The type of the error value returned by the mapping function.
+ * @param asyncResult The `AsyncResult` to map.
+ * @param mapFn The function to apply to the error value if present.
+ * @returns A new `AsyncResult<S, E2>`.
+ */
+export declare function mapErr<S, E, E2>(asyncResult: AsyncResult<S, E>, mapFn: (error: E) => E2 | Promise<E2>): AsyncResult<S, E2>;
+export declare function mapErr<E, E2>(mapFn: (error: E) => E2 | Promise<E2>): <S>(asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>;
+//# sourceMappingURL=async-result-map-err.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-map-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-map-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAC7B,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,GACpC,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAQtB,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,GACpC,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,23 @@
+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);
+    }
+    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));
+};
+
+export { mapErr };
+//# sourceMappingURL=async-result-map-err.mjs.map

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

@@ -0,0 +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;;;;"}

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

@@ -0,0 +1,45 @@
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Maps an `AsyncResult<S, E>` to `AsyncResult<S2, E>` by applying a function
+ * to the success value. The mapping function may be synchronous or return a
+ * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
+ * `Err`, the original `Err` is passed through and the function is not called.
+ *
+ * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
+ * as-is — it is **not** caught and converted into an `Err`. `map` performs no
+ * implicit error conversion; write a fallible step as
+ * `AsyncResult.flatMap` combined with `AsyncResult.fromThrowable` instead, so
+ * that the error type stays explicit.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = AsyncResult.fromPromise(
+ *   Promise.resolve(5),
+ *   () => 'failed',
+ * );
+ *
+ * const doubled = await AsyncResult.map(okValue, (value) => value * 2);
+ *
+ * assert.deepStrictEqual(doubled, Result.ok(10));
+ *
+ * const double = AsyncResult.map((value: number) => value * 2);
+ *
+ * const curried = await double(
+ *   AsyncResult.fromPromise(Promise.resolve(21), () => 'failed'),
+ * );
+ *
+ * assert.deepStrictEqual(curried, Result.ok(42));
+ * ```
+ *
+ * @template S The type of the success value of the input.
+ * @template S2 The type of the success value returned by the mapping
+ *   function.
+ * @template E The type of the error value.
+ * @param asyncResult The `AsyncResult` to map.
+ * @param mapFn The function to apply to the success value if present.
+ * @returns A new `AsyncResult<S2, E>`.
+ */
+export declare function map<S, S2, E>(asyncResult: AsyncResult<S, E>, mapFn: (value: S) => Promise<S2> | S2): AsyncResult<S2, E>;
+export declare function map<S, S2>(mapFn: (value: S) => Promise<S2> | S2): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>;
+//# sourceMappingURL=async-result-map.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAC1B,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GACpC,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAQtB,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GACpC,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,23 @@
+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);
+    }
+    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));
+};
+
+export { map };
+//# sourceMappingURL=async-result-map.mjs.map

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

@@ -0,0 +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;;;;"}

package/dist/functional/async-result/impl/async-result-unwrap-or.d.mts

@@ -0,0 +1,34 @@
+import { type AsyncResult } from '../async-result.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 declare const unwrapOr: <S, E, D>(asyncResult: AsyncResult<S, E>, defaultValue: D) => Promise<D | S>;
+//# sourceMappingURL=async-result-unwrap-or.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-result-unwrap-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-unwrap-or.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,QAAQ,GAAU,CAAC,EAAE,CAAC,EAAE,CAAC,eACvB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,gBAChB,CAAC,KACd,OAAO,CAAC,CAAC,GAAG,CAAC,CAIf,CAAC"}

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

@@ -0,0 +1,10 @@
+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;
+};
+
+export { unwrapOr };
+//# sourceMappingURL=async-result-unwrap-or.mjs.map

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

@@ -0,0 +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;;;;"}

package/dist/functional/async-result/impl/index.d.mts

@@ -0,0 +1,8 @@
+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.d.mts.map

package/dist/functional/async-result/impl/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","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/index.mjs

@@ -0,0 +1,7 @@
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/functional/async-result/impl/types.d.mts

@@ -0,0 +1,45 @@
+import { type Err, type Ok } from '../../../types.mjs';
+import { type UnknownResult } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+/**
+ * Base type for any `AsyncResult`, used for generic constraints. Represents
+ * an `AsyncResult` with unknown success and error types.
+ */
+export type UnknownAsyncResult = AsyncResult<unknown, unknown>;
+/**
+ * Extracts the success value type `S` from a `Result.Ok<S>`, or from an
+ * `AsyncResult` resolving to one. Distributes over unions, so an
+ * `Ok<S> | Err<E>` union resolves to `S`.
+ *
+ * @template R The `Result` or `AsyncResult` type to unwrap.
+ */
+export type UnwrapOk<R extends UnknownAsyncResult | UnknownResult> = UnwrapOkImpl<SyncResultOf<R>>;
+/**
+ * Extracts the error value type `E` from a `Result.Err<E>`, or from an
+ * `AsyncResult` resolving to one. Distributes over unions, so an
+ * `Ok<S> | Err<E>` union resolves to `E`.
+ *
+ * @template R The `Result` or `AsyncResult` type to unwrap.
+ */
+export type UnwrapErr<R extends UnknownAsyncResult | UnknownResult> = UnwrapErrImpl<SyncResultOf<R>>;
+/**
+ * @template R The `Result` or `AsyncResult` type.
+ * @internal
+ * Resolves an `AsyncResult` to its `Result`, leaving a plain `Result`
+ * unchanged. Distributive.
+ */
+type SyncResultOf<R> = R extends Promise<infer P> ? P : R;
+/**
+ * @template R The `Result` type to unwrap.
+ * @internal
+ * Distributive extraction of the `Ok` value type.
+ */
+type UnwrapOkImpl<R> = R extends Ok<infer S> ? S : never;
+/**
+ * @template R The `Result` type to unwrap.
+ * @internal
+ * Distributive extraction of the `Err` value type.
+ */
+type UnwrapErrImpl<R> = R extends Err<infer E> ? E : never;
+export {};
+//# sourceMappingURL=types.d.mts.map

package/dist/functional/async-result/impl/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/types.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,kBAAkB,GAAG,aAAa,IAC/D,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,kBAAkB,GAAG,aAAa,IAChE,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjC;;;;;GAKG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE1D;;;;GAIG;AACH,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzD;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC"}

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/functional/async-result/index.d.mts

@@ -0,0 +1,2 @@
+export * from './async-result.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/functional/async-result/index.d.mts.map

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/functional/index.d.mts

@@ -1,3 +1,4 @@
+export * from './async-result/index.mjs';
 export * from './match.mjs';
 export * from './optional/index.mjs';
 export * from './pipe.mjs';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/functional/index.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.mts","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/index.mjs

@@ -1,9 +1,11 @@
+import * as index from './async-result/impl/index.mjs';
+export { index as AsyncResult };
 export { match } from './match.mjs';
-import * as index from './optional/impl/index.mjs';
-export { index as Optional };
+import * as index$1 from './optional/impl/index.mjs';
+export { index$1 as Optional };
 export { pipe } from './pipe.mjs';
-import * as index$1 from './result/impl/index.mjs';
-export { index$1 as Result };
-import * as index$2 from './ternary-result/impl/index.mjs';
-export { index$2 as TernaryResult };
+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

package/dist/functional/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/dist/functional/result/impl/result-from-promise.d.mts

@@ -11,6 +11,11 @@ type UnwrapPromise<P extends Promise<unknown>> = P extends Promise<infer V> ? V
  * input Promise rejects, the `Result` will be `Err` with the rejection
  * reason.
  *
+ * The error channel is `unknown`, since the rejection reason is carried
+ * through untouched. For a concrete error type, use `AsyncResult.fromPromise`
+ * with a `mapError` function; called without one it behaves exactly as this
+ * function does.
+ *
  * @example
  *
  * ```ts

package/dist/functional/result/impl/result-from-promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,WAC3C,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}
+{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,WAC3C,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * @template P The Promise type.\n * @internal\n * Utility type to extract the resolved value type from a Promise.\n */\ntype UnwrapPromise<P extends Promise<unknown>> =\n  P extends Promise<infer V> ? V : never;\n\n/**\n * Converts a Promise into a Promise that resolves to a `Result`. If the input\n * Promise resolves, the `Result` will be `Ok` with the resolved value. If the\n * input Promise rejects, the `Result` will be `Err` with the rejection\n * reason.\n *\n * @example\n *\n * ```ts\n * const successPromise = Result.fromPromise(Promise.resolve('ok'));\n *\n * const failurePromise = Result.fromPromise(\n *   Promise.reject(new Error('fail')),\n * );\n *\n * const resolved = await successPromise;\n *\n * const rejected = await failurePromise;\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.isTrue(Result.isErr(rejected));\n * ```\n *\n * @template P The type of the input Promise.\n * @param promise The Promise to convert.\n * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.\n */\nexport const fromPromise = <P extends Promise<unknown>>(\n  promise: P,\n): Promise<Result<UnwrapPromise<P>, unknown>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  promise.then((v) => ok(v) as Ok<UnwrapPromise<P>>).catch(err);\n"],"names":[],"mappings":";;;AAyCO,MAAM,cAAc,CACzB,OAAA;AAAA;AAAA,EAGA,OAAA,CAAQ,KAAK,CAAC,CAAA,KAAM,GAAG,CAAC,CAAyB,CAAA,CAAE,KAAA,CAAM,GAAG;AAAA;;;;"}
+{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * @template P The Promise type.\n * @internal\n * Utility type to extract the resolved value type from a Promise.\n */\ntype UnwrapPromise<P extends Promise<unknown>> =\n  P extends Promise<infer V> ? V : never;\n\n/**\n * Converts a Promise into a Promise that resolves to a `Result`. If the input\n * Promise resolves, the `Result` will be `Ok` with the resolved value. If the\n * input Promise rejects, the `Result` will be `Err` with the rejection\n * reason.\n *\n * The error channel is `unknown`, since the rejection reason is carried\n * through untouched. For a concrete error type, use `AsyncResult.fromPromise`\n * with a `mapError` function; called without one it behaves exactly as this\n * function does.\n *\n * @example\n *\n * ```ts\n * const successPromise = Result.fromPromise(Promise.resolve('ok'));\n *\n * const failurePromise = Result.fromPromise(\n *   Promise.reject(new Error('fail')),\n * );\n *\n * const resolved = await successPromise;\n *\n * const rejected = await failurePromise;\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.isTrue(Result.isErr(rejected));\n * ```\n *\n * @template P The type of the input Promise.\n * @param promise The Promise to convert.\n * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.\n */\nexport const fromPromise = <P extends Promise<unknown>>(\n  promise: P,\n): Promise<Result<UnwrapPromise<P>, unknown>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  promise.then((v) => ok(v) as Ok<UnwrapPromise<P>>).catch(err);\n"],"names":[],"mappings":";;;AA8CO,MAAM,cAAc,CACzB,OAAA;AAAA;AAAA,EAGA,OAAA,CAAQ,KAAK,CAAC,CAAA,KAAM,GAAG,CAAC,CAAyB,CAAA,CAAE,KAAA,CAAM,GAAG;AAAA;;;;"}

package/dist/json/json.mjs

@@ -34,13 +34,13 @@ import '../number/enum/int8.mjs';
 import '../number/enum/uint8.mjs';
 import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
-import { isRecord } from '../guard/is-record.mjs';
-import { pipe } from '../functional/pipe.mjs';
 import { err } from '../functional/result/impl/result-err.mjs';
 import { ok } from '../functional/result/impl/result-ok.mjs';
+import { isRecord } from '../guard/is-record.mjs';
 import '@sindresorhus/is';
 import { castMutable } from '../others/cast-mutable.mjs';
 import { unknownToString } from '../others/unknown-to-string.mjs';
+import { pipe } from '../functional/pipe.mjs';
 import '../collections/imap-mapped.mjs';
 import '../collections/imap.mjs';
 import '../collections/iset-mapped.mjs';

package/dist/number/enum/int8.mjs

@@ -21,7 +21,7 @@ const castType = (x) => (
 );
 const fromNumber = (a) => castType(fromNumberImpl(a));
 const abs = (x) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `Math.abs` as returning `number`
   Math.abs(x)
 );
 const min_ = (...values) => castType(Math.min(...values));

package/dist/number/enum/int8.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"int8.mjs","sources":["../../../src/number/enum/int8.mts"],"sourcesContent":["import {\n  type AbsoluteValue,\n  type Int16,\n  type StrictExclude,\n  type Int8 as TtfImported_Int8,\n} from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type Int8 = TtfImported_Int8;\n\nconst typeNameInMessage = 'an integer in [-128, 127]';\n\nconst {\n  MAX_VALUE,\n  MIN_VALUE,\n  castType: castTypeImpl,\n  fromNumber: fromNumberImpl,\n  is: isImpl,\n  random: randomImpl,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n  Int16,\n  -128,\n  127\n>({\n  integerOrSafeInteger: 'SafeInteger',\n  MIN_VALUE: -128,\n  MAX_VALUE: 127,\n  typeNameInMessage,\n} as const);\n\nconst is = (x: number): x is Int8 => isImpl(x);\n\nconst castType = (x: number): Int8 =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  castTypeImpl(x) as Int8;\n\nconst fromNumber = (a: number): Int8 => castType(fromNumberImpl(a));\n\nconst abs = <N extends Int8>(x: N): AbsoluteValue<N> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Math.abs(x) as unknown as AbsoluteValue<N>;\n\nconst min_ = (...values: readonly Int8[]): Int8 =>\n  castType(Math.min(...values));\n\nconst max_ = (...values: readonly Int8[]): Int8 =>\n  castType(Math.max(...values));\n\nconst pow = (x: Int8, y: Int8): Int8 => fromNumber(x ** y);\n\nconst add = (x: Int8, y: Int8): Int8 => fromNumber(x + y);\n\nconst sub = (x: Int8, y: Int8): Int8 => fromNumber(x - y);\n\nconst mul = (x: Int8, y: Int8): Int8 => fromNumber(x * y);\n\nconst div = (x: Int8, y: StrictExclude<Int8, 0>): Int8 =>\n  fromNumber(Math.floor(x / y));\n\nconst random = (min: Int8, max: Int8): Int8 =>\n  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));\n\n/**\n * Type guard that checks if a value is an integer in [-128, 127].\n *\n * Returns `true` for an integer in [-128, 127] — a value with no fractional\n * component.\n *\n * @param value - The value to check\n * @returns `true` if the value is an integer in [-128, 127], `false` otherwise\n */\nexport const isInt8 = is;\n\n/**\n * Casts a `number` to the `Int8` branded type.\n *\n * Validates that the value is an integer in [-128, 127] and returns it with the\n * `Int8` brand. Throws a `TypeError` otherwise.\n *\n * @param value - The value to cast\n * @returns The value as an `Int8`\n * @throws {TypeError} If the value is not an integer in [-128, 127]\n */\nexport const asInt8 = castType;\n\n/**\n * Namespace providing type-safe operations for the `Int8` branded type.\n *\n * The `Int8` type represents an integer in [-128, 127]. Division (`div`) uses\n * floor division.\n */\nexport const Int8 = {\n  /**\n   * Type guard that checks if a value is an integer in [-128, 127].\n   *\n   * @param value - The value to check\n   * @returns `true` if the value is an integer in [-128, 127], `false` otherwise\n   * @see {@link isInt8} for usage examples\n   */\n  is,\n\n  /**\n   * The smallest value representable as `Int8` (the lower saturation target of\n   * `fromNumber`).\n   */\n  MIN_VALUE,\n\n  /**\n   * The largest value representable as `Int8` (the upper saturation target of\n   * `fromNumber`).\n   */\n  MAX_VALUE,\n\n  /**\n   * Returns the smallest of the given integers.\n   *\n   * @param values - The integers to compare (at least one required)\n   * @returns The smallest value as an `Int8`\n   */\n  min: min_,\n\n  /**\n   * Returns the largest of the given integers.\n   *\n   * @param values - The integers to compare (at least one required)\n   * @returns The largest value as an `Int8`\n   */\n  max: max_,\n\n  /**\n   * Converts an arbitrary `number` into an `Int8`, rounding to the nearest\n   * integer and saturating the result into the range `[MIN_VALUE, MAX_VALUE]`.\n   *\n   * Unlike `asInt8`, this is total: out-of-range inputs are clamped to the\n   * nearest representable `Int8` instead of throwing.\n   *\n   * @param value - The value to convert\n   * @returns The value as an `Int8`\n   */\n  fromNumber,\n\n  /**\n   * Returns the absolute value of an integer in [-128, 127].\n   *\n   * The result is non-negative and keeps the `Int8` brand.\n   *\n   * @param a - The integer value\n   * @returns The absolute value as a non-negative `Int8`\n   */\n  abs,\n\n  /**\n   * Generates a random `Int8` within the given range.\n   *\n   * The range is inclusive on both ends.\n   *\n   * @param min - The minimum value (inclusive)\n   * @param max - The maximum value (inclusive)\n   * @returns A random `Int8` in `[min, max]`\n   */\n  random,\n\n  /**\n   * Raises `a` to the power `b`, returning `a ** b` as an `Int8` (floored to an\n   * integer).\n   *\n   * @param a - The base integer\n   * @param b - The exponent integer\n   * @returns `a ** b` as an `Int8`\n   */\n  pow,\n\n  /**\n   * Adds two integers, returning `a + b` as an `Int8`.\n   *\n   * @param a - The first integer\n   * @param b - The second integer\n   * @returns The sum of `a` and `b` as an `Int8`\n   */\n  add,\n\n  /**\n   * Subtracts two integers, returning `a - b` as an `Int8`.\n   *\n   * @param a - The first integer\n   * @param b - The second integer\n   * @returns The difference of `a` and `b` as an `Int8`\n   */\n  sub,\n\n  /**\n   * Multiplies two integers, returning `a * b` as an `Int8`.\n   *\n   * @param a - The first integer\n   * @param b - The second integer\n   * @returns The product of `a` and `b` as an `Int8`\n   */\n  mul,\n\n  /**\n   * Divides two integers using floor division (`⌊a / b⌋`): the result is `a /\n   * b` rounded toward negative infinity, as an `Int8`.\n   *\n   * @param a - The dividend\n   * @param b - The divisor (must be non-zero)\n   * @returns The floored quotient as an `Int8`\n   */\n  div,\n} as const;\n\nexpectType<\n  keyof typeof Int8,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    Int16,\n    'int' | 'range'\n  >\n>('=');\n"],"names":[],"mappings":";;AAWA,MAAM,iBAAA,GAAoB,2BAAA;AAE1B,MAAM;AAAA,EACJ,SAAA;AAAA,EACA,SAAA;AAAA,EACA,QAAA,EAAU,YAAA;AAAA,EACV,UAAA,EAAY,cAAA;AAAA,EACZ,EAAA,EAAI,MAAA;AAAA,EACJ,MAAA,EAAQ;AACV,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,mBAAA,CAI1C;AAAA,EACA,oBAAA,EAAsB,aAAA;AAAA,EACtB,SAAA,EAAW,IAAA;AAAA,EACX,SAAA,EAAW,GAAA;AAAA,EACX;AACF,CAAU,CAAA;AAEV,MAAM,EAAA,GAAK,CAAC,CAAA,KAAyB,MAAA,CAAO,CAAC,CAAA;AAE7C,MAAM,WAAW,CAAC,CAAA;AAAA;AAAA,EAEhB,aAAa,CAAC;AAAA,CAAA;AAEhB,MAAM,aAAa,CAAC,CAAA,KAAoB,QAAA,CAAS,cAAA,CAAe,CAAC,CAAC,CAAA;AAElE,MAAM,MAAM,CAAiB,CAAA;AAAA;AAAA,EAE3B,IAAA,CAAK,IAAI,CAAC;AAAA,CAAA;AAEZ,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,KAAK,CAAC,CAAA;AAEzD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAExD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAExD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAExD,MAAM,GAAA,GAAM,CAAC,CAAA,EAAS,CAAA,KACpB,WAAW,IAAA,CAAK,KAAA,CAAM,CAAA,GAAI,CAAC,CAAC,CAAA;AAE9B,MAAM,MAAA,GAAS,CAAC,GAAA,EAAW,GAAA,KACzB,QAAA,CAAS,UAAA,CAAW,YAAA,CAAa,GAAG,CAAA,EAAG,YAAA,CAAa,GAAG,CAAC,CAAC,CAAA;AAWpD,MAAM,MAAA,GAAS;AAYf,MAAM,MAAA,GAAS;AAQf,MAAM,IAAA,GAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQlB,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYL,UAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA;AACF;;;;"}
+{"version":3,"file":"int8.mjs","sources":["../../../src/number/enum/int8.mts"],"sourcesContent":["import {\n  type AbsoluteValue,\n  type Int16,\n  type StrictExclude,\n  type Int8 as TtfImported_Int8,\n} from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type Int8 = TtfImported_Int8;\n\nconst typeNameInMessage = 'an integer in [-128, 127]';\n\nconst {\n  MAX_VALUE,\n  MIN_VALUE,\n  castType: castTypeImpl,\n  fromNumber: fromNumberImpl,\n  is: isImpl,\n  random: randomImpl,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n  Int16,\n  -128,\n  127\n>({\n  integerOrSafeInteger: 'SafeInteger',\n  MIN_VALUE: -128,\n  MAX_VALUE: 127,\n  typeNameInMessage,\n} as const);\n\nconst is = (x: number): x is Int8 => isImpl(x);\n\nconst castType = (x: number): Int8 =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  castTypeImpl(x) as Int8;\n\nconst fromNumber = (a: number): Int8 => castType(fromNumberImpl(a));\n\nconst abs = <N extends Int8>(x: N): AbsoluteValue<N> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `Math.abs` as returning `number`\n  Math.abs(x) as unknown as AbsoluteValue<N>;\n\nconst min_ = (...values: readonly Int8[]): Int8 =>\n  castType(Math.min(...values));\n\nconst max_ = (...values: readonly Int8[]): Int8 =>\n  castType(Math.max(...values));\n\nconst pow = (x: Int8, y: Int8): Int8 => fromNumber(x ** y);\n\nconst add = (x: Int8, y: Int8): Int8 => fromNumber(x + y);\n\nconst sub = (x: Int8, y: Int8): Int8 => fromNumber(x - y);\n\nconst mul = (x: Int8, y: Int8): Int8 => fromNumber(x * y);\n\nconst div = (x: Int8, y: StrictExclude<Int8, 0>): Int8 =>\n  fromNumber(Math.floor(x / y));\n\nconst random = (min: Int8, max: Int8): Int8 =>\n  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));\n\n/**\n * Type guard that checks if a value is an integer in [-128, 127].\n *\n * Returns `true` for an integer in [-128, 127] — a value with no fractional\n * component.\n *\n * @param value - The value to check\n * @returns `true` if the value is an integer in [-128, 127], `false` otherwise\n */\nexport const isInt8 = is;\n\n/**\n * Casts a `number` to the `Int8` branded type.\n *\n * Validates that the value is an integer in [-128, 127] and returns it with the\n * `Int8` brand. Throws a `TypeError` otherwise.\n *\n * @param value - The value to cast\n * @returns The value as an `Int8`\n * @throws {TypeError} If the value is not an integer in [-128, 127]\n */\nexport const asInt8 = castType;\n\n/**\n * Namespace providing type-safe operations for the `Int8` branded type.\n *\n * The `Int8` type represents an integer in [-128, 127]. Division (`div`) uses\n * floor division.\n */\nexport const Int8 = {\n  /**\n   * Type guard that checks if a value is an integer in [-128, 127].\n   *\n   * @param value - The value to check\n   * @returns `true` if the value is an integer in [-128, 127], `false` otherwise\n   * @see {@link isInt8} for usage examples\n   */\n  is,\n\n  /**\n   * The smallest value representable as `Int8` (the lower saturation target of\n   * `fromNumber`).\n   */\n  MIN_VALUE,\n\n  /**\n   * The largest value representable as `Int8` (the upper saturation target of\n   * `fromNumber`).\n   */\n  MAX_VALUE,\n\n  /**\n   * Returns the smallest of the given integers.\n   *\n   * @param values - The integers to compare (at least one required)\n   * @returns The smallest value as an `Int8`\n   */\n  min: min_,\n\n  /**\n   * Returns the largest of the given integers.\n   *\n   * @param values - The integers to compare (at least one required)\n   * @returns The largest value as an `Int8`\n   */\n  max: max_,\n\n  /**\n   * Converts an arbitrary `number` into an `Int8`, rounding to the nearest\n   * integer and saturating the result into the range `[MIN_VALUE, MAX_VALUE]`.\n   *\n   * Unlike `asInt8`, this is total: out-of-range inputs are clamped to the\n   * nearest representable `Int8` instead of throwing.\n   *\n   * @param value - The value to convert\n   * @returns The value as an `Int8`\n   */\n  fromNumber,\n\n  /**\n   * Returns the absolute value of an integer in [-128, 127].\n   *\n   * The result is non-negative and keeps the `Int8` brand.\n   *\n   * @param a - The integer value\n   * @returns The absolute value as a non-negative `Int8`\n   */\n  abs,\n\n  /**\n   * Generates a random `Int8` within the given range.\n   *\n   * The range is inclusive on both ends.\n   *\n   * @param min - The minimum value (inclusive)\n   * @param max - The maximum value (inclusive)\n   * @returns A random `Int8` in `[min, max]`\n   */\n  random,\n\n  /**\n   * Raises `a` to the power `b`, returning `a ** b` as an `Int8` (floored to an\n   * integer).\n   *\n   * @param a - The base integer\n   * @param b - The exponent integer\n   * @returns `a ** b` as an `Int8`\n   */\n  pow,\n\n  /**\n   * Adds two integers, returning `a + b` as an `Int8`.\n   *\n   * @param a - The first integer\n   * @param b - The second integer\n   * @returns The sum of `a` and `b` as an `Int8`\n   */\n  add,\n\n  /**\n   * Subtracts two integers, returning `a - b` as an `Int8`.\n   *\n   * @param a - The first integer\n   * @param b - The second integer\n   * @returns The difference of `a` and `b` as an `Int8`\n   */\n  sub,\n\n  /**\n   * Multiplies two integers, returning `a * b` as an `Int8`.\n   *\n   * @param a - The first integer\n   * @param b - The second integer\n   * @returns The product of `a` and `b` as an `Int8`\n   */\n  mul,\n\n  /**\n   * Divides two integers using floor division (`⌊a / b⌋`): the result is `a /\n   * b` rounded toward negative infinity, as an `Int8`.\n   *\n   * @param a - The dividend\n   * @param b - The divisor (must be non-zero)\n   * @returns The floored quotient as an `Int8`\n   */\n  div,\n} as const;\n\nexpectType<\n  keyof typeof Int8,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    Int16,\n    'int' | 'range'\n  >\n>('=');\n"],"names":[],"mappings":";;AAWA,MAAM,iBAAA,GAAoB,2BAAA;AAE1B,MAAM;AAAA,EACJ,SAAA;AAAA,EACA,SAAA;AAAA,EACA,QAAA,EAAU,YAAA;AAAA,EACV,UAAA,EAAY,cAAA;AAAA,EACZ,EAAA,EAAI,MAAA;AAAA,EACJ,MAAA,EAAQ;AACV,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,mBAAA,CAI1C;AAAA,EACA,oBAAA,EAAsB,aAAA;AAAA,EACtB,SAAA,EAAW,IAAA;AAAA,EACX,SAAA,EAAW,GAAA;AAAA,EACX;AACF,CAAU,CAAA;AAEV,MAAM,EAAA,GAAK,CAAC,CAAA,KAAyB,MAAA,CAAO,CAAC,CAAA;AAE7C,MAAM,WAAW,CAAC,CAAA;AAAA;AAAA,EAEhB,aAAa,CAAC;AAAA,CAAA;AAEhB,MAAM,aAAa,CAAC,CAAA,KAAoB,QAAA,CAAS,cAAA,CAAe,CAAC,CAAC,CAAA;AAElE,MAAM,MAAM,CAAiB,CAAA;AAAA;AAAA,EAE3B,IAAA,CAAK,IAAI,CAAC;AAAA,CAAA;AAEZ,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,KAAK,CAAC,CAAA;AAEzD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAExD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAExD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAExD,MAAM,GAAA,GAAM,CAAC,CAAA,EAAS,CAAA,KACpB,WAAW,IAAA,CAAK,KAAA,CAAM,CAAA,GAAI,CAAC,CAAC,CAAA;AAE9B,MAAM,MAAA,GAAS,CAAC,GAAA,EAAW,GAAA,KACzB,QAAA,CAAS,UAAA,CAAW,YAAA,CAAa,GAAG,CAAA,EAAG,YAAA,CAAa,GAAG,CAAC,CAAC,CAAA;AAWpD,MAAM,MAAA,GAAS;AAYf,MAAM,MAAA,GAAS;AAQf,MAAM,IAAA,GAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQlB,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYL,UAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA;AACF;;;;"}

package/dist/number/refined-number-utils.mjs

@@ -1,5 +1,5 @@
-import { pipe } from '../functional/pipe.mjs';
 import '@sindresorhus/is';
+import { pipe } from '../functional/pipe.mjs';
 import { Num } from './num.mjs';
 
 var TsDataForgeInternals;

package/dist/object/object.mjs

@@ -34,9 +34,9 @@ import '../number/enum/int8.mjs';
 import '../number/enum/uint8.mjs';
 import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
+import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import { hasKey } from '../guard/has-key.mjs';
 import { isRecord } from '../guard/is-record.mjs';
-import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import '@sindresorhus/is';
 import { isNonEmpty } from '../array/impl/array-utils-length-bounded-array-guard.mjs';
 import '../collections/imap-mapped.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.5.0",
+  "version": "14.6.1",
   "private": false,
   "keywords": [
     "typescript",
@@ -46,20 +46,20 @@
     "@types/react": "19.2.18",
     "@vitest/browser-playwright": "4.1.11",
     "dedent": "1.7.2",
-    "eslint-config-typed": "5.10.0",
-    "eslint-plugin-ts-fortress": "1.0.5",
-    "eslint-plugin-ts-type-forge": "0.7.1",
+    "eslint-config-typed": "5.10.1",
+    "eslint-plugin-ts-fortress": "1.0.6",
+    "eslint-plugin-ts-type-forge": "0.7.2",
     "immer": "11.1.18",
     "playwright": "1.62.1",
     "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.8",
-    "rollup": "4.62.4",
-    "ts-repo-utils": "10.3.2",
+    "rollup": "4.62.5",
+    "ts-repo-utils": "10.4.0",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
-    "vite": "8.2.1"
+    "vite": "8.2.2"
   },
   "peerDependencies": {
     "typescript": ">=4.8"