ts-data-forge 14.6.1 → 14.6.2

package/dist/others/tuple.mjs

@@ -1,4 +1,52 @@
-const tp = (...args) => args;
-
-export { tp };
-//# sourceMappingURL=tuple.mjs.map
+/**
+ * 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
+ */
+export const tp = (...args) => args;
+//# sourceMappingURL=tuple.mjs.map

package/dist/others/tuple.mjs.map

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"tuple.mjs","sourceRoot":"","sources":["../../src/others/tuple.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,CAChB,GAAG,IAAO,EACG,EAAE,CAAC,IAAI,CAAC"}

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

@@ -1,50 +1,94 @@
-import { isDate, isRegExp, isError, isMap, isSet } from '@sindresorhus/is';
-
-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 {
-        if (isDate(value)) {
-          return value.toISOString();
+import { isDate, isError, isMap, isRegExp, 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
+ */
+export 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]';
+            }
         }
-        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 };
-//# sourceMappingURL=unknown-to-string.mjs.map
+//# sourceMappingURL=unknown-to-string.mjs.map

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":["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;;;;"}
+{"version":3,"file":"unknown-to-string.mjs","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,EACnD,EAAE;IACV,QAAQ,OAAO,KAAK,EAAE,CAAC;QACrB,KAAK,QAAQ;YACX,OAAO,KAAK,CAAC;QAEf,KAAK,QAAQ;YACX,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC;QAEhC,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,QAAQ,CAAC;QACd,KAAK,UAAU;YACb,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;QAE1B,KAAK,WAAW;YACd,OAAO,WAAW,CAAC;QAErB,KAAK,QAAQ,EAAE,CAAC;YACd,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,OAAO,MAAM,CAAC;YAChB,CAAC;YAED,IAAI,CAAC;gBACH,4BAA4B;gBAC5B,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;oBAClB,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC7B,CAAC;gBAED,8BAA8B;gBAC9B,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;oBACpB,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;gBAC1B,CAAC;gBAED,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;oBACnB,OAAO,KAAK,CAAC,OAAO,CAAC;gBACvB,CAAC;gBAED,MAAM,iBAAiB,GAAG,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;gBAE9D,2BAA2B;gBAC3B,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;oBACjB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAElC,MAAM,UAAU,GAAG,iBAAiB;wBAClC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;wBACvC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;oBAE5B,OAAO,OAAO,UAAU,GAAG,CAAC;gBAC9B,CAAC;gBAED,2BAA2B;gBAC3B,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;oBACjB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAEjC,MAAM,SAAS,GAAG,iBAAiB;wBACjC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;wBACtC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;oBAE3B,OAAO,OAAO,SAAS,GAAG,CAAC;gBAC7B,CAAC;gBAED,OAAO,iBAAiB;oBACtB,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;oBACrC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,OAAO,CAAC,KAAK,CAAC;oBACnB,CAAC,CAAC,KAAK,CAAC,OAAO;oBACf,CAAC,CAAC,gCAAgC,CAAC;YACvC,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAC"}

package/dist/promise/index.mjs

@@ -1,2 +1,2 @@
-export { createPromise } from './promise.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './promise.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/promise/index.mjs.map

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

package/dist/promise/promise.mjs

@@ -1,10 +1,51 @@
-import { fromPromise } from '../functional/result/impl/result-from-promise.mjs';
-import '@sindresorhus/is';
-
-const createPromise = (executor) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  fromPromise(new Promise(executor))
-);
-
-export { createPromise };
-//# sourceMappingURL=promise.mjs.map
+import { Result } from '../functional/index.mjs';
+/**
+ * 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
+ */
+export const createPromise = (executor) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Result.fromPromise(new Promise(executor));
+//# sourceMappingURL=promise.mjs.map

package/dist/promise/promise.mjs.map

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"promise.mjs","sourceRoot":"","sources":["../../src/promise/promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,QAA6E,EACtD,EAAE;AACzB,oEAAoE;AACpE,MAAM,CAAC,WAAW,CAAC,IAAI,OAAO,CAAI,QAAQ,CAAC,CAEjB,CAAC"}

package/dist/string/index.mjs

@@ -1,2 +1,2 @@
-export { Str } from './str.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './str.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/string/index.mjs.map

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