@duplojs/utils 1.4.35 → 1.4.37

package/dist/common/asserts.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var errorKindNamespace = require('./errorKindNamespace.cjs');
+var kind = require('./kind.cjs');
+
+class AssertsError extends kind.kindHeritage("asserts-error", errorKindNamespace.createErrorKind("asserts-error"), Error) {
+    value;
+    constructor(value) {
+        super({}, ["Asserts Error."]);
+        this.value = value;
+    }
+}
+/**
+ * {@include common/asserts/index.md}
+ */
+function asserts(input, predicate) {
+    if (!predicate(input)) {
+        throw new AssertsError(input);
+    }
+}
+
+exports.AssertsError = AssertsError;
+exports.asserts = asserts;

package/dist/common/asserts.d.ts

@@ -0,0 +1,38 @@
+declare const AssertsError_base: new (params: {
+    "@DuplojsUtilsError/asserts-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"asserts-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/asserts-error", unknown>, unknown>;
+export declare class AssertsError extends AssertsError_base {
+    value: unknown;
+    constructor(value: unknown);
+}
+/**
+ * The asserts() function throws when a predicate fails and narrows the input type when it passes.
+ * 
+ * **Supported call styles:**
+ * - Classic: `asserts(input, predicate)` → narrows the input type or throws
+ * 
+ * It throws an `AssertsError` with the failing input value.
+ * 
+ * ```ts
+ * const input: string | number = "demo";
+ * asserts(input, isType("string"));
+ * 
+ * const payload: { id?: number } = { id: 1 };
+ * asserts(payload.id, isType("undefined"));
+ * 
+ * try {
+ * 	asserts(42 as string | number, isType("string"));
+ * } catch (error) {
+ * 	if (error instanceof AssertsError) {
+ * 		const failedValue = error.value;
+ * 	}
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/asserts
+ * 
+ * @namespace C
+ * 
+ */
+export declare function asserts<GenericInput extends unknown, GenericPredicate extends GenericInput>(input: GenericInput, predicate: (input: GenericInput) => input is GenericPredicate): asserts input is GenericPredicate;
+export {};

package/dist/common/asserts.mjs

@@ -0,0 +1,20 @@
+import { createErrorKind } from './errorKindNamespace.mjs';
+import { kindHeritage } from './kind.mjs';
+
+class AssertsError extends kindHeritage("asserts-error", createErrorKind("asserts-error"), Error) {
+    value;
+    constructor(value) {
+        super({}, ["Asserts Error."]);
+        this.value = value;
+    }
+}
+/**
+ * {@include common/asserts/index.md}
+ */
+function asserts(input, predicate) {
+    if (!predicate(input)) {
+        throw new AssertsError(input);
+    }
+}
+
+export { AssertsError, asserts };

package/dist/common/index.d.ts

@@ -14,7 +14,7 @@
  * 
  * What you will find in this namespace:
  * - composition helpers (`pipe`, `innerPipe`, `asyncPipe`, `asyncInnerPipe`, `forward`)
- * - predicates and guards (`when`, `whenNot`, `whenElse`, `and`, `or`, `isType`, `instanceOf`)
+ * - predicates and guards (`when`, `whenNot`, `whenElse`, `and`, `or`, `isType`, `asserts`, `instanceOf`)
  * - control flow (`loop`, `asyncLoop`, `asyncRetry`, `sleep`, `memo`)
  * - promise utilities (`externalPromise`, `promiseObject`)
  * - string and value conversions (`toString`, `stringToMillisecond`, `stringToBytes`, `escapeRegExp`)
@@ -74,3 +74,4 @@ export * from "./hasSomeKinds";
 export * from "./hasKinds";
 export * from "./toCurriedPredicate";
 export * from "./pipeCall";
+export * from "./asserts";

package/dist/common/simpleClone.cjs

@@ -12,10 +12,17 @@ function simpleClone(unknownValue) {
     }
     else if (unknownValue.constructor === undefined
         || unknownValue.constructor.name === "Object") {
-        return Object.entries(unknownValue).reduce((pv, [key, value]) => {
-            pv[key] = simpleClone(value);
-            return pv;
-        }, {});
+        const result = {};
+        for (const key in unknownValue) {
+            const desc = Object.getOwnPropertyDescriptor(unknownValue, key);
+            if (desc?.set || desc?.get) {
+                Object.defineProperty(result, key, desc);
+            }
+            else {
+                result[key] = simpleClone(unknownValue[key]);
+            }
+        }
+        return result;
     }
     else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
         return unknownValue.map(simpleClone);

package/dist/common/simpleClone.mjs

@@ -10,10 +10,17 @@ function simpleClone(unknownValue) {
     }
     else if (unknownValue.constructor === undefined
         || unknownValue.constructor.name === "Object") {
-        return Object.entries(unknownValue).reduce((pv, [key, value]) => {
-            pv[key] = simpleClone(value);
-            return pv;
-        }, {});
+        const result = {};
+        for (const key in unknownValue) {
+            const desc = Object.getOwnPropertyDescriptor(unknownValue, key);
+            if (desc?.set || desc?.get) {
+                Object.defineProperty(result, key, desc);
+            }
+            else {
+                result[key] = simpleClone(unknownValue[key]);
+            }
+        }
+        return result;
     }
     else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
         return unknownValue.map(simpleClone);

package/dist/common/types/index.d.ts

@@ -44,3 +44,4 @@ export * from "./sortType";
 export * from "./maybeGetter";
 export * from "./falsyValue";
 export * from "./DeepReadonly";
+export * from "./json";

package/dist/common/types/json.d.ts

@@ -0,0 +1,4 @@
+import { type MaybeArray } from "./maybeArray";
+export type Json = MaybeArray<string | undefined | boolean | number | null | {
+    [key: string]: Json;
+}>;

package/dist/dataParser/base.cjs

@@ -27,7 +27,7 @@ const DPE = error.createError();
 const EE = error$1.error(null);
 const ES = success.success(null);
 const KWV = wrapValue.keyWrappedValue;
-function dataParserInit(kind, definition, exec) {
+function dataParserInit(kind, definition, exec, specificOverrideHandler) {
     const formattedExec = typeof exec === "object"
         ? exec
         : {
@@ -35,18 +35,18 @@ function dataParserInit(kind, definition, exec) {
             async: exec,
         };
     function middleExec(data, error$1) {
-        let result = formattedExec.sync(data, error$1, dataParser);
+        let result = formattedExec.sync(data, error$1, self);
         if (result === SDPEI) {
-            error.addIssue(error$1, dataParser, data);
+            error.addIssue(error$1, self, data);
             return SDPE;
         }
         else if (result === SDPEPI) {
-            error.addPromiseIssue(error$1, dataParser, data);
+            error.addPromiseIssue(error$1, self, data);
             return SDPE;
         }
         else if (result !== SDPE
-            && dataParser.definition.checkers.length) {
-            for (const checker of dataParser.definition.checkers) {
+            && self.definition.checkers.length) {
+            for (const checker of self.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
                 if (checkerResult === SDPEI) {
                     error.addIssue(error$1, checker, result);
@@ -60,18 +60,18 @@ function dataParserInit(kind, definition, exec) {
         return result;
     }
     async function middleAsyncExec(data, error$1) {
-        let result = await formattedExec.async(data, error$1, dataParser);
+        let result = await formattedExec.async(data, error$1, self);
         if (result === SDPEI) {
-            error.addIssue(error$1, dataParser, data);
+            error.addIssue(error$1, self, data);
             return SDPE;
         }
         else if (result === SDPEPI) {
-            error.addPromiseIssue(error$1, dataParser, data);
+            error.addPromiseIssue(error$1, self, data);
             return SDPE;
         }
         else if (result !== SDPE
-            && dataParser.definition.checkers.length) {
-            for (const checker of dataParser.definition.checkers) {
+            && self.definition.checkers.length) {
+            for (const checker of self.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
                 if (checkerResult === SDPEI) {
                     error.addIssue(error$1, checker, result);
@@ -84,7 +84,7 @@ function dataParserInit(kind, definition, exec) {
         }
         return result;
     }
-    const dataParser = pipe.pipe({
+    const self = pipe.pipe({
         definition,
         exec: middleExec,
         asyncExec: middleAsyncExec,
@@ -127,10 +127,11 @@ function dataParserInit(kind, definition, exec) {
         addChecker: (...checkers) => dataParserInit(kind, simpleClone.simpleClone({
             ...definition,
             checkers: [...definition.checkers, ...checkers],
-        }), exec),
-        clone: () => dataParserInit(kind, simpleClone.simpleClone(definition), exec),
-    }, (value) => dataParserKind.setTo(value, null), kind.setTo, dataParserInit.overrideHandler.apply);
-    return dataParser;
+        }), exec, specificOverrideHandler),
+        clone: () => dataParserInit(kind, simpleClone.simpleClone(definition), exec, specificOverrideHandler),
+        contract: () => self,
+    }, (value) => dataParserKind.setTo(value, null), kind.setTo, (value) => dataParserInit.overrideHandler.apply(value), (value) => specificOverrideHandler.apply(value));
+    return self;
 }
 dataParserInit.overrideHandler = override.createOverride("@duplojs/utils/data-parser/base");
 

package/dist/dataParser/base.d.ts

@@ -1,4 +1,4 @@
-import { type GetKindHandler, type GetKindValue, type Kind, type KindHandler, type RemoveKind } from "../common";
+import { type GetKindHandler, type GetKindValue, type IsEqual, type Kind, type KindHandler, type OverrideHandler, type RemoveKind } from "../common";
 import { SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue, type DataParserError } from "./error";
 import * as DEither from "../either";
 export declare const SymbolDataParserErrorLabel = "SymbolDataParserError";
@@ -22,6 +22,7 @@ export interface DataParserDefinition<GenericChecker extends DataParserChecker =
     readonly errorMessage?: string;
     readonly checkers: readonly GenericChecker[];
 }
+declare const SymbolContractError: unique symbol;
 export interface DataParser<GenericDefinition extends DataParserDefinition = DataParserDefinition, GenericOutput extends unknown = unknown, GenericInput extends unknown = GenericOutput> extends Kind<typeof dataParserKind.definition, {
     input: GenericInput;
     output: GenericOutput;
@@ -137,14 +138,45 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
      * 
      */
     clone(): this;
+    /**
+     * The contract() method validates that the parser output type exactly matches the type you want to assign it to.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.contract<Output>()` -> returns the same parser if types match
+     * 
+     * It does not change runtime behavior; it enforces at compile time that the parser output type and the expected type are exactly the same.
+     * 
+     * ```ts
+     * interface User {
+     * 	id: number;
+     * 	name: string;
+     * }
+     * 
+     * const userParser: DP.Contract<User> = DP.object({
+     * 	id: DP.number(),
+     * 	name: DP.string(),
+     * }).contract();
+     * 
+     * const statusParser: DP.Contract<"draft" | "published">
+     * 	= DP.literal(["draft", "published"]).contract();
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser
+     * 
+     * @namespace DP
+     * 
+     */
+    contract<GenericValue extends unknown>(...args: IsEqual<Output<this>, GenericValue> extends true ? [] : [] & {
+        [SymbolContractError]: "Contract error.";
+    }): Contract<GenericValue>;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {
     sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
     async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
 }
-export declare function dataParserInit<GenericDataParser extends DataParser>(kind: Exclude<GetKindHandler<GenericDataParser>, typeof dataParserKind>, definition: GenericDataParser["definition"], exec: (DataParserInitExecParams<GenericDataParser> | DataParserInitExecParams<GenericDataParser>["sync"])): GenericDataParser;
+export declare function dataParserInit<GenericDataParser extends DataParser>(kind: Exclude<GetKindHandler<GenericDataParser>, typeof dataParserKind>, definition: GenericDataParser["definition"], exec: (DataParserInitExecParams<GenericDataParser> | DataParserInitExecParams<GenericDataParser>["sync"]), specificOverrideHandler: OverrideHandler<GenericDataParser>): GenericDataParser;
 export declare namespace dataParserInit {
-    var overrideHandler: import("../common").OverrideHandler<DataParser<DataParserDefinition<DataParserChecker<DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
+    var overrideHandler: OverrideHandler<DataParser<DataParserDefinition<DataParserChecker<DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }
 export type Output<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["output"];
 export type Input<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["input"];

package/dist/dataParser/base.mjs

@@ -25,7 +25,7 @@ const DPE = createError();
 const EE = error(null);
 const ES = success(null);
 const KWV = keyWrappedValue;
-function dataParserInit(kind, definition, exec) {
+function dataParserInit(kind, definition, exec, specificOverrideHandler) {
     const formattedExec = typeof exec === "object"
         ? exec
         : {
@@ -33,18 +33,18 @@ function dataParserInit(kind, definition, exec) {
             async: exec,
         };
     function middleExec(data, error) {
-        let result = formattedExec.sync(data, error, dataParser);
+        let result = formattedExec.sync(data, error, self);
         if (result === SDPEI) {
-            addIssue(error, dataParser, data);
+            addIssue(error, self, data);
             return SDPE;
         }
         else if (result === SDPEPI) {
-            addPromiseIssue(error, dataParser, data);
+            addPromiseIssue(error, self, data);
             return SDPE;
         }
         else if (result !== SDPE
-            && dataParser.definition.checkers.length) {
-            for (const checker of dataParser.definition.checkers) {
+            && self.definition.checkers.length) {
+            for (const checker of self.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
                 if (checkerResult === SDPEI) {
                     addIssue(error, checker, result);
@@ -58,18 +58,18 @@ function dataParserInit(kind, definition, exec) {
         return result;
     }
     async function middleAsyncExec(data, error) {
-        let result = await formattedExec.async(data, error, dataParser);
+        let result = await formattedExec.async(data, error, self);
         if (result === SDPEI) {
-            addIssue(error, dataParser, data);
+            addIssue(error, self, data);
             return SDPE;
         }
         else if (result === SDPEPI) {
-            addPromiseIssue(error, dataParser, data);
+            addPromiseIssue(error, self, data);
             return SDPE;
         }
         else if (result !== SDPE
-            && dataParser.definition.checkers.length) {
-            for (const checker of dataParser.definition.checkers) {
+            && self.definition.checkers.length) {
+            for (const checker of self.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
                 if (checkerResult === SDPEI) {
                     addIssue(error, checker, result);
@@ -82,7 +82,7 @@ function dataParserInit(kind, definition, exec) {
         }
         return result;
     }
-    const dataParser = pipe({
+    const self = pipe({
         definition,
         exec: middleExec,
         asyncExec: middleAsyncExec,
@@ -125,10 +125,11 @@ function dataParserInit(kind, definition, exec) {
         addChecker: (...checkers) => dataParserInit(kind, simpleClone({
             ...definition,
             checkers: [...definition.checkers, ...checkers],
-        }), exec),
-        clone: () => dataParserInit(kind, simpleClone(definition), exec),
-    }, (value) => dataParserKind.setTo(value, null), kind.setTo, dataParserInit.overrideHandler.apply);
-    return dataParser;
+        }), exec, specificOverrideHandler),
+        clone: () => dataParserInit(kind, simpleClone(definition), exec, specificOverrideHandler),
+        contract: () => self,
+    }, (value) => dataParserKind.setTo(value, null), kind.setTo, (value) => dataParserInit.overrideHandler.apply(value), (value) => specificOverrideHandler.apply(value));
+    return self;
 }
 dataParserInit.overrideHandler = createOverride("@duplojs/utils/data-parser/base");
 

package/dist/dataParser/baseExtended.cjs

@@ -59,6 +59,9 @@ function dataParserExtendedInit(dataParser, rest) {
         recover(recoveredValue, definition) {
             return recover.recover(self, recoveredValue, definition);
         },
+        contract() {
+            return self;
+        },
     }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply);
     return self;
 }

package/dist/dataParser/baseExtended.mjs

@@ -57,6 +57,9 @@ function dataParserExtendedInit(dataParser, rest) {
         recover(recoveredValue, definition) {
             return recover(self, recoveredValue, definition);
         },
+        contract() {
+            return self;
+        },
     }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply);
     return self;
 }

package/dist/dataParser/parsers/array/index.cjs

@@ -59,8 +59,8 @@ function array(element, definition) {
             void (data.length && error.popErrorPath(error$1));
             return output;
         },
-    });
-    return array.overrideHandler.apply(self);
+    }, array.overrideHandler);
+    return self;
 }
 array.overrideHandler = override.createOverride("@duplojs/utils/data-parser/array");
 

package/dist/dataParser/parsers/array/index.mjs

@@ -57,8 +57,8 @@ function array(element, definition) {
             void (data.length && popErrorPath(error));
             return output;
         },
-    });
-    return array.overrideHandler.apply(self);
+    }, array.overrideHandler);
+    return self;
 }
 array.overrideHandler = createOverride("@duplojs/utils/data-parser/array");
 

package/dist/dataParser/parsers/bigint/index.cjs

@@ -26,8 +26,8 @@ function bigint(definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return bigint.overrideHandler.apply(self);
+    }, bigint.overrideHandler);
+    return self;
 }
 bigint.overrideHandler = override.createOverride("@duplojs/utils/data-parser/bigint");
 

package/dist/dataParser/parsers/bigint/index.mjs

@@ -24,8 +24,8 @@ function bigint(definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return bigint.overrideHandler.apply(self);
+    }, bigint.overrideHandler);
+    return self;
 }
 bigint.overrideHandler = createOverride("@duplojs/utils/data-parser/bigint");
 

package/dist/dataParser/parsers/boolean.cjs

@@ -35,8 +35,8 @@ function boolean(definition) {
             }
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return boolean.overrideHandler.apply(self);
+    }, boolean.overrideHandler);
+    return self;
 }
 boolean.overrideHandler = override.createOverride("@duplojs/utils/data-parser/boolean");
 

package/dist/dataParser/parsers/boolean.mjs

@@ -33,8 +33,8 @@ function boolean(definition) {
             }
         }
         return SymbolDataParserErrorIssue;
-    });
-    return boolean.overrideHandler.apply(self);
+    }, boolean.overrideHandler);
+    return self;
 }
 boolean.overrideHandler = createOverride("@duplojs/utils/data-parser/boolean");
 

package/dist/dataParser/parsers/date.cjs

@@ -44,8 +44,8 @@ function date(definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return date.overrideHandler.apply(self);
+    }, date.overrideHandler);
+    return self;
 }
 date.overrideHandler = override.createOverride("@duplojs/utils/data-parser/date");
 

package/dist/dataParser/parsers/date.mjs

@@ -42,8 +42,8 @@ function date(definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return date.overrideHandler.apply(self);
+    }, date.overrideHandler);
+    return self;
 }
 date.overrideHandler = createOverride("@duplojs/utils/data-parser/date");
 

package/dist/dataParser/parsers/empty.cjs

@@ -22,8 +22,8 @@ function empty(definition) {
             return undefined;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return empty.overrideHandler.apply(self);
+    }, empty.overrideHandler);
+    return self;
 }
 empty.overrideHandler = override.createOverride("@duplojs/utils/data-parser/empty");
 

package/dist/dataParser/parsers/empty.mjs

@@ -20,8 +20,8 @@ function empty(definition) {
             return undefined;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return empty.overrideHandler.apply(self);
+    }, empty.overrideHandler);
+    return self;
 }
 empty.overrideHandler = createOverride("@duplojs/utils/data-parser/empty");
 

package/dist/dataParser/parsers/lazy.cjs

@@ -17,8 +17,8 @@ function lazy(getter, definition) {
     }, {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
-    });
-    return lazy.overrideHandler.apply(self);
+    }, lazy.overrideHandler);
+    return self;
 }
 lazy.overrideHandler = override.createOverride("@duplojs/utils/data-parser/lazy");
 

package/dist/dataParser/parsers/lazy.d.ts

@@ -63,6 +63,6 @@ export declare function lazy<GenericDataParser extends DataParser, const Generic
     getter: Memoized<GenericDataParser>;
 }>>;
 export declare namespace lazy {
-    var overrideHandler: import("../../common").OverrideHandler<DataParserLazyCheckerCustom<unknown>>;
+    var overrideHandler: import("../../common").OverrideHandler<DataParserLazy<DataParserDefinitionLazy>>;
 }
 export {};

package/dist/dataParser/parsers/lazy.mjs

@@ -15,8 +15,8 @@ function lazy(getter, definition) {
     }, {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
-    });
-    return lazy.overrideHandler.apply(self);
+    }, lazy.overrideHandler);
+    return self;
 }
 lazy.overrideHandler = createOverride("@duplojs/utils/data-parser/lazy");
 

package/dist/dataParser/parsers/literal.cjs

@@ -20,8 +20,8 @@ function literal(value, definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return literal.overrideHandler.apply(self);
+    }, literal.overrideHandler);
+    return self;
 }
 literal.overrideHandler = override.createOverride("@duplojs/utils/data-parser/literal");
 

package/dist/dataParser/parsers/literal.mjs

@@ -18,8 +18,8 @@ function literal(value, definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return literal.overrideHandler.apply(self);
+    }, literal.overrideHandler);
+    return self;
 }
 literal.overrideHandler = createOverride("@duplojs/utils/data-parser/literal");
 

package/dist/dataParser/parsers/nil.cjs

@@ -22,8 +22,8 @@ function nil(definition) {
             return null;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return nil.overrideHandler.apply(self);
+    }, nil.overrideHandler);
+    return self;
 }
 nil.overrideHandler = override.createOverride("@duplojs/utils/data-parser/nil");
 

package/dist/dataParser/parsers/nil.mjs

@@ -20,8 +20,8 @@ function nil(definition) {
             return null;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return nil.overrideHandler.apply(self);
+    }, nil.overrideHandler);
+    return self;
 }
 nil.overrideHandler = createOverride("@duplojs/utils/data-parser/nil");
 

package/dist/dataParser/parsers/nullable.cjs

@@ -27,8 +27,8 @@ function nullable(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
-    });
-    return nullable.overrideHandler.apply(self);
+    }, nullable.overrideHandler);
+    return self;
 }
 nullable.overrideHandler = override.createOverride("@duplojs/utils/data-parser/nullable");
 

package/dist/dataParser/parsers/nullable.d.ts

@@ -51,7 +51,7 @@ export interface DataParserNullable<GenericDefinition extends DataParserDefiniti
  * @namespace DP
  * 
  */
-export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace nullable {

package/dist/dataParser/parsers/nullable.mjs

@@ -25,8 +25,8 @@ function nullable(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
-    });
-    return nullable.overrideHandler.apply(self);
+    }, nullable.overrideHandler);
+    return self;
 }
 nullable.overrideHandler = createOverride("@duplojs/utils/data-parser/nullable");
 

package/dist/dataParser/parsers/number/index.cjs

@@ -26,8 +26,8 @@ function number(definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return number.overrideHandler.apply(self);
+    }, number.overrideHandler);
+    return self;
 }
 number.overrideHandler = override.createOverride("@duplojs/utils/data-parser/number");
 

package/dist/dataParser/parsers/number/index.mjs

@@ -24,8 +24,8 @@ function number(definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return number.overrideHandler.apply(self);
+    }, number.overrideHandler);
+    return self;
 }
 number.overrideHandler = createOverride("@duplojs/utils/data-parser/number");
 

package/dist/dataParser/parsers/object/index.cjs

@@ -69,8 +69,8 @@ function object(shape, definition) {
             void (self.definition.optimizedShape.value.length && error.popErrorPath(error$1));
             return output;
         },
-    });
-    return object.overrideHandler.apply(self);
+    }, object.overrideHandler);
+    return self;
 }
 object.overrideHandler = override.createOverride("@duplojs/utils/data-parser/object");
 

package/dist/dataParser/parsers/object/index.mjs

@@ -67,8 +67,8 @@ function object(shape, definition) {
             void (self.definition.optimizedShape.value.length && popErrorPath(error));
             return output;
         },
-    });
-    return object.overrideHandler.apply(self);
+    }, object.overrideHandler);
+    return self;
 }
 object.overrideHandler = createOverride("@duplojs/utils/data-parser/object");
 

package/dist/dataParser/parsers/optional.cjs

@@ -27,8 +27,8 @@ function optional(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
-    });
-    return optional.overrideHandler.apply(self);
+    }, optional.overrideHandler);
+    return self;
 }
 optional.overrideHandler = override.createOverride("@duplojs/utils/data-parser/optional");
 

package/dist/dataParser/parsers/optional.d.ts

@@ -51,7 +51,7 @@ export interface DataParserOptional<GenericDefinition extends DataParserDefiniti
  * @namespace DP
  * 
  */
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace optional {

package/dist/dataParser/parsers/optional.mjs

@@ -25,8 +25,8 @@ function optional(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
-    });
-    return optional.overrideHandler.apply(self);
+    }, optional.overrideHandler);
+    return self;
 }
 optional.overrideHandler = createOverride("@duplojs/utils/data-parser/optional");
 

package/dist/dataParser/parsers/pipe.cjs

@@ -29,8 +29,8 @@ function pipe(input, output, definition) {
             }
             return self.definition.output.asyncExec(result, error);
         },
-    });
-    return pipe.overrideHandler.apply(self);
+    }, pipe.overrideHandler);
+    return self;
 }
 pipe.overrideHandler = override.createOverride("@duplojs/utils/data-parser/pipe");
 

package/dist/dataParser/parsers/pipe.mjs

@@ -27,8 +27,8 @@ function pipe(input, output, definition) {
             }
             return self.definition.output.asyncExec(result, error);
         },
-    });
-    return pipe.overrideHandler.apply(self);
+    }, pipe.overrideHandler);
+    return self;
 }
 pipe.overrideHandler = createOverride("@duplojs/utils/data-parser/pipe");
 

package/dist/dataParser/parsers/record/index.cjs

@@ -94,8 +94,8 @@ function record(key, value, definition) {
             }
             return output;
         },
-    });
-    return record.overrideHandler.apply(self);
+    }, record.overrideHandler);
+    return self;
 }
 record.overrideHandler = override.createOverride("@duplojs/utils/data-parser/record");
 

package/dist/dataParser/parsers/record/index.mjs

@@ -93,8 +93,8 @@ function record(key, value, definition) {
             }
             return output;
         },
-    });
-    return record.overrideHandler.apply(self);
+    }, record.overrideHandler);
+    return self;
 }
 record.overrideHandler = createOverride("@duplojs/utils/data-parser/record");
 

package/dist/dataParser/parsers/recover.cjs

@@ -27,8 +27,8 @@ function recover(inner, recoveredValue, definition) {
                 ? self.definition.recoveredValue
                 : result;
         },
-    });
-    return recover.overrideHandler.apply(self);
+    }, recover.overrideHandler);
+    return self;
 }
 recover.overrideHandler = override.createOverride("@duplojs/utils/data-parser/recover");
 

package/dist/dataParser/parsers/recover.mjs

@@ -25,8 +25,8 @@ function recover(inner, recoveredValue, definition) {
                 ? self.definition.recoveredValue
                 : result;
         },
-    });
-    return recover.overrideHandler.apply(self);
+    }, recover.overrideHandler);
+    return self;
 }
 recover.overrideHandler = createOverride("@duplojs/utils/data-parser/recover");
 

package/dist/dataParser/parsers/string/index.cjs

@@ -26,8 +26,8 @@ function string(definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return string.overrideHandler.apply(self);
+    }, string.overrideHandler);
+    return self;
 }
 string.overrideHandler = override.createOverride("@duplojs/utils/data-parser/string");
 

package/dist/dataParser/parsers/string/index.mjs

@@ -24,8 +24,8 @@ function string(definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return string.overrideHandler.apply(self);
+    }, string.overrideHandler);
+    return self;
 }
 string.overrideHandler = createOverride("@duplojs/utils/data-parser/string");
 

package/dist/dataParser/parsers/templateLiteral/index.cjs

@@ -23,8 +23,8 @@ function templateLiteral(template, definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return templateLiteral.overrideHandler.apply(self);
+    }, templateLiteral.overrideHandler);
+    return self;
 }
 templateLiteral.overrideHandler = override.createOverride("@duplojs/utils/data-parser/templateLiteral");
 

package/dist/dataParser/parsers/templateLiteral/index.mjs

@@ -21,8 +21,8 @@ function templateLiteral(template, definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return templateLiteral.overrideHandler.apply(self);
+    }, templateLiteral.overrideHandler);
+    return self;
 }
 templateLiteral.overrideHandler = createOverride("@duplojs/utils/data-parser/templateLiteral");
 

package/dist/dataParser/parsers/time/index.cjs

@@ -41,8 +41,8 @@ function time(definition) {
             return data;
         }
         return error.SymbolDataParserErrorIssue;
-    });
-    return time.overrideHandler.apply(self);
+    }, time.overrideHandler);
+    return self;
 }
 time.overrideHandler = override.createOverride("@duplojs/utils/data-parser/time");
 

package/dist/dataParser/parsers/time/index.mjs

@@ -39,8 +39,8 @@ function time(definition) {
             return data;
         }
         return SymbolDataParserErrorIssue;
-    });
-    return time.overrideHandler.apply(self);
+    }, time.overrideHandler);
+    return self;
 }
 time.overrideHandler = createOverride("@duplojs/utils/data-parser/time");
 

package/dist/dataParser/parsers/transform.cjs

@@ -38,8 +38,8 @@ function transform(inner, theFunction, definition) {
             }
             return result;
         },
-    });
-    return transform.overrideHandler.apply(self);
+    }, transform.overrideHandler);
+    return self;
 }
 transform.overrideHandler = override.createOverride("@duplojs/utils/data-parser/transform");
 

package/dist/dataParser/parsers/transform.mjs

@@ -36,8 +36,8 @@ function transform(inner, theFunction, definition) {
             }
             return result;
         },
-    });
-    return transform.overrideHandler.apply(self);
+    }, transform.overrideHandler);
+    return self;
 }
 transform.overrideHandler = createOverride("@duplojs/utils/data-parser/transform");
 

package/dist/dataParser/parsers/tuple.cjs

@@ -78,8 +78,8 @@ function tuple(shape, definition) {
             void (self.definition.shape.length && error.popErrorPath(error$1));
             return output;
         },
-    });
-    return tuple.overrideHandler.apply(self);
+    }, tuple.overrideHandler);
+    return self;
 }
 tuple.overrideHandler = override.createOverride("@duplojs/utils/data-parser/tuple");
 

package/dist/dataParser/parsers/tuple.mjs

@@ -76,8 +76,8 @@ function tuple(shape, definition) {
             void (self.definition.shape.length && popErrorPath(error));
             return output;
         },
-    });
-    return tuple.overrideHandler.apply(self);
+    }, tuple.overrideHandler);
+    return self;
 }
 tuple.overrideHandler = createOverride("@duplojs/utils/data-parser/tuple");
 

package/dist/dataParser/parsers/union.cjs

@@ -33,8 +33,8 @@ function union(options, definition) {
             }
             return error.SymbolDataParserErrorIssue;
         },
-    });
-    return union.overrideHandler.apply(self);
+    }, union.overrideHandler);
+    return self;
 }
 union.overrideHandler = override.createOverride("@duplojs/utils/data-parser/union");
 

package/dist/dataParser/parsers/union.mjs

@@ -31,8 +31,8 @@ function union(options, definition) {
             }
             return SymbolDataParserErrorIssue;
         },
-    });
-    return union.overrideHandler.apply(self);
+    }, union.overrideHandler);
+    return self;
 }
 union.overrideHandler = createOverride("@duplojs/utils/data-parser/union");
 

package/dist/dataParser/parsers/unknown.cjs

@@ -12,8 +12,8 @@ function unknown(definition) {
     const self = base.dataParserInit(unknownKind, {
         errorMessage: definition?.errorMessage,
         checkers: definition?.checkers ?? [],
-    }, (data) => data);
-    return unknown.overrideHandler.apply(self);
+    }, (data) => data, unknown.overrideHandler);
+    return self;
 }
 unknown.overrideHandler = override.createOverride("@duplojs/utils/data-parser/unknown");
 

package/dist/dataParser/parsers/unknown.mjs

@@ -10,8 +10,8 @@ function unknown(definition) {
     const self = dataParserInit(unknownKind, {
         errorMessage: definition?.errorMessage,
         checkers: definition?.checkers ?? [],
-    }, (data) => data);
-    return unknown.overrideHandler.apply(self);
+    }, (data) => data, unknown.overrideHandler);
+    return self;
 }
 unknown.overrideHandler = createOverride("@duplojs/utils/data-parser/unknown");
 

package/dist/index.cjs

@@ -60,6 +60,7 @@ var hasSomeKinds = require('./common/hasSomeKinds.cjs');
 var hasKinds = require('./common/hasKinds.cjs');
 var toCurriedPredicate = require('./common/toCurriedPredicate.cjs');
 var pipeCall = require('./common/pipeCall.cjs');
+var asserts = require('./common/asserts.cjs');
 
 
 
@@ -147,3 +148,5 @@ exports.hasSomeKinds = hasSomeKinds.hasSomeKinds;
 exports.hasKinds = hasKinds.hasKinds;
 exports.toCurriedPredicate = toCurriedPredicate.toCurriedPredicate;
 exports.pipeCall = pipeCall.pipeCall;
+exports.AssertsError = asserts.AssertsError;
+exports.asserts = asserts.asserts;

package/dist/index.mjs

@@ -82,3 +82,4 @@ export { hasSomeKinds } from './common/hasSomeKinds.mjs';
 export { hasKinds } from './common/hasKinds.mjs';
 export { toCurriedPredicate } from './common/toCurriedPredicate.mjs';
 export { pipeCall } from './common/pipeCall.mjs';
+export { AssertsError, asserts } from './common/asserts.mjs';

package/dist/metadata.json

@@ -1074,6 +1074,9 @@
             {
               "name": "isUnion.d.ts"
             },
+            {
+              "name": "json.d.ts"
+            },
             {
               "name": "lastUnionElement.d.ts"
             },
@@ -1166,6 +1169,15 @@
         {
           "name": "and.mjs"
         },
+        {
+          "name": "asserts.cjs"
+        },
+        {
+          "name": "asserts.d.ts"
+        },
+        {
+          "name": "asserts.mjs"
+        },
         {
           "name": "asyncInnerPipe.cjs"
         },
@@ -4898,6 +4910,15 @@
         {
           "name": "test.mjs"
         },
+        {
+          "name": "to.cjs"
+        },
+        {
+          "name": "to.d.ts"
+        },
+        {
+          "name": "to.mjs"
+        },
         {
           "name": "toLowerCase.cjs"
         },

package/dist/string/index.cjs

@@ -29,6 +29,7 @@ var isIn = require('./isIn.cjs');
 var length = require('./length.cjs');
 var sort = require('./sort.cjs');
 var sortCompare = require('./sortCompare.cjs');
+var to = require('./to.cjs');
 var _default = require('./at/default.cjs');
 var first = require('./at/first.cjs');
 var last = require('./at/last.cjs');
@@ -69,6 +70,7 @@ exports.isIn = isIn.isIn;
 exports.length = length.length;
 exports.sort = sort.sort;
 exports.sortCompare = sortCompare.sortCompare;
+exports.to = to.to;
 exports.at = _default.at;
 exports.first = first.first;
 exports.last = last.last;

package/dist/string/index.d.ts

@@ -18,7 +18,7 @@
  * - composition and slicing (`S.concat`, `S.slice`, `S.substring`, `S.split`)
  * - indexing (`S.at`, `S.charAt`, `S.indexOf`, `S.lastIndexOf`)
  * - padding and repeat (`S.padStart`, `S.padEnd`, `S.repeat`)
- * - misc helpers (`S.normalize`, `S.isKeyof`, `S.isIn`, `S.length`, `S.sort`, `S.sortCompare`)
+ * - misc helpers (`S.normalize`, `S.isKeyof`, `S.isIn`, `S.length`, `S.sort`, `S.sortCompare`, `S.to`)
  * 
  * @see https://utils.duplojs.dev/en/v1/api/string
  * 
@@ -57,3 +57,4 @@ export * from "./isIn";
 export * from "./length";
 export * from "./sort";
 export * from "./sortCompare";
+export * from "./to";

package/dist/string/index.mjs

@@ -27,6 +27,7 @@ export { isIn } from './isIn.mjs';
 export { length } from './length.mjs';
 export { sort } from './sort.mjs';
 export { sortCompare } from './sortCompare.mjs';
+export { to } from './to.mjs';
 export { at } from './at/default.mjs';
 export { first } from './at/first.mjs';
 export { last } from './at/last.mjs';

package/dist/string/to.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * {@include string/to/index.md}
+ */
+function to(value) {
+    return `${value}`;
+}
+
+exports.to = to;

package/dist/string/to.d.ts

@@ -0,0 +1,23 @@
+type Primitive = (string | boolean | null | number | undefined | bigint);
+/**
+ * Converts a primitive value to its string representation.
+ * 
+ * **Supported call styles:**
+ * - Classic: `to(value)` -> returns a string
+ * 
+ * It uses template literal conversion and preserves literal types when possible.
+ * 
+ * ```ts
+ * const fromNumber = S.to(42);
+ * const fromBoolean = S.to(false);
+ * const fromNull = S.to(null);
+ * const fromBigInt = S.to(10n);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/string/to
+ * 
+ * @namespace S
+ * 
+ */
+export declare function to<GenericValue extends Primitive>(value: GenericValue): `${GenericValue}`;
+export {};

package/dist/string/to.mjs

@@ -0,0 +1,8 @@
+/**
+ * {@include string/to/index.md}
+ */
+function to(value) {
+    return `${value}`;
+}
+
+export { to };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.35",
+  "version": "1.4.37",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"