@duplojs/utils 1.1.9 → 1.1.11

package/dist/dataParser/parsers/literal.cjs

@@ -3,12 +3,13 @@
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var coalescing = require('../../array/coalescing.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserLiteralKind = kind.createDataParserKind("literal");
+const literalKind = kind.createDataParserKind("literal");
 function literal(value, definition) {
-    return base.dataParserInit(dataParserLiteralKind, {
+    return base.dataParserInit(literalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -22,5 +23,5 @@ function literal(value, definition) {
     });
 }
 
-exports.dataParserLiteralKind = dataParserLiteralKind;
 exports.literal = literal;
+exports.literalKind = literalKind;

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

@@ -5,8 +5,8 @@ export type LiteralValue = string | number | bigint | undefined | null | boolean
 export interface DataParserDefinitionLiteral extends DataParserDefinition<never> {
     readonly value: LiteralValue[];
 }
-export declare const dataParserLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/literal", unknown>>;
-type _DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral> = (DataParser<GenericDefinition, GenericDefinition["value"][number], GenericDefinition["value"][number]> & Kind<typeof dataParserLiteralKind.definition>);
+export declare const literalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>>;
+type _DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral> = (DataParser<GenericDefinition, GenericDefinition["value"][number], GenericDefinition["value"][number]> & Kind<typeof literalKind.definition>);
 export interface DataParserLiteral<GenericDefinition extends DataParserDefinitionLiteral = DataParserDefinitionLiteral> extends _DataParserLiteral<GenericDefinition> {
 }
 export declare function literal<const GenericValue extends LiteralValue, const GenericDefinition extends Partial<Omit<DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteral<MergeDefinition<DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {

package/dist/dataParser/parsers/literal.mjs

@@ -1,12 +1,13 @@
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { coalescing } from '../../array/coalescing.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserLiteralKind = createDataParserKind("literal");
+const literalKind = createDataParserKind("literal");
 function literal(value, definition) {
-    return dataParserInit(dataParserLiteralKind, {
+    return dataParserInit(literalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -20,4 +21,4 @@ function literal(value, definition) {
     });
 }
 
-export { dataParserLiteralKind, literal };
+export { literal, literalKind };

package/dist/dataParser/parsers/nil.cjs

@@ -4,9 +4,9 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserNilKind = kind.createDataParserKind("nil");
+const nilKind = kind.createDataParserKind("nil");
 function nil(definition) {
-    return base.dataParserInit(dataParserNilKind, {
+    return base.dataParserInit(nilKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -23,5 +23,5 @@ function nil(definition) {
     });
 }
 
-exports.dataParserNilKind = dataParserNilKind;
 exports.nil = nil;
+exports.nilKind = nilKind;

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

@@ -4,8 +4,8 @@ import { type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionNil extends DataParserDefinition<never> {
     readonly coerce: boolean;
 }
-export declare const dataParserNilKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/nil", unknown>>;
-type _DataParserNil<GenericDefinition extends DataParserDefinitionNil> = (DataParser<GenericDefinition, null, null> & Kind<typeof dataParserNilKind.definition>);
+export declare const nilKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/nil", unknown>>;
+type _DataParserNil<GenericDefinition extends DataParserDefinitionNil> = (DataParser<GenericDefinition, null, null> & Kind<typeof nilKind.definition>);
 export interface DataParserNil<GenericDefinition extends DataParserDefinitionNil = DataParserDefinitionNil> extends _DataParserNil<GenericDefinition> {
 }
 export declare function nil<const GenericDefinition extends Partial<DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNil<MergeDefinition<DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;

package/dist/dataParser/parsers/nil.mjs

@@ -2,9 +2,9 @@ import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserNilKind = createDataParserKind("nil");
+const nilKind = createDataParserKind("nil");
 function nil(definition) {
-    return dataParserInit(dataParserNilKind, {
+    return dataParserInit(nilKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -21,4 +21,4 @@ function nil(definition) {
     });
 }
 
-export { dataParserNilKind, nil };
+export { nil, nilKind };

package/dist/dataParser/parsers/nullable.cjs

@@ -3,9 +3,9 @@
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserNullableKind = kind.createDataParserKind("nullable");
+const nullableKind = kind.createDataParserKind("nullable");
 function nullable(inner, definition) {
-    return base.dataParserInit(dataParserNullableKind, {
+    return base.dataParserInit(nullableKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -27,5 +27,5 @@ function nullable(inner, definition) {
     });
 }
 
-exports.dataParserNullableKind = dataParserNullableKind;
 exports.nullable = nullable;
+exports.nullableKind = nullableKind;

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

@@ -1,14 +1,14 @@
 import { type NeverCoalescing, type Kind } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionNullable extends DataParserDefinition<never> {
-    readonly inner: DataParsers;
+    readonly inner: DataParser;
 }
-export declare const dataParserNullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/nullable", unknown>>;
-type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | null, Input<GenericDefinition["inner"]> | null> & Kind<typeof dataParserNullableKind.definition>);
+export declare const nullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>>;
+type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | null, Input<GenericDefinition["inner"]> | null> & Kind<typeof nullableKind.definition>);
 export interface DataParserNullable<GenericDefinition extends DataParserDefinitionNullable = DataParserDefinitionNullable> extends _DataParserNullable<GenericDefinition> {
 }
-export declare function nullable<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullable<MergeDefinition<DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/parsers/nullable.mjs

@@ -1,9 +1,9 @@
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserNullableKind = createDataParserKind("nullable");
+const nullableKind = createDataParserKind("nullable");
 function nullable(inner, definition) {
-    return dataParserInit(dataParserNullableKind, {
+    return dataParserInit(nullableKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -25,4 +25,4 @@ function nullable(inner, definition) {
     });
 }
 
-export { dataParserNullableKind, nullable };
+export { nullable, nullableKind };

package/dist/dataParser/parsers/number/checkers/int.d.ts

@@ -2,7 +2,7 @@ import { type Kind } from "../../../../common";
 import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
 export interface DataParserCheckerDefinitionInt extends DataParserCheckerDefinition {
 }
-export declare const dataParserCheckerIntKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-number-int", unknown>>;
+export declare const dataParserCheckerIntKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-int", unknown>>;
 type _DataParserCheckerInt = (Kind<typeof dataParserCheckerIntKind.definition> & DataParserChecker<DataParserCheckerDefinitionInt, number>);
 export interface DataParserCheckerInt extends _DataParserCheckerInt {
 }

package/dist/dataParser/parsers/number/checkers/max.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionNumberMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerNumberMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-number-max", unknown>>;
+export declare const dataParserCheckerNumberMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-max", unknown>>;
 type _DataParserCheckerNumberMax = (Kind<typeof dataParserCheckerNumberMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMax, number>);
 export interface DataParserCheckerNumberMax extends _DataParserCheckerNumberMax {
 }

package/dist/dataParser/parsers/number/checkers/min.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionNumberMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-number-min", unknown>>;
+export declare const dataParserCheckerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-min", unknown>>;
 type _DataParserCheckerNumberMin = (Kind<typeof dataParserCheckerNumberMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMin, number>);
 export interface DataParserCheckerNumberMin extends _DataParserCheckerNumberMin {
 }

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

@@ -4,9 +4,9 @@ var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 
-const dataParserNumberKind = kind.createDataParserKind("number");
+const numberKind = kind.createDataParserKind("number");
 function number(definition) {
-    return base.dataParserInit(dataParserNumberKind, {
+    return base.dataParserInit(numberKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -27,5 +27,5 @@ function number(definition) {
     });
 }
 
-exports.dataParserNumberKind = dataParserNumberKind;
 exports.number = number;
+exports.numberKind = numberKind;

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

@@ -7,8 +7,8 @@ export type DataParserNumberCheckers = (DataParserCheckerInt | DataParserChecker
 export interface DataParserDefinitionNumber extends DataParserDefinition<DataParserNumberCheckers> {
     readonly coerce: boolean;
 }
-export declare const dataParserNumberKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DataParser/number", unknown>>;
-type _DataParserNumber<GenericDefinition extends DataParserDefinitionNumber> = (DataParser<GenericDefinition, number, number> & Kind<typeof dataParserNumberKind.definition>);
+export declare const numberKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>>;
+type _DataParserNumber<GenericDefinition extends DataParserDefinitionNumber> = (DataParser<GenericDefinition, number, number> & Kind<typeof numberKind.definition>);
 export interface DataParserNumber<GenericDefinition extends DataParserDefinitionNumber = DataParserDefinitionNumber> extends _DataParserNumber<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserNumberCheckers,

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

@@ -2,9 +2,9 @@ import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 
-const dataParserNumberKind = createDataParserKind("number");
+const numberKind = createDataParserKind("number");
 function number(definition) {
-    return dataParserInit(dataParserNumberKind, {
+    return dataParserInit(numberKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -25,4 +25,4 @@ function number(definition) {
     });
 }
 
-export { dataParserNumberKind, number };
+export { number, numberKind };

package/dist/dataParser/parsers/object.cjs

@@ -7,13 +7,14 @@ var memo = require('../../common/memo.cjs');
 var filter = require('../../array/filter.cjs');
 var map = require('../../array/map.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserObjectKind = kind.createDataParserKind("object");
+const objectKind = kind.createDataParserKind("object");
 function object(shape, definition) {
-    return base.dataParserInit(dataParserObjectKind, {
+    return base.dataParserInit(objectKind, {
         definition: {
             shape,
             errorMessage: definition?.errorMessage,
@@ -71,5 +72,5 @@ function object(shape, definition) {
     });
 }
 
-exports.dataParserObjectKind = dataParserObjectKind;
 exports.object = object;
+exports.objectKind = objectKind;

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

@@ -1,8 +1,8 @@
 import { type Kind, type IsEqual, type NeverCoalescing, type Memoized } from "../../common";
 import { dataParserKind, type Input, type Output, type DataParser, type DataParserDefinition } from "../base";
-import { type MergeDefinition, type DataParsers } from "../types";
+import { type MergeDefinition } from "../types";
 import * as DObject from "../../object";
-export type DataParserObjectShape = Readonly<Record<string, DataParsers>>;
+export type DataParserObjectShape = Readonly<Record<string, DataParser>>;
 export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectShape> = IsEqual<GenericShape, DataParserObjectShape> extends true ? DataParserObjectShape : {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Output<GenericShape[Prop]>;
 } extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
@@ -13,11 +13,11 @@ export interface DataParserDefinitionObject extends DataParserDefinition<never>
     readonly shape: DataParserObjectShape;
     readonly optimizedShape: Memoized<{
         readonly key: string;
-        readonly value: DataParsers;
+        readonly value: DataParser;
     }[]>;
 }
-export declare const dataParserObjectKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/object", unknown>>;
-type _DataParserObject<GenericDefinition extends DataParserDefinitionObject> = (DataParser<GenericDefinition, DataParserObjectShapeOutput<GenericDefinition["shape"]>, DataParserObjectShapeInput<GenericDefinition["shape"]>> & Kind<typeof dataParserObjectKind.definition>);
+export declare const objectKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>>;
+type _DataParserObject<GenericDefinition extends DataParserDefinitionObject> = (DataParser<GenericDefinition, DataParserObjectShapeOutput<GenericDefinition["shape"]>, DataParserObjectShapeInput<GenericDefinition["shape"]>> & Kind<typeof objectKind.definition>);
 export interface DataParserObject<GenericDefinition extends DataParserDefinitionObject = DataParserDefinitionObject> extends _DataParserObject<GenericDefinition> {
 }
 export declare function object<const GenericShape extends DataParserObjectShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {

package/dist/dataParser/parsers/object.mjs

@@ -5,13 +5,14 @@ import { memo } from '../../common/memo.mjs';
 import { filter } from '../../array/filter.mjs';
 import { map } from '../../array/map.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { dataParserInit, SymbolDataParserError, dataParserKind } from '../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserObjectKind = createDataParserKind("object");
+const objectKind = createDataParserKind("object");
 function object(shape, definition) {
-    return dataParserInit(dataParserObjectKind, {
+    return dataParserInit(objectKind, {
         definition: {
             shape,
             errorMessage: definition?.errorMessage,
@@ -69,4 +70,4 @@ function object(shape, definition) {
     });
 }
 
-export { dataParserObjectKind, object };
+export { object, objectKind };

package/dist/dataParser/parsers/optional.cjs

@@ -3,9 +3,9 @@
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserOptionalKind = kind.createDataParserKind("optional");
+const optionalKind = kind.createDataParserKind("optional");
 function optional(inner, definition) {
-    return base.dataParserInit(dataParserOptionalKind, {
+    return base.dataParserInit(optionalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -27,5 +27,5 @@ function optional(inner, definition) {
     });
 }
 
-exports.dataParserOptionalKind = dataParserOptionalKind;
 exports.optional = optional;
+exports.optionalKind = optionalKind;

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

@@ -1,14 +1,14 @@
 import { type NeverCoalescing, type Kind } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionOptional extends DataParserDefinition<never> {
-    readonly inner: DataParsers;
+    readonly inner: DataParser;
 }
-export declare const dataParserOptionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/optional", unknown>>;
-type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | undefined, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof dataParserOptionalKind.definition>);
+export declare const optionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>>;
+type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | undefined, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof optionalKind.definition>);
 export interface DataParserOptional<GenericDefinition extends DataParserDefinitionOptional = DataParserDefinitionOptional> extends _DataParserOptional<GenericDefinition> {
 }
-export declare function optional<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/parsers/optional.mjs

@@ -1,9 +1,9 @@
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserOptionalKind = createDataParserKind("optional");
+const optionalKind = createDataParserKind("optional");
 function optional(inner, definition) {
-    return dataParserInit(dataParserOptionalKind, {
+    return dataParserInit(optionalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -25,4 +25,4 @@ function optional(inner, definition) {
     });
 }
 
-export { dataParserOptionalKind, optional };
+export { optional, optionalKind };

package/dist/dataParser/parsers/pipe.cjs

@@ -3,9 +3,9 @@
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserPipeKind = kind.createDataParserKind("pipe");
+const pipeKind = kind.createDataParserKind("pipe");
 function pipe(input, output, definition) {
-    return base.dataParserInit(dataParserPipeKind, {
+    return base.dataParserInit(pipeKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -30,5 +30,5 @@ function pipe(input, output, definition) {
     });
 }
 
-exports.dataParserPipeKind = dataParserPipeKind;
 exports.pipe = pipe;
+exports.pipeKind = pipeKind;

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

@@ -1,15 +1,15 @@
 import { type NeverCoalescing, type Kind } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionPipe extends DataParserDefinition<never> {
-    readonly input: DataParsers;
-    readonly output: DataParsers;
+    readonly input: DataParser;
+    readonly output: DataParser;
 }
-export declare const dataParserPipeKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/pipe", unknown>>;
-type _DataParserPipe<GenericDefinition extends DataParserDefinitionPipe> = (DataParser<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>> & Kind<typeof dataParserPipeKind.definition>);
+export declare const pipeKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>>;
+type _DataParserPipe<GenericDefinition extends DataParserDefinitionPipe> = (DataParser<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>> & Kind<typeof pipeKind.definition>);
 export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPipe = DataParserDefinitionPipe> extends _DataParserPipe<GenericDefinition> {
 }
-export declare function pipe<GenericInput extends DataParsers, GenericOutput extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
+export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;
     output: GenericOutput;
 }>>;

package/dist/dataParser/parsers/pipe.mjs

@@ -1,9 +1,9 @@
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserPipeKind = createDataParserKind("pipe");
+const pipeKind = createDataParserKind("pipe");
 function pipe(input, output, definition) {
-    return dataParserInit(dataParserPipeKind, {
+    return dataParserInit(pipeKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -28,4 +28,4 @@ function pipe(input, output, definition) {
     });
 }
 
-export { dataParserPipeKind, pipe };
+export { pipe, pipeKind };

package/dist/dataParser/parsers/record.cjs

@@ -4,9 +4,9 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserRecordKind = kind.createDataParserKind("record");
+const recordKind = kind.createDataParserKind("record");
 function record(key, value, definition) {
-    return base.dataParserInit(dataParserRecordKind, {
+    return base.dataParserInit(recordKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -79,5 +79,5 @@ function record(key, value, definition) {
     });
 }
 
-exports.dataParserRecordKind = dataParserRecordKind;
 exports.record = record;
+exports.recordKind = recordKind;

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

@@ -1,6 +1,6 @@
 import { type NeverCoalescing, type Kind } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type MergeDefinition } from "../../dataParser/types";
 import { type DataParserString } from "./string";
 import { type DataParserTemplateLiteral } from "./templateLiteral";
 import { type DataParserDefinitionLiteral, type DataParserLiteral } from "./literal";
@@ -15,15 +15,15 @@ export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral
 }>);
 export interface DataParserDefinitionRecord extends DataParserDefinition<never> {
     readonly key: DataParserRecordKey;
-    readonly value: DataParsers;
+    readonly value: DataParser;
 }
-export declare const dataParserRecordKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/record", unknown>>;
-export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers> = 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 DataParsers> = 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 ? InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof dataParserRecordKind.definition>);
+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 ? InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof recordKind.definition>);
 export interface DataParserRecord<GenericDefinition extends DataParserDefinitionRecord = DataParserDefinitionRecord> extends _DataParserRecord<GenericDefinition> {
 }
-export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
+export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;
     value: GenericDataParserValue;
 }>>;

package/dist/dataParser/parsers/record.mjs

@@ -2,9 +2,9 @@ import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserRecordKind = createDataParserKind("record");
+const recordKind = createDataParserKind("record");
 function record(key, value, definition) {
-    return dataParserInit(dataParserRecordKind, {
+    return dataParserInit(recordKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -77,4 +77,4 @@ function record(key, value, definition) {
     });
 }
 
-export { dataParserRecordKind, record };
+export { record, recordKind };

package/dist/dataParser/parsers/string/checkers/email.d.ts

@@ -4,7 +4,7 @@ export interface DataParserCheckerDefinitionEmail extends DataParserCheckerDefin
     normalize?: boolean;
     pattern: RegExp;
 }
-export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-email", unknown>>;
+export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-email", unknown>>;
 type _DataParserCheckerEmail = (Kind<typeof dataParserCheckerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
 export interface DataParserCheckerEmail extends _DataParserCheckerEmail {
 }

package/dist/dataParser/parsers/string/checkers/max.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-max", unknown>>;
+export declare const dataParserCheckerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
 type _DataParserCheckerStringMax = (Kind<typeof dataParserCheckerStringMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMax, string>);
 export interface DataParserCheckerStringMax extends _DataParserCheckerStringMax {
 }

package/dist/dataParser/parsers/string/checkers/min.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerStringMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-min", unknown>>;
+export declare const dataParserCheckerStringMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-min", unknown>>;
 type _DataParserCheckerStringMin = (Kind<typeof dataParserCheckerStringMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMin, string>);
 export interface DataParserCheckerStringMin extends _DataParserCheckerStringMin {
 }

package/dist/dataParser/parsers/string/checkers/regex.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringRegex extends DataParserCheckerDefinition {
     regex: RegExp;
 }
-export declare const dataParserCheckerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-regex", unknown>>;
+export declare const dataParserCheckerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-regex", unknown>>;
 type _DataParserCheckerStringRegex = (Kind<typeof dataParserCheckerStringRegexKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringRegex, string>);
 export interface DataParserCheckerStringRegex extends _DataParserCheckerStringRegex {
 }

package/dist/dataParser/parsers/string/checkers/url.d.ts

@@ -5,7 +5,7 @@ export interface DataParserCheckerDefinitionUrl extends DataParserCheckerDefinit
     protocol?: RegExp;
     normalize?: boolean;
 }
-export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-url", unknown>>;
+export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-url", unknown>>;
 type _DataParserCheckerUrl = (Kind<typeof dataParserCheckerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
 export interface DataParserCheckerUrl extends _DataParserCheckerUrl {
 }

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

@@ -4,9 +4,9 @@ var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 
-const dataParserStringKind = kind.createDataParserKind("string");
+const stringKind = kind.createDataParserKind("string");
 function string(definition) {
-    return base.dataParserInit(dataParserStringKind, {
+    return base.dataParserInit(stringKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -27,5 +27,5 @@ function string(definition) {
     });
 }
 
-exports.dataParserStringKind = dataParserStringKind;
 exports.string = string;
+exports.stringKind = stringKind;

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

@@ -7,8 +7,8 @@ export type DataParserStringCheckers = (DataParserCheckerUrl | DataParserChecker
 export interface DataParserDefinitionString extends DataParserDefinition<DataParserStringCheckers> {
     readonly coerce: boolean;
 }
-export declare const dataParserStringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DataParser/string", unknown>>;
-type _DataParserString<GenericDefinition extends DataParserDefinitionString> = (DataParser<GenericDefinition, string, string> & Kind<typeof dataParserStringKind.definition>);
+export declare const stringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/string", unknown>>;
+type _DataParserString<GenericDefinition extends DataParserDefinitionString> = (DataParser<GenericDefinition, string, string> & Kind<typeof stringKind.definition>);
 export interface DataParserString<GenericDefinition extends DataParserDefinitionString = DataParserDefinitionString> extends _DataParserString<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserStringCheckers,