@duplojs/utils 1.5.1 → 1.5.3

package/dist/array/is.d.ts

@@ -23,4 +23,4 @@
  * @namespace A
  * 
  */
-export declare function is<GenericValue extends unknown>(arg: GenericValue): arg is GenericValue extends any[] ? GenericValue : never;
+export declare function is<GenericValue extends unknown>(arg: GenericValue): arg is Extract<GenericValue, readonly any[]>;

package/dist/clean/primitive/base.d.ts

@@ -239,7 +239,7 @@ export type Boolean = ReturnType<typeof Boolean["createWithUnknownOrThrow"]>;
  * @namespace C
  * 
  */
-export declare const Date: PrimitiveHandler<DDate.TheDate, DDate.TheDate | `date${number}-` | `date${number}+` | globalThis.Date>;
+export declare const Date: PrimitiveHandler<DDate.TheDate, `date${number}-` | `date${number}+` | DDate.TheDate | globalThis.Date>;
 export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
 /**
  * Business primitive for duration values (`TheTime`).

package/dist/common/formData.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+var escapeRegExp = require('./escapeRegExp.cjs');
+var theTime = require('../date/theTime.cjs');
+var theDate = require('../date/theDate.cjs');
+
+const separator = "/*\\";
+const firstElementInPathRegex = new RegExp(`^((?:(?!${escapeRegExp.escapeRegExp(separator)}).)*)(?:${escapeRegExp.escapeRegExp(separator)})?`);
+const getIndexRegex = /^\[(\d+)\]$/;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
+class TheFormData extends FormData {
+    inputValues;
+    constructor(inputValues) {
+        super();
+        this.inputValues = inputValues;
+        for (const entry of TheFormData.toFlatEntries(inputValues)) {
+            this.append(entry[0], entry[1]);
+        }
+    }
+    static *toFlatEntries(value, path) {
+        if (typeof value === "string"
+            || value instanceof theTime.TheTime
+            || value instanceof theDate.TheDate
+            || typeof value === "number"
+            || typeof value === "boolean") {
+            yield [path ?? "", value.toString()];
+        }
+        else if (value instanceof File) {
+            yield [path ?? "", value];
+        }
+        else if (value === null) {
+            yield [path ?? "", "null"];
+        }
+        else if (value === undefined) {
+            return;
+        }
+        else if (value instanceof Array) {
+            for (let index = 0; index < value.length; index++) {
+                const entriesIterator = this.toFlatEntries(value[index], path === undefined
+                    ? `[${index}]`
+                    : `${path}${separator}[${index}]`);
+                for (const entry of entriesIterator) {
+                    yield entry;
+                }
+            }
+        }
+        else {
+            for (const key in value) {
+                const entriesIterator = this.toFlatEntries(value[key], path === undefined
+                    ? key
+                    : `${path}${separator}${key}`);
+                for (const entry of entriesIterator) {
+                    yield entry;
+                }
+            }
+        }
+    }
+    static fromEntries(iterable, arrayMaxIndex) {
+        const constructObject = (object, path, value) => {
+            const firstElement = path.match(firstElementInPathRegex)[1];
+            const index = firstElement.match(getIndexRegex)?.[1];
+            if (index && Number(index) > arrayMaxIndex) {
+                return object;
+            }
+            let currentObject = object;
+            if (currentObject === undefined) {
+                if (index !== undefined) {
+                    currentObject = [];
+                }
+                else {
+                    currentObject = {};
+                }
+            }
+            if (firstElement === path) {
+                currentObject[(index ?? firstElement)] = value;
+                return currentObject;
+            }
+            currentObject[(index ?? firstElement)] = constructObject(currentObject[(index ?? firstElement)], path.replace(firstElementInPathRegex, ""), value);
+            return currentObject;
+        };
+        let result = undefined;
+        for (const entry of iterable) {
+            if (invalidEntryRegex.test(entry[0])) {
+                continue;
+            }
+            result = constructObject(result, entry[0], entry[1]);
+        }
+        return result ?? {};
+    }
+    /**
+     * @internal
+     */
+    static "new"(inputValues) {
+        return new TheFormData(inputValues);
+    }
+}
+/**
+ * {@include common/createFormData/index.md}
+ */
+function createFormData(inputValues) {
+    return TheFormData.new(inputValues);
+}
+
+exports.TheFormData = TheFormData;
+exports.createFormData = createFormData;

package/dist/common/formData.d.ts

@@ -0,0 +1,69 @@
+import * as DDate from "../date";
+export type EligibleFormDataValue = (boolean | number | null | string | File | undefined | DDate.TheDate | DDate.TheTime | {
+    [key: string]: EligibleFormDataValue;
+} | EligibleFormDataValue[]);
+export declare class TheFormData<GenericValues extends Record<string, EligibleFormDataValue>> extends FormData {
+    readonly inputValues: GenericValues;
+    private constructor();
+    static toFlatEntries(value: EligibleFormDataValue, path?: string): Iterable<[string, string | File], void>;
+    static fromEntries(iterable: Iterable<[string, unknown]>, arrayMaxIndex: number): object;
+}
+/**
+ * Creates an extended `FormData` instance from nested values and provides helpers to flatten or rebuild entries.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createFormData(inputValues)` -> returns a `TheFormData` instance
+ * 
+ * The returned instance extends native `FormData` and stores the original object in `inputValues`.
+ * Supported values are `string`, `File`, `boolean`, `number`, `null`, `undefined`, `DDate.TheDate`, `DDate.TheTime`, objects, and arrays.
+ * At flatten time, non-`File` values are serialized to strings (`null` becomes `"null"`).
+ * For backend reconstruction, use `TheFormData.fromEntries(...)` to rebuild nested objects from flattened form-data keys.
+ * 
+ * ```ts
+ * const created = createFormData(
+ * 	{
+ * 		profile: {
+ * 			name: "Ada",
+ * 			tags: ["core", "utils"],
+ * 		},
+ * 		enabled: true,
+ * 		retryCount: 2,
+ * 		optionalValue: null,
+ * 		createdDate: DDate.createOrThrow(1735689600000),
+ * 		createdTime: DDate.createTimeOrThrow(45000000),
+ * 	},
+ * );
+ * const flattenedName = created.get("profile/*\\name");
+ * // flattenedName: "Ada"
+ * const flattenedEnabled = created.get("enabled");
+ * // flattenedEnabled: "true"
+ * const flattenedNull = created.get("optionalValue");
+ * // flattenedNull: "null"
+ * 
+ * const flatEntries = Array.from(
+ * 	TheFormData.toFlatEntries({
+ * 		tags: ["core", "utils"],
+ * 		time: DDate.createTimeOrThrow(31500000),
+ * 	}),
+ * );
+ * // flatEntries: [["tags/*\\[0]", "core"], ["tags/*\\[1]", "utils"], ["time", "time31500000+"]]
+ * 
+ * const rebuilt = TheFormData.fromEntries(
+ * 	[
+ * 		["profile/*\\name", "Ada"],
+ * 		["profile/*\\tags/*\\[0]", "core"],
+ * 		["enabled", "true"],
+ * 	],
+ * 	10,
+ * );
+ * // rebuilt: { profile: { name: "Ada", tags: ["core"] }, enabled: "true" }
+ * ```
+ * 
+ * @remarks
+ * - `TheFormData.toFlatEntries(...)` flattens nested objects/arrays into path keys using the `/*\` separator.
+ * - `TheFormData.fromEntries(...)` ignores `__proto__`, `constructor`, and `prototype` paths for safety.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/createFormData
+ * 
+ */
+export declare function createFormData<GenericValues extends Record<string, EligibleFormDataValue>>(inputValues: GenericValues): TheFormData<GenericValues>;

package/dist/common/formData.mjs

@@ -0,0 +1,102 @@
+import { escapeRegExp } from './escapeRegExp.mjs';
+import { TheTime } from '../date/theTime.mjs';
+import { TheDate } from '../date/theDate.mjs';
+
+const separator = "/*\\";
+const firstElementInPathRegex = new RegExp(`^((?:(?!${escapeRegExp(separator)}).)*)(?:${escapeRegExp(separator)})?`);
+const getIndexRegex = /^\[(\d+)\]$/;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
+class TheFormData extends FormData {
+    inputValues;
+    constructor(inputValues) {
+        super();
+        this.inputValues = inputValues;
+        for (const entry of TheFormData.toFlatEntries(inputValues)) {
+            this.append(entry[0], entry[1]);
+        }
+    }
+    static *toFlatEntries(value, path) {
+        if (typeof value === "string"
+            || value instanceof TheTime
+            || value instanceof TheDate
+            || typeof value === "number"
+            || typeof value === "boolean") {
+            yield [path ?? "", value.toString()];
+        }
+        else if (value instanceof File) {
+            yield [path ?? "", value];
+        }
+        else if (value === null) {
+            yield [path ?? "", "null"];
+        }
+        else if (value === undefined) {
+            return;
+        }
+        else if (value instanceof Array) {
+            for (let index = 0; index < value.length; index++) {
+                const entriesIterator = this.toFlatEntries(value[index], path === undefined
+                    ? `[${index}]`
+                    : `${path}${separator}[${index}]`);
+                for (const entry of entriesIterator) {
+                    yield entry;
+                }
+            }
+        }
+        else {
+            for (const key in value) {
+                const entriesIterator = this.toFlatEntries(value[key], path === undefined
+                    ? key
+                    : `${path}${separator}${key}`);
+                for (const entry of entriesIterator) {
+                    yield entry;
+                }
+            }
+        }
+    }
+    static fromEntries(iterable, arrayMaxIndex) {
+        const constructObject = (object, path, value) => {
+            const firstElement = path.match(firstElementInPathRegex)[1];
+            const index = firstElement.match(getIndexRegex)?.[1];
+            if (index && Number(index) > arrayMaxIndex) {
+                return object;
+            }
+            let currentObject = object;
+            if (currentObject === undefined) {
+                if (index !== undefined) {
+                    currentObject = [];
+                }
+                else {
+                    currentObject = {};
+                }
+            }
+            if (firstElement === path) {
+                currentObject[(index ?? firstElement)] = value;
+                return currentObject;
+            }
+            currentObject[(index ?? firstElement)] = constructObject(currentObject[(index ?? firstElement)], path.replace(firstElementInPathRegex, ""), value);
+            return currentObject;
+        };
+        let result = undefined;
+        for (const entry of iterable) {
+            if (invalidEntryRegex.test(entry[0])) {
+                continue;
+            }
+            result = constructObject(result, entry[0], entry[1]);
+        }
+        return result ?? {};
+    }
+    /**
+     * @internal
+     */
+    static "new"(inputValues) {
+        return new TheFormData(inputValues);
+    }
+}
+/**
+ * {@include common/createFormData/index.md}
+ */
+function createFormData(inputValues) {
+    return TheFormData.new(inputValues);
+}
+
+export { TheFormData, createFormData };

package/dist/common/index.d.ts

@@ -16,6 +16,7 @@
  * - predicates and guards (`when`, `whenNot`, `whenElse`, `and`, `or`, `isType`, `asserts`, `instanceOf`)
  * - control flow (`loop`, `asyncLoop`, `asyncRetry`, `sleep`, `memo`)
  * - promise utilities (`externalPromise`, `promiseObject`)
+ * - form-data utilities (`createFormData`, `TheFormData.fromEntries`, `TheFormData.toFlatEntries`)
  * - string and value conversions (`stringToMillisecond`, `stringToBytes`, `escapeRegExp`, `toRegExp`)
  * - wrappers and kinds (`wrapValue`, `unwrap`, `toWrappedValue`, `hasKinds`, `hasSomeKinds`)
  * 
@@ -67,6 +68,7 @@ export * from "./override";
 export * from "./errorKindNamespace";
 export * from "./truthy";
 export * from "./falsy";
+export * from "./formData";
 export * from "./hasSomeKinds";
 export * from "./hasKinds";
 export * from "./toCurriedPredicate";

package/dist/common/kind.d.ts

@@ -36,6 +36,9 @@ export type GetKindValue<GenericKindHandler extends KindHandler, GenericObject e
 export type GetKindHandler<GenericObject extends Kind<any>> = {
     [Prop in keyof GenericObject[SymbolKind]]: KindHandler<KindDefinition<Adaptor<Prop, string>, GenericObject[SymbolKind][Prop]>>;
 }[keyof GenericObject[SymbolKind]];
+export interface GetKind<GenericObject extends Kind<any>> {
+    [SymbolKind]: GenericObject[SymbolKind];
+}
 export declare const keyKindPrefix = "@duplojs/utils/kind/";
 type ForbiddenKindCharacters<GenericValue extends string> = ForbiddenString<GenericValue, "@" | "/">;
 /**

package/dist/dataParser/base.d.ts

@@ -1,4 +1,4 @@
-import { type GetKindHandler, type GetKindValue, type IsEqual, type Kind, type KindHandler, type OverrideHandler, type RemoveKind } from "../common";
+import { type GetKind, type GetKindHandler, type GetKindValue, type IsEqual, type Kind, type KindHandler, type OverrideHandler, type RemoveKind } from "../common";
 import { SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue, type DataParserError } from "./error";
 import * as DEither from "../either";
 export declare const SymbolDataParserErrorLabel = "SymbolDataParserError";
@@ -257,4 +257,8 @@ export declare namespace dataParserInit {
 export type Output<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["output"];
 export type Input<GenericDataParser extends DataParser> = GetKindValue<typeof dataParserKind, GenericDataParser>["input"];
 export type Contract<GenericOutput extends unknown, GenericInput extends unknown = GenericOutput> = DataParser<DataParserDefinition, GenericOutput, GenericInput>;
+export type AdvancedContract<GenericDataParser extends DataParser> = (GetKind<GenericDataParser> & Omit<RemoveKind<DataParser>, "addChecker" | "clone" | "definition"> & Pick<GenericDataParser, "definition"> & {
+    addChecker(...args: never): AdvancedContract<GenericDataParser>;
+    clone(): AdvancedContract<GenericDataParser>;
+});
 export {};

package/dist/dataParser/baseExtended.d.ts

@@ -1,4 +1,4 @@
-import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue, type OverrideHandler } from "../common";
+import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue, type OverrideHandler, type GetKind, type RemoveKind } from "../common";
 import { type MergeDefinition } from "./types";
 import { type Output, type DataParser, type DataParserDefinition } from "./base";
 import type * as DEither from "../either";
@@ -416,4 +416,8 @@ export declare namespace dataParserExtendedInit {
     var overrideHandler: OverrideHandler<DataParserExtended<DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }
 export type ContractExtended<GenericOutput extends unknown, GenericInput extends unknown = GenericOutput> = DataParserExtended<DataParserDefinition, GenericOutput, GenericInput>;
+export type AdvancedContractExtended<GenericDataParser extends DataParserExtended> = (GetKind<GenericDataParser> & Omit<RemoveKind<DataParserExtended>, "addChecker" | "clone" | "definition"> & Pick<GenericDataParser, "definition"> & {
+    addChecker(...args: never): AdvancedContractExtended<GenericDataParser>;
+    clone(): AdvancedContractExtended<GenericDataParser>;
+});
 export {};

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

@@ -3,7 +3,7 @@ import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output, type DataParser } from "../base";
-type _DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray> = (Kind<typeof dataParsers.arrayKind.definition> & DataParserExtended<GenericDefinition, Output<GenericDefinition["element"]>[], Input<GenericDefinition["element"]>[]>);
+type _DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray> = (Kind<typeof dataParsers.arrayKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserArray<GenericDefinition>>, Input<dataParsers.DataParserArray<GenericDefinition>>>);
 export interface DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray = dataParsers.DataParserDefinitionArray> extends _DataParserArrayExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserArrayCheckers<Output<this>>,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt> = (Kind<typeof dataParsers.bigIntKind.definition> & DataParserExtended<GenericDefinition, bigint, bigint>);
+import { type Input, type Output } from "../base";
+type _DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt> = (Kind<typeof dataParsers.bigIntKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserBigInt<GenericDefinition>>, Input<dataParsers.DataParserBigInt<GenericDefinition>>>);
 export interface DataParserBigIntExtended<GenericDefinition extends dataParsers.DataParserDefinitionBigInt = dataParsers.DataParserDefinitionBigInt> extends _DataParserBigIntExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserBigIntCheckers,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserBooleanExtended<GenericDefinition extends dataParsers.DataParserDefinitionBoolean> = (Kind<typeof dataParsers.booleanKind.definition> & DataParserExtended<GenericDefinition, boolean, boolean>);
+import { type Input, type Output } from "../base";
+type _DataParserBooleanExtended<GenericDefinition extends dataParsers.DataParserDefinitionBoolean> = (Kind<typeof dataParsers.booleanKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserBoolean<GenericDefinition>>, Input<dataParsers.DataParserBoolean<GenericDefinition>>>);
 export interface DataParserBooleanExtended<GenericDefinition extends dataParsers.DataParserDefinitionBoolean = dataParsers.DataParserDefinitionBoolean> extends _DataParserBooleanExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserBooleanCheckers,

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

@@ -2,9 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-import { type TheDate } from "../../date";
-type _DataParserDateExtended<GenericDefinition extends dataParsers.DataParserDefinitionDate> = (Kind<typeof dataParsers.dateKind.definition> & DataParserExtended<GenericDefinition, TheDate, TheDate>);
+import { type Output, type Input } from "../base";
+type _DataParserDateExtended<GenericDefinition extends dataParsers.DataParserDefinitionDate> = (Kind<typeof dataParsers.dateKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserDate<GenericDefinition>>, Input<dataParsers.DataParserDate<GenericDefinition>>>);
 export interface DataParserDateExtended<GenericDefinition extends dataParsers.DataParserDefinitionDate = dataParsers.DataParserDefinitionDate> extends _DataParserDateExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserDateCheckers,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty> = (Kind<typeof dataParsers.emptyKind.definition> & DataParserExtended<GenericDefinition, undefined, undefined>);
+import { type Input, type Output } from "../base";
+type _DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty> = (Kind<typeof dataParsers.emptyKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserEmpty<GenericDefinition>>, Input<dataParsers.DataParserEmpty<GenericDefinition>>>);
 export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty = dataParsers.DataParserDefinitionEmpty> extends _DataParserEmptyExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserEmptyCheckers,

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

@@ -3,7 +3,7 @@ import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output, type DataParser } from "../base";
-type _DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy> = (Kind<typeof dataParsers.lazyKind.definition> & DataParserExtended<GenericDefinition, Output<GenericDefinition["getter"]["value"]>, Input<GenericDefinition["getter"]["value"]>>);
+type _DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy> = (Kind<typeof dataParsers.lazyKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserLazy<GenericDefinition>>, Input<dataParsers.DataParserLazy<GenericDefinition>>>);
 export interface DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy = dataParsers.DataParserDefinitionLazy> extends _DataParserLazyExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserLazyCheckers<Output<this>>,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral> = (Kind<typeof dataParsers.literalKind.definition> & DataParserExtended<GenericDefinition, GenericDefinition["value"][number], GenericDefinition["value"][number]>);
+import { type Input, type Output } from "../base";
+type _DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral> = (Kind<typeof dataParsers.literalKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserLiteral<GenericDefinition>>, Input<dataParsers.DataParserLiteral<GenericDefinition>>>);
 export interface DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral = dataParsers.DataParserDefinitionLiteral> extends _DataParserLiteralExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserLiteralCheckers<Output<this>>,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil> = (Kind<typeof dataParsers.nilKind.definition> & DataParserExtended<GenericDefinition, null, null>);
+import { type Input, type Output } from "../base";
+type _DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil> = (Kind<typeof dataParsers.nilKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserNil<GenericDefinition>>, Input<dataParsers.DataParserNil<GenericDefinition>>>);
 export interface DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil = dataParsers.DataParserDefinitionNil> extends _DataParserNilExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserNilCheckers,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output, type DataParser } from "../base";
-type _DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable> = (Kind<typeof dataParsers.nullableKind.definition> & DataParserExtended<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | null : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | null>);
+type _DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable> = (Kind<typeof dataParsers.nullableKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserNullable<GenericDefinition>>, Input<dataParsers.DataParserNullable<GenericDefinition>>>);
 export interface DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable = dataParsers.DataParserDefinitionNullable> extends _DataParserNullableExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserNullableCheckers<Output<this>>,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber> = (Kind<typeof dataParsers.numberKind.definition> & DataParserExtended<GenericDefinition, number, number>);
+import { type Input, type Output } from "../base";
+type _DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber> = (Kind<typeof dataParsers.numberKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserNumber<GenericDefinition>>, Input<dataParsers.DataParserNumber<GenericDefinition>>>);
 export interface DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber = dataParsers.DataParserDefinitionNumber> extends _DataParserNumberExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserNumberCheckers,

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

@@ -2,9 +2,9 @@ import { type Adaptor, type FixDeepFunctionInfer, type Kind, type NeverCoalescin
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
+import { type Input, type Output } from "../base";
 import { type AssignObjects } from "../../object";
-type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (Kind<typeof dataParsers.objectKind.definition> & DataParserExtended<GenericDefinition, dataParsers.DataParserObjectShapeOutput<GenericDefinition["shape"]>, dataParsers.DataParserObjectShapeInput<GenericDefinition["shape"]>>);
+type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (Kind<typeof dataParsers.objectKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserObject<GenericDefinition>>, Input<dataParsers.DataParserObject<GenericDefinition>>>);
 export interface DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject = dataParsers.DataParserDefinitionObject> extends _DataParserObjectExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserObjectCheckers<Output<this>>,

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

@@ -1,9 +1,9 @@
-import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output, type DataParser } from "../base";
-type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (Kind<typeof dataParsers.optionalKind.definition> & DataParserExtended<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | undefined : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | undefined>);
+type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (Kind<typeof dataParsers.optionalKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserOptional<GenericDefinition>>, Input<dataParsers.DataParserOptional<GenericDefinition>>>);
 export interface DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional = dataParsers.DataParserDefinitionOptional> extends _DataParserOptionalExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserOptionalCheckers<Output<this>>,

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

@@ -3,7 +3,7 @@ import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output, type DataParser } from "../base";
-type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (Kind<typeof dataParsers.pipeKind.definition> & DataParserExtended<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>>);
+type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (Kind<typeof dataParsers.pipeKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserPipe<GenericDefinition>>, Input<dataParsers.DataParserPipe<GenericDefinition>>>);
 export interface DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe = dataParsers.DataParserDefinitionPipe> extends _DataParserPipeExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserPipeCheckers<Output<this>>,

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

@@ -3,7 +3,7 @@ import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output, type DataParser } from "../base";
-type _DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover> = (Kind<typeof dataParsers.recoverKind.definition> & DataParserExtended<GenericDefinition, GenericDefinition["recoveredValue"], Input<GenericDefinition["inner"]>>);
+type _DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover> = (Kind<typeof dataParsers.recoverKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserRecover<GenericDefinition>>, Input<dataParsers.DataParserRecover<GenericDefinition>>>);
 export interface DataParserRecoverExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecover = dataParsers.DataParserDefinitionRecover> extends _DataParserRecoverExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserRecoverCheckers<Output<this>>,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString> = (Kind<typeof dataParsers.stringKind.definition> & DataParserExtended<GenericDefinition, string, string>);
+import { type Input, type Output } from "../base";
+type _DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString> = (Kind<typeof dataParsers.stringKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserString<GenericDefinition>>, Input<dataParsers.DataParserString<GenericDefinition>>>);
 export interface DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString = dataParsers.DataParserDefinitionString> extends _DataParserStringExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserStringCheckers,

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral> = (Kind<typeof dataParsers.templateLiteralKind.definition> & DataParserExtended<GenericDefinition, dataParsers.TemplateLiteralShapeOutput<GenericDefinition["template"]>, dataParsers.TemplateLiteralShapeInput<GenericDefinition["template"]>>);
+import { type Input, type Output } from "../base";
+type _DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral> = (Kind<typeof dataParsers.templateLiteralKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTemplateLiteral<GenericDefinition>>, Input<dataParsers.DataParserTemplateLiteral<GenericDefinition>>>);
 export interface DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral = dataParsers.DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteralExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserTemplateLiteralCheckers<Output<this>>,

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

@@ -2,9 +2,9 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
+import { type Input, type Output } from "../base";
 import { type TheTime } from "../../date";
-type _DataParserTimeExtended<GenericDefinition extends dataParsers.DataParserDefinitionTime> = (Kind<typeof dataParsers.timeKind.definition> & DataParserExtended<GenericDefinition, TheTime, TheTime>);
+type _DataParserTimeExtended<GenericDefinition extends dataParsers.DataParserDefinitionTime> = (Kind<typeof dataParsers.timeKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTime<GenericDefinition>>, Input<dataParsers.DataParserTime<GenericDefinition>>>);
 export interface DataParserTimeExtended<GenericDefinition extends dataParsers.DataParserDefinitionTime = dataParsers.DataParserDefinitionTime> extends _DataParserTimeExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserTimeCheckers,

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

@@ -4,7 +4,7 @@ import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type DataParser, type Input, type Output } from "../base";
 import { type DataParserError } from "../error";
-type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (Kind<typeof dataParsers.transformKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTransform<GenericDefinition>>, Input<GenericDefinition["inner"]>>);
+type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (Kind<typeof dataParsers.transformKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTransform<GenericDefinition>>, Input<dataParsers.DataParserTransform<GenericDefinition>>>);
 export interface DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform = dataParsers.DataParserDefinitionTransform> extends _DataParserTransformExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserTransformCheckers<Output<this>>,

package/dist/dataParser/extended/tuple.cjs

@@ -17,6 +17,10 @@ function tuple(shape, definition) {
         max(self, max$1, definition) {
             return self.addChecker(max.checkerArrayMax(max$1, definition));
         },
+        rest: (self, dataParser) => tuple(self.definition.shape, {
+            ...self.definition,
+            rest: dataParser,
+        }),
     }, tuple.overrideHandler);
     return self;
 }

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

@@ -1,6 +1,6 @@
-import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition, type DataParsers } from "../types";
 import * as dataParsers from "../parsers";
 import { type Input, type Output } from "../base";
 type _DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple> = (Kind<typeof dataParsers.tupleKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserTuple<GenericDefinition>>, Input<dataParsers.DataParserTuple<GenericDefinition>>>);
@@ -13,8 +13,102 @@ export interface DataParserTupleExtended<GenericDefinition extends dataParsers.D
         ...dataParsers.DataParserTupleCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
+    /**
+     * Adds a minimum length checker to a tuple parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.min(min, definition?)` -> returns a tuple parser
+     * 
+     * Ensures the parsed tuple has at least the given number of items.
+     * 
+     * ```ts
+     * const parser = DPE.tuple([DPE.string(), DPE.number()]).min(2);
+     * const result = parser.parse(["id", 42]);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: [string, number]
+     * }
+     * 
+     * const withRest = DPE.tuple([DPE.string()], { rest: DPE.number() }).min(2);
+     * const withRestResult = withRest.parse(["a", 1, 2]);
+     * 
+     * const withMessage = DPE.tuple(
+     * 	[DPE.boolean()],
+     * ).min(1, { errorMessage: "tuple.too-short" });
+     * const withMessageResult = withMessage.parse([true]);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/tuple
+     * 
+     * @namespace DPE
+     * 
+     */
     min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMin, "min">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerArrayMin]>>;
+    /**
+     * Adds a maximum length checker to a tuple parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.max(max, definition?)` -> returns a tuple parser
+     * 
+     * Ensures the parsed tuple has at most the given number of items.
+     * 
+     * ```ts
+     * const parser = DPE.tuple([DPE.string(), DPE.number()]).max(2);
+     * const result = parser.parse(["id", 42]);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: [string, number]
+     * }
+     * 
+     * const withRest = DPE.tuple([DPE.string()], { rest: DPE.number() }).max(3);
+     * const withRestResult = withRest.parse(["a", 1, 2]);
+     * 
+     * const withMessage = DPE.tuple(
+     * 	[DPE.boolean(), DPE.boolean()],
+     * ).max(2, { errorMessage: "tuple.too-long" });
+     * const withMessageResult = withMessage.parse([true, false]);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/tuple
+     * 
+     * @namespace DPE
+     * 
+     */
     max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionArrayMax, "max">>): DataParserTupleExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.DataParserCheckerArrayMax]>>;
+    /**
+     * Adds or replaces the rest parser of a tuple parser.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.rest(dataParser)` -> returns a tuple parser
+     * 
+     * Returns a new tuple parser where items after the fixed shape are validated by the provided parser.
+     * 
+     * ```ts
+     * const parser = DPE.tuple([DPE.string()]).rest(DPE.number());
+     * const result = parser.parse(["id", 1, 2]);
+     * if (E.isRight(result)) {
+     * 	const value = unwrap(result);
+     * 	// value: [string, ...number[]]
+     * }
+     * 
+     * const boolTail = DPE.tuple([DPE.boolean()]).rest(DPE.boolean());
+     * const boolTailResult = boolTail.parse([true, false, true]);
+     * 
+     * const chained = DPE.tuple([DPE.string()])
+     * 	.rest(DPE.number())
+     * 	.min(2)
+     * 	.max(4);
+     * const chainedResult = chained.parse(["a", 1, 2]);
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/tuple
+     * 
+     * @namespace DPE
+     * 
+     */
+    rest<GenericDataParser extends DataParsers>(dataParser: GenericDataParser): DataParserTupleExtended<SimplifyTopLevel<Omit<GenericDefinition, "rest"> & {
+        readonly rest: GenericDataParser;
+    }>>;
 }
 /**
  * Creates an extended data parser for tuples with a fixed shape.

package/dist/dataParser/extended/tuple.mjs

@@ -15,6 +15,10 @@ function tuple(shape, definition) {
         max(self, max, definition) {
             return self.addChecker(checkerArrayMax(max, definition));
         },
+        rest: (self, dataParser) => tuple(self.definition.shape, {
+            ...self.definition,
+            rest: dataParser,
+        }),
     }, tuple.overrideHandler);
     return self;
 }

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

@@ -2,8 +2,8 @@ import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../.
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
-type _DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown> = (Kind<typeof dataParsers.unknownKind.definition> & DataParserExtended<GenericDefinition, unknown, unknown>);
+import { type Input, type Output } from "../base";
+type _DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown> = (Kind<typeof dataParsers.unknownKind.definition> & DataParserExtended<GenericDefinition, Output<dataParsers.DataParserUnknown<GenericDefinition>>, Input<dataParsers.DataParserUnknown<GenericDefinition>>>);
 export interface DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown = dataParsers.DataParserDefinitionUnknown> extends _DataParserUnknownExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         dataParsers.DataParserUnknownCheckers,

package/dist/dataParser/identifier.d.ts

@@ -42,7 +42,7 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: import("../date").TheDate | `date${number}-` | `date${number}+` | Date;
+        input: `date${number}-` | `date${number}+` | import("../date").TheDate | Date;
         output: import("../date").TheDate;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: number | import("../date").TheTime | `time${number}-` | `time${number}+`;
@@ -56,15 +56,6 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: Record<never, unknown>;
         output: Record<never, unknown>;
-    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: unknown[];
-        output: unknown[];
-    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: import("../date").TheDate;
-        output: import("../date").TheDate;
-    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: import("../date").TheTime;
-        output: import("../date").TheTime;
     }>>, 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,7 +91,7 @@ export declare const identifier: {
         input: boolean;
         output: boolean;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: import("../date").TheDate | `date${number}-` | `date${number}+` | Date;
+        input: `date${number}-` | `date${number}+` | import("../date").TheDate | Date;
         output: import("../date").TheDate;
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: number | import("../date").TheTime | `time${number}-` | `time${number}+`;
@@ -114,14 +105,5 @@ export declare const identifier: {
     }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
         input: Record<never, unknown>;
         output: Record<never, unknown>;
-    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: unknown[];
-        output: unknown[];
-    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: import("../date").TheDate;
-        output: import("../date").TheDate;
-    }>> | import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
-        input: import("../date").TheTime;
-        output: import("../date").TheTime;
     }>>, 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.d.ts

@@ -53,7 +53,7 @@ export interface DataParserArray<GenericDefinition extends DataParserDefinitionA
  * 
  */
 export declare function array<GenericElement extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
-    element: GenericElement;
+    readonly element: GenericElement;
 }>>;
 export declare namespace array {
     var overrideHandler: import("../../../common").OverrideHandler<DataParserArray<DataParserDefinitionArray>>;

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

@@ -24,9 +24,9 @@ export interface DataParserDefinitionRecord extends DataParserDefinition<DataPar
     readonly requireKey: string[] | null;
 }
 export declare const recordKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>>;
-export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Output<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Output<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
-export type DataParserRecordShapeInput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Input<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Input<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
-type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredOutput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredOutput, string>> extends true ? Partial<InferredOutput> : InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredInput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredInput, string>> extends true ? Partial<InferredInput> : InferredInput : never> & Kind<typeof recordKind.definition>);
+export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Output<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Output<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any> extends infer InferredOutput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredOutput, string>> extends true ? Partial<InferredOutput> : InferredOutput : never;
+export type DataParserRecordShapeInput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Input<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Input<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any> extends infer InferredInput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredInput, string>> extends true ? Partial<InferredInput> : InferredInput : never;
+type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]>, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof recordKind.definition>);
 export interface DataParserRecord<GenericDefinition extends DataParserDefinitionRecord = DataParserDefinitionRecord> extends _DataParserRecord<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserRecordCheckers<Output<this>>,

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

@@ -12,7 +12,8 @@ export interface DataParserDefinitionTransform extends DataParserDefinition<Data
     theFunction(input: any, error: DataParserError): unknown;
 }
 export declare const transformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>>;
-type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, Exclude<Awaited<ReturnType<GenericDefinition["theFunction"]>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>, Input<GenericDefinition["inner"]>> & Kind<typeof transformKind.definition>);
+export type DataParserTransformOutput<GenericTheFunction extends DataParserDefinitionTransform["theFunction"]> = Exclude<Awaited<ReturnType<GenericTheFunction>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, DataParserTransformOutput<GenericDefinition["theFunction"]>, Input<GenericDefinition["inner"]>> & Kind<typeof transformKind.definition>);
 export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserTransformCheckers<Output<this>>,

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

@@ -1,23 +1,25 @@
-import { type UnionContain, type IsEqual, type Kind, type Adaptor, type NeverCoalescing, type FixDeepFunctionInfer, type AnyTuple } from "../../common";
+import { type UnionContain, type IsEqual, type Kind, type Adaptor, type NeverCoalescing, type FixDeepFunctionInfer, type AnyTuple, type Or } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type DataParserCheckerArrayMax, type DataParserCheckerArrayMin } from "./array";
 import { type CheckerRefineImplementation } from "./refine";
 import { type GetPropsWithValueExtends } from "../../object";
 export type TupleShape = readonly [DataParser, ...DataParser[]];
-export type DataParserTupleShapeOutput<GenericShape extends TupleShape, GenericRest extends DataParser | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
+export type DataParserTupleShapeOutput<GenericShape extends TupleShape, GenericRest extends DataParser | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends readonly [
     infer InferredFirst extends DataParser,
     ...infer InferredRest extends DataParser[]
 ] ? [
     Output<InferredFirst>,
+    ...(Exclude<InferredRest, TupleShape> extends infer InferredShapeRest extends readonly any[] ? IsEqual<InferredShapeRest[number], never> extends true ? [] : Output<InferredShapeRest[number]>[] : []),
     ...(InferredRest extends TupleShape ? DataParserTupleShapeOutput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Output<Adaptor<GenericRest, DataParser>>[])
 ] : never;
-export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRest extends DataParser | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
+export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRest extends DataParser | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends readonly [
     infer InferredFirst extends DataParser,
     ...infer InferredRest extends DataParser[]
 ] ? [
     Input<InferredFirst>,
-    ...(InferredRest extends TupleShape ? DataParserTupleShapeOutput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Input<Adaptor<GenericRest, DataParser>>[])
+    ...(Exclude<InferredRest, TupleShape> extends infer InferredShapeRest extends readonly any[] ? IsEqual<InferredShapeRest[number], never> extends true ? [] : Input<InferredShapeRest[number]>[] : []),
+    ...(InferredRest extends TupleShape ? DataParserTupleShapeInput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Input<Adaptor<GenericRest, DataParser>>[])
 ] : never;
 export interface DataParserTupleCheckerCustom<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> {
 }
@@ -63,8 +65,12 @@ export interface DataParserTuple<GenericDefinition extends DataParserDefinitionT
  * @namespace DP
  * 
  */
-export declare function tuple<GenericShape extends TupleShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
-    shape: GenericShape;
+export declare function tuple<const GenericShape extends TupleShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
+    readonly shape: GenericShape;
+    readonly rest: Or<[
+        IsEqual<GenericDefinition["rest"], unknown>,
+        IsEqual<GenericDefinition, never>
+    ]> extends true ? undefined : GenericDefinition["rest"];
 }>>;
 export declare namespace tuple {
     var overrideHandler: import("../../common").OverrideHandler<DataParserTuple<DataParserDefinitionTuple>>;

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

@@ -53,7 +53,7 @@ export interface DataParserUnion<GenericDefinition extends DataParserDefinitionU
  * 
  */
 export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
-    options: GenericOptions;
+    readonly options: GenericOptions;
 }>>;
 export declare namespace union {
     var overrideHandler: import("../../common").OverrideHandler<DataParserUnion<DataParserDefinitionUnion>>;

package/dist/date/createOrThrow.cjs

@@ -2,9 +2,9 @@
 
 var create = require('./create.cjs');
 var kind = require('../common/kind.cjs');
+var errorKindNamespace = require('../common/errorKindNamespace.cjs');
 var is = require('../either/left/is.cjs');
 var unwrap = require('../common/unwrap.cjs');
-var errorKindNamespace = require('../common/errorKindNamespace.cjs');
 
 class CreateTheDateError extends kind.kindHeritage("create-the-date-error", errorKindNamespace.createErrorKind("create-the-date-error"), Error) {
     input;

package/dist/date/createOrThrow.mjs

@@ -1,8 +1,8 @@
 import { create } from './create.mjs';
 import { kindHeritage } from '../common/kind.mjs';
+import { createErrorKind } from '../common/errorKindNamespace.mjs';
 import { isLeft } from '../either/left/is.mjs';
 import { unwrap } from '../common/unwrap.mjs';
-import { createErrorKind } from '../common/errorKindNamespace.mjs';
 
 class CreateTheDateError extends kindHeritage("create-the-date-error", createErrorKind("create-the-date-error"), Error) {
     input;

package/dist/index.cjs

@@ -56,6 +56,7 @@ var override = require('./common/override.cjs');
 var errorKindNamespace = require('./common/errorKindNamespace.cjs');
 var truthy = require('./common/truthy.cjs');
 var falsy = require('./common/falsy.cjs');
+var formData = require('./common/formData.cjs');
 var hasSomeKinds = require('./common/hasSomeKinds.cjs');
 var hasKinds = require('./common/hasKinds.cjs');
 var toCurriedPredicate = require('./common/toCurriedPredicate.cjs');
@@ -147,6 +148,8 @@ exports.createOverride = override.createOverride;
 exports.createErrorKind = errorKindNamespace.createErrorKind;
 exports.truthy = truthy.truthy;
 exports.falsy = falsy.falsy;
+exports.TheFormData = formData.TheFormData;
+exports.createFormData = formData.createFormData;
 exports.hasSomeKinds = hasSomeKinds.hasSomeKinds;
 exports.hasKinds = hasKinds.hasKinds;
 exports.toCurriedPredicate = toCurriedPredicate.toCurriedPredicate;

package/dist/index.mjs

@@ -78,6 +78,7 @@ export { createOverride } from './common/override.mjs';
 export { createErrorKind } from './common/errorKindNamespace.mjs';
 export { truthy } from './common/truthy.mjs';
 export { falsy } from './common/falsy.mjs';
+export { TheFormData, createFormData } from './common/formData.mjs';
 export { hasSomeKinds } from './common/hasSomeKinds.mjs';
 export { hasKinds } from './common/hasKinds.mjs';
 export { toCurriedPredicate } from './common/toCurriedPredicate.mjs';

package/dist/metadata.json

@@ -1322,6 +1322,15 @@
         {
           "name": "falsy.mjs"
         },
+        {
+          "name": "formData.cjs"
+        },
+        {
+          "name": "formData.d.ts"
+        },
+        {
+          "name": "formData.mjs"
+        },
         {
           "name": "forward.cjs"
         },

package/dist/object/fromEntries.d.ts

@@ -43,5 +43,5 @@ type ComputeEntries<GenericEntry extends ObjectEntry> = UnionContain<ObjectKey,
  * @namespace O
  * 
  */
-export declare function fromEntries<GenericKey extends ObjectKey, const GenericEntry extends readonly [GenericKey, unknown]>(entries: readonly GenericEntry[]): ComputeEntries<GenericEntry>;
+export declare function fromEntries<GenericKey extends ObjectKey, const GenericEntry extends readonly [GenericKey, unknown]>(entries: Iterable<GenericEntry>): ComputeEntries<GenericEntry>;
 export {};

package/package.json

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