@duplojs/utils 1.1.9 → 1.1.11

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

@@ -9,6 +9,7 @@ var whenElse = require('../../common/whenElse.cjs');
 var map = require('../../array/map.cjs');
 var join = require('../../array/join.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 require('../../pattern/result.cjs');
@@ -24,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 ?? [],
@@ -42,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<"@DataParser/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

@@ -7,25 +7,26 @@ import { whenElse } from '../../common/whenElse.mjs';
 import { map } from '../../array/map.mjs';
 import { join } from '../../array/join.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 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 ?? [],
@@ -40,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<"@DataParser/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<"@DataParser/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<"@DataParser/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, {}> & {

package/dist/dataParser/parsers/union.mjs

@@ -2,9 +2,9 @@ import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserUnionKind = createDataParserKind("union");
+const unionKind = createDataParserKind("union");
 function union(options, definition) {
-    return dataParserInit(dataParserUnionKind, {
+    return dataParserInit(unionKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -32,4 +32,4 @@ function union(options, definition) {
     });
 }
 
-export { dataParserUnionKind, union };
+export { union, unionKind };

package/dist/dataParser/parsers/unknown.cjs

@@ -3,9 +3,9 @@
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserUnknownKind = kind.createDataParserKind("unknown");
+const unknownKind = kind.createDataParserKind("unknown");
 function unknown(definition) {
-    return base.dataParserInit(dataParserUnknownKind, {
+    return base.dataParserInit(unknownKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -13,5 +13,5 @@ function unknown(definition) {
     }, (data) => data);
 }
 
-exports.dataParserUnknownKind = dataParserUnknownKind;
 exports.unknown = unknown;
+exports.unknownKind = unknownKind;

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

@@ -3,8 +3,8 @@ import { type DataParserDefinition, type DataParser } from "../base";
 import { type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionUnknown extends DataParserDefinition<never> {
 }
-export declare const dataParserUnknownKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/unknown", unknown>>;
-type _DataParserUnknown<GenericDefinition extends DataParserDefinitionUnknown> = (DataParser<GenericDefinition, unknown, unknown> & Kind<typeof dataParserUnknownKind.definition>);
+export declare const unknownKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/unknown", unknown>>;
+type _DataParserUnknown<GenericDefinition extends DataParserDefinitionUnknown> = (DataParser<GenericDefinition, unknown, unknown> & Kind<typeof unknownKind.definition>);
 export interface DataParserUnknown<GenericDefinition extends DataParserDefinitionUnknown = DataParserDefinitionUnknown> extends _DataParserUnknown<GenericDefinition> {
 }
 export declare function unknown<const GenericDefinition extends Partial<DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;

package/dist/dataParser/parsers/unknown.mjs

@@ -1,9 +1,9 @@
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserUnknownKind = createDataParserKind("unknown");
+const unknownKind = createDataParserKind("unknown");
 function unknown(definition) {
-    return dataParserInit(dataParserUnknownKind, {
+    return dataParserInit(unknownKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -11,4 +11,4 @@ function unknown(definition) {
     }, (data) => data);
 }
 
-export { dataParserUnknownKind, unknown };
+export { unknown, unknownKind };

package/dist/dataParser/types/checkers.d.ts

@@ -1,3 +1,7 @@
+import { type GetPropsWithValueExtends } from "../../object";
 import { type DataParserChecker } from "../base";
 import type * as AllDataParser from "../parsers";
-export type Checkers = (DataParserChecker | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail);
+export interface CheckerCustom {
+    base: DataParserChecker;
+}
+export type DataParserCheckers = (CheckerCustom[GetPropsWithValueExtends<CheckerCustom, DataParserChecker>] | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail);

package/dist/dataParser/types/dataParsers.d.ts

@@ -1,5 +1,13 @@
+import { type GetPropsWithValueExtends } from "../../object";
 import { type DataParser } from "../base";
 import type * as AllDataParser from "../parsers";
+import type * as AllDataParserExtended from "../extended";
+import { type DataParserExtended } from "../baseExtended";
 export interface DataParserCustom {
+    base: DataParser;
 }
-export type DataParsers = (DataParserCustom[keyof DataParserCustom] | DataParser | AllDataParser.DataParserString | AllDataParser.DataParserObject | AllDataParser.DataParserNumber | AllDataParser.DataParserLiteral | AllDataParser.DataParserUnion | AllDataParser.DataParserArray | AllDataParser.DataParserBigInt | AllDataParser.DataParserTuple | AllDataParser.DataParserTransform | AllDataParser.DataParserBoolean | AllDataParser.DataParserNil | AllDataParser.DataParserEmpty | AllDataParser.DataParserTemplateLiteral | AllDataParser.DataParserPipe | AllDataParser.DataParserNullable | AllDataParser.DataParserOptional | AllDataParser.DataParserLazy | AllDataParser.DataParserUnknown | AllDataParser.DataParserRecord);
+export type DataParsers = (DataParserCustom[GetPropsWithValueExtends<DataParserCustom, DataParser>] | AllDataParser.DataParserString | AllDataParser.DataParserObject | AllDataParser.DataParserNumber | AllDataParser.DataParserLiteral | AllDataParser.DataParserUnion | AllDataParser.DataParserArray | AllDataParser.DataParserBigInt | AllDataParser.DataParserTuple | AllDataParser.DataParserTransform | AllDataParser.DataParserBoolean | AllDataParser.DataParserNil | AllDataParser.DataParserEmpty | AllDataParser.DataParserTemplateLiteral | AllDataParser.DataParserPipe | AllDataParser.DataParserNullable | AllDataParser.DataParserOptional | AllDataParser.DataParserLazy | AllDataParser.DataParserUnknown | AllDataParser.DataParserRecord);
+export interface DataParserExtendedCustom {
+    base: DataParserExtended;
+}
+export type DataParsersExtended = (DataParserExtendedCustom[GetPropsWithValueExtends<DataParserExtendedCustom, DataParserExtended>] | AllDataParserExtended.DataParserStringExtended | AllDataParserExtended.DataParserObjectExtended | AllDataParserExtended.DataParserNumberExtended | AllDataParserExtended.DataParserLiteralExtended | AllDataParserExtended.DataParserUnionExtended | AllDataParserExtended.DataParserArrayExtended | AllDataParserExtended.DataParserBigIntExtended | AllDataParserExtended.DataParserTupleExtended | AllDataParserExtended.DataParserTransformExtended | AllDataParserExtended.DataParserBooleanExtended | AllDataParserExtended.DataParserNilExtended | AllDataParserExtended.DataParserEmptyExtended | AllDataParserExtended.DataParserTemplateLiteralExtended | AllDataParserExtended.DataParserPipeExtended | AllDataParserExtended.DataParserNullableExtended | AllDataParserExtended.DataParserOptionalExtended | AllDataParserExtended.DataParserLazyExtended | AllDataParserExtended.DataParserUnknownExtended | AllDataParserExtended.DataParserRecordExtended);

package/dist/either/bool/base.d.ts

@@ -1 +1 @@
-export declare const eitherBoolKind: import("../..").KindHandler<import("../..").KindDefinition<"@Either/bool", unknown>>;
+export declare const eitherBoolKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/bool", unknown>>;

package/dist/either/bool/falsy.cjs

@@ -2,6 +2,7 @@
 
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 var create$1 = require('./create.cjs');

package/dist/either/bool/falsy.d.ts

@@ -5,7 +5,7 @@ import { bool } from "./create";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 export type BoolFalsyValue = 0 | "" | undefined | null | false;
-export declare const eitherBoolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/bool-falsy", unknown>>;
+export declare const eitherBoolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-falsy", unknown>>;
 type _EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> = (EitherLeft<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolFalsyKind.definition>);
 export interface EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> extends _EitherBoolFalsy<GenericValue> {
 }

package/dist/either/bool/falsy.mjs

@@ -1,5 +1,6 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { eitherBoolKind } from './base.mjs';
 import { bool } from './create.mjs';

package/dist/either/bool/truthy.cjs

@@ -2,6 +2,7 @@
 
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('./base.cjs');
 var kind = require('../kind.cjs');
 var is$1 = require('../left/is.cjs');

package/dist/either/bool/truthy.d.ts

@@ -4,7 +4,7 @@ import { eitherBoolKind } from "./base";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { bool } from "./create";
-export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/bool-truthy", unknown>>;
+export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-truthy", unknown>>;
 type _EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
 export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extends _EitherBoolTruthy<GenericValue> {
 }

package/dist/either/bool/truthy.mjs

@@ -1,5 +1,6 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { eitherBoolKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { isLeft } from '../left/is.mjs';

package/dist/either/future/base.d.ts

@@ -1 +1 @@
-export declare const eitherFutureKind: import("../..").KindHandler<import("../..").KindDefinition<"@Either/future", unknown>>;
+export declare const eitherFutureKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/future", unknown>>;

package/dist/either/future/create.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var is$1 = require('../left/is.cjs');
 var success = require('./success.cjs');
 var error = require('./error.cjs');

package/dist/either/future/create.mjs

@@ -1,4 +1,5 @@
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { isLeft } from '../left/is.mjs';
 import { futureSuccess } from './success.mjs';
 import { futureError } from './error.mjs';

package/dist/either/future/error.cjs

@@ -3,6 +3,7 @@
 var create = require('../left/create.cjs');
 var kind = require('../kind.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('./base.cjs');
 
 const eitherFutureErrorKind = kind.createEitherKind("future-error");

package/dist/either/future/error.d.ts

@@ -1,7 +1,7 @@
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "../left";
 import { eitherFutureKind } from "./base";
-export declare const eitherFutureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/future-error", unknown>>;
+export declare const eitherFutureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-error", unknown>>;
 type _EitherFutureError = (EitherLeft<"future", unknown> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureErrorKind.definition>);
 export interface EitherFutureError extends _EitherFutureError {
 }

package/dist/either/future/error.mjs

@@ -1,6 +1,7 @@
 import { left } from '../left/create.mjs';
 import { createEitherKind } from '../kind.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { eitherFutureKind } from './base.mjs';
 
 const eitherFutureErrorKind = createEitherKind("future-error");

package/dist/either/future/success.cjs

@@ -3,6 +3,7 @@
 var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var create = require('../right/create.cjs');
 
 const eitherFutureSuccessKind = kind.createEitherKind("future-success");

package/dist/either/future/success.d.ts

@@ -1,7 +1,7 @@
 import { type Kind } from "../../common/kind";
 import { eitherFutureKind } from "./base";
 import { type EitherRight } from "../right";
-export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/future-success", unknown>>;
+export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-success", unknown>>;
 type _EitherFutureSuccess<GenericValue extends unknown = unknown> = (EitherRight<"future", GenericValue> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureSuccessKind.definition>);
 export interface EitherFutureSuccess<GenericValue extends unknown = unknown> extends _EitherFutureSuccess<GenericValue> {
 }

package/dist/either/future/success.mjs

@@ -1,6 +1,7 @@
 import { createEitherKind } from '../kind.mjs';
 import { eitherFutureKind } from './base.mjs';
 import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { right } from '../right/create.mjs';
 
 const eitherFutureSuccessKind = createEitherKind("future-success");

package/dist/either/kind.cjs

@@ -2,10 +2,11 @@
 
 var kind = require('../common/kind.cjs');
 require('../common/globalStore.cjs');
+require('../common/builder.cjs');
 
 const createEitherKind = kind.createKindNamespace(
 // @ts-expect-error reserved kind namespace
-"Either");
+"DuplojsUtilsEither");
 const eitherInformationKind = createEitherKind("information");
 
 exports.createEitherKind = createEitherKind;

package/dist/either/kind.d.ts

@@ -1,2 +1,2 @@
-export declare const createEitherKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@Either/${GenericName}`, GenericKindValue>>;
-export declare const eitherInformationKind: import("../common").KindHandler<import("../common").KindDefinition<"@Either/information", string>>;
+export declare const createEitherKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DuplojsUtilsEither/${GenericName}`, GenericKindValue>>;
+export declare const eitherInformationKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/information", string>>;

package/dist/either/kind.mjs

@@ -1,9 +1,10 @@
 import { createKindNamespace } from '../common/kind.mjs';
 import '../common/globalStore.mjs';
+import '../common/builder.mjs';
 
 const createEitherKind = createKindNamespace(
 // @ts-expect-error reserved kind namespace
-"Either");
+"DuplojsUtilsEither");
 const eitherInformationKind = createEitherKind("information");
 
 export { createEitherKind, eitherInformationKind };

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

@@ -1,7 +1,7 @@
 import { type Kind } from "../../common/kind";
 import { type WrappedValue } from "../../common/wrapValue";
 import { eitherInformationKind } from "../kind";
-export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/left", unknown>>;
+export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/left", unknown>>;
 type _EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherLeftKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
 export interface EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _EitherLeft<GenericInformation, GenericValue> {
 }

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

@@ -1,6 +1,6 @@
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "./create";
-export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/error", unknown>>;
+export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/error", unknown>>;
 type _EitherError<GenericValue extends unknown = unknown> = (EitherLeft<"error", GenericValue> & Kind<typeof eitherErrorKind.definition>);
 export interface EitherError<GenericValue extends unknown = unknown> extends _EitherError<GenericValue> {
 }

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

@@ -1,6 +1,6 @@
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "./create";
-export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/fail", unknown>>;
+export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
 type _EitherFail = (EitherLeft<"fail", never> & Kind<typeof eitherFailKind.definition>);
 export interface EitherFail extends _EitherFail {
 }