ts-data-forge 9.0.0 → 9.0.1

package/dist/others/fast-deep-equal.mjs

@@ -2,70 +2,54 @@ import { isMap, isSet, isTypedArray, isRegExp } from '@sindresorhus/is';
 import { hasKey } from '../guard/has-key.mjs';
 import { isRecord } from '../guard/is-record.mjs';
 
-/**
- * The fastest deep equal with ES6 Map, Set and Typed arrays support.
- * Checks equality of Date and RegExp objects by value.
- *
- * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst
- */
 const fastDeepEqual = (a, b) => {
-    if (a === b) {
-        return true;
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    return Array.isArray(b) && a.constructor === b.constructor && a.length === b.length && a.every((ai, index) => fastDeepEqual(ai, b[index]));
+  }
+  if (isRecord(a)) {
+    if (!isRecord(b)) {
+      return false;
     }
-    if (typeof a !== typeof b) {
-        return false;
+    if (a.constructor !== b.constructor) {
+      return false;
     }
-    // Arrays are handled before `isRecord`, which excludes them.
-    if (Array.isArray(a)) {
-        return (Array.isArray(b) &&
-            a.constructor === b.constructor &&
-            a.length === b.length &&
-            a.every((ai, index) => fastDeepEqual(ai, b[index])));
+    if (isMap(a)) {
+      return isMap(b) && a.size === b.size && Array.from(a.entries()).every(
+        ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key))
+      );
     }
-    if (isRecord(a)) {
-        if (!isRecord(b)) {
-            return false;
-        }
-        if (a.constructor !== b.constructor) {
-            return false;
-        }
-        if (isMap(a)) {
-            return (isMap(b) &&
-                a.size === b.size &&
-                Array.from(a.entries()).every(([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key))));
-        }
-        if (isSet(a)) {
-            return (isSet(b) &&
-                a.size === b.size &&
-                Array.from(a.entries()).every(([value]) => b.has(value)));
-        }
-        if (isTypedArray(a)) {
-            return (isTypedArray(b) &&
-                a.length === b.length &&
-                a.every((value, index) => value === b[index]));
-        }
-        if (isRegExp(a)) {
-            return isRegExp(b) && a.source === b.source && a.flags === b.flags;
-        }
-        if (a.valueOf !== Object.prototype.valueOf) {
-            return a.valueOf() === b.valueOf();
-        }
-        if (a.toString !== Object.prototype.toString) {
-            return a.toString() === b.toString();
-        }
-        const aKeys = Object.keys(a);
-        const bKeys = Object.keys(b);
-        return (aKeys.length === bKeys.length &&
-            aKeys.every((key) => hasKey(b, key) &&
-                // React-specific: avoid traversing React elements' _owner.
-                //  _owner contains circular references
-                // and is not needed when comparing the actual elements (and not their owners)
-                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-                !(key === '_owner' && a['$$typeof']) &&
-                fastDeepEqual(a[key], b[key])));
+    if (isSet(a)) {
+      return isSet(b) && a.size === b.size && Array.from(a.entries()).every(([value]) => b.has(value));
     }
-    // true if both NaN, false otherwise
-    return Number.isNaN(a) && Number.isNaN(b);
+    if (isTypedArray(a)) {
+      return isTypedArray(b) && a.length === b.length && a.every((value, index) => value === b[index]);
+    }
+    if (isRegExp(a)) {
+      return isRegExp(b) && a.source === b.source && a.flags === b.flags;
+    }
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every(
+      (key) => hasKey(b, key) && // React-specific: avoid traversing React elements' _owner.
+      //  _owner contains circular references
+      // and is not needed when comparing the actual elements (and not their owners)
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      !(key === "_owner" && a["$$typeof"]) && fastDeepEqual(a[key], b[key])
+    );
+  }
+  return Number.isNaN(a) && Number.isNaN(b);
 };
 
 export { fastDeepEqual };

package/dist/others/fast-deep-equal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"sourcesContent":["import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';\nimport { hasKey, isRecord } from '../guard/index.mjs';\n\n/**\n * The fastest deep equal with ES6 Map, Set and Typed arrays support.\n * Checks equality of Date and RegExp objects by value.\n *\n * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst\n */\nexport const fastDeepEqual = <T,>(a: T, b: T): boolean => {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  // Arrays are handled before `isRecord`, which excludes them.\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.constructor === b.constructor &&\n      a.length === b.length &&\n      a.every((ai, index) => fastDeepEqual(ai, b[index]))\n    );\n  }\n\n  if (isRecord(a)) {\n    if (!isRecord(b)) {\n      return false;\n    }\n\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (isMap(a)) {\n      return (\n        isMap(b) &&\n        a.size === b.size &&\n        Array.from(a.entries()).every(\n          ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),\n        )\n      );\n    }\n\n    if (isSet(a)) {\n      return (\n        isSet(b) &&\n        a.size === b.size &&\n        Array.from(a.entries()).every(([value]) => b.has(value))\n      );\n    }\n\n    if (isTypedArray(a)) {\n      return (\n        isTypedArray(b) &&\n        a.length === b.length &&\n        a.every((value, index) => value === b[index])\n      );\n    }\n\n    if (isRegExp(a)) {\n      return isRegExp(b) && a.source === b.source && a.flags === b.flags;\n    }\n\n    if (a.valueOf !== Object.prototype.valueOf) {\n      return a.valueOf() === b.valueOf();\n    }\n\n    if (a.toString !== Object.prototype.toString) {\n      return a.toString() === b.toString();\n    }\n\n    const aKeys: readonly string[] = Object.keys(a);\n\n    const bKeys: readonly string[] = Object.keys(b);\n\n    return (\n      aKeys.length === bKeys.length &&\n      aKeys.every(\n        (key) =>\n          hasKey(b, key) &&\n          // React-specific: avoid traversing React elements' _owner.\n          //  _owner contains circular references\n          // and is not needed when comparing the actual elements (and not their owners)\n          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n          !(key === '_owner' && a['$$typeof']) &&\n          fastDeepEqual(a[key], b[key]),\n      )\n    );\n  }\n\n  // true if both NaN, false otherwise\n  return Number.isNaN(a) && Number.isNaN(b);\n};\n"],"names":[],"mappings":"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"}

package/dist/others/if-then.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,GAAI,YAAY,OAAO,EAAE,YAAY,OAAO,KAAG,OACvC,CAAC;AAE5B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,eAbe,OAAO,cAAc,OAAO,KAAG,OAarC,CAAC"}
+{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,eAAgB,OAAO,cAAc,OAAO,KAAG,OACvC,CAAC;AAE5B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,eAbe,OAAO,cAAc,OAAO,KAAG,OAarC,CAAC"}

package/dist/others/if-then.mjs

@@ -1,33 +1,4 @@
-/**
- * Implements the logical implication (if-then) operator.
- *
- * Returns `true` if the antecedent is `false` or the consequent is `true`. In
- * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨
- * consequent`.
- *
- * **Truth table:**
- *
- * - `true → true` = `true` (valid implication)
- * - `true → false` = `false` (invalid implication)
- * - `false → true` = `true` (vacuously true)
- * - `false → false` = `true` (vacuously true)
- *
- * @param antecedent - The condition (if part)
- * @param consequent - The result that should hold if the condition is true
- *   (then part)
- * @returns `true` if the implication holds, `false` otherwise
- */
 const ifThen = (antecedent, consequent) => !antecedent || consequent;
-/**
- * Alias for {@link ifThen}.
- *
- * Implements the logical implication (if-then) operator.
- *
- * @param antecedent - The condition (if part)
- * @param consequent - The result that should hold if the condition is true
- *   (then part)
- * @returns `true` if the implication holds, `false` otherwise
- */
 const implies = ifThen;
 
 export { ifThen, implies };

package/dist/others/if-then.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"if-then.mjs","sources":["../../src/others/if-then.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,MAAM,GAAG,CAAC,UAAmB,EAAE,UAAmB,KAC7D,CAAC,UAAU,IAAI;AAEjB;;;;;;;;;AASG;AACI,MAAM,OAAO,GAAG;;;;"}
+{"version":3,"file":"if-then.mjs","sources":["../../src/others/if-then.mts"],"sourcesContent":["/**\n * Implements the logical implication (if-then) operator.\n *\n * Returns `true` if the antecedent is `false` or the consequent is `true`. In\n * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨\n * consequent`.\n *\n * **Truth table:**\n *\n * - `true → true` = `true` (valid implication)\n * - `true → false` = `false` (invalid implication)\n * - `false → true` = `true` (vacuously true)\n * - `false → false` = `true` (vacuously true)\n *\n * @param antecedent - The condition (if part)\n * @param consequent - The result that should hold if the condition is true\n *   (then part)\n * @returns `true` if the implication holds, `false` otherwise\n */\nexport const ifThen = (antecedent: boolean, consequent: boolean): boolean =>\n  !antecedent || consequent;\n\n/**\n * Alias for {@link ifThen}.\n *\n * Implements the logical implication (if-then) operator.\n *\n * @param antecedent - The condition (if part)\n * @param consequent - The result that should hold if the condition is true\n *   (then part)\n * @returns `true` if the implication holds, `false` otherwise\n */\nexport const implies = ifThen;\n"],"names":[],"mappings":"AAmBO,MAAM,MAAA,GAAS,CAAC,UAAA,EAAqB,UAAA,KAC1C,CAAC,UAAA,IAAc;AAYV,MAAM,OAAA,GAAU;;;;"}

package/dist/others/map-nullable.mjs

@@ -1,14 +1,14 @@
 function mapNullable(...args) {
-    switch (args.length) {
-        case 2: {
-            const [value, mapFn] = args;
-            return value == null ? undefined : mapFn(value);
-        }
-        case 1: {
-            const [mapFn] = args;
-            return (value) => mapNullable(value, mapFn);
-        }
+  switch (args.length) {
+    case 2: {
+      const [value, mapFn] = args;
+      return value == null ? void 0 : mapFn(value);
     }
+    case 1: {
+      const [mapFn] = args;
+      return (value) => mapNullable(value, mapFn);
+    }
+  }
 }
 
 export { mapNullable };

package/dist/others/map-nullable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-nullable.mjs","sources":["../../src/others/map-nullable.mts"],"sourcesContent":[null],"names":[],"mappings":"AA8BM,SAAU,WAAW,CACzB,GAAG,IAE8B,EAAA;AAEjC,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI;AAE3B,YAAA,OAAO,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC;QACjD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YAEpB,OAAO,CAAC,KAA2B,KAAK,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC;QACnE;;AAEJ;;;;"}
+{"version":3,"file":"map-nullable.mjs","sources":["../../src/others/map-nullable.mts"],"sourcesContent":["/**\n * Applies a function to a value if the value is not `null` or `undefined`. If\n * the value is `null` or `undefined`, it returns `undefined`.\n *\n * This function provides a safe way to transform nullable values without\n * explicit null checks. It's similar to Optional.map() but works directly with\n * TypeScript's nullable types. Supports both regular and curried usage for\n * functional composition.\n *\n * @template A - The type of the input value (excluding null/undefined)\n * @template B - The type of the value returned by the mapping function\n * @param value - The value to potentially transform (can be `A`, `null`, or\n *   `undefined`)\n * @param mapFn - A function that transforms a non-nullable value of type `A` to\n *   type `B`\n * @returns The result of applying `mapFn` to `value` if value is not\n *   null/undefined; otherwise `undefined`\n * @see Optional - For more complex optional value handling\n * @see Result - For error handling with detailed error information\n */\nexport function mapNullable<const A, const B>(\n  value: A | null | undefined,\n  mapFn: (v: A) => B,\n): B | undefined;\n\n// Curried version\nexport function mapNullable<const A, const B>(\n  mapFn: (v: A) => B,\n): (value: A | null | undefined) => B | undefined;\n\nexport function mapNullable<const A, const B>(\n  ...args:\n    | readonly [value: A | null | undefined, mapFn: (v: A) => B]\n    | readonly [mapFn: (v: A) => B]\n): (B | undefined) | ((value: A | null | undefined) => B | undefined) {\n  switch (args.length) {\n    case 2: {\n      const [value, mapFn] = args;\n\n      return value == null ? undefined : mapFn(value);\n    }\n\n    case 1: {\n      const [mapFn] = args;\n\n      return (value: A | null | undefined) => mapNullable(value, mapFn);\n    }\n  }\n}\n"],"names":[],"mappings":"AA8BO,SAAS,eACX,IAAA,EAGiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,KAAK,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,KAAA,IAAS,IAAA,GAAO,MAAA,GAAY,KAAA,CAAM,KAAK,CAAA;AAAA,IAChD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,KAAA,KAAgC,WAAA,CAAY,KAAA,EAAO,KAAK,CAAA;AAAA,IAClE;AAAA;AAEJ;;;;"}

package/dist/others/memoize-function.mjs

@@ -1,16 +1,16 @@
 function memoizeFunction(fn, argsToCacheKey) {
-    const mut_cache = new Map();
-    const defaultKey = Symbol('memoize-default-key');
-    return (...args) => {
-        const key = argsToCacheKey === undefined ? defaultKey : argsToCacheKey(...args);
-        const cached = mut_cache.get(key);
-        if (cached !== undefined) {
-            return cached.value;
-        }
-        const result = fn(...args);
-        mut_cache.set(key, { value: result });
-        return result;
-    };
+  const mut_cache = /* @__PURE__ */ new Map();
+  const defaultKey = /* @__PURE__ */ Symbol("memoize-default-key");
+  return (...args) => {
+    const key = argsToCacheKey === void 0 ? defaultKey : argsToCacheKey(...args);
+    const cached = mut_cache.get(key);
+    if (cached !== void 0) {
+      return cached.value;
+    }
+    const result = fn(...args);
+    mut_cache.set(key, { value: result });
+    return result;
+  };
 }
 
 export { memoizeFunction };

package/dist/others/memoize-function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"sourcesContent":[null],"names":[],"mappings":"AA0CM,SAAU,eAAe,CAK7B,EAAwB,EACxB,cAAqC,EAAA;AAIrC,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAA0B;AAEnD,IAAA,MAAM,UAAU,GAAG,MAAM,CAAC,qBAAqB,CAAC;AAEhD,IAAA,OAAO,CAAC,GAAG,IAAU,KAAO;AAC1B,QAAA,MAAM,GAAG,GACP,cAAc,KAAK,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC,GAAG,IAAI,CAAC;QAErE,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC;AAEjC,QAAA,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,OAAO,MAAM,CAAC,KAAK;QACrB;AAEA,QAAA,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;QAE1B,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAErC,QAAA,OAAO,MAAM;AACf,IAAA,CAAC;AACH;;;;"}
+{"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"sourcesContent":["import { type Primitive } from 'ts-type-forge';\n\n/**\n * Creates a memoized version of a function that caches results based on input\n * arguments.\n *\n * The memoized function stores results in an internal Map and returns cached\n * values for repeated calls with the same arguments. This can significantly\n * improve performance for expensive computations or I/O operations.\n *\n * **Important considerations:**\n *\n * - The cache grows unbounded - consider memory implications for long-running\n *   applications\n * - Cache keys must be primitives (string, number, boolean, symbol, null,\n *   undefined, bigint)\n * - Object arguments require careful key generation to ensure uniqueness\n * - Pure functions only - memoizing functions with side effects can lead to bugs\n *\n * @template A - The tuple type of the function arguments\n * @template R - The return type of the function\n * @template K - The primitive type used as the cache key (must be valid Map\n *   key)\n * @param fn - The pure function to memoize\n * @param argsToCacheKey - Function that converts arguments to a unique cache\n *   key. Optional for zero-argument functions.\n * @returns A memoized version of the input function with the same signature\n *\n * @see https://en.wikipedia.org/wiki/Memoization\n */\nexport function memoizeFunction<R>(fn: () => R): () => R;\n\nexport function memoizeFunction<\n  Arg0,\n  const RestArgs extends readonly unknown[],\n  R,\n  K extends Primitive,\n>(\n  fn: (arg0: Arg0, ...args: RestArgs) => R,\n  argsToCacheKey: (arg0: Arg0, ...args: RestArgs) => K,\n): (arg0: Arg0, ...args: RestArgs) => R;\n\nexport function memoizeFunction<\n  const Args extends readonly unknown[],\n  R,\n  K extends Primitive,\n>(\n  fn: (...args: Args) => R,\n  argsToCacheKey?: (...args: Args) => K,\n): (...args: Args) => R {\n  type CacheEntry = Readonly<{ value: R }>;\n\n  const mut_cache = new Map<K | symbol, CacheEntry>();\n\n  const defaultKey = Symbol('memoize-default-key');\n\n  return (...args: Args): R => {\n    const key: K | symbol =\n      argsToCacheKey === undefined ? defaultKey : argsToCacheKey(...args);\n\n    const cached = mut_cache.get(key);\n\n    if (cached !== undefined) {\n      return cached.value;\n    }\n\n    const result = fn(...args);\n\n    mut_cache.set(key, { value: result });\n\n    return result;\n  };\n}\n"],"names":[],"mappings":"AA0CO,SAAS,eAAA,CAKd,IACA,cAAA,EACsB;AAGtB,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAA4B;AAElD,EAAA,MAAM,UAAA,0BAAoB,qBAAqB,CAAA;AAE/C,EAAA,OAAO,IAAI,IAAA,KAAkB;AAC3B,IAAA,MAAM,MACJ,cAAA,KAAmB,MAAA,GAAY,UAAA,GAAa,cAAA,CAAe,GAAG,IAAI,CAAA;AAEpE,IAAA,MAAM,MAAA,GAAS,SAAA,CAAU,GAAA,CAAI,GAAG,CAAA;AAEhC,IAAA,IAAI,WAAW,MAAA,EAAW;AACxB,MAAA,OAAO,MAAA,CAAO,KAAA;AAAA,IAChB;AAEA,IAAA,MAAM,MAAA,GAAS,EAAA,CAAG,GAAG,IAAI,CAAA;AAEzB,IAAA,SAAA,CAAU,GAAA,CAAI,GAAA,EAAK,EAAE,KAAA,EAAO,QAAQ,CAAA;AAEpC,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;;"}

package/dist/others/tuple.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.d.mts","sourceRoot":"","sources":["../../src/others/tuple.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,EAAE,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EACnD,GAAG,MAAM,CAAC,KACT,QAAQ,CAAC,CAAC,CAAS,CAAC"}
+{"version":3,"file":"tuple.d.mts","sourceRoot":"","sources":["../../src/others/tuple.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,EAAE,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,WAC1C,CAAC,KACT,QAAQ,CAAC,CAAC,CAAS,CAAC"}

package/dist/others/tuple.mjs

@@ -1,53 +1,3 @@
-/**
- * Creates a readonly tuple from the given arguments with precise literal type
- * inference. It is a convenient shorthand for `[...args] as const`.
- *
- * @example
- *
- * ```ts
- * // Create a tuple with literal types preserved
- * const coordinates = tp(10, 20, 30);
- *
- * expectType<typeof coordinates, readonly [10, 20, 30]>('=');
- *
- * expectType<typeof coordinates, readonly number[]>('!=');
- *
- * assert.deepStrictEqual(coordinates, [10, 20, 30]);
- *
- * // The following two are equivalent
- * const a = tp(1, 2);
- *
- * const b = [1, 2] as const;
- *
- * expectType<typeof a, typeof b>('=');
- *
- * assert.deepStrictEqual(a, b);
- *
- * // Without tp, type would be number[]
- * const point = tp('x', 42, true);
- *
- * expectType<typeof point, readonly ['x', 42, true]>('=');
- *
- * assert.deepStrictEqual(point, ['x', 42, true]);
- *
- * // Useful for creating const tuples
- * const rgb = tp(255, 128, 0);
- *
- * expectType<typeof rgb, readonly [255, 128, 0]>('=');
- *
- * assert.isTrue(rgb[0] === 255);
- *
- * assert.isTrue(rgb[1] === 128);
- *
- * assert.isTrue(rgb[2] === 0);
- * ```
- *
- * @template T - A tuple type with literal types inferred from the arguments
- * @param args - The elements to include in the tuple (variadic)
- * @returns A readonly tuple containing the provided arguments with preserved
- *   literal types
- * @see https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types
- */
 const tp = (...args) => args;
 
 export { tp };

package/dist/others/tuple.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.mjs","sources":["../../src/others/tuple.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDG;AACI,MAAM,EAAE,GAAG,CAChB,GAAG,IAAO,KACM;;;;"}
+{"version":3,"file":"tuple.mjs","sources":["../../src/others/tuple.mts"],"sourcesContent":["/**\n * Creates a readonly tuple from the given arguments with precise literal type\n * inference. It is a convenient shorthand for `[...args] as const`.\n *\n * @example\n *\n * ```ts\n * // Create a tuple with literal types preserved\n * const coordinates = tp(10, 20, 30);\n *\n * expectType<typeof coordinates, readonly [10, 20, 30]>('=');\n *\n * expectType<typeof coordinates, readonly number[]>('!=');\n *\n * assert.deepStrictEqual(coordinates, [10, 20, 30]);\n *\n * // The following two are equivalent\n * const a = tp(1, 2);\n *\n * const b = [1, 2] as const;\n *\n * expectType<typeof a, typeof b>('=');\n *\n * assert.deepStrictEqual(a, b);\n *\n * // Without tp, type would be number[]\n * const point = tp('x', 42, true);\n *\n * expectType<typeof point, readonly ['x', 42, true]>('=');\n *\n * assert.deepStrictEqual(point, ['x', 42, true]);\n *\n * // Useful for creating const tuples\n * const rgb = tp(255, 128, 0);\n *\n * expectType<typeof rgb, readonly [255, 128, 0]>('=');\n *\n * assert.isTrue(rgb[0] === 255);\n *\n * assert.isTrue(rgb[1] === 128);\n *\n * assert.isTrue(rgb[2] === 0);\n * ```\n *\n * @template T - A tuple type with literal types inferred from the arguments\n * @param args - The elements to include in the tuple (variadic)\n * @returns A readonly tuple containing the provided arguments with preserved\n *   literal types\n * @see https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types\n */\nexport const tp = <const T extends readonly unknown[]>(\n  ...args: T\n): Readonly<T> => args;\n"],"names":[],"mappings":"AAkDO,MAAM,EAAA,GAAK,IACb,IAAA,KACa;;;;"}

package/dist/others/unknown-to-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MAuEF,CAAC"}
+{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,eAAe,UACnB,OAAO,YACJ,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MAuEF,CAAC"}

package/dist/others/unknown-to-string.mjs

@@ -1,96 +1,49 @@
 import { isDate, isRegExp, isError, isMap, isSet } from '@sindresorhus/is';
 
-/**
- * Converts an unknown value to its string representation in a type-safe manner.
- *
- * This function handles all JavaScript types and provides consistent string
- * conversion with proper error handling for edge cases like circular
- * references. Unlike naive toString() calls, this function never throws and
- * handles all value types gracefully.
- *
- * **Type conversion rules:**
- *
- * - Strings: returned as-is
- * - Numbers, booleans, bigints: converted via toString()
- * - Symbols: converted to their description string
- * - Functions: converted to their string representation
- * - null: returns "null" (not "null" from JSON)
- * - undefined: returns "undefined"
- * - Date: converted to ISO string
- * - RegExp: converted to regex literal string
- * - Map: converted to Map representation with entries
- * - Set: converted to Set representation with values
- * - Error: returns error message
- * - Objects: JSON stringified (with optional pretty printing)
- *
- * @param value - The unknown value to convert to string
- * @param options - Optional configuration for the conversion
- * @param options.prettyPrintObject - If true, objects are formatted with
- *   2-space indentation
- * @returns The string representation of the value. For circular references or
- *   non-serializable objects, returns an error message string
- *
- *   **Error Handling:** Circular references and non-serializable objects return
- *   descriptive error messages instead of throwing
- * @see JSON.stringify - Underlying serialization for objects
- */
 const unknownToString = (value, options) => {
-    switch (typeof value) {
-        case 'string':
-            return value;
-        case 'bigint':
-            return `${value.toString()}n`;
-        case 'number':
-        case 'boolean':
-        case 'symbol':
-        case 'function':
-            return value.toString();
-        case 'undefined':
-            return 'undefined';
-        case 'object': {
-            if (value === null) {
-                return 'null';
-            }
-            try {
-                // Special handling for Date
-                if (isDate(value)) {
-                    return value.toISOString();
-                }
-                // Special handling for RegExp
-                if (isRegExp(value)) {
-                    return value.toString();
-                }
-                if (isError(value)) {
-                    return value.message;
-                }
-                const prettyPrintObject = options?.prettyPrintObject === true;
-                // Special handling for Map
-                if (isMap(value)) {
-                    const entries = Array.from(value);
-                    const entriesStr = prettyPrintObject
-                        ? JSON.stringify(entries, undefined, 2)
-                        : JSON.stringify(entries);
-                    return `Map(${entriesStr})`;
-                }
-                // Special handling for Set
-                if (isSet(value)) {
-                    const values = Array.from(value);
-                    const valuesStr = prettyPrintObject
-                        ? JSON.stringify(values, undefined, 2)
-                        : JSON.stringify(values);
-                    return `Set(${valuesStr})`;
-                }
-                return prettyPrintObject
-                    ? JSON.stringify(value, undefined, 2)
-                    : JSON.stringify(value);
-            }
-            catch (error) {
-                return isError(error)
-                    ? error.message
-                    : '[Circular or Non-serializable]';
-            }
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "bigint":
+      return `${value.toString()}n`;
+    case "number":
+    case "boolean":
+    case "symbol":
+    case "function":
+      return value.toString();
+    case "undefined":
+      return "undefined";
+    case "object": {
+      if (value === null) {
+        return "null";
+      }
+      try {
+        if (isDate(value)) {
+          return value.toISOString();
         }
+        if (isRegExp(value)) {
+          return value.toString();
+        }
+        if (isError(value)) {
+          return value.message;
+        }
+        const prettyPrintObject = options?.prettyPrintObject === true;
+        if (isMap(value)) {
+          const entries = Array.from(value);
+          const entriesStr = prettyPrintObject ? JSON.stringify(entries, void 0, 2) : JSON.stringify(entries);
+          return `Map(${entriesStr})`;
+        }
+        if (isSet(value)) {
+          const values = Array.from(value);
+          const valuesStr = prettyPrintObject ? JSON.stringify(values, void 0, 2) : JSON.stringify(values);
+          return `Set(${valuesStr})`;
+        }
+        return prettyPrintObject ? JSON.stringify(value, void 0, 2) : JSON.stringify(value);
+      } catch (error) {
+        return isError(error) ? error.message : "[Circular or Non-serializable]";
+      }
     }
+  }
 };
 
 export { unknownToString };

package/dist/others/unknown-to-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG;AAE/B,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;QAEpB,KAAK,QAAQ,EAAE;AACb,YAAA,IAAI,KAAK,KAAK,IAAI,EAAE;AAClB,gBAAA,OAAO,MAAM;YACf;AAEA,YAAA,IAAI;;AAEF,gBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE;AACjB,oBAAA,OAAO,KAAK,CAAC,WAAW,EAAE;gBAC5B;;AAGA,gBAAA,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;AACnB,oBAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;gBACzB;AAEA,gBAAA,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;oBAClB,OAAO,KAAK,CAAC,OAAO;gBACtB;AAEA,gBAAA,MAAM,iBAAiB,GAAG,OAAO,EAAE,iBAAiB,KAAK,IAAI;;AAG7D,gBAAA,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;oBAChB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;oBAEjC,MAAM,UAAU,GAAG;0BACf,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC;AACtC,0BAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;oBAE3B,OAAO,CAAA,IAAA,EAAO,UAAU,CAAA,CAAA,CAAG;gBAC7B;;AAGA,gBAAA,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;oBAChB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;oBAEhC,MAAM,SAAS,GAAG;0BACd,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC;AACrC,0BAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;oBAE1B,OAAO,CAAA,IAAA,EAAO,SAAS,CAAA,CAAA,CAAG;gBAC5B;AAEA,gBAAA,OAAO;sBACH,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;YAC3B;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,OAAO,CAAC,KAAK;sBAChB,KAAK,CAAC;sBACN,gCAAgC;YACtC;QACF;;AAEJ;;;;"}
+{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":["import { isDate, isError, isMap, isRegExp, isSet } from '@sindresorhus/is';\n\n/**\n * Converts an unknown value to its string representation in a type-safe manner.\n *\n * This function handles all JavaScript types and provides consistent string\n * conversion with proper error handling for edge cases like circular\n * references. Unlike naive toString() calls, this function never throws and\n * handles all value types gracefully.\n *\n * **Type conversion rules:**\n *\n * - Strings: returned as-is\n * - Numbers, booleans, bigints: converted via toString()\n * - Symbols: converted to their description string\n * - Functions: converted to their string representation\n * - null: returns \"null\" (not \"null\" from JSON)\n * - undefined: returns \"undefined\"\n * - Date: converted to ISO string\n * - RegExp: converted to regex literal string\n * - Map: converted to Map representation with entries\n * - Set: converted to Set representation with values\n * - Error: returns error message\n * - Objects: JSON stringified (with optional pretty printing)\n *\n * @param value - The unknown value to convert to string\n * @param options - Optional configuration for the conversion\n * @param options.prettyPrintObject - If true, objects are formatted with\n *   2-space indentation\n * @returns The string representation of the value. For circular references or\n *   non-serializable objects, returns an error message string\n *\n *   **Error Handling:** Circular references and non-serializable objects return\n *   descriptive error messages instead of throwing\n * @see JSON.stringify - Underlying serialization for objects\n */\nexport const unknownToString = (\n  value: unknown,\n  options?: Partial<Readonly<{ prettyPrintObject: boolean }>>,\n): string => {\n  switch (typeof value) {\n    case 'string':\n      return value;\n\n    case 'bigint':\n      return `${value.toString()}n`;\n\n    case 'number':\n    case 'boolean':\n    case 'symbol':\n    case 'function':\n      return value.toString();\n\n    case 'undefined':\n      return 'undefined';\n\n    case 'object': {\n      if (value === null) {\n        return 'null';\n      }\n\n      try {\n        // Special handling for Date\n        if (isDate(value)) {\n          return value.toISOString();\n        }\n\n        // Special handling for RegExp\n        if (isRegExp(value)) {\n          return value.toString();\n        }\n\n        if (isError(value)) {\n          return value.message;\n        }\n\n        const prettyPrintObject = options?.prettyPrintObject === true;\n\n        // Special handling for Map\n        if (isMap(value)) {\n          const entries = Array.from(value);\n\n          const entriesStr = prettyPrintObject\n            ? JSON.stringify(entries, undefined, 2)\n            : JSON.stringify(entries);\n\n          return `Map(${entriesStr})`;\n        }\n\n        // Special handling for Set\n        if (isSet(value)) {\n          const values = Array.from(value);\n\n          const valuesStr = prettyPrintObject\n            ? JSON.stringify(values, undefined, 2)\n            : JSON.stringify(values);\n\n          return `Set(${valuesStr})`;\n        }\n\n        return prettyPrintObject\n          ? JSON.stringify(value, undefined, 2)\n          : JSON.stringify(value);\n      } catch (error) {\n        return isError(error)\n          ? error.message\n          : '[Circular or Non-serializable]';\n      }\n    }\n  }\n};\n"],"names":[],"mappings":";;AAoCO,MAAM,eAAA,GAAkB,CAC7B,KAAA,EACA,OAAA,KACW;AACX,EAAA,QAAQ,OAAO,KAAA;AAAO,IACpB,KAAK,QAAA;AACH,MAAA,OAAO,KAAA;AAAA,IAET,KAAK,QAAA;AACH,MAAA,OAAO,CAAA,EAAG,KAAA,CAAM,QAAA,EAAU,CAAA,CAAA,CAAA;AAAA,IAE5B,KAAK,QAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,UAAA;AACH,MAAA,OAAO,MAAM,QAAA,EAAS;AAAA,IAExB,KAAK,WAAA;AACH,MAAA,OAAO,WAAA;AAAA,IAET,KAAK,QAAA,EAAU;AACb,MAAA,IAAI,UAAU,IAAA,EAAM;AAClB,QAAA,OAAO,MAAA;AAAA,MACT;AAEA,MAAA,IAAI;AAEF,QAAA,IAAI,MAAA,CAAO,KAAK,CAAA,EAAG;AACjB,UAAA,OAAO,MAAM,WAAA,EAAY;AAAA,QAC3B;AAGA,QAAA,IAAI,QAAA,CAAS,KAAK,CAAA,EAAG;AACnB,UAAA,OAAO,MAAM,QAAA,EAAS;AAAA,QACxB;AAEA,QAAA,IAAI,OAAA,CAAQ,KAAK,CAAA,EAAG;AAClB,UAAA,OAAO,KAAA,CAAM,OAAA;AAAA,QACf;AAEA,QAAA,MAAM,iBAAA,GAAoB,SAAS,iBAAA,KAAsB,IAAA;AAGzD,QAAA,IAAI,KAAA,CAAM,KAAK,CAAA,EAAG;AAChB,UAAA,MAAM,OAAA,GAAU,KAAA,CAAM,IAAA,CAAK,KAAK,CAAA;AAEhC,UAAA,MAAM,UAAA,GAAa,iBAAA,GACf,IAAA,CAAK,SAAA,CAAU,OAAA,EAAS,QAAW,CAAC,CAAA,GACpC,IAAA,CAAK,SAAA,CAAU,OAAO,CAAA;AAE1B,UAAA,OAAO,OAAO,UAAU,CAAA,CAAA,CAAA;AAAA,QAC1B;AAGA,QAAA,IAAI,KAAA,CAAM,KAAK,CAAA,EAAG;AAChB,UAAA,MAAM,MAAA,GAAS,KAAA,CAAM,IAAA,CAAK,KAAK,CAAA;AAE/B,UAAA,MAAM,SAAA,GAAY,iBAAA,GACd,IAAA,CAAK,SAAA,CAAU,MAAA,EAAQ,QAAW,CAAC,CAAA,GACnC,IAAA,CAAK,SAAA,CAAU,MAAM,CAAA;AAEzB,UAAA,OAAO,OAAO,SAAS,CAAA,CAAA,CAAA;AAAA,QACzB;AAEA,QAAA,OAAO,iBAAA,GACH,KAAK,SAAA,CAAU,KAAA,EAAO,QAAW,CAAC,CAAA,GAClC,IAAA,CAAK,SAAA,CAAU,KAAK,CAAA;AAAA,MAC1B,SAAS,KAAA,EAAO;AACd,QAAA,OAAO,OAAA,CAAQ,KAAK,CAAA,GAChB,KAAA,CAAM,OAAA,GACN,gCAAA;AAAA,MACN;AAAA,IACF;AAAA;AAEJ;;;;"}

package/dist/promise/promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"promise.d.mts","sourceRoot":"","sources":["../../src/promise/promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,KAC5E,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIK,CAAC"}
+{"version":3,"file":"promise.d.mts","sourceRoot":"","sources":["../../src/promise/promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,YACtB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,KAC5E,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIK,CAAC"}

package/dist/promise/promise.mjs

@@ -1,55 +1,10 @@
 import { fromPromise } from '../functional/result/impl/result-from-promise.mjs';
 import '@sindresorhus/is';
 
-/**
- * Creates a Promise that wraps the result in a Result type for type-safe error
- * handling. This function is an alternative to `new Promise(executor)` that
- * provides enhanced type safety by returning a Result type instead of throwing
- * exceptions.
- *
- * @example
- *
- * ```ts
- * // Create a promise that resolves successfully
- * const successPromise = createPromise<number, string>((resolve) => {
- *   setTimeout(() => {
- *     resolve(42);
- *   }, 0);
- * });
- *
- * const successResult = await successPromise;
- *
- * assert.isTrue(Result.isOk(successResult));
- *
- * if (Result.isOk(successResult)) {
- *   assert.isTrue(successResult.value === 42);
- * }
- *
- * // Create a promise that rejects with an error
- * const errorPromise = createPromise<number, string>((_, reject) => {
- *   setTimeout(() => {
- *     reject('Something went wrong');
- *   }, 0);
- * });
- *
- * const errorResult = await errorPromise;
- *
- * assert.isTrue(Result.isErr(errorResult));
- *
- * if (Result.isErr(errorResult)) {
- *   assert.isTrue(errorResult.value === 'Something went wrong');
- * }
- * ```
- *
- * @template S - The type of successful value
- * @template E - The type of error value
- * @param executor - Function that takes resolve and reject callbacks
- * @returns A Promise that resolves to a Result containing either success or
- *   error
- */
-const createPromise = (executor) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-fromPromise(new Promise(executor));
+const createPromise = (executor) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  fromPromise(new Promise(executor))
+);
 
 export { createPromise };
 //# sourceMappingURL=promise.mjs.map

package/dist/promise/promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"promise.mjs","sources":["../../src/promise/promise.mts"],"sourcesContent":[null],"names":["Result.fromPromise"],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CG;AACI,MAAM,aAAa,GAAG,CAC3B,QAA6E;AAE7E;AACAA,WAAkB,CAAC,IAAI,OAAO,CAAI,QAAQ,CAAC;;;;"}
+{"version":3,"file":"promise.mjs","sources":["../../src/promise/promise.mts"],"sourcesContent":["import { Result } from '../functional/index.mjs';\n\n/**\n * Creates a Promise that wraps the result in a Result type for type-safe error\n * handling. This function is an alternative to `new Promise(executor)` that\n * provides enhanced type safety by returning a Result type instead of throwing\n * exceptions.\n *\n * @example\n *\n * ```ts\n * // Create a promise that resolves successfully\n * const successPromise = createPromise<number, string>((resolve) => {\n *   setTimeout(() => {\n *     resolve(42);\n *   }, 0);\n * });\n *\n * const successResult = await successPromise;\n *\n * assert.isTrue(Result.isOk(successResult));\n *\n * if (Result.isOk(successResult)) {\n *   assert.isTrue(successResult.value === 42);\n * }\n *\n * // Create a promise that rejects with an error\n * const errorPromise = createPromise<number, string>((_, reject) => {\n *   setTimeout(() => {\n *     reject('Something went wrong');\n *   }, 0);\n * });\n *\n * const errorResult = await errorPromise;\n *\n * assert.isTrue(Result.isErr(errorResult));\n *\n * if (Result.isErr(errorResult)) {\n *   assert.isTrue(errorResult.value === 'Something went wrong');\n * }\n * ```\n *\n * @template S - The type of successful value\n * @template E - The type of error value\n * @param executor - Function that takes resolve and reject callbacks\n * @returns A Promise that resolves to a Result containing either success or\n *   error\n */\nexport const createPromise = <S, E>(\n  executor: (resolve: (value: S) => void, reject: (reason?: E) => void) => void,\n): Promise<Result<S, E>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Result.fromPromise(new Promise<S>(executor)) satisfies Promise<\n    Result<S, unknown>\n  > as Promise<Result<S, E>>;\n"],"names":["Result.fromPromise"],"mappings":";;;AAgDO,MAAM,gBAAgB,CAC3B,QAAA;AAAA;AAAA,EAGAA,WAAO,CAAY,IAAI,OAAA,CAAW,QAAQ,CAAC;AAAA;;;;"}