@duplojs/utils 1.1.10 → 1.1.11

package/dist/dataParser/index.mjs

@@ -1,29 +1,30 @@
-export { SymbolDataParserError, SymbolDataParserErrorLabel, dataParserCheckerInit, dataParserCheckerKind, dataParserInit, dataParserKind } from './base.mjs';
-export { dataParserExtendedInit, dataParserExtendedKind } from './baseExtended.mjs';
-export { SymbolDataParserErrorIssue, SymbolDataParserErrorIssueLabel, SymbolDataParserErrorPromiseIssue, SymbolDataParserErrorPromiseIssueLabel, addIssue, addPromiseIssue, createError, dataParserErrorIssueKind, dataParserErrorKind, dataParserErrorPromiseIssueKind, popErrorPath, setErrorPath } from './error.mjs';
+export { SymbolDataParserError, SymbolDataParserErrorLabel, checkerKind, dataParserCheckerInit, dataParserInit, dataParserKind } from './base.mjs';
+export { dataParserExtendedInit, extendedKind } from './baseExtended.mjs';
+export { SymbolDataParserErrorIssue, SymbolDataParserErrorIssueLabel, SymbolDataParserErrorPromiseIssue, SymbolDataParserErrorPromiseIssueLabel, addIssue, addPromiseIssue, createError, errorIssueKind, errorKind, errorPromiseIssueKind, popErrorPath, setErrorPath } from './error.mjs';
 import * as index$1 from './parsers/coerce/index.mjs';
 export { index$1 as coerce };
-export { dataParserStringKind, string } from './parsers/string/index.mjs';
-export { dataParserObjectKind, object } from './parsers/object.mjs';
-export { dataParserNumberKind, number } from './parsers/number/index.mjs';
-export { dataParserLiteralKind, literal } from './parsers/literal.mjs';
-export { dataParserUnionKind, union } from './parsers/union.mjs';
-export { array, dataParserArrayKind } from './parsers/array/index.mjs';
-export { bigint, dataParserBigIntKind } from './parsers/bigint/index.mjs';
-export { dataParserTupleKind, tuple } from './parsers/tuple.mjs';
-export { dataParserTransformKind, transform } from './parsers/transform.mjs';
-export { dataParserNilKind, nil } from './parsers/nil.mjs';
-export { boolean, dataParserBooleanKind } from './parsers/boolean.mjs';
-export { dataParserEmptyKind, empty } from './parsers/empty.mjs';
-export { dataParserTemplateLiteralKind, templateLiteral } from './parsers/templateLiteral.mjs';
-export { dataParserPipeKind, pipe } from './parsers/pipe.mjs';
-export { dataParserOptionalKind, optional } from './parsers/optional.mjs';
-export { dataParserNullableKind, nullable } from './parsers/nullable.mjs';
-export { dataParserLazyKind, lazy } from './parsers/lazy.mjs';
-export { dataParserUnknownKind, unknown } from './parsers/unknown.mjs';
-export { dataParserRecordKind, record } from './parsers/record.mjs';
+export { string, stringKind } from './parsers/string/index.mjs';
+export { object, objectKind } from './parsers/object.mjs';
+export { number, numberKind } from './parsers/number/index.mjs';
+export { literal, literalKind } from './parsers/literal.mjs';
+export { union, unionKind } from './parsers/union.mjs';
+export { array, arrayKind } from './parsers/array/index.mjs';
+export { bigIntKind, bigint } from './parsers/bigint/index.mjs';
+export { tuple, tupleKind } from './parsers/tuple.mjs';
+export { transform, transformKind } from './parsers/transform.mjs';
+export { nil, nilKind } from './parsers/nil.mjs';
+export { boolean, booleanKind } from './parsers/boolean.mjs';
+export { empty, emptyKind } from './parsers/empty.mjs';
+export { templateLiteral, templateLiteralKind } from './parsers/templateLiteral.mjs';
+export { pipe, pipeKind } from './parsers/pipe.mjs';
+export { optional, optionalKind } from './parsers/optional.mjs';
+export { nullable, nullableKind } from './parsers/nullable.mjs';
+export { lazy, lazyKind } from './parsers/lazy.mjs';
+export { unknown, unknownKind } from './parsers/unknown.mjs';
+export { record, recordKind } from './parsers/record.mjs';
 import * as index from './extended/index.mjs';
 export { index as extended };
+export { identifier } from './identifier.mjs';
 export { checkerUrl, dataParserCheckerUrlKind, url } from './parsers/string/checkers/url.mjs';
 export { checkerEmail, dataParserCheckerEmailKind, email } from './parsers/string/checkers/email.mjs';
 export { checkerStringMax, dataParserCheckerStringMaxKind } from './parsers/string/checkers/max.mjs';

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

@@ -4,9 +4,9 @@ var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 
-const dataParserArrayKind = kind.createDataParserKind("array");
+const arrayKind = kind.createDataParserKind("array");
 function array(element, definition) {
-    return base.dataParserInit(dataParserArrayKind, {
+    return base.dataParserInit(arrayKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -61,4 +61,4 @@ function array(element, definition) {
 }
 
 exports.array = array;
-exports.dataParserArrayKind = dataParserArrayKind;
+exports.arrayKind = arrayKind;

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

@@ -1,20 +1,20 @@
 import { type NeverCoalescing, type Kind } from "../../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input } from "../../base";
-import { type AddCheckersToDefinition, type DataParsers, type MergeDefinition } from "../../../dataParser/types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserCheckerArrayMin, type DataParserCheckerArrayMax } from "./checkers";
 export * from "./checkers";
 export type DataParserArrayCheckers = (DataParserCheckerArrayMin | DataParserCheckerArrayMax);
 export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers> {
-    readonly element: DataParsers;
+    readonly element: DataParser;
 }
-export declare const dataParserArrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>>;
-type _DataParserArray<GenericDefinition extends DataParserDefinitionArray> = (DataParser<GenericDefinition, Output<GenericDefinition["element"]>[], Input<GenericDefinition["element"]>[]> & Kind<typeof dataParserArrayKind.definition>);
+export declare const arrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>>;
+type _DataParserArray<GenericDefinition extends DataParserDefinitionArray> = (DataParser<GenericDefinition, Output<GenericDefinition["element"]>[], Input<GenericDefinition["element"]>[]> & Kind<typeof arrayKind.definition>);
 export interface DataParserArray<GenericDefinition extends DataParserDefinitionArray = DataParserDefinitionArray> extends _DataParserArray<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserArrayCheckers,
         ...DataParserArrayCheckers[]
     ]>(...args: GenericChecker): DataParserArray<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
-export declare function array<GenericElement extends DataParsers, const GenericDefinition extends Partial<Omit<DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArray<MergeDefinition<DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
+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;
 }>>;

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

@@ -2,9 +2,9 @@ import { dataParserInit, SymbolDataParserError } from '../../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 
-const dataParserArrayKind = createDataParserKind("array");
+const arrayKind = createDataParserKind("array");
 function array(element, definition) {
-    return dataParserInit(dataParserArrayKind, {
+    return dataParserInit(arrayKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -58,4 +58,4 @@ function array(element, definition) {
     });
 }
 
-export { array, dataParserArrayKind };
+export { array, arrayKind };

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

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

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

@@ -7,8 +7,8 @@ export type DataParserBigIntCheckers = (DataParserCheckerBigIntMin | DataParserC
 export interface DataParserDefinitionBigInt extends DataParserDefinition<DataParserBigIntCheckers> {
     readonly coerce: boolean;
 }
-export declare const dataParserBigIntKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>>;
-type _DataParserBigInt<GenericDefinition extends DataParserDefinitionBigInt> = (DataParser<GenericDefinition, bigint, bigint> & Kind<typeof dataParserBigIntKind.definition>);
+export declare const bigIntKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/bigint", unknown>>;
+type _DataParserBigInt<GenericDefinition extends DataParserDefinitionBigInt> = (DataParser<GenericDefinition, bigint, bigint> & Kind<typeof bigIntKind.definition>);
 export interface DataParserBigInt<GenericDefinition extends DataParserDefinitionBigInt = DataParserDefinitionBigInt> extends _DataParserBigInt<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserBigIntCheckers,

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

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

package/dist/dataParser/parsers/boolean.cjs

@@ -4,9 +4,9 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserBooleanKind = kind.createDataParserKind("boolean");
+const booleanKind = kind.createDataParserKind("boolean");
 function boolean(definition) {
-    return base.dataParserInit(dataParserBooleanKind, {
+    return base.dataParserInit(booleanKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -37,4 +37,4 @@ function boolean(definition) {
 }
 
 exports.boolean = boolean;
-exports.dataParserBooleanKind = dataParserBooleanKind;
+exports.booleanKind = booleanKind;

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

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

package/dist/dataParser/parsers/boolean.mjs

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

package/dist/dataParser/parsers/empty.cjs

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

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

@@ -4,8 +4,8 @@ import { type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionEmpty extends DataParserDefinition<never> {
     readonly coerce: boolean;
 }
-export declare const dataParserEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>>;
-type _DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty> = (DataParser<GenericDefinition, undefined, undefined> & Kind<typeof dataParserEmptyKind.definition>);
+export declare const emptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/empty", unknown>>;
+type _DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty> = (DataParser<GenericDefinition, undefined, undefined> & Kind<typeof emptyKind.definition>);
 export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionEmpty = DataParserDefinitionEmpty> extends _DataParserEmpty<GenericDefinition> {
 }
 export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;

package/dist/dataParser/parsers/empty.mjs

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

package/dist/dataParser/parsers/lazy.cjs

@@ -3,9 +3,9 @@
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserLazyKind = kind.createDataParserKind("lazy");
+const lazyKind = kind.createDataParserKind("lazy");
 function lazy(getter, definition) {
-    return base.dataParserInit(dataParserLazyKind, {
+    return base.dataParserInit(lazyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -17,5 +17,5 @@ function lazy(getter, definition) {
     });
 }
 
-exports.dataParserLazyKind = dataParserLazyKind;
 exports.lazy = lazy;
+exports.lazyKind = lazyKind;

package/dist/dataParser/parsers/lazy.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 DataParserDefinitionLazy extends DataParserDefinition<never> {
-    getter(): DataParsers;
+    getter(): DataParser;
 }
-export declare const dataParserLazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;
-type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<ReturnType<GenericDefinition["getter"]>>, Input<ReturnType<GenericDefinition["getter"]>>> & Kind<typeof dataParserLazyKind.definition>);
+export declare const lazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;
+type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<ReturnType<GenericDefinition["getter"]>>, Input<ReturnType<GenericDefinition["getter"]>>> & Kind<typeof lazyKind.definition>);
 export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLazy = DataParserDefinitionLazy> extends _DataParserLazy<GenericDefinition> {
 }
-export declare function lazy<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
+export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter(): GenericDataParser;
 }>>;
 export {};

package/dist/dataParser/parsers/lazy.mjs

@@ -1,9 +1,9 @@
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserLazyKind = createDataParserKind("lazy");
+const lazyKind = createDataParserKind("lazy");
 function lazy(getter, definition) {
-    return dataParserInit(dataParserLazyKind, {
+    return dataParserInit(lazyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -15,4 +15,4 @@ function lazy(getter, definition) {
     });
 }
 
-export { dataParserLazyKind, lazy };
+export { lazy, lazyKind };

package/dist/dataParser/parsers/literal.cjs

@@ -7,9 +7,9 @@ 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 ?? [],
@@ -23,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<"@DuplojsUtilsDataParser/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

@@ -5,9 +5,9 @@ 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 ?? [],
@@ -21,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<"@DuplojsUtilsDataParser/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<"@DuplojsUtilsDataParser/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/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<"@DuplojsUtilsDataParser/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

@@ -12,9 +12,9 @@ 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,
@@ -72,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<"@DuplojsUtilsDataParser/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

@@ -10,9 +10,9 @@ import { dataParserInit, SymbolDataParserError, dataParserKind } from '../base.m
 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,
@@ -70,4 +70,4 @@ function object(shape, definition) {
     });
 }
 
-export { dataParserObjectKind, object };
+export { object, objectKind };