ts-data-forge 14.6.1 → 14.6.3

package/dist/others/tuple.mjs

@@ -1,4 +1,52 @@
-const tp = (...args) => args;
 
-export { tp };
-//# sourceMappingURL=tuple.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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();
-        }
-        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})`;
+import { isDate, isError, isMap, isRegExp, isSet } from '@sindresorhus/is';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 {
+
+                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, undefined, 2)
+                        : JSON.stringify(entries);
+                    return `Map(${entriesStr})`;
+                }
+
+                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]';
+            }
         }
-        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';
+import { Result } from '../functional/index.mjs';
 
-const createPromise = (executor) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  fromPromise(new Promise(executor))
-);
 
-export { createPromise };
-//# sourceMappingURL=promise.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const createPromise = (executor) => 
+
+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"}

package/dist/string/str.mjs

@@ -1,88 +1,255 @@
-var Str;
-((Str2) => {
-  Str2.isMinLengthString = (minLength, s) => s.length >= minLength;
-  Str2.isMaxLengthString = (maxLength, s) => s.length <= maxLength;
-  Str2.isBoundedLengthString = (minLength, maxLength, s) => s.length >= minLength && s.length <= maxLength;
-  Str2.isFixedLengthString = (length, s) => s.length === length;
-  function asMinLengthString(...args) {
-    switch (args.length) {
-      case 2:
-        return asMinLengthStringImpl(...args);
-      case 1:
-        return (s) => asMinLengthStringImpl(args[0], s);
-    }
-  }
-  Str2.asMinLengthString = asMinLengthString;
-  const asMinLengthStringImpl = (minLength, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isMinLengthString)(minLength, s)) {
-      throw new TypeError(
-        `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`
-      );
-    }
-    return s;
-  };
-  function asMaxLengthString(...args) {
-    switch (args.length) {
-      case 2:
-        return asMaxLengthStringImpl(...args);
-      case 1:
-        return (s) => asMaxLengthStringImpl(args[0], s);
-    }
-  }
-  Str2.asMaxLengthString = asMaxLengthString;
-  const asMaxLengthStringImpl = (maxLength, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isMaxLengthString)(maxLength, s)) {
-      throw new TypeError(
-        `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`
-      );
-    }
-    return s;
-  };
-  function asBoundedLengthString(...args) {
-    switch (args.length) {
-      case 3:
-        return asBoundedLengthStringImpl(...args);
-      case 2:
-        return (s) => asBoundedLengthStringImpl(...args, s);
-    }
-  }
-  Str2.asBoundedLengthString = asBoundedLengthString;
-  const asBoundedLengthStringImpl = (minLength, maxLength, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isBoundedLengthString)(minLength, maxLength, s)) {
-      throw new TypeError(
-        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`
-      );
+
+
+
+
+
+
+
+
+
+export var Str;
+(function (Str) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Str.isMinLengthString = (minLength, s) => s.length >= minLength;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Str.isMaxLengthString = (maxLength, s) => s.length <= maxLength;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Str.isBoundedLengthString = (minLength, maxLength, s) => s.length >= minLength && s.length <= maxLength;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Str.isFixedLengthString = (length, s) => s.length === length;
+    function asMinLengthString(...args) {
+        switch (args.length) {
+            case 2:
+                return asMinLengthStringImpl(...args);
+            case 1:
+                return (s) => asMinLengthStringImpl(args[0], s);
+        }
     }
-    return s;
-  };
-  function asFixedLengthString(...args) {
-    switch (args.length) {
-      case 2:
-        return asFixedLengthStringImpl(...args);
-      case 1:
-        return (s) => asFixedLengthStringImpl(args[0], s);
+    Str.asMinLengthString = asMinLengthString;
+    const asMinLengthStringImpl = (minLength, s) => {
+        const actualLength = s.length;
+        if (!Str.isMinLengthString(minLength, s)) {
+            throw new TypeError(`Expected a string of length >= ${minLength}, got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+    function asMaxLengthString(...args) {
+        switch (args.length) {
+            case 2:
+                return asMaxLengthStringImpl(...args);
+            case 1:
+                return (s) => asMaxLengthStringImpl(args[0], s);
+        }
     }
-  }
-  Str2.asFixedLengthString = asFixedLengthString;
-  const asFixedLengthStringImpl = (length, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isFixedLengthString)(length, s)) {
-      throw new TypeError(
-        `Expected a string of length ${length}, got a string of length ${actualLength}`
-      );
+    Str.asMaxLengthString = asMaxLengthString;
+    const asMaxLengthStringImpl = (maxLength, s) => {
+        const actualLength = s.length;
+        if (!Str.isMaxLengthString(maxLength, s)) {
+            throw new TypeError(`Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+    function asBoundedLengthString(...args) {
+        switch (args.length) {
+            case 3:
+                return asBoundedLengthStringImpl(...args);
+            case 2:
+                return (s) => asBoundedLengthStringImpl(...args, s);
+        }
     }
-    return s;
-  };
-  Str2.asNonEmptyString = (s) => {
-    if (!(0, Str2.isMinLengthString)(1, s)) {
-      throw new TypeError("Expected a non-empty string, got an empty string");
+    Str.asBoundedLengthString = asBoundedLengthString;
+    const asBoundedLengthStringImpl = (minLength, maxLength, s) => {
+        const actualLength = s.length;
+        if (!Str.isBoundedLengthString(minLength, maxLength, s)) {
+            throw new TypeError(`Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+    function asFixedLengthString(...args) {
+        switch (args.length) {
+            case 2:
+                return asFixedLengthStringImpl(...args);
+            case 1:
+                return (s) => asFixedLengthStringImpl(args[0], s);
+        }
     }
-    return s;
-  };
-})(Str || (Str = {}));
+    Str.asFixedLengthString = asFixedLengthString;
+    const asFixedLengthStringImpl = (length, s) => {
+        const actualLength = s.length;
+        if (!Str.isFixedLengthString(length, s)) {
+            throw new TypeError(`Expected a string of length ${length}, got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+
+
+
+
+
 
-export { Str };
-//# sourceMappingURL=str.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Str.asNonEmptyString = (s) => {
+        if (!Str.isMinLengthString(1, s)) {
+            throw new TypeError('Expected a non-empty string, got an empty string');
+        }
+        return s;
+    };
+})(Str || (Str = {}));
+//# sourceMappingURL=str.mjs.map