@duplojs/utils 1.1.10 → 1.1.11

package/dist/common/types/index.d.ts

@@ -37,3 +37,4 @@ export * from "./isStringLIteral";
 export * from "./maybeWrapped";
 export * from "./anyConstructor";
 export * from "./anyPredicate";
+export * from "./removeFromUnion";

package/dist/common/types/removeFromUnion.d.ts

@@ -0,0 +1,2 @@
+import { type UnionContain } from "./unionContain";
+export type RemoveFromUnion<GenericUnion extends unknown, GenericValue extends unknown> = GenericUnion extends any ? UnionContain<GenericValue, GenericUnion> extends true ? never : GenericUnion : never;

package/dist/common/types/unionContain.d.ts

@@ -1,2 +1,2 @@
 import { type IsEqual } from "./isEqual";
-export type UnionContain<GenericUnion extends unknown, GenericValue extends unknown> = IsEqual<(GenericUnion extends any ? IsEqual<GenericUnion, GenericValue> : never) | false, boolean>;
+export type UnionContain<GenericUnion extends unknown, GenericValue extends unknown> = IsEqual<GenericValue extends any ? IsEqual<(GenericUnion extends any ? IsEqual<GenericUnion, GenericValue> : never) | false, boolean> : never, true>;

package/dist/dataParser/base.cjs

@@ -10,9 +10,9 @@ var kind = require('./kind.cjs');
 
 const SymbolDataParserErrorLabel = "SymbolDataParserError";
 const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
-const dataParserCheckerKind = kind.createDataParserKind("checker");
+const checkerKind = kind.createDataParserKind("checker");
 function dataParserCheckerInit(kind, params, exec) {
-    return kind.setTo(dataParserCheckerKind.setTo({
+    return kind.setTo(checkerKind.setTo({
         ...params,
         exec,
     }));
@@ -112,7 +112,7 @@ function dataParserInit(kind, params, exec) {
 
 exports.SymbolDataParserError = SymbolDataParserError;
 exports.SymbolDataParserErrorLabel = SymbolDataParserErrorLabel;
+exports.checkerKind = checkerKind;
 exports.dataParserCheckerInit = dataParserCheckerInit;
-exports.dataParserCheckerKind = dataParserCheckerKind;
 exports.dataParserInit = dataParserInit;
 exports.dataParserKind = dataParserKind;

package/dist/dataParser/base.d.ts

@@ -4,15 +4,15 @@ import * as DEither from "../either";
 export declare const SymbolDataParserErrorLabel = "SymbolDataParserError";
 export declare const SymbolDataParserError: unique symbol;
 export type SymbolDataParserError = typeof SymbolDataParserError;
-export declare const dataParserCheckerKind: KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/checker", unknown>>;
+export declare const checkerKind: KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/checker", unknown>>;
 export interface DataParserCheckerDefinition {
     readonly errorMessage?: string;
 }
-export interface DataParserChecker<GenericDefinition extends DataParserCheckerDefinition = DataParserCheckerDefinition, GenericInput extends AnyValue = AnyValue> extends Kind<typeof dataParserCheckerKind.definition, GenericInput> {
+export interface DataParserChecker<GenericDefinition extends DataParserCheckerDefinition = DataParserCheckerDefinition, GenericInput extends AnyValue = AnyValue> extends Kind<typeof checkerKind.definition, GenericInput> {
     readonly definition: GenericDefinition;
     exec(data: GenericInput, self: this): GenericInput | SymbolDataParserErrorIssue;
 }
-export declare function dataParserCheckerInit<GenericDataParserChecker extends DataParserChecker>(kind: Exclude<GetKindHandler<GenericDataParserChecker>, typeof dataParserCheckerKind>, params: NoInfer<Omit<RemoveKind<GenericDataParserChecker>, "exec">>, exec: (...args: Parameters<GenericDataParserChecker["exec"]>) => GetKindValue<typeof dataParserCheckerKind, GenericDataParserChecker> | SymbolDataParserErrorIssue): GenericDataParserChecker;
+export declare function dataParserCheckerInit<GenericDataParserChecker extends DataParserChecker>(kind: Exclude<GetKindHandler<GenericDataParserChecker>, typeof checkerKind>, params: NoInfer<Omit<RemoveKind<GenericDataParserChecker>, "exec">>, exec: (...args: Parameters<GenericDataParserChecker["exec"]>) => GetKindValue<typeof checkerKind, GenericDataParserChecker> | SymbolDataParserErrorIssue): GenericDataParserChecker;
 export declare const dataParserKind: KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/base", {
     input: unknown;
     output: unknown;

package/dist/dataParser/base.mjs

@@ -8,9 +8,9 @@ import { createDataParserKind } from './kind.mjs';
 
 const SymbolDataParserErrorLabel = "SymbolDataParserError";
 const SymbolDataParserError = Symbol.for(SymbolDataParserErrorLabel);
-const dataParserCheckerKind = createDataParserKind("checker");
+const checkerKind = createDataParserKind("checker");
 function dataParserCheckerInit(kind, params, exec) {
-    return kind.setTo(dataParserCheckerKind.setTo({
+    return kind.setTo(checkerKind.setTo({
         ...params,
         exec,
     }));
@@ -108,4 +108,4 @@ function dataParserInit(kind, params, exec) {
     return dataParser;
 }
 
-export { SymbolDataParserError, SymbolDataParserErrorLabel, dataParserCheckerInit, dataParserCheckerKind, dataParserInit, dataParserKind };
+export { SymbolDataParserError, SymbolDataParserErrorLabel, checkerKind, dataParserCheckerInit, dataParserInit, dataParserKind };

package/dist/dataParser/baseExtended.cjs

@@ -16,9 +16,9 @@ var nullable = require('./extended/nullable.cjs');
 var optional = require('./extended/optional.cjs');
 var pipe$1 = require('./extended/pipe.cjs');
 
-const dataParserExtendedKind = kind.createDataParserKind("extended");
+const extendedKind = kind.createDataParserKind("extended");
 function dataParserExtendedInit(dataParser, rest) {
-    const self = dataParserExtendedKind.setTo({
+    const self = extendedKind.setTo({
         ...dataParser,
         ...pipe.pipe(rest, entries.entries, map.map(([key, value]) => entry.entry(key, typeof value === "function"
             ? (...args) => value(self, ...args)
@@ -54,4 +54,4 @@ function dataParserExtendedInit(dataParser, rest) {
 }
 
 exports.dataParserExtendedInit = dataParserExtendedInit;
-exports.dataParserExtendedKind = dataParserExtendedKind;
+exports.extendedKind = extendedKind;

package/dist/dataParser/baseExtended.d.ts

@@ -1,11 +1,11 @@
 import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue } from "../common";
-import { type DataParsers, type MergeDefinition } from "./types";
+import { type MergeDefinition } from "./types";
 import { type Output, type DataParser } from "./base";
 import type * as dataParsers from "./parsers";
 import * as dataParsersExtended from "./extended";
 import { type DataParserError } from "./error";
-export declare const dataParserExtendedKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>>;
-type _DataParserExtended = (DataParser & Kind<typeof dataParserExtendedKind.definition>);
+export declare const extendedKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/extended", unknown>>;
+type _DataParserExtended = (DataParser & Kind<typeof extendedKind.definition>);
 export interface DataParserExtended extends _DataParserExtended {
     array<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionArray, "element">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
         element: GenericThis;
@@ -25,7 +25,7 @@ export interface DataParserExtended extends _DataParserExtended {
             }>>
         ];
     }>>;
-    pipe<GenericThis extends this = this, GenericOutput extends DataParsers = DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(output: GenericOutput, definition?: GenericDefinition): dataParsersExtended.DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
+    pipe<GenericThis extends this = this, GenericOutput extends DataParser = DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(output: GenericOutput, definition?: GenericDefinition): dataParsersExtended.DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
         input: GenericThis;
         output: GenericOutput;
     }>>;
@@ -35,7 +35,7 @@ export interface DataParserExtended extends _DataParserExtended {
     optional<GenericThis extends this = this, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
         inner: GenericThis;
     }>>;
-    or<GenericThis extends this = this, GenericDataParser extends DataParsers = DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(option: GenericDataParser, definition?: GenericDefinition): dataParsersExtended.DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
+    or<GenericThis extends this = this, GenericDataParser extends DataParser = DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(option: GenericDataParser, definition?: GenericDefinition): dataParsersExtended.DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
         options: [GenericThis, GenericDataParser];
     }>>;
 }

package/dist/dataParser/baseExtended.mjs

@@ -14,9 +14,9 @@ import { nullable } from './extended/nullable.mjs';
 import { optional } from './extended/optional.mjs';
 import { pipe as pipe$1 } from './extended/pipe.mjs';
 
-const dataParserExtendedKind = createDataParserKind("extended");
+const extendedKind = createDataParserKind("extended");
 function dataParserExtendedInit(dataParser, rest) {
-    const self = dataParserExtendedKind.setTo({
+    const self = extendedKind.setTo({
         ...dataParser,
         ...pipe(rest, entries, map(([key, value]) => entry(key, typeof value === "function"
             ? (...args) => value(self, ...args)
@@ -51,4 +51,4 @@ function dataParserExtendedInit(dataParser, rest) {
     return self;
 }
 
-export { dataParserExtendedInit, dataParserExtendedKind };
+export { dataParserExtendedInit, extendedKind };

package/dist/dataParser/error.cjs

@@ -4,19 +4,19 @@ var kind = require('./kind.cjs');
 
 const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
 const SymbolDataParserErrorIssue = Symbol.for(SymbolDataParserErrorIssueLabel);
-const dataParserErrorIssueKind = kind.createDataParserKind("error-issue");
+const errorIssueKind = kind.createDataParserKind("error-issue");
 const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
 const SymbolDataParserErrorPromiseIssue = Symbol.for(SymbolDataParserErrorPromiseIssueLabel);
-const dataParserErrorPromiseIssueKind = kind.createDataParserKind("error-issue-promise");
-const dataParserErrorKind = kind.createDataParserKind("error");
+const errorPromiseIssueKind = kind.createDataParserKind("error-issue-promise");
+const errorKind = kind.createDataParserKind("error");
 function createError() {
-    return dataParserErrorKind.setTo({
+    return errorKind.setTo({
         issues: [],
         currentPath: [],
     });
 }
 function addIssue(error, source, data) {
-    error.issues.push(dataParserErrorIssueKind.setTo({
+    error.issues.push(errorIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
@@ -24,7 +24,7 @@ function addIssue(error, source, data) {
     return error;
 }
 function addPromiseIssue(error, source, data) {
-    error.issues.push(dataParserErrorPromiseIssueKind.setTo({
+    error.issues.push(errorPromiseIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
@@ -47,8 +47,8 @@ exports.SymbolDataParserErrorPromiseIssueLabel = SymbolDataParserErrorPromiseIss
 exports.addIssue = addIssue;
 exports.addPromiseIssue = addPromiseIssue;
 exports.createError = createError;
-exports.dataParserErrorIssueKind = dataParserErrorIssueKind;
-exports.dataParserErrorKind = dataParserErrorKind;
-exports.dataParserErrorPromiseIssueKind = dataParserErrorPromiseIssueKind;
+exports.errorIssueKind = errorIssueKind;
+exports.errorKind = errorKind;
+exports.errorPromiseIssueKind = errorPromiseIssueKind;
 exports.popErrorPath = popErrorPath;
 exports.setErrorPath = setErrorPath;

package/dist/dataParser/error.d.ts

@@ -1,31 +1,32 @@
 import { type Kind } from "../common";
-import { type DataParsers, type Checkers } from "./types";
 import { type DataParserTransform } from "./parsers";
+import { type DataParser } from "./base";
+import { type DataParserCheckers } from "./types";
 export declare const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
 export declare const SymbolDataParserErrorIssue: unique symbol;
 export type SymbolDataParserErrorIssue = typeof SymbolDataParserErrorIssue;
-export declare const dataParserErrorIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error-issue", unknown>>;
-export interface DataParserErrorIssue extends Kind<typeof dataParserErrorIssueKind.definition> {
-    readonly source: DataParsers | Checkers;
+export declare const errorIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error-issue", unknown>>;
+export interface DataParserErrorIssue extends Kind<typeof errorIssueKind.definition> {
+    readonly source: DataParser | DataParserCheckers;
     readonly path: string;
     readonly data: unknown;
 }
 export declare const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
 export declare const SymbolDataParserErrorPromiseIssue: unique symbol;
 export type SymbolDataParserErrorPromiseIssue = typeof SymbolDataParserErrorPromiseIssue;
-export declare const dataParserErrorPromiseIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error-issue-promise", unknown>>;
-export interface DataParserErrorPromiseIssue extends Kind<typeof dataParserErrorPromiseIssueKind.definition> {
+export declare const errorPromiseIssueKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error-issue-promise", unknown>>;
+export interface DataParserErrorPromiseIssue extends Kind<typeof errorPromiseIssueKind.definition> {
     readonly source: DataParserTransform;
     readonly path: string;
     readonly data: unknown;
 }
-export declare const dataParserErrorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error", unknown>>;
-export interface DataParserError extends Kind<typeof dataParserErrorKind.definition> {
+export declare const errorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsDataParser/error", unknown>>;
+export interface DataParserError extends Kind<typeof errorKind.definition> {
     readonly issues: (DataParserErrorIssue | DataParserErrorPromiseIssue)[];
     readonly currentPath: string[];
 }
 export declare function createError(): DataParserError;
-export declare function addIssue(error: DataParserError, source: DataParsers | Checkers, data: unknown): DataParserError;
+export declare function addIssue(error: DataParserError, source: DataParser | DataParserCheckers, data: unknown): DataParserError;
 export declare function addPromiseIssue(error: DataParserError, source: DataParserTransform, data: unknown): DataParserError;
 export declare function setErrorPath(error: DataParserError, value: string, index: number): DataParserError;
 export declare function popErrorPath(error: DataParserError): DataParserError;

package/dist/dataParser/error.mjs

@@ -2,19 +2,19 @@ import { createDataParserKind } from './kind.mjs';
 
 const SymbolDataParserErrorIssueLabel = "SymbolDataParserErrorIssue";
 const SymbolDataParserErrorIssue = Symbol.for(SymbolDataParserErrorIssueLabel);
-const dataParserErrorIssueKind = createDataParserKind("error-issue");
+const errorIssueKind = createDataParserKind("error-issue");
 const SymbolDataParserErrorPromiseIssueLabel = "SymbolDataParserErrorPromiseIssue";
 const SymbolDataParserErrorPromiseIssue = Symbol.for(SymbolDataParserErrorPromiseIssueLabel);
-const dataParserErrorPromiseIssueKind = createDataParserKind("error-issue-promise");
-const dataParserErrorKind = createDataParserKind("error");
+const errorPromiseIssueKind = createDataParserKind("error-issue-promise");
+const errorKind = createDataParserKind("error");
 function createError() {
-    return dataParserErrorKind.setTo({
+    return errorKind.setTo({
         issues: [],
         currentPath: [],
     });
 }
 function addIssue(error, source, data) {
-    error.issues.push(dataParserErrorIssueKind.setTo({
+    error.issues.push(errorIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
@@ -22,7 +22,7 @@ function addIssue(error, source, data) {
     return error;
 }
 function addPromiseIssue(error, source, data) {
-    error.issues.push(dataParserErrorPromiseIssueKind.setTo({
+    error.issues.push(errorPromiseIssueKind.setTo({
         source,
         path: error.currentPath.join("."),
         data,
@@ -38,4 +38,4 @@ function popErrorPath(error) {
     return error;
 }
 
-export { SymbolDataParserErrorIssue, SymbolDataParserErrorIssueLabel, SymbolDataParserErrorPromiseIssue, SymbolDataParserErrorPromiseIssueLabel, addIssue, addPromiseIssue, createError, dataParserErrorIssueKind, dataParserErrorKind, dataParserErrorPromiseIssueKind, popErrorPath, setErrorPath };
+export { SymbolDataParserErrorIssue, SymbolDataParserErrorIssueLabel, SymbolDataParserErrorPromiseIssue, SymbolDataParserErrorPromiseIssueLabel, addIssue, addPromiseIssue, createError, errorIssueKind, errorKind, errorPromiseIssueKind, popErrorPath, setErrorPath };

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

@@ -1,7 +1,8 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type AddCheckersToDefinition, type DataParsers, type MergeDefinition } from "../types";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type DataParser } from "../base";
 type _DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray> = (dataParsers.DataParserArray<GenericDefinition> & DataParserExtended);
 export interface DataParserArrayExtended<GenericDefinition extends dataParsers.DataParserDefinitionArray = dataParsers.DataParserDefinitionArray> extends _DataParserArrayExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
@@ -15,7 +16,7 @@ export interface DataParserArrayExtended<GenericDefinition extends dataParsers.D
         dataParsers.DataParserCheckerArrayMax
     ]>>;
 }
-export declare function array<GenericElement extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
+export declare function array<GenericElement extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionArray, "element">> = never>(element: GenericElement, definition?: GenericDefinition): DataParserArrayExtended<MergeDefinition<dataParsers.DataParserDefinitionArray, NeverCoalescing<GenericDefinition, {}> & {
     element: GenericElement;
 }>>;
 export {};

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

@@ -1,11 +1,12 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type DataParsers, type MergeDefinition } from "../types";
+import { type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type DataParser } from "../base";
 type _DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy> = (dataParsers.DataParserLazy<GenericDefinition> & DataParserExtended);
 export interface DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy = dataParsers.DataParserDefinitionLazy> extends _DataParserLazyExtended<GenericDefinition> {
 }
-export declare function lazy<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
+export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
     getter(): GenericDataParser;
 }>>;
 export {};

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

@@ -1,11 +1,12 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type DataParsers, type MergeDefinition } from "../types";
+import { type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type DataParser } from "../base";
 type _DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable> = (dataParsers.DataParserNullable<GenericDefinition> & DataParserExtended);
 export interface DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable = dataParsers.DataParserDefinitionNullable> extends _DataParserNullableExtended<GenericDefinition> {
 }
-export declare function nullable<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

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

@@ -1,11 +1,12 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type DataParsers, type MergeDefinition } from "../types";
+import { type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type DataParser } from "../base";
 type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (dataParsers.DataParserOptional<GenericDefinition> & DataParserExtended);
 export interface DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional = dataParsers.DataParserDefinitionOptional> extends _DataParserOptionalExtended<GenericDefinition> {
 }
-export declare function optional<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export {};

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

@@ -1,11 +1,12 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type DataParsers, type MergeDefinition } from "../types";
+import { type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type DataParser } from "../base";
 type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (dataParsers.DataParserPipe<GenericDefinition> & DataParserExtended);
 export interface DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe = dataParsers.DataParserDefinitionPipe> extends _DataParserPipeExtended<GenericDefinition> {
 }
-export declare function pipe<GenericInput extends DataParsers, GenericOutput extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
+export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;
     output: GenericOutput;
 }>>;

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

@@ -1,11 +1,12 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type DataParsers, type MergeDefinition } from "../types";
+import { type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
+import { type DataParser } from "../base";
 type _DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord> = (dataParsers.DataParserRecord<GenericDefinition> & DataParserExtended);
 export interface DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord = dataParsers.DataParserDefinitionRecord> extends _DataParserRecordExtended<GenericDefinition> {
 }
-export declare function record<GenericDataParserKey extends dataParsers.DataParserRecordKey, GenericDataParserValue extends DataParsers, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecordExtended<MergeDefinition<dataParsers.DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
+export declare function record<GenericDataParserKey extends dataParsers.DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecordExtended<MergeDefinition<dataParsers.DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;
     value: GenericDataParserValue;
 }>>;

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

@@ -1,13 +1,13 @@
 import { type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
-import { type DataParsers, type MergeDefinition } from "../types";
+import { type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
-import { type Output } from "../base";
+import { type DataParser, type Output } from "../base";
 import { type DataParserError } from "../error";
 type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (dataParsers.DataParserTransform<GenericDefinition> & DataParserExtended);
 export interface DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform = dataParsers.DataParserDefinitionTransform> extends _DataParserTransformExtended<GenericDefinition> {
 }
-export declare function transform<GenericDataParser extends DataParsers, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
+export declare function transform<GenericDataParser extends DataParser, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     theFunction(input: Output<GenericDataParser>): GenericOutput;
 }>>;

package/dist/dataParser/identifier.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var coalescing = require('../array/coalescing.cjs');
+require('../common/globalStore.cjs');
+require('../common/builder.cjs');
+var error = require('../either/left/error.cjs');
+var success = require('../either/right/success.cjs');
+
+/**
+ * Due to the recursive typing of `DataParsers`, it can’t be used without
+ * causing an infinity error. You therefore have to go through the parent
+ * type `DataParser`, which makes type discrimination impossible. That’s
+ * why the `identifier` function was created. The function ensures that,
+ * starting from the parent type and the kinds associated with the data
+ * parsers, the correct type can be retrieved.
+ */
+function identifier(...args) {
+    if (args.length === 1) {
+        const [kind] = args;
+        return (input) => identifier(input, kind);
+    }
+    const [input, kind] = args;
+    const formattedKind = coalescing.coalescing(kind);
+    for (const kind of formattedKind) {
+        if (!kind.has(input)) {
+            return error.error(input);
+        }
+    }
+    return success.success(input);
+}
+
+exports.identifier = identifier;

package/dist/dataParser/identifier.d.ts

@@ -0,0 +1,9 @@
+import { type KindHandler, type UnionToIntersection, type GetKindHandler, type Kind, type UnionContain } from "../common";
+import { type DataParser } from "./base";
+import { type DataParsers, type DataParsersExtended } from "./types";
+import * as DEither from "../either";
+type AllDataParsers = (DataParsers | DataParsersExtended);
+type KindHandlers = AllDataParsers extends infer InferredDataParser ? InferredDataParser extends DataParser ? GetKindHandler<InferredDataParser> : never : never;
+export declare function identifier<GenericKindHandler extends KindHandlers, GenericInput extends DataParser, GenericDataParserResult extends Extract<AllDataParsers, UnionToIntersection<GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never>>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => ((GenericInput extends any ? UnionContain<GetKindHandler<GenericInput>, GenericKindHandler> extends true ? DEither.EitherSuccess<GenericInput> : DEither.EitherError<GenericInput> : never) | DEither.EitherSuccess<GenericDataParserResult>);
+export declare function identifier<GenericKindHandler extends KindHandlers, GenericInput extends DataParser, GenericDataParserResult extends Extract<AllDataParsers, UnionToIntersection<GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never>>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): ((GenericInput extends any ? UnionContain<GetKindHandler<GenericInput>, GenericKindHandler> extends true ? DEither.EitherSuccess<GenericInput> : DEither.EitherError<GenericInput> : never) | DEither.EitherSuccess<GenericDataParserResult>);
+export {};

package/dist/dataParser/identifier.mjs

@@ -0,0 +1,30 @@
+import { coalescing } from '../array/coalescing.mjs';
+import '../common/globalStore.mjs';
+import '../common/builder.mjs';
+import { error } from '../either/left/error.mjs';
+import { success } from '../either/right/success.mjs';
+
+/**
+ * Due to the recursive typing of `DataParsers`, it can’t be used without
+ * causing an infinity error. You therefore have to go through the parent
+ * type `DataParser`, which makes type discrimination impossible. That’s
+ * why the `identifier` function was created. The function ensures that,
+ * starting from the parent type and the kinds associated with the data
+ * parsers, the correct type can be retrieved.
+ */
+function identifier(...args) {
+    if (args.length === 1) {
+        const [kind] = args;
+        return (input) => identifier(input, kind);
+    }
+    const [input, kind] = args;
+    const formattedKind = coalescing(kind);
+    for (const kind of formattedKind) {
+        if (!kind.has(input)) {
+            return error(input);
+        }
+    }
+    return success(input);
+}
+
+export { identifier };

package/dist/dataParser/index.cjs

@@ -24,6 +24,7 @@ var lazy = require('./parsers/lazy.cjs');
 var unknown = require('./parsers/unknown.cjs');
 var record = require('./parsers/record.cjs');
 var index = require('./extended/index.cjs');
+var identifier = require('./identifier.cjs');
 var url = require('./parsers/string/checkers/url.cjs');
 var email = require('./parsers/string/checkers/email.cjs');
 var max = require('./parsers/string/checkers/max.cjs');
@@ -41,12 +42,12 @@ var max$3 = require('./parsers/bigint/checkers/max.cjs');
 
 exports.SymbolDataParserError = base.SymbolDataParserError;
 exports.SymbolDataParserErrorLabel = base.SymbolDataParserErrorLabel;
+exports.checkerKind = base.checkerKind;
 exports.dataParserCheckerInit = base.dataParserCheckerInit;
-exports.dataParserCheckerKind = base.dataParserCheckerKind;
 exports.dataParserInit = base.dataParserInit;
 exports.dataParserKind = base.dataParserKind;
 exports.dataParserExtendedInit = baseExtended.dataParserExtendedInit;
-exports.dataParserExtendedKind = baseExtended.dataParserExtendedKind;
+exports.extendedKind = baseExtended.extendedKind;
 exports.SymbolDataParserErrorIssue = error.SymbolDataParserErrorIssue;
 exports.SymbolDataParserErrorIssueLabel = error.SymbolDataParserErrorIssueLabel;
 exports.SymbolDataParserErrorPromiseIssue = error.SymbolDataParserErrorPromiseIssue;
@@ -54,51 +55,52 @@ exports.SymbolDataParserErrorPromiseIssueLabel = error.SymbolDataParserErrorProm
 exports.addIssue = error.addIssue;
 exports.addPromiseIssue = error.addPromiseIssue;
 exports.createError = error.createError;
-exports.dataParserErrorIssueKind = error.dataParserErrorIssueKind;
-exports.dataParserErrorKind = error.dataParserErrorKind;
-exports.dataParserErrorPromiseIssueKind = error.dataParserErrorPromiseIssueKind;
+exports.errorIssueKind = error.errorIssueKind;
+exports.errorKind = error.errorKind;
+exports.errorPromiseIssueKind = error.errorPromiseIssueKind;
 exports.popErrorPath = error.popErrorPath;
 exports.setErrorPath = error.setErrorPath;
 exports.coerce = index$1;
-exports.dataParserStringKind = index$2.dataParserStringKind;
 exports.string = index$2.string;
-exports.dataParserObjectKind = object.dataParserObjectKind;
+exports.stringKind = index$2.stringKind;
 exports.object = object.object;
-exports.dataParserNumberKind = index$3.dataParserNumberKind;
+exports.objectKind = object.objectKind;
 exports.number = index$3.number;
-exports.dataParserLiteralKind = literal.dataParserLiteralKind;
+exports.numberKind = index$3.numberKind;
 exports.literal = literal.literal;
-exports.dataParserUnionKind = union.dataParserUnionKind;
+exports.literalKind = literal.literalKind;
 exports.union = union.union;
+exports.unionKind = union.unionKind;
 exports.array = index$4.array;
-exports.dataParserArrayKind = index$4.dataParserArrayKind;
+exports.arrayKind = index$4.arrayKind;
+exports.bigIntKind = index$5.bigIntKind;
 exports.bigint = index$5.bigint;
-exports.dataParserBigIntKind = index$5.dataParserBigIntKind;
-exports.dataParserTupleKind = tuple.dataParserTupleKind;
 exports.tuple = tuple.tuple;
-exports.dataParserTransformKind = transform.dataParserTransformKind;
+exports.tupleKind = tuple.tupleKind;
 exports.transform = transform.transform;
-exports.dataParserNilKind = nil.dataParserNilKind;
+exports.transformKind = transform.transformKind;
 exports.nil = nil.nil;
+exports.nilKind = nil.nilKind;
 exports.boolean = boolean.boolean;
-exports.dataParserBooleanKind = boolean.dataParserBooleanKind;
-exports.dataParserEmptyKind = empty.dataParserEmptyKind;
+exports.booleanKind = boolean.booleanKind;
 exports.empty = empty.empty;
-exports.dataParserTemplateLiteralKind = templateLiteral.dataParserTemplateLiteralKind;
+exports.emptyKind = empty.emptyKind;
 exports.templateLiteral = templateLiteral.templateLiteral;
-exports.dataParserPipeKind = pipe.dataParserPipeKind;
+exports.templateLiteralKind = templateLiteral.templateLiteralKind;
 exports.pipe = pipe.pipe;
-exports.dataParserOptionalKind = optional.dataParserOptionalKind;
+exports.pipeKind = pipe.pipeKind;
 exports.optional = optional.optional;
-exports.dataParserNullableKind = nullable.dataParserNullableKind;
+exports.optionalKind = optional.optionalKind;
 exports.nullable = nullable.nullable;
-exports.dataParserLazyKind = lazy.dataParserLazyKind;
+exports.nullableKind = nullable.nullableKind;
 exports.lazy = lazy.lazy;
-exports.dataParserUnknownKind = unknown.dataParserUnknownKind;
+exports.lazyKind = lazy.lazyKind;
 exports.unknown = unknown.unknown;
-exports.dataParserRecordKind = record.dataParserRecordKind;
+exports.unknownKind = unknown.unknownKind;
 exports.record = record.record;
+exports.recordKind = record.recordKind;
 exports.extended = index;
+exports.identifier = identifier.identifier;
 exports.checkerUrl = url.checkerUrl;
 exports.dataParserCheckerUrlKind = url.dataParserCheckerUrlKind;
 exports.url = url.url;

package/dist/dataParser/index.d.ts

@@ -4,3 +4,4 @@ export * from "./error";
 export * from "./types";
 export * from "./parsers";
 export * as extended from "./extended";
+export * from "./identifier";