@duplojs/utils 1.1.10 → 1.1.12

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 };

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<"@DuplojsUtilsDataParser/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<"@DuplojsUtilsDataParser/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<"@DuplojsUtilsDataParser/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/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<"@DuplojsUtilsDataParser/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,

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

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

package/dist/dataParser/parsers/templateLiteral.cjs

@@ -25,10 +25,10 @@ var nil = require('./nil.cjs');
 var boolean = require('./boolean.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserTemplateLiteralKind = kind.createDataParserKind("template-literal");
+const templateLiteralKind = kind.createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
-    const pattern = pipe.pipe(template, map.map(innerPipe.innerPipe(when.when(isType.isType("string"), (value) => `(?:${escapeRegExp.escapeRegExp(value)})`), when.when(index$2.dataParserNumberKind.has, () => "(:?[0-9]+)"), when.when(index$1.dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.dataParserBooleanKind.has, () => "(?:true|false)"), when.when(nil.dataParserNilKind.has, () => "(?:null)"), when.when(empty.dataParserEmptyKind.has, () => "(?:undefined)"), when.when(literal.dataParserLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp)), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index.dataParserStringKind.has, innerPipe.innerPipe(whenElse.whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe.pipe(dataParser.definition.checkers, map.map((element) => pipe.pipe(element.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""))), join.join("")), () => "(?:[^]*)"))), when.when(dataParserTemplateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive)), join.join(""), (pattern) => new RegExp(`^${pattern}$`));
-    return base.dataParserInit(dataParserTemplateLiteralKind, {
+    const pattern = pipe.pipe(template, map.map(innerPipe.innerPipe(when.when(isType.isType("string"), (value) => `(?:${escapeRegExp.escapeRegExp(value)})`), when.when(index$2.numberKind.has, () => "(:?[0-9]+)"), when.when(index$1.bigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.booleanKind.has, () => "(?:true|false)"), when.when(nil.nilKind.has, () => "(?:null)"), when.when(empty.emptyKind.has, () => "(?:undefined)"), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp)), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index.stringKind.has, innerPipe.innerPipe(whenElse.whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe.pipe(dataParser.definition.checkers, map.map((element) => pipe.pipe(element.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""))), join.join("")), () => "(?:[^]*)"))), when.when(templateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive)), join.join(""), (pattern) => new RegExp(`^${pattern}$`));
+    return base.dataParserInit(templateLiteralKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -43,5 +43,5 @@ function templateLiteral(template, definition) {
     });
 }
 
-exports.dataParserTemplateLiteralKind = dataParserTemplateLiteralKind;
 exports.templateLiteral = templateLiteral;
+exports.templateLiteralKind = templateLiteralKind;

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

@@ -39,8 +39,8 @@ export interface DataParserDefinitionTemplateLiteral extends DataParserDefinitio
     readonly template: TemplateLiteralShape;
     readonly pattern: RegExp;
 }
-export declare const dataParserTemplateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>>;
-type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof dataParserTemplateLiteralKind.definition>);
+export declare const templateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>>;
+type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof templateLiteralKind.definition>);
 export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
 }
 export declare function templateLiteral<const GenericTemplate extends TemplateLiteralShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -14,19 +14,19 @@ import '../../pattern/result.mjs';
 import { exhaustive } from '../../pattern/exhaustive.mjs';
 import { when } from '../../pattern/when.mjs';
 import { replace } from '../../string/replace.mjs';
-import { dataParserStringKind } from './string/index.mjs';
-import { dataParserNumberKind } from './number/index.mjs';
-import { dataParserBigIntKind } from './bigint/index.mjs';
-import { dataParserLiteralKind } from './literal.mjs';
-import { dataParserEmptyKind } from './empty.mjs';
-import { dataParserNilKind } from './nil.mjs';
-import { dataParserBooleanKind } from './boolean.mjs';
+import { stringKind } from './string/index.mjs';
+import { numberKind } from './number/index.mjs';
+import { bigIntKind } from './bigint/index.mjs';
+import { literalKind } from './literal.mjs';
+import { emptyKind } from './empty.mjs';
+import { nilKind } from './nil.mjs';
+import { booleanKind } from './boolean.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserTemplateLiteralKind = createDataParserKind("template-literal");
+const templateLiteralKind = createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
-    const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(dataParserNumberKind.has, () => "(:?[0-9]+)"), when(dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when(dataParserBooleanKind.has, () => "(?:true|false)"), when(dataParserNilKind.has, () => "(?:null)"), when(dataParserEmptyKind.has, () => "(?:undefined)"), when(dataParserLiteralKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(dataParserStringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(dataParserTemplateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
-    return dataParserInit(dataParserTemplateLiteralKind, {
+    const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(numberKind.has, () => "(:?[0-9]+)"), when(bigIntKind.has, () => "(?:[0-9]+n)"), when(booleanKind.has, () => "(?:true|false)"), when(nilKind.has, () => "(?:null)"), when(emptyKind.has, () => "(?:undefined)"), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(templateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
+    return dataParserInit(templateLiteralKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -41,4 +41,4 @@ function templateLiteral(template, definition) {
     });
 }
 
-export { dataParserTemplateLiteralKind, templateLiteral };
+export { templateLiteral, templateLiteralKind };

package/dist/dataParser/parsers/transform.cjs

@@ -4,9 +4,9 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserTransformKind = kind.createDataParserKind("transform");
+const transformKind = kind.createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
-    return base.dataParserInit(dataParserTransformKind, {
+    return base.dataParserInit(transformKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -39,5 +39,5 @@ function transform(inner, theFunction, definition) {
     });
 }
 
-exports.dataParserTransformKind = dataParserTransformKind;
 exports.transform = transform;
+exports.transformKind = transformKind;

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

@@ -1,16 +1,16 @@
 import { type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError } from "../base";
-import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+import { type MergeDefinition } from "../../dataParser/types";
 import { type DataParserError, type SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from "../../dataParser/error";
 export interface DataParserDefinitionTransform extends DataParserDefinition<never> {
-    readonly inner: DataParsers;
+    readonly inner: DataParser;
     theFunction(input: any, error: DataParserError): unknown;
 }
-export declare const dataParserTransformKind: 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 dataParserTransformKind.definition>);
+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 interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
 }
-export declare function transform<GenericDataParser extends DataParsers, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
+export declare function transform<GenericDataParser extends DataParser, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     theFunction(input: Output<GenericDataParser>): GenericOutput;
 }>>;

package/dist/dataParser/parsers/transform.mjs

@@ -2,9 +2,9 @@ import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorPromiseIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserTransformKind = createDataParserKind("transform");
+const transformKind = createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
-    return dataParserInit(dataParserTransformKind, {
+    return dataParserInit(transformKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -37,4 +37,4 @@ function transform(inner, theFunction, definition) {
     });
 }
 
-export { dataParserTransformKind, transform };
+export { transform, transformKind };

package/dist/dataParser/parsers/tuple.cjs

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

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

@@ -1,18 +1,18 @@
 import { type UnionContain, type IsEqual, type Kind, type Adaptor, type NeverCoalescing } 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 DataParserCheckerArrayMax, type DataParserCheckerArrayMin } from "./array";
-export type TupleShape = readonly [DataParsers, ...DataParsers[]];
-export type DataParserTupleShapeOutput<GenericShape extends TupleShape, GenericRest extends DataParsers | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
-    infer InferredFirst extends DataParsers,
-    ...infer InferredRest extends DataParsers[]
+export type TupleShape = readonly [DataParser, ...DataParser[]];
+export type DataParserTupleShapeOutput<GenericShape extends TupleShape, GenericRest extends DataParser | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
+    infer InferredFirst extends DataParser,
+    ...infer InferredRest extends DataParser[]
 ] ? [
     Output<InferredFirst>,
     ...(InferredRest extends TupleShape ? DataParserTupleShapeOutput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Output<Adaptor<GenericRest, DataParser>>[])
 ] : never;
-export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRest extends DataParsers | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
-    infer InferredFirst extends DataParsers,
-    ...infer InferredRest extends DataParsers[]
+export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRest extends DataParser | undefined> = IsEqual<GenericShape, TupleShape> extends true ? TupleShape : GenericShape extends [
+    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>>[])
@@ -20,10 +20,10 @@ export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRe
 export type DataParserTupleCheckers = (DataParserCheckerArrayMin | DataParserCheckerArrayMax);
 export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers> {
     readonly shape: TupleShape;
-    readonly rest?: DataParsers;
+    readonly rest?: DataParser;
 }
-export declare const dataParserTupleKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>>;
-type _DataParserTuple<GenericDefinition extends DataParserDefinitionTuple> = (DataParser<GenericDefinition, DataParserTupleShapeOutput<GenericDefinition["shape"], GenericDefinition["rest"]>, DataParserTupleShapeInput<GenericDefinition["shape"], GenericDefinition["rest"]>> & Kind<typeof dataParserTupleKind.definition>);
+export declare const tupleKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>>;
+type _DataParserTuple<GenericDefinition extends DataParserDefinitionTuple> = (DataParser<GenericDefinition, DataParserTupleShapeOutput<GenericDefinition["shape"], GenericDefinition["rest"]>, DataParserTupleShapeInput<GenericDefinition["shape"], GenericDefinition["rest"]>> & Kind<typeof tupleKind.definition>);
 export interface DataParserTuple<GenericDefinition extends DataParserDefinitionTuple = DataParserDefinitionTuple> extends _DataParserTuple<GenericDefinition> {
     addChecker<GenericChecker extends [DataParserTupleCheckers, ...DataParserTupleCheckers[]]>(...args: GenericChecker): DataParserTuple<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }

package/dist/dataParser/parsers/tuple.mjs

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

package/dist/dataParser/parsers/union.cjs

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

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

@@ -1,12 +1,12 @@
 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";
-export type UnionOptions = readonly [DataParsers, ...DataParsers[]];
+import { type MergeDefinition } from "../../dataParser/types";
+export type UnionOptions = readonly [DataParser, ...DataParser[]];
 export interface DataParserDefinitionUnion extends DataParserDefinition<never> {
     readonly options: UnionOptions;
 }
-export declare const dataParserUnionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>>;
-type _DataParserUnion<GenericDefinition extends DataParserDefinitionUnion> = (DataParser<GenericDefinition, Output<GenericDefinition["options"][number]>, Input<GenericDefinition["options"][number]>> & Kind<typeof dataParserUnionKind.definition>);
+export declare const unionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>>;
+type _DataParserUnion<GenericDefinition extends DataParserDefinitionUnion> = (DataParser<GenericDefinition, Output<GenericDefinition["options"][number]>, Input<GenericDefinition["options"][number]>> & Kind<typeof unionKind.definition>);
 export interface DataParserUnion<GenericDefinition extends DataParserDefinitionUnion = DataParserDefinitionUnion> extends _DataParserUnion<GenericDefinition> {
 }
 export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {