@duplojs/utils 1.4.57 → 1.4.59

package/dist/clean/unwrapEntity.mjs

@@ -1,8 +1,13 @@
 import { entityKind } from './entity.mjs';
 import { flagKind } from './flag.mjs';
+import { forward } from '../common/forward.mjs';
 import { unwrap } from '../common/unwrap.mjs';
 
-function unwrapEntity(entity) {
+/**
+ * {@include clean/unwrapEntity/index.md}
+ */
+function unwrapEntity(entity, params) {
+    const transformer = params?.transformer ?? forward;
     const unwrapEntity = {};
     for (const prop in entity) {
         if (prop === entityKind.runTimeKey) {
@@ -12,10 +17,15 @@ function unwrapEntity(entity) {
             unwrapEntity._flags = entity[prop];
         }
         else if (entity[prop] instanceof Array) {
-            unwrapEntity[prop] = entity[prop].map(unwrap);
+            const length = entity[prop].length;
+            const result = [];
+            for (let index = 0; index < length; index++) {
+                result[index] = transformer(unwrap(entity[prop][index]));
+            }
+            unwrapEntity[prop] = result;
         }
         else {
-            unwrapEntity[prop] = unwrap(entity[prop]);
+            unwrapEntity[prop] = transformer(unwrap(entity[prop]));
         }
     }
     return unwrapEntity;

package/dist/common/index.d.ts

@@ -16,7 +16,7 @@
  * - 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`)
+ * - string and value conversions (`stringToMillisecond`, `stringToBytes`, `escapeRegExp`, `toRegExp`)
  * - wrappers and kinds (`wrapValue`, `unwrap`, `toWrappedValue`, `hasKinds`, `hasSomeKinds`)
  * 
  * @see https://utils.duplojs.dev/en/v1/api/common
@@ -38,15 +38,12 @@ export * from "./sleep";
 export * from "./stringToBytes";
 export * from "./mimeType";
 export * from "./stringToMillisecond";
-export * from "./toJSON";
-export * from "./toTransform";
 export * from "./toWrappedValue";
 export * from "./unwrap";
 export * from "./unwrapGroup";
 export * from "./asyncLoop";
 export * from "./asyncRetry";
 export * from "./wrapValue";
-export * from "./toString";
 export * from "./innerPipe";
 export * from "./asyncInnerPipe";
 export * from "./loop";
@@ -76,3 +73,5 @@ export * from "./toCurriedPredicate";
 export * from "./pipeCall";
 export * from "./asserts";
 export * from "./path";
+export * from "./transformer";
+export * from "./toRegExp";

package/dist/common/kind.d.ts

@@ -90,6 +90,7 @@ export interface ReservedKindNamespace {
     DuplojsUtilsBuilder: true;
     DuplojsUtilsError: true;
     DuplojsUtilsClean: true;
+    DuplojsUtilsDate: true;
 }
 type ForbiddenKindNamespace<GenericValue extends string> = (ForbiddenKindCharacters<GenericValue> & ForbiddenString<GenericValue, GetPropsWithValue<ReservedKindNamespace, true>>);
 /**

package/dist/common/path.cjs

@@ -1,14 +1,11 @@
 'use strict';
 
-var success = require('../either/right/success.cjs');
-var fail = require('../either/left/fail.cjs');
-
 exports.Path = void 0;
 (function (Path) {
     Path.baseNameRegex = /\/?([^/]+)$/;
     Path.folderNameRegex = /([^]+)\/[^/]+\/?$/;
     Path.extensionNameRegex = /\.([^./]+)$/;
-    Path.isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+    Path.isContainBackPathRegex = /(^|\/)\.\.(?=\/|$)/;
     Path.segmentTrailingRegex = /\/$/;
     Path.segmentRelativeRegex = /^(.\/)/;
     /**
@@ -52,17 +49,21 @@ exports.Path = void 0;
      */
     function isAbsolute(path) {
         return path.startsWith("/")
-            && !Path.isRelativeRegex.test(path);
+            && !Path.isContainBackPathRegex.test(path);
     }
     Path.isAbsolute = isAbsolute;
     /**
      * {@include common/path/resolveFrom/index.md}
      */
-    function resolveFrom(origin, segments) {
-        const result = resolveRelative([origin, ...segments]);
+    function resolveFrom(origin, segments, params) {
+        const resultRelative = resolveRelative(segments);
+        if (params?.stayInOrigin && resultRelative.startsWith("../")) {
+            return null;
+        }
+        const result = resolveRelative([origin, resultRelative]);
         return isAbsolute(result)
-            ? success.success(result)
-            : fail.fail();
+            ? result
+            : null;
     }
     Path.resolveFrom = resolveFrom;
     /**
@@ -74,16 +75,15 @@ exports.Path = void 0;
             if (segment.length === 0) {
                 continue;
             }
-            if (segment === "/") {
+            else if (segment === "/") {
                 clearedPath = segment;
                 continue;
             }
             const formattedSegment = fix(segment);
-            if (formattedSegment.startsWith("/")) {
+            if (formattedSegment.startsWith("/") || clearedPath === "") {
                 clearedPath = formattedSegment;
-                continue;
             }
-            if (clearedPath === "/") {
+            else if (clearedPath === "/") {
                 clearedPath += formattedSegment;
             }
             else {

package/dist/common/path.d.ts

@@ -1,10 +1,9 @@
-import * as DEither from "../either";
 import type { AnyTuple } from "./types";
 export declare namespace Path {
     const baseNameRegex: RegExp;
     const folderNameRegex: RegExp;
     const extensionNameRegex: RegExp;
-    const isRelativeRegex: RegExp;
+    const isContainBackPathRegex: RegExp;
     const segmentTrailingRegex: RegExp;
     const segmentRelativeRegex: RegExp;
     interface GetBaseNameParams {
@@ -95,31 +94,38 @@ export declare namespace Path {
      * 
      */
     function isAbsolute<GenericPath extends string>(path: GenericPath): boolean;
+    interface ResolveFromParams {
+        stayInOrigin?: boolean;
+    }
     /**
-     * Resolves a list of path segments from an origin and returns an Either.
+     * Resolves a list of path segments from an origin.
      * 
      * **Supported call styles:**
-     * - Classic: `resolveFrom(origin, segments)` -> returns an Either
+     * - Classic: `resolveFrom(origin, segments, params?)` -> returns the resolved absolute path or null
      * 
      * Segments are resolved in order using `resolveRelative`.
-     * The result is an `Either` that is `success` only when the resolved path is absolute; otherwise it returns `fail`.
+     * The function returns `null` when the final path is not absolute.
+     * When `params.stayInOrigin` is `true`, the resolution returns `null` if segments escape the origin with leading `../`.
      * 
      * ```ts
      * const absoluteResult = Path.resolveFrom("/root", ["alpha", "beta"]);
-     * // absoluteResult: DEither.success<"/root/alpha/beta">
-     * const result = unwrap(absoluteResult);
-     * // result: "/root/alpha/beta"
+     * // absoluteResult: "/root/alpha/beta"
      * 
      * const overrideResult = Path.resolveFrom("gamma", ["alpha", "/root", "beta"]);
-     * // overrideResult: DEither.success<"/root/beta">
+     * // overrideResult: "/root/beta"
+     * 
      * const relativeResult = Path.resolveFrom("alpha", ["..", ".."]);
-     * // relativeResult: DEither.fail
+     * // relativeResult: null
+     * 
+     * const blockedResult = Path.resolveFrom("/root", ["..", "etc"], {
+     * 	stayInOrigin: true,
+     * });
      * ```
      * 
      * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveFrom
      * 
      */
-    function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.Fail | DEither.Success<string>;
+    function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>, params?: ResolveFromParams): string | null;
     /**
      * Resolves path segments into a single POSIX-like path.
      * 

package/dist/common/path.mjs

@@ -1,12 +1,9 @@
-import { success } from '../either/right/success.mjs';
-import { fail } from '../either/left/fail.mjs';
-
 var Path;
 (function (Path) {
     Path.baseNameRegex = /\/?([^/]+)$/;
     Path.folderNameRegex = /([^]+)\/[^/]+\/?$/;
     Path.extensionNameRegex = /\.([^./]+)$/;
-    Path.isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+    Path.isContainBackPathRegex = /(^|\/)\.\.(?=\/|$)/;
     Path.segmentTrailingRegex = /\/$/;
     Path.segmentRelativeRegex = /^(.\/)/;
     /**
@@ -50,17 +47,21 @@ var Path;
      */
     function isAbsolute(path) {
         return path.startsWith("/")
-            && !Path.isRelativeRegex.test(path);
+            && !Path.isContainBackPathRegex.test(path);
     }
     Path.isAbsolute = isAbsolute;
     /**
      * {@include common/path/resolveFrom/index.md}
      */
-    function resolveFrom(origin, segments) {
-        const result = resolveRelative([origin, ...segments]);
+    function resolveFrom(origin, segments, params) {
+        const resultRelative = resolveRelative(segments);
+        if (params?.stayInOrigin && resultRelative.startsWith("../")) {
+            return null;
+        }
+        const result = resolveRelative([origin, resultRelative]);
         return isAbsolute(result)
-            ? success(result)
-            : fail();
+            ? result
+            : null;
     }
     Path.resolveFrom = resolveFrom;
     /**
@@ -72,16 +73,15 @@ var Path;
             if (segment.length === 0) {
                 continue;
             }
-            if (segment === "/") {
+            else if (segment === "/") {
                 clearedPath = segment;
                 continue;
             }
             const formattedSegment = fix(segment);
-            if (formattedSegment.startsWith("/")) {
+            if (formattedSegment.startsWith("/") || clearedPath === "") {
                 clearedPath = formattedSegment;
-                continue;
             }
-            if (clearedPath === "/") {
+            else if (clearedPath === "/") {
                 clearedPath += formattedSegment;
             }
             else {

package/dist/common/toRegExp.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var escapeRegExp = require('./escapeRegExp.cjs');
+
+/**
+ * {@include common/toRegExp/index.md}
+ */
+function toRegExp(input) {
+    if (typeof input === "string") {
+        return new RegExp(`^${escapeRegExp.escapeRegExp(input)}$`);
+    }
+    if (Array.isArray(input)) {
+        const result = input.map(escapeRegExp.escapeRegExp).join("|");
+        return new RegExp(`^(?:${result})$`);
+    }
+    return input;
+}
+
+exports.toRegExp = toRegExp;

package/dist/common/toRegExp.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The toRegExp() function normalizes a value into a regular expression. Strings and string arrays are escaped and converted to exact-match regex patterns.
+ * 
+ * Supported call style:
+ * - Classic: `toRegExp(input)` → returns a value
+ * 
+ * Behavior:
+ * - `string` input becomes an exact regex (`^.../**
+)
+ * - `string[]` input becomes an exact alternation regex (`^(?:...|...)/**
+)
+ * - `RegExp` input is returned as-is
+ * 
+ * ```ts
+ * const fromString = toRegExp("a.c");
+ * // matches only the literal "a.c"
+ * 
+ * const fromList = toRegExp([
+ * 	"jpg",
+ * 	"png",
+ * ]);
+ * // matches "jpg" or "png"
+ * 
+ * const existing = /hello/i;
+ * const sameInstance = toRegExp(existing);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/toRegExp
+ * 
+ */
+export declare function toRegExp(input: string | string[] | RegExp): RegExp;

package/dist/common/toRegExp.mjs

@@ -0,0 +1,17 @@
+import { escapeRegExp } from './escapeRegExp.mjs';
+
+/**
+ * {@include common/toRegExp/index.md}
+ */
+function toRegExp(input) {
+    if (typeof input === "string") {
+        return new RegExp(`^${escapeRegExp(input)}$`);
+    }
+    if (Array.isArray(input)) {
+        const result = input.map(escapeRegExp).join("|");
+        return new RegExp(`^(?:${result})$`);
+    }
+    return input;
+}
+
+export { toRegExp };

package/dist/common/transformer.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+function transformer(input, methodName) {
+    if (input
+        && typeof input === "object"
+        && methodName in input
+        && typeof input[methodName] === "function") {
+        return input[methodName]();
+    }
+    else if (typeof input === "object"
+        && input !== null
+        && (!input.constructor
+            || input.constructor.name === "Object")) {
+        const result = {};
+        for (const key in input) {
+            result[key] = transformer(input[key], methodName);
+        }
+        return result;
+    }
+    else if (input instanceof Array
+        && input.constructor.name === "Array") {
+        const length = input.length;
+        const result = [];
+        for (let index = 0; index < length; index++) {
+            result[index] = transformer(input[index], methodName);
+        }
+        return result;
+    }
+    else {
+        return input;
+    }
+}
+/**
+ * {@include common/createTransformer/index.md}
+ */
+function createTransformer(methodName) {
+    return (input) => transformer(input, methodName);
+}
+const toNative = createTransformer("toNative");
+const toJSON = createTransformer("toJSON");
+
+exports.createTransformer = createTransformer;
+exports.toJSON = toJSON;
+exports.toNative = toNative;
+exports.transformer = transformer;

package/dist/common/transformer.d.ts

@@ -0,0 +1,61 @@
+import type { GetPropsWithValueExtends } from "../object/types";
+import type { Adaptor, AnyFunction, IsEqual, NeverCoalescing, Or, UnionToIntersection } from "./types";
+export type Transformer<GenericValue extends unknown, GenericMethodName extends string> = GenericValue extends Record<GenericMethodName, () => unknown> ? ReturnType<GenericValue[GenericMethodName]> : GenericValue extends readonly [infer InferredFirst, ...infer InferredRest] ? [
+    Transformer<InferredFirst, GenericMethodName>,
+    ...Adaptor<Transformer<InferredRest, GenericMethodName>, readonly any[]>
+] : GenericValue extends readonly [] ? [] : GenericValue extends readonly any[] ? Transformer<GenericValue[number], GenericMethodName>[] : GenericValue extends string ? GenericValue : GenericValue extends Record<number, unknown> ? {
+    [Prop in keyof GenericValue]: Transformer<GenericValue[Prop], GenericMethodName>;
+} : GenericValue;
+declare const SymbolTransformError: unique symbol;
+export type CheckTransformArgument<GenericValue extends unknown, GenericMethodName extends string = string> = NeverCoalescing<GenericValue extends any ? (Or<[
+    IsEqual<GenericValue, unknown>,
+    IsEqual<GenericValue, never>,
+    IsEqual<GenericValue, object>,
+    IsEqual<GenericValue, any>,
+    IsEqual<GenericMethodName, string>
+]> extends true ? {
+    [SymbolTransformError]: "Input contain an indeterminate value.";
+} : GenericValue extends Record<GenericMethodName, () => unknown> ? unknown : GenericValue extends Record<GenericMethodName, AnyFunction> ? {
+    [SymbolTransformError]: `A method ${GenericMethodName} in input have an argument.`;
+} : GenericValue extends readonly [infer InferredFirst, ...infer InferredRest] ? (CheckTransformArgument<InferredFirst, GenericMethodName> & CheckTransformArgument<InferredRest, GenericMethodName>) : GenericValue extends readonly [] ? unknown : GenericValue extends string ? unknown : GenericValue extends readonly (infer InferredValue)[] ? CheckTransformArgument<InferredValue, GenericMethodName> : GenericValue extends Record<number, unknown> ? {
+    [Prop in keyof GenericValue]: CheckTransformArgument<GenericValue[Prop], GenericMethodName>;
+} extends infer InferredResult extends object ? UnionToIntersection<NeverCoalescing<InferredResult[GetPropsWithValueExtends<InferredResult, object>], unknown>> : never : unknown) extends infer InferredResult ? IsEqual<InferredResult, unknown> extends true ? never : InferredResult : never : never, unknown>;
+export declare function transformer<GenericInput extends unknown, GenericMethodName extends string>(input: GenericInput & CheckTransformArgument<GenericInput, GenericMethodName>, methodName: GenericMethodName): Transformer<GenericInput, GenericMethodName>;
+export type TransformerFunction<GenericMethodName extends string = string> = <GenericInput extends unknown>(input: GenericInput) => Transformer<GenericInput, GenericMethodName>;
+/**
+ * Creates a recursive transformer function based on a method name.
+ * 
+ * Signature: `createTransformer(methodName)` → `TransformerFunction`
+ * 
+ * The returned function walks through nested objects and arrays, and calls `methodName()` on values that implement it.
+ * 
+ * ```ts
+ * const input = {
+ * 	date: D.create("2024-01-01"),
+ * 	duration: D.createTime(90, "minute"),
+ * 	list: [D.create("2024-01-02")],
+ * };
+ * 
+ * const nativeValues = toNative(input);
+ * // nativeValues: { date: Date; duration: number; list: Date[] }
+ * 
+ * const jsonValues = toJSON(input);
+ * // jsonValues: { date: SerializedTheDate; duration: SerializedTheTime; list: SerializedTheDate[] }
+ * 
+ * const toStringTree = createTransformer("toString");
+ * const stringValues = toStringTree(input);
+ * // stringValues: string-based recursive projection
+ * ```
+ * 
+ * @remarks
+ * - Two default transformers are provided out of the box: `toNative` and `toJSON`.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/createTransformer
+ * 
+ * @namespace C
+ * 
+ */
+export declare function createTransformer<GenericMethodName extends string>(methodName: GenericMethodName): TransformerFunction<GenericMethodName>;
+export declare const toNative: TransformerFunction<"toNative">;
+export declare const toJSON: TransformerFunction<"toJSON">;
+export {};

package/dist/common/transformer.mjs

@@ -0,0 +1,40 @@
+function transformer(input, methodName) {
+    if (input
+        && typeof input === "object"
+        && methodName in input
+        && typeof input[methodName] === "function") {
+        return input[methodName]();
+    }
+    else if (typeof input === "object"
+        && input !== null
+        && (!input.constructor
+            || input.constructor.name === "Object")) {
+        const result = {};
+        for (const key in input) {
+            result[key] = transformer(input[key], methodName);
+        }
+        return result;
+    }
+    else if (input instanceof Array
+        && input.constructor.name === "Array") {
+        const length = input.length;
+        const result = [];
+        for (let index = 0; index < length; index++) {
+            result[index] = transformer(input[index], methodName);
+        }
+        return result;
+    }
+    else {
+        return input;
+    }
+}
+/**
+ * {@include common/createTransformer/index.md}
+ */
+function createTransformer(methodName) {
+    return (input) => transformer(input, methodName);
+}
+const toNative = createTransformer("toNative");
+const toJSON = createTransformer("toJSON");
+
+export { createTransformer, toJSON, toNative, transformer };

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

@@ -1,3 +1,3 @@
-export type DeepReadonly<GenericValue extends unknown> = GenericValue extends object ? {
+export type DeepReadonly<GenericValue extends unknown> = GenericValue extends Record<number, unknown> ? {
     readonly [Prop in keyof GenericValue]: DeepReadonly<GenericValue[Prop]>;
 } : GenericValue;

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

@@ -1,6 +1,6 @@
 export type ToLargeEnsemble<GenericValue extends unknown> = GenericValue extends string ? string : GenericValue extends number ? number : GenericValue extends bigint ? bigint : GenericValue extends boolean ? boolean : GenericValue extends null ? null : GenericValue extends undefined ? undefined : GenericValue extends symbol ? symbol : GenericValue extends [infer InferredValue, ...infer InferredRest] ? [
     ToLargeEnsemble<InferredValue>,
     ...ToLargeEnsemble<InferredRest>
-] : GenericValue extends never[] ? [] : GenericValue extends (infer InferredValue)[] ? ToLargeEnsemble<InferredValue>[] : GenericValue extends object ? {
+] : GenericValue extends never[] ? [] : GenericValue extends (infer InferredValue)[] ? ToLargeEnsemble<InferredValue>[] : GenericValue extends Record<number, unknown> ? {
     [Prop in keyof GenericValue]: ToLargeEnsemble<GenericValue[Prop]>;
-} : GenericValue extends (...args: infer InferredArgs) => infer InferredReturn ? (...args: ToLargeEnsemble<InferredArgs>) => ToLargeEnsemble<InferredReturn> : GenericValue extends Promise<infer InferredValue> ? InferredValue : never;
+} : GenericValue extends (...args: infer InferredArgs) => infer InferredReturn ? (...args: ToLargeEnsemble<InferredArgs>) => ToLargeEnsemble<InferredReturn> : GenericValue extends Promise<infer InferredValue> ? InferredValue : GenericValue;

package/dist/dataParser/error.cjs

@@ -15,19 +15,21 @@ function createError() {
         currentPath: [],
     });
 }
-function addIssue(error, source, data) {
+function addIssue(error, source, data, moreInformation) {
     error.issues.push(errorIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }
-function addPromiseIssue(error, source, data) {
+function addPromiseIssue(error, source, data, moreInformation) {
     error.issues.push(errorPromiseIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }

package/dist/dataParser/error.d.ts

@@ -10,6 +10,7 @@ export interface DataParserErrorIssue extends Kind<typeof errorIssueKind.definit
     readonly source: DataParser | DataParserCheckers;
     readonly path: string;
     readonly data: unknown;
+    readonly moreInformation?: string;
 }
 export declare const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
 export declare const SymbolDataParserErrorPromiseIssue: unique symbol;
@@ -19,6 +20,7 @@ export interface DataParserErrorPromiseIssue extends Kind<typeof errorPromiseIss
     readonly source: DataParserTransform;
     readonly path: string;
     readonly data: unknown;
+    readonly moreInformation?: string;
 }
 export declare const errorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error", unknown>>;
 export interface DataParserError extends Kind<typeof errorKind.definition> {
@@ -26,7 +28,7 @@ export interface DataParserError extends Kind<typeof errorKind.definition> {
     readonly currentPath: string[];
 }
 export declare function createError(): DataParserError;
-export declare function addIssue(error: DataParserError, source: DataParser | DataParserCheckers, data: unknown): DataParserError;
-export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown): DataParserError;
+export declare function addIssue(error: DataParserError, source: DataParser | DataParserCheckers, data: unknown, moreInformation?: string): DataParserError;
+export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown, moreInformation?: string): DataParserError;
 export declare function setErrorPath(error: DataParserError, value: string, index: number): DataParserError;
 export declare function popErrorPath(error: DataParserError): DataParserError;

package/dist/dataParser/error.mjs

@@ -13,19 +13,21 @@ function createError() {
         currentPath: [],
     });
 }
-function addIssue(error, source, data) {
+function addIssue(error, source, data, moreInformation) {
     error.issues.push(errorIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }
-function addPromiseIssue(error, source, data) {
+function addPromiseIssue(error, source, data, moreInformation) {
     error.issues.push(errorPromiseIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
+        moreInformation,
     }));
     return error;
 }

package/dist/dataParser/extended/date.d.ts

@@ -16,12 +16,11 @@ export interface DataParserDateExtended<GenericDefinition extends dataParsers.Da
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserDateExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
 }
 /**
- * Creates an extended data parser for TheDate values.
+ * Creates an extended parser for `TheDate`.
  * 
- * **Supported call styles:**
- * - Method: `DPE.date(definition?)` -> returns a date parser
+ * Signature: `DPE.date(definition?)` → `DataParserDateExtended`
  * 
- * Validates TheDate values and can coerce from string or timestamp when enabled.
+ * This parser extends classic `DP.date(...)` behavior and keeps the extended chainable base API (`nullable`, `optional`, `pipe`, `transform`, etc.).
  * 
  * ```ts
  * const parser = DPE.date();
@@ -33,11 +32,17 @@ export interface DataParserDateExtended<GenericDefinition extends dataParsers.Da
  * 
  * const coerceParser = DPE.coerce.date();
  * const coerceResult = coerceParser.parse("2024-01-01T00:00:00.000Z");
+ * // coerceResult: E.Error<DP.DataParserError> | E.Success<TheDate>
  * 
  * const nullableDate = DPE.date().nullable();
  * const nullableResult = nullableDate.parse(null);
+ * // nullableResult: E.Error<DPE.DataParserError> | E.Success<TheDate | null>
  * ```
  * 
+ * @remarks
+ * - Parsed output is always `TheDate`.
+ * - `DPE.coerce.date()` enables coercion by default.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/date
  * 
  * @namespace DPE