@duplojs/utils 1.4.46 → 1.4.48

package/dist/common/path.cjs

@@ -0,0 +1,114 @@
+'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.segmentTrailingRegex = /\/$/;
+    Path.segmentRelativeRegex = /^(.\/)/;
+    /**
+     * {@include common/path/getBaseName/index.md}
+     */
+    function getBaseName(path, params) {
+        const match = Path.baseNameRegex.exec(path);
+        if (!match) {
+            return null;
+        }
+        if (params?.removeExtension) {
+            return match[1].replace(Path.extensionNameRegex, "");
+        }
+        return match[1];
+    }
+    Path.getBaseName = getBaseName;
+    /**
+     * {@include common/path/getExtensionName/index.md}
+     */
+    function getExtensionName(path) {
+        const match = Path.extensionNameRegex.exec(path);
+        if (match) {
+            return match[1];
+        }
+        return null;
+    }
+    Path.getExtensionName = getExtensionName;
+    /**
+     * {@include common/path/getParentFolderPath/index.md}
+     */
+    function getParentFolderPath(path) {
+        const match = path.match(Path.folderNameRegex);
+        if (!match) {
+            return null;
+        }
+        return match[1];
+    }
+    Path.getParentFolderPath = getParentFolderPath;
+    /**
+     * {@include common/path/isAbsolute/index.md}
+     */
+    function isAbsolute(path) {
+        return path.startsWith("/")
+            && !Path.isRelativeRegex.test(path);
+    }
+    Path.isAbsolute = isAbsolute;
+    /**
+     * {@include common/path/resolveFrom/index.md}
+     */
+    function resolveFrom(origin, segments) {
+        const result = resolveRelative([origin, ...segments]);
+        return isAbsolute(result)
+            ? success.success(result)
+            : fail.fail();
+    }
+    Path.resolveFrom = resolveFrom;
+    /**
+     * {@include common/path/resolveRelative/index.md}
+     */
+    function resolveRelative(segments) {
+        let clearedPath = "";
+        for (const segment of segments) {
+            if (segment.length === 0) {
+                continue;
+            }
+            if (segment === "/") {
+                clearedPath = segment;
+                continue;
+            }
+            const formattedSegment = segment
+                .replace(Path.segmentTrailingRegex, "")
+                .replace(Path.segmentRelativeRegex, "");
+            if (formattedSegment.startsWith("/")) {
+                clearedPath = formattedSegment;
+                continue;
+            }
+            if (clearedPath === "/") {
+                clearedPath += formattedSegment;
+            }
+            else {
+                clearedPath += `/${formattedSegment}`;
+            }
+        }
+        const dotResult = [];
+        const result = [];
+        for (const element of clearedPath.split("/")) {
+            if (element === "..") {
+                const deletedElement = result.pop();
+                if (!deletedElement) {
+                    dotResult.push(element);
+                }
+            }
+            else {
+                result.push(element);
+            }
+        }
+        if (dotResult.length === 0) {
+            return result.join("/");
+        }
+        return `${dotResult.join("/")}/${result.join("/")}`;
+    }
+    Path.resolveRelative = resolveRelative;
+})(exports.Path || (exports.Path = {}));

package/dist/common/path.d.ts

@@ -0,0 +1,145 @@
+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 segmentTrailingRegex: RegExp;
+    const segmentRelativeRegex: RegExp;
+    interface GetBaseNameParams {
+        removeExtension?: boolean;
+    }
+    /**
+     * Returns the last segment of a path (after the final slash), with optional extension removal.
+     * 
+     * **Supported call styles:**
+     * - Classic: `getBaseName(path, params?)` -> returns the base name or null
+     * 
+     * The path must contain at least one `/` to match. It returns null when no segment is found.
+     * When `removeExtension` is true, the file extension is removed from the base name.
+     * 
+     * ```ts
+     * const defaultResult = Path.getBaseName("/foo/bar.txt");
+     * // defaultResult: "bar.txt"
+     * const withoutExtResult = Path.getBaseName("/foo/bar.txt", { removeExtension: true });
+     * // withoutExtResult: "bar"
+     * const nullResult = Path.getBaseName("bar.txt");
+     * // nullResult: null
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/getBaseName
+     * 
+     */
+    function getBaseName<GenericPath extends string>(path: GenericPath, params?: GetBaseNameParams): string | null;
+    /**
+     * Returns the last extension of a path, without the leading dot.
+     * 
+     * **Supported call styles:**
+     * - Classic: `getExtensionName(path)` -> returns the extension or null
+     * 
+     * It returns null when no extension is found, when the path ends with a dot, or when the path is `..`.
+     * 
+     * ```ts
+     * const txtResult = Path.getExtensionName("/foo/bar.txt");
+     * // txtResult: "txt"
+     * const tarResult = Path.getExtensionName("archive.tar.gz");
+     * // tarResult: "gz"
+     * const dotResult = Path.getExtensionName("file.");
+     * // dotResult: null
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/getExtensionName
+     * 
+     */
+    function getExtensionName<GenericPath extends string>(path: GenericPath): string | null;
+    /**
+     * Returns the parent folder path of a POSIX path.
+     * 
+     * **Supported call styles:**
+     * - Classic: `getParentFolderPath(path)` -> returns the parent folder or null
+     * 
+     * The path must contain at least one `/` to match. It removes a trailing slash and drops the last segment.
+     * 
+     * ```ts
+     * const result = Path.getParentFolderPath("/foo/bar/baz");
+     * // result: "/foo/bar"
+     * const trailingResult = Path.getParentFolderPath("/foo/bar/");
+     * // trailingResult: "/foo"
+     * const relativeResult = Path.getParentFolderPath("foo");
+     * // relativeResult: null
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/getParentFolderPath
+     * 
+     */
+    function getParentFolderPath<GenericPath extends string>(path: GenericPath): string | null;
+    /**
+     * Checks whether a path is absolute (POSIX).
+     * 
+     * **Supported call styles:**
+     * - Classic: `isAbsolute(path)` -> returns a boolean
+     * 
+     * It returns true when the path starts with `/` and does not contain `..` segments.
+     * 
+     * ```ts
+     * const absolutePath = Path.isAbsolute("/var/log");
+     * // absolutePath: true
+     * const parentTraversal = Path.isAbsolute("/var/../log");
+     * // parentTraversal: false
+     * const relativePath = Path.isAbsolute("var/log");
+     * // relativePath: false
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/isAbsolute
+     * 
+     */
+    function isAbsolute<GenericPath extends string>(path: GenericPath): boolean;
+    /**
+     * Resolves a list of path segments from an origin and returns an Either.
+     * 
+     * **Supported call styles:**
+     * - Classic: `resolveFrom(origin, segments)` -> returns an Either
+     * 
+     * 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`.
+     * 
+     * ```ts
+     * const absoluteResult = Path.resolveFrom("/root", ["alpha", "beta"]);
+     * // absoluteResult: DEither.success<"/root/alpha/beta">
+     * const result = unwrap(absoluteResult);
+     * // result: "/root/alpha/beta"
+     * 
+     * const overrideResult = Path.resolveFrom("gamma", ["alpha", "/root", "beta"]);
+     * // overrideResult: DEither.success<"/root/beta">
+     * const relativeResult = Path.resolveFrom("alpha", ["..", ".."]);
+     * // relativeResult: DEither.fail
+     * ```
+     * 
+     * @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>;
+    /**
+     * Resolves path segments into a single POSIX-like path.
+     * 
+     * **Supported call styles:**
+     * - Classic: `resolveRelative(segments)` -> returns the resolved path
+     * 
+     * Empty segments are ignored, trailing slashes and leading `./` are removed, and absolute segments reset the base.
+     * `..` segments remove previous segments and may remain leading when resolving above root.
+     * 
+     * ```ts
+     * const basicResult = Path.resolveRelative(["alpha", "beta"]);
+     * // basicResult: "/alpha/beta"
+     * const overrideResult = Path.resolveRelative(["alpha", "/root", "beta"]);
+     * // overrideResult: "/root/beta"
+     * const parentResult = Path.resolveRelative(["alpha", "..", "..", "beta"]);
+     * // parentResult: "../beta"
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveRelative
+     * 
+     */
+    function resolveRelative<GenericSegment extends string>(segments: AnyTuple<GenericSegment>): string;
+}

package/dist/common/path.mjs

@@ -0,0 +1,114 @@
+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.segmentTrailingRegex = /\/$/;
+    Path.segmentRelativeRegex = /^(.\/)/;
+    /**
+     * {@include common/path/getBaseName/index.md}
+     */
+    function getBaseName(path, params) {
+        const match = Path.baseNameRegex.exec(path);
+        if (!match) {
+            return null;
+        }
+        if (params?.removeExtension) {
+            return match[1].replace(Path.extensionNameRegex, "");
+        }
+        return match[1];
+    }
+    Path.getBaseName = getBaseName;
+    /**
+     * {@include common/path/getExtensionName/index.md}
+     */
+    function getExtensionName(path) {
+        const match = Path.extensionNameRegex.exec(path);
+        if (match) {
+            return match[1];
+        }
+        return null;
+    }
+    Path.getExtensionName = getExtensionName;
+    /**
+     * {@include common/path/getParentFolderPath/index.md}
+     */
+    function getParentFolderPath(path) {
+        const match = path.match(Path.folderNameRegex);
+        if (!match) {
+            return null;
+        }
+        return match[1];
+    }
+    Path.getParentFolderPath = getParentFolderPath;
+    /**
+     * {@include common/path/isAbsolute/index.md}
+     */
+    function isAbsolute(path) {
+        return path.startsWith("/")
+            && !Path.isRelativeRegex.test(path);
+    }
+    Path.isAbsolute = isAbsolute;
+    /**
+     * {@include common/path/resolveFrom/index.md}
+     */
+    function resolveFrom(origin, segments) {
+        const result = resolveRelative([origin, ...segments]);
+        return isAbsolute(result)
+            ? success(result)
+            : fail();
+    }
+    Path.resolveFrom = resolveFrom;
+    /**
+     * {@include common/path/resolveRelative/index.md}
+     */
+    function resolveRelative(segments) {
+        let clearedPath = "";
+        for (const segment of segments) {
+            if (segment.length === 0) {
+                continue;
+            }
+            if (segment === "/") {
+                clearedPath = segment;
+                continue;
+            }
+            const formattedSegment = segment
+                .replace(Path.segmentTrailingRegex, "")
+                .replace(Path.segmentRelativeRegex, "");
+            if (formattedSegment.startsWith("/")) {
+                clearedPath = formattedSegment;
+                continue;
+            }
+            if (clearedPath === "/") {
+                clearedPath += formattedSegment;
+            }
+            else {
+                clearedPath += `/${formattedSegment}`;
+            }
+        }
+        const dotResult = [];
+        const result = [];
+        for (const element of clearedPath.split("/")) {
+            if (element === "..") {
+                const deletedElement = result.pop();
+                if (!deletedElement) {
+                    dotResult.push(element);
+                }
+            }
+            else {
+                result.push(element);
+            }
+        }
+        if (dotResult.length === 0) {
+            return result.join("/");
+        }
+        return `${dotResult.join("/")}/${result.join("/")}`;
+    }
+    Path.resolveRelative = resolveRelative;
+})(Path || (Path = {}));
+
+export { Path };

package/dist/dataParser/base.cjs

@@ -42,6 +42,7 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
         : {
             sync: exec,
             async: exec,
+            isAsynchronous: () => false,
         };
     function middleExec(data, error$1) {
         let result = formattedExec.sync(data, error$1, self);
@@ -163,6 +164,9 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
             }
             return result;
         },
+        isAsynchronous() {
+            return formattedExec.isAsynchronous(self);
+        },
     }, (value) => dataParserKind.setTo(value, null), kind.setTo, (value) => dataParserInit.overrideHandler.apply(value), (value) => specificOverrideHandler.apply(value));
     return self;
 }

package/dist/dataParser/base.d.ts

@@ -204,10 +204,44 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
      * 
      */
     asyncParseOrThrow(data: unknown): Promise<GenericOutput>;
+    /**
+     * The isAsynchronous() method tells whether a data parser requires async execution.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.isAsynchronous()` -> returns a boolean
+     * 
+     * It checks the parser definition (and nested parsers when relevant) and does not run any parsing.
+     * 
+     * ```ts
+     * const syncParser = DDataParser.string();
+     * syncParser.isAsynchronous(); // false
+     * 
+     * const asyncTransform = DDataParser.transform(
+     * 	DDataParser.number(),
+     * 	async(value) => {
+     * 		const result = await Promise.resolve(value);
+     * 
+     * 		return result;
+     * 	},
+     * );
+     * asyncTransform.isAsynchronous(); // true
+     * 
+     * const asyncArray = DDataParser.array(asyncTransform);
+     * asyncArray.isAsynchronous(); // true
+     * 
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/isAsynchronous
+     * 
+     * @namespace DP
+     * 
+     */
+    isAsynchronous(): boolean;
 }
 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>;
+    isAsynchronous(self: GenericDataParser): boolean;
 }
 declare const DataParserThrowError_base: new (params: {
     "@DuplojsUtilsError/dataParserThrowError"?: unknown;

package/dist/dataParser/base.mjs

@@ -40,6 +40,7 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
         : {
             sync: exec,
             async: exec,
+            isAsynchronous: () => false,
         };
     function middleExec(data, error) {
         let result = formattedExec.sync(data, error, self);
@@ -161,6 +162,9 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
             }
             return result;
         },
+        isAsynchronous() {
+            return formattedExec.isAsynchronous(self);
+        },
     }, (value) => dataParserKind.setTo(value, null), kind.setTo, (value) => dataParserInit.overrideHandler.apply(value), (value) => specificOverrideHandler.apply(value));
     return self;
 }

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

@@ -16,16 +16,16 @@ 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 data parser for TheDate values or native Date instances.
  * 
  * **Supported call styles:**
  * - Method: `DPE.date(definition?)` -> returns a date parser
  * 
- * Validates TheDate values and can coerce from string or timestamp when enabled.
+ * Validates TheDate values (or Date instances) and can coerce from ISO strings or timestamps when enabled.
  * 
  * ```ts
  * const parser = DPE.date();
- * const result = parser.parse("date0+");
+ * const result = parser.parse(new Date("2024-01-01T00:00:00.000Z"));
  * if (E.isRight(result)) {
  * 	const value = unwrap(result);
  * 	// value: TheDate

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

@@ -74,16 +74,16 @@ export interface DataParserTimeExtended<GenericDefinition extends dataParsers.Da
     max(max: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMax, "max">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerTimeMax]>>;
 }
 /**
- * Creates an extended data parser for TheTime values.
+ * Creates an extended data parser for TheTime values or safe millisecond numbers.
  * 
  * **Supported call styles:**
  * - Method: `DPE.time(definition?)` -> returns a time parser
  * 
- * Validates TheTime values and exposes time-specific methods like min and max.
+ * Validates TheTime values (or safe millisecond numbers) and exposes time-specific methods like min and max.
  * 
  * ```ts
  * const parser = DPE.time().min("time0+").max("time100+");
- * const result = parser.parse("time10+");
+ * const result = parser.parse(10);
  * if (E.isRight(result)) {
  * 	const value = unwrap(result);
  * 	// value: TheTime

package/dist/dataParser/identifier.d.ts

@@ -42,10 +42,10 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `date${number}-` | `date${number}+`;
+        input: `date${number}-` | `date${number}+` | Date;
         output: `date${number}-` | `date${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `time${number}-` | `time${number}+`;
+        input: number | `time${number}-` | `time${number}+`;
         output: `time${number}-` | `time${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: null;
@@ -59,6 +59,12 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: unknown[];
         output: unknown[];
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: `date${number}-` | `date${number}+`;
+        output: `date${number}-` | `date${number}+`;
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: `time${number}-` | `time${number}+`;
+        output: `time${number}-` | `time${number}+`;
     }>>, GenericInput extends unknown, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
     <GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/boolean", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/recover", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: string;
@@ -94,10 +100,10 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `date${number}-` | `date${number}+`;
+        input: `date${number}-` | `date${number}+` | Date;
         output: `date${number}-` | `date${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `time${number}-` | `time${number}+`;
+        input: number | `time${number}-` | `time${number}+`;
         output: `time${number}-` | `time${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: null;
@@ -111,5 +117,11 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: unknown[];
         output: unknown[];
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: `date${number}-` | `date${number}+`;
+        output: `date${number}-` | `date${number}+`;
+    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
+        input: `time${number}-` | `time${number}+`;
+        output: `time${number}-` | `time${number}+`;
     }>>, GenericInput extends unknown, GenericGroupedKind extends import("../common").UnionToIntersection<GenericKindHandler extends import("../common").KindHandler<import("../common").KindDefinition<string, unknown>> ? import("../common").Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("../common").IsEqual<import("../common").IsEqual<false | (GenericInput extends any ? import("../common").IsEqual<GenericInput, DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>> : never), boolean>, true> extends true ? Extract<DataParser<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserString<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./parsers").DataParserObject<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./parsers").DataParserNumber<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./parsers").DataParserLiteral<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnion<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./parsers").DataParserArray<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./parsers").DataParserBigInt<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./parsers").DataParserTuple<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./parsers").DataParserTransform<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./parsers").DataParserBoolean<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./parsers").DataParserDate<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./parsers").DataParserTime<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./parsers").DataParserNil<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./parsers").DataParserEmpty<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./parsers").DataParserTemplateLiteral<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./parsers").DataParserPipe<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./parsers").DataParserNullable<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserOptional<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./parsers").DataParserLazy<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./parsers").DataParserUnknown<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecord<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./parsers").DataParserRecover<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> | Extract<import("./baseExtended").DataParserExtended<import("./base").DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>, GenericGroupedKind> | Extract<import("./extended").DataParserStringExtended<import("./parsers").DataParserDefinitionString>, GenericGroupedKind> | Extract<import("./extended").DataParserObjectExtended<import("./parsers").DataParserDefinitionObject>, GenericGroupedKind> | Extract<import("./extended").DataParserNumberExtended<import("./parsers").DataParserDefinitionNumber>, GenericGroupedKind> | Extract<import("./extended").DataParserLiteralExtended<import("./parsers").DataParserDefinitionLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserUnionExtended<import("./parsers").DataParserDefinitionUnion>, GenericGroupedKind> | Extract<import("./extended").DataParserArrayExtended<import("./parsers").DataParserDefinitionArray>, GenericGroupedKind> | Extract<import("./extended").DataParserBigIntExtended<import("./parsers").DataParserDefinitionBigInt>, GenericGroupedKind> | Extract<import("./extended").DataParserTupleExtended<import("./parsers").DataParserDefinitionTuple>, GenericGroupedKind> | Extract<import("./extended").DataParserTransformExtended<import("./parsers").DataParserDefinitionTransform>, GenericGroupedKind> | Extract<import("./extended").DataParserBooleanExtended<import("./parsers").DataParserDefinitionBoolean>, GenericGroupedKind> | Extract<import("./extended").DataParserDateExtended<import("./parsers").DataParserDefinitionDate>, GenericGroupedKind> | Extract<import("./extended").DataParserTimeExtended<import("./parsers").DataParserDefinitionTime>, GenericGroupedKind> | Extract<import("./extended").DataParserNilExtended<import("./parsers").DataParserDefinitionNil>, GenericGroupedKind> | Extract<import("./extended").DataParserEmptyExtended<import("./parsers").DataParserDefinitionEmpty>, GenericGroupedKind> | Extract<import("./extended").DataParserTemplateLiteralExtended<import("./parsers").DataParserDefinitionTemplateLiteral>, GenericGroupedKind> | Extract<import("./extended").DataParserPipeExtended<import("./parsers").DataParserDefinitionPipe>, GenericGroupedKind> | Extract<import("./extended").DataParserNullableExtended<import("./parsers").DataParserDefinitionNullable<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserOptionalExtended<import("./parsers").DataParserDefinitionOptional<unknown>>, GenericGroupedKind> | Extract<import("./extended").DataParserLazyExtended<import("./parsers").DataParserDefinitionLazy>, GenericGroupedKind> | Extract<import("./extended").DataParserUnknownExtended<import("./parsers").DataParserDefinitionUnknown>, GenericGroupedKind> | Extract<import("./extended").DataParserRecordExtended<import("./parsers").DataParserDefinitionRecord>, GenericGroupedKind> | Extract<import("./extended").DataParserRecoverExtended<import("./parsers").DataParserDefinitionRecover>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

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

@@ -59,6 +59,7 @@ function array(element, definition) {
             void (data.length && error.popErrorPath(error$1));
             return output;
         },
+        isAsynchronous: (self) => self.definition.element.isAsynchronous(),
     }, array.overrideHandler);
     return self;
 }

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

@@ -57,6 +57,7 @@ function array(element, definition) {
             void (data.length && popErrorPath(error));
             return output;
         },
+        isAsynchronous: (self) => self.definition.element.isAsynchronous(),
     }, array.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/date.cjs

@@ -19,13 +19,6 @@ function date(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
-            if (data instanceof Date) {
-                const timestamp = data.getTime();
-                if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
-                    return error.SymbolDataParserErrorIssue;
-                }
-                return createTheDate.createTheDate(timestamp);
-            }
             if (typeof data === "number") {
                 if (!isSafeTimestamp.isSafeTimestamp(data)) {
                     return error.SymbolDataParserErrorIssue;
@@ -43,6 +36,13 @@ function date(definition) {
         if (typeof data === "string" && is.is(data)) {
             return data;
         }
+        if (data instanceof Date) {
+            const timestamp = data.getTime();
+            if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            return createTheDate.createTheDate(timestamp);
+        }
         return error.SymbolDataParserErrorIssue;
     }, date.overrideHandler);
     return self;