@duplojs/utils 1.4.48 → 1.4.50

package/dist/common/path.cjs

@@ -78,9 +78,7 @@ exports.Path = void 0;
                 clearedPath = segment;
                 continue;
             }
-            const formattedSegment = segment
-                .replace(Path.segmentTrailingRegex, "")
-                .replace(Path.segmentRelativeRegex, "");
+            const formattedSegment = fix(segment);
             if (formattedSegment.startsWith("/")) {
                 clearedPath = formattedSegment;
                 continue;
@@ -111,4 +109,13 @@ exports.Path = void 0;
         return `${dotResult.join("/")}/${result.join("/")}`;
     }
     Path.resolveRelative = resolveRelative;
+    /**
+     * {@include common/path/fix/index.md}
+     */
+    function fix(path) {
+        return path
+            .replace(Path.segmentTrailingRegex, "")
+            .replace(Path.segmentRelativeRegex, "");
+    }
+    Path.fix = fix;
 })(exports.Path || (exports.Path = {}));

package/dist/common/path.d.ts

@@ -142,4 +142,25 @@ export declare namespace Path {
      * 
      */
     function resolveRelative<GenericSegment extends string>(segments: AnyTuple<GenericSegment>): string;
+    /**
+     * Cleans a POSIX path by removing a trailing slash and a leading `./` prefix.
+     * 
+     * **Supported call styles:**
+     * - Classic: `fix(path)` -> returns a cleaned path
+     * 
+     * The function does not resolve `..` segments and only removes a single trailing slash and a single leading `./`.
+     * 
+     * ```ts
+     * const trimmedTrailing = Path.fix("alpha/beta/");
+     * // trimmedTrailing: "alpha/beta"
+     * const trimmedRelative = Path.fix("./alpha/beta");
+     * // trimmedRelative: "alpha/beta"
+     * const cleanedBoth = Path.fix("./alpha/");
+     * // cleanedBoth: "alpha"
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/common/path/fix
+     * 
+     */
+    function fix(path: string): string;
 }

package/dist/common/path.mjs

@@ -76,9 +76,7 @@ var Path;
                 clearedPath = segment;
                 continue;
             }
-            const formattedSegment = segment
-                .replace(Path.segmentTrailingRegex, "")
-                .replace(Path.segmentRelativeRegex, "");
+            const formattedSegment = fix(segment);
             if (formattedSegment.startsWith("/")) {
                 clearedPath = formattedSegment;
                 continue;
@@ -109,6 +107,15 @@ var Path;
         return `${dotResult.join("/")}/${result.join("/")}`;
     }
     Path.resolveRelative = resolveRelative;
+    /**
+     * {@include common/path/fix/index.md}
+     */
+    function fix(path) {
+        return path
+            .replace(Path.segmentTrailingRegex, "")
+            .replace(Path.segmentRelativeRegex, "");
+    }
+    Path.fix = fix;
 })(Path || (Path = {}));
 
 export { Path };

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 or native Date instances.
+ * Creates an extended data parser for TheDate values.
  * 
  * **Supported call styles:**
  * - Method: `DPE.date(definition?)` -> returns a date parser
  * 
- * Validates TheDate values (or Date instances) and can coerce from ISO strings or timestamps when enabled.
+ * Validates TheDate values and can coerce from string or timestamp when enabled.
  * 
  * ```ts
  * const parser = DPE.date();
- * const result = parser.parse(new Date("2024-01-01T00:00:00.000Z"));
+ * const result = parser.parse("date0+");
  * 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 or safe millisecond numbers.
+ * Creates an extended data parser for TheTime values.
  * 
  * **Supported call styles:**
  * - Method: `DPE.time(definition?)` -> returns a time parser
  * 
- * Validates TheTime values (or safe millisecond numbers) and exposes time-specific methods like min and max.
+ * Validates TheTime values and exposes time-specific methods like min and max.
  * 
  * ```ts
  * const parser = DPE.time().min("time0+").max("time100+");
- * const result = parser.parse(10);
+ * const result = parser.parse("time10+");
  * 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}+` | Date;
+        input: `date${number}-` | `date${number}+`;
         output: `date${number}-` | `date${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: number | `time${number}-` | `time${number}+`;
+        input: `time${number}-` | `time${number}+`;
         output: `time${number}-` | `time${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: null;
@@ -59,12 +59,6 @@ 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;
@@ -100,10 +94,10 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: `date${number}-` | `date${number}+` | Date;
+        input: `date${number}-` | `date${number}+`;
         output: `date${number}-` | `date${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: number | `time${number}-` | `time${number}+`;
+        input: `time${number}-` | `time${number}+`;
         output: `time${number}-` | `time${number}+`;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: null;
@@ -117,11 +111,5 @@ 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/date.cjs

@@ -19,6 +19,13 @@ 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;
@@ -36,13 +43,6 @@ 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;

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

@@ -11,7 +11,7 @@ export interface DataParserDefinitionDate extends DataParserDefinition<DataParse
     readonly coerce: boolean;
 }
 export declare const dateKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>>;
-type _DataParserDate<GenericDefinition extends DataParserDefinitionDate> = (DataParser<GenericDefinition, TheDate, TheDate | Date> & Kind<typeof dateKind.definition>);
+type _DataParserDate<GenericDefinition extends DataParserDefinitionDate> = (DataParser<GenericDefinition, TheDate, TheDate> & Kind<typeof dateKind.definition>);
 export interface DataParserDate<GenericDefinition extends DataParserDefinitionDate = DataParserDefinitionDate> extends _DataParserDate<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserDateCheckers,
@@ -22,17 +22,17 @@ export interface DataParserDate<GenericDefinition extends DataParserDefinitionDa
     ], GenericChecker>): DataParserDate<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 /**
- * Creates a data parser for TheDate values or native Date instances.
+ * Creates a data parser for TheDate values.
  * 
  * **Supported call styles:**
  * - Classic: `DP.date(definition?)` -> returns a date parser
  * - Curried: not available
  * 
- * Validates that the input is a TheDate (or a Date instance), optionally applies number/ISO string coercion, and runs the configured checkers.
+ * Validates that the input is a TheDate, optionally applies coerce, and runs the configured checkers.
  * 
  * ```ts
  * const parser = DP.date();
- * const result = parser.parse(new Date("2024-01-01T00:00:00.000Z"));
+ * const result = parser.parse("date0+");
  * if (E.isRight(result)) {
  * 	const value = unwrap(result);
  * 	// value: TheDate

package/dist/dataParser/parsers/date.mjs

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

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

@@ -3,13 +3,13 @@
 var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
+var isSafeTimeValue = require('../../../date/isSafeTimeValue.cjs');
+var createTheTime = require('../../../date/createTheTime.cjs');
 var constants = require('../../../date/constants.cjs');
 var createTime = require('../../../date/createTime.cjs');
 var is = require('../../../either/left/is.cjs');
 var unwrap = require('../../../common/unwrap.cjs');
 var isTime = require('../../../date/isTime.cjs');
-var isSafeTimeValue = require('../../../date/isSafeTimeValue.cjs');
-var createTheTime = require('../../../date/createTheTime.cjs');
 var override = require('../../../common/override.cjs');
 
 const timeKind = kind.createDataParserKind("time");
@@ -23,6 +23,12 @@ function time(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
+            if (typeof data === "number") {
+                if (!isSafeTimeValue.isSafeTimeValue(data)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                return createTheTime.createTheTime(data);
+            }
             if (typeof data === "string" && constants.isoTimeRegex.test(data)) {
                 const result = createTime.createTime({ value: data });
                 if (is.isLeft(result)) {
@@ -34,12 +40,6 @@ function time(definition) {
         if (typeof data === "string" && isTime.isTime(data)) {
             return data;
         }
-        if (typeof data === "number") {
-            if (!isSafeTimeValue.isSafeTimeValue(data)) {
-                return error.SymbolDataParserErrorIssue;
-            }
-            return createTheTime.createTheTime(data);
-        }
         return error.SymbolDataParserErrorIssue;
     }, time.overrideHandler);
     return self;

package/dist/dataParser/parsers/time/index.d.ts

@@ -13,7 +13,7 @@ export interface DataParserDefinitionTime extends DataParserDefinition<DataParse
     readonly coerce: boolean;
 }
 export declare const timeKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>>;
-type _DataParserTime<GenericDefinition extends DataParserDefinitionTime> = (DataParser<GenericDefinition, TheTime, TheTime | number> & Kind<typeof timeKind.definition>);
+type _DataParserTime<GenericDefinition extends DataParserDefinitionTime> = (DataParser<GenericDefinition, TheTime, TheTime> & Kind<typeof timeKind.definition>);
 export interface DataParserTime<GenericDefinition extends DataParserDefinitionTime = DataParserDefinitionTime> extends _DataParserTime<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserTimeCheckers,
@@ -24,17 +24,17 @@ export interface DataParserTime<GenericDefinition extends DataParserDefinitionTi
     ], GenericChecker>): DataParserTime<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 /**
- * Creates a data parser for TheTime values or safe millisecond numbers.
+ * Creates a data parser for TheTime values.
  * 
  * **Supported call styles:**
  * - Classic: `DP.time(definition?)` -> returns a time parser
  * - Curried: not available
  * 
- * Validates that the input is a TheTime (or a safe millisecond number), optionally applies ISO string coercion, and runs the configured checkers.
+ * Validates that the input is a TheTime, optionally applies coerce, and runs the configured checkers.
  * 
  * ```ts
  * const parser = DP.time();
- * const result = parser.parse(60000);
+ * const result = parser.parse("time0+");
  * if (E.isRight(result)) {
  * 	const value = unwrap(result);
  * 	// value: TheTime

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

@@ -1,13 +1,13 @@
 import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
+import { isSafeTimeValue } from '../../../date/isSafeTimeValue.mjs';
+import { createTheTime } from '../../../date/createTheTime.mjs';
 import { isoTimeRegex } from '../../../date/constants.mjs';
 import { createTime } from '../../../date/createTime.mjs';
 import { isLeft } from '../../../either/left/is.mjs';
 import { unwrap } from '../../../common/unwrap.mjs';
 import { isTime } from '../../../date/isTime.mjs';
-import { isSafeTimeValue } from '../../../date/isSafeTimeValue.mjs';
-import { createTheTime } from '../../../date/createTheTime.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const timeKind = createDataParserKind("time");
@@ -21,6 +21,12 @@ function time(definition) {
         coerce: definition?.coerce ?? false,
     }, (data, _error, self) => {
         if (self.definition.coerce) {
+            if (typeof data === "number") {
+                if (!isSafeTimeValue(data)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                return createTheTime(data);
+            }
             if (typeof data === "string" && isoTimeRegex.test(data)) {
                 const result = createTime({ value: data });
                 if (isLeft(result)) {
@@ -32,12 +38,6 @@ function time(definition) {
         if (typeof data === "string" && isTime(data)) {
             return data;
         }
-        if (typeof data === "number") {
-            if (!isSafeTimeValue(data)) {
-                return SymbolDataParserErrorIssue;
-            }
-            return createTheTime(data);
-        }
         return SymbolDataParserErrorIssue;
     }, time.overrideHandler);
     return self;

package/dist/either/left/fail.d.ts

@@ -5,7 +5,7 @@ export declare const failKind: import("../../common/kind").KindHandler<import(".
  * @deprecated use failKind
  */
 export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
-type _Fail = (Left<"fail", never> & Kind<typeof failKind.definition>);
+type _Fail = (Left<"fail", void> & Kind<typeof failKind.definition>);
 export interface Fail extends _Fail {
 }
 /**
@@ -13,7 +13,7 @@ export interface Fail extends _Fail {
  */
 export type EitherFail = Fail;
 /**
- * Returns an Left<"fail", never>: perfect to signal a failure without carrying extra data.
+ * Returns an Left<"fail", void>: perfect to signal a failure without carrying extra data.
  * 
  * Signature: `fail()` → returns a value
  * 

package/dist/either/right/ok.d.ts

@@ -5,7 +5,7 @@ export declare const okKind: import("../../common/kind").KindHandler<import("../
  * @deprecated use okKind
  */
 export declare const eitherOkKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/ok", unknown>>;
-type _Ok = (Right<"ok", never> & Kind<typeof okKind.definition>);
+type _Ok = (Right<"ok", void> & Kind<typeof okKind.definition>);
 export interface Ok extends _Ok {
 }
 /**
@@ -13,7 +13,7 @@ export interface Ok extends _Ok {
  */
 export type EitherOk = Ok;
 /**
- * Returns an Right<"ok", never>: an empty success that confirms an operation went fine without extra data.
+ * Returns an Right<"ok", void>: an empty success that confirms an operation went fine without extra data.
  * 
  * Signature: `ok()` → returns a value
  * 

package/package.json

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