@duplojs/utils 1.1.13 → 1.1.15

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.mjs

@@ -0,0 +1,73 @@
+import { escapeRegExp } from '../../../common/escapeRegExp.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { innerPipe } from '../../../common/innerPipe.mjs';
+import { when as when$1 } from '../../../common/when.mjs';
+import { isType } from '../../../common/isType.mjs';
+import { or } from '../../../common/or.mjs';
+import { justReturn } from '../../../common/justReturn.mjs';
+import { find } from '../../../array/find.mjs';
+import { to } from '../../../object/to.mjs';
+import { map } from '../../../array/map.mjs';
+import { join } from '../../../array/join.mjs';
+import '../../../common/globalStore.mjs';
+import '../../../common/builder.mjs';
+import { templateLiteralKind } from './index.mjs';
+import '../../../pattern/result.mjs';
+import { exhaustive } from '../../../pattern/exhaustive.mjs';
+import { when } from '../../../pattern/when.mjs';
+import { replace } from '../../../string/replace.mjs';
+import { numberKind } from '../number/index.mjs';
+import { bigIntKind } from '../bigint/index.mjs';
+import { booleanKind } from '../boolean.mjs';
+import { nilKind } from '../nil.mjs';
+import { emptyKind } from '../empty.mjs';
+import { literalKind } from '../literal.mjs';
+import { stringKind } from '../string/index.mjs';
+import { unionKind } from '../union.mjs';
+import { checkerStringRegexKind } from '../string/checkers/regex.mjs';
+import { checkerStringMaxKind } from '../string/checkers/max.mjs';
+import { checkerStringMinKind } from '../string/checkers/min.mjs';
+import { checkerEmailKind } from '../string/checkers/email.mjs';
+import { checkerIntKind } from '../number/checkers/int.mjs';
+
+function createTemplateLiteralPattern(templatePart) {
+    return pipe(templatePart, map(innerPipe(when(or([
+        isType("string"),
+        isType("boolean"),
+        isType("bigint"),
+        isType("null"),
+        isType("undefined"),
+        isType("number"),
+    ]), innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp, (value) => `(?:${value})`)), when(numberKind.has, (dataParser) => pipe(dataParser.definition.checkers, to({
+        int: innerPipe(find(checkerIntKind.has), when$1(checkerIntKind.has, justReturn(true))),
+    }), ({ int }) => {
+        if (int) {
+            return "(?:[0-9]+)";
+        }
+        return "(?:[0-9]+(\\.[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((element) => createTemplateLiteralPattern([element])), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, (dataParser) => pipe(dataParser.definition.checkers, to({
+        email: innerPipe(find(checkerEmailKind.has), when$1(checkerEmailKind.has, (checker) => pipe(checker.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, "")))),
+        min: innerPipe(find(checkerStringMinKind.has), when$1(checkerStringMinKind.has, (checker) => checker.definition.min)),
+        max: innerPipe(find(checkerStringMaxKind.has), when$1(checkerStringMaxKind.has, (checker) => checker.definition.max)),
+        regex: innerPipe(find(checkerStringRegexKind.has), when$1(checkerStringRegexKind.has, (checker) => pipe(checker.definition.regex.source, replace(/^\^/, ""), replace(/\$$/, "")))),
+    }), ({ email, regex, max, min }) => {
+        if (email) {
+            return email;
+        }
+        else if (regex) {
+            return regex;
+        }
+        else if (max !== undefined && min !== undefined) {
+            return `(?:[^]{${min},${max}})`;
+        }
+        else if (max !== undefined) {
+            return `(?:[^]{0,${max}})`;
+        }
+        else if (min !== undefined) {
+            return `(?:[^]{${min},})`;
+        }
+        return "(?:[^]*)";
+    })), innerPipe(when(templateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map((option) => createTemplateLiteralPattern([option])), join("|"), (pattern) => `(?:${pattern})`)), exhaustive))), join(""));
+}
+
+export { createTemplateLiteralPattern };

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var pipe = require('../../../common/pipe.cjs');
+require('../../../common/globalStore.cjs');
+require('../../../common/builder.cjs');
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+var kind = require('../../kind.cjs');
+var createTemplateLiteralPattern = require('./createTemplateLiteralPattern.cjs');
+
+const templateLiteralKind = kind.createDataParserKind("template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe.pipe(createTemplateLiteralPattern.createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
+    return base.dataParserInit(templateLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            template,
+            pattern,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "string" && self.definition.pattern.test(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+}
+
+exports.createTemplateLiteralPattern = createTemplateLiteralPattern.createTemplateLiteralPattern;
+exports.templateLiteral = templateLiteral;
+exports.templateLiteralKind = templateLiteralKind;

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

@@ -0,0 +1,66 @@
+import { type Adaptor, type AnyTuple, type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserCheckerStringMax, type DataParserCheckerStringMin, type DataParserCheckerStringRegex, type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "../string";
+import { type DataParserCheckerInt, type DataParserDefinitionNumber, type DataParserNumber } from "../number";
+import { type DataParserDefinitionBigInt, type DataParserBigInt } from "../bigint";
+import { type DataParserDefinitionLiteral, type DataParserLiteral } from "../literal";
+import { type DataParserDefinitionEmpty, type DataParserEmpty } from "../empty";
+import { type DataParserDefinitionNil, type DataParserNil } from "../nil";
+import { type DataParserDefinitionBoolean, type DataParserBoolean } from "../boolean";
+import { type CheckerRefineImplementation } from "../refine";
+import { type DataParserDefinitionUnion, type DataParserUnion } from "../union";
+import { type GetPropsWithValueExtends } from "../../../object";
+export * from "./createTemplateLiteralPattern";
+export type TemplateLiteralPrimitiveParts = (string | number | null | undefined | bigint | boolean);
+export type TemplateLiteralParts = (TemplateLiteralPrimitiveParts | DataParserString<Omit<DataParserDefinitionString, "checkers"> & {
+    readonly checkers: readonly (DataParserCheckerEmail | DataParserCheckerStringMax | DataParserCheckerStringMin | DataParserCheckerStringRegex)[];
+}> | DataParserNumber<Omit<DataParserDefinitionNumber, "checkers"> & {
+    readonly checkers: readonly DataParserCheckerInt[];
+}> | DataParserBigInt<Omit<DataParserDefinitionBigInt, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserBoolean<Omit<DataParserDefinitionBoolean, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserLiteral<Omit<DataParserDefinitionLiteral, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserEmpty<Omit<DataParserDefinitionEmpty, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserNil<Omit<DataParserDefinitionNil, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserTemplateLiteral<Omit<DataParserDefinitionTemplateLiteral, "checkers"> & {
+    readonly checkers: readonly [];
+}> | DataParserUnion<Omit<DataParserDefinitionUnion, "checkers" | "options"> & {
+    readonly options: AnyTuple<Exclude<TemplateLiteralParts, TemplateLiteralPrimitiveParts>>;
+    readonly checkers: readonly [];
+}>);
+export type TemplateLiteralShape = readonly [TemplateLiteralParts, ...TemplateLiteralParts[]];
+type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
+export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends TemplateLiteralParts,
+    ...infer InferredRest extends TemplateLiteralParts[]
+] ? (`${GenericLastResult}${InferredFirst extends TemplateLiteralPrimitiveParts ? InferredFirst extends bigint ? `${InferredFirst}n` : InferredFirst : Adaptor<Output<Exclude<InferredFirst, TemplateLiteralPrimitiveParts>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeOutput<InferredRest, InferredResult> : TemplateLiteralShapeOutput<[InferredRest[number]], InferredResult> : never : never;
+export type TemplateLiteralShapeInput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
+    infer InferredFirst extends TemplateLiteralParts,
+    ...infer InferredRest extends TemplateLiteralParts[]
+] ? (`${GenericLastResult}${InferredFirst extends TemplateLiteralPrimitiveParts ? InferredFirst extends bigint ? `${InferredFirst}n` : InferredFirst : Adaptor<Input<Exclude<InferredFirst, TemplateLiteralPrimitiveParts>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeInput<InferredRest, InferredResult> : TemplateLiteralShapeInput<[InferredRest[number]], InferredResult> : never : never;
+export interface DataParserTemplateLiteralCheckerCustom<GenericInput extends string = string> {
+}
+export type DataParserTemplateLiteralCheckers<GenericInput extends string = string> = (DataParserTemplateLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTemplateLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<DataParserTemplateLiteralCheckers> {
+    readonly template: TemplateLiteralShape;
+    readonly pattern: RegExp;
+}
+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> {
+    addChecker<GenericChecker extends readonly [
+        DataParserTemplateLiteralCheckers<Output<this>>,
+        ...DataParserTemplateLiteralCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserTemplateLiteralCheckers<Output<this>>,
+        ...DataParserTemplateLiteralCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTemplateLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+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, {}> & {
+    template: GenericTemplate;
+}>>;

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

@@ -0,0 +1,27 @@
+import { pipe } from '../../../common/pipe.mjs';
+import '../../../common/globalStore.mjs';
+import '../../../common/builder.mjs';
+import { dataParserInit } from '../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../error.mjs';
+import { createDataParserKind } from '../../kind.mjs';
+import { createTemplateLiteralPattern } from './createTemplateLiteralPattern.mjs';
+
+const templateLiteralKind = createDataParserKind("template-literal");
+function templateLiteral(template, definition) {
+    const pattern = pipe(createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
+    return dataParserInit(templateLiteralKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            template,
+            pattern,
+        },
+    }, (data, _error, self) => {
+        if (typeof data === "string" && self.definition.pattern.test(data)) {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+}
+
+export { createTemplateLiteralPattern, templateLiteral, templateLiteralKind };

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

@@ -1,14 +1,26 @@
-import { type Kind, type NeverCoalescing } from "../../common";
-import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type DataParserError, type SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from "../../dataParser/error";
-export interface DataParserDefinitionTransform extends DataParserDefinition<never> {
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserTransformCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserTransformCheckers<GenericInput extends unknown = unknown> = (DataParserTransformCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTransformCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionTransform extends DataParserDefinition<DataParserTransformCheckers> {
     readonly inner: DataParser;
     theFunction(input: any, error: DataParserError): unknown;
 }
 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> {
+    addChecker<GenericChecker extends readonly [
+        DataParserTransformCheckers<Output<this>>,
+        ...DataParserTransformCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserTransformCheckers<Output<this>>,
+        ...DataParserTransformCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTransform<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 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;

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

@@ -1,7 +1,9 @@
-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 UnionContain, type IsEqual, type Kind, type Adaptor, type NeverCoalescing, type FixDeepFunctionInfer, type AnyTuple } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type DataParserCheckerArrayMax, type DataParserCheckerArrayMin } from "./array";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
 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,
@@ -17,7 +19,9 @@ export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRe
     Input<InferredFirst>,
     ...(InferredRest extends TupleShape ? DataParserTupleShapeOutput<InferredRest, GenericRest> : UnionContain<GenericRest, undefined> extends true ? [] : Input<Adaptor<GenericRest, DataParser>>[])
 ] : never;
-export type DataParserTupleCheckers = (DataParserCheckerArrayMin | DataParserCheckerArrayMax);
+export interface DataParserTupleCheckerCustom<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> {
+}
+export type DataParserTupleCheckers<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> = (DataParserTupleCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTupleCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
 export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers> {
     readonly shape: TupleShape;
     readonly rest?: DataParser;
@@ -25,7 +29,13 @@ export interface DataParserDefinitionTuple extends DataParserDefinition<DataPars
 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>>;
+    addChecker<GenericChecker extends readonly [
+        DataParserTupleCheckers<Output<this>>,
+        ...DataParserTupleCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserTupleCheckers<Output<this>>,
+        ...DataParserTupleCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserTuple<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function tuple<GenericShape extends TupleShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;

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

@@ -1,13 +1,25 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
 export type UnionOptions = readonly [DataParser, ...DataParser[]];
-export interface DataParserDefinitionUnion extends DataParserDefinition<never> {
+export interface DataParserUnionCheckerCustom<GenericInput extends unknown = unknown> {
+}
+export type DataParserUnionCheckers<GenericInput extends unknown = unknown> = (DataParserUnionCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserUnionCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionUnion extends DataParserDefinition<DataParserUnionCheckers> {
     readonly options: UnionOptions;
 }
 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> {
+    addChecker<GenericChecker extends readonly [
+        DataParserUnionCheckers<Output<this>>,
+        ...DataParserUnionCheckers<Output<this>>[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserUnionCheckers<Output<this>>,
+        ...DataParserUnionCheckers<Output<this>>[]
+    ], GenericChecker>): DataParserUnion<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
     options: GenericOptions;

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

@@ -1,11 +1,23 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-export interface DataParserDefinitionUnknown extends DataParserDefinition<never> {
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+export interface DataParserUnknownCheckerCustom {
+}
+export type DataParserUnknownCheckers = (DataParserUnknownCheckerCustom[GetPropsWithValueExtends<DataParserUnknownCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<unknown>);
+export interface DataParserDefinitionUnknown extends DataParserDefinition<DataParserUnknownCheckers> {
 }
 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> {
+    addChecker<GenericChecker extends readonly [
+        DataParserUnknownCheckers,
+        ...DataParserUnknownCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserUnknownCheckers,
+        ...DataParserUnknownCheckers[]
+    ], GenericChecker>): DataParserUnknown<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function unknown<const GenericDefinition extends Partial<DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
 export {};

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

@@ -4,4 +4,4 @@ import type * as AllDataParser from "../parsers";
 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);
+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 | AllDataParser.DataParserCheckerRefine);

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

@@ -6,8 +6,8 @@ import { type DataParserExtended } from "../baseExtended";
 export interface DataParserCustom {
     base: DataParser;
 }
-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 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 | AllDataParser.DataParserRecover);
 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);
+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 | AllDataParserExtended.DataParserRecoverExtended);

package/dist/either/bool/falsy.cjs

@@ -3,9 +3,9 @@
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
+var create$1 = require('./create.cjs');
 var kind = require('../kind.cjs');
 var base = require('./base.cjs');
-var create$1 = require('./create.cjs');
 var create = require('../left/create.cjs');
 var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');

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

@@ -13,6 +13,6 @@ export declare function boolFalsy<const GenericValue extends BoolFalsyValue = un
 type Either = EitherRight | EitherLeft;
 export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
 export {};

package/dist/either/bool/falsy.mjs

@@ -1,9 +1,9 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
+import { bool } from './create.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { eitherBoolKind } from './base.mjs';
-import { bool } from './create.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';

package/dist/either/bool/truthy.cjs

@@ -3,12 +3,12 @@
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
-var base = require('./base.cjs');
+var create$1 = require('./create.cjs');
 var kind = require('../kind.cjs');
+var base = require('./base.cjs');
 var is$1 = require('../left/is.cjs');
 var create = require('../right/create.cjs');
 var is = require('../right/is.cjs');
-var create$1 = require('./create.cjs');
 
 const eitherBoolTruthyKind = kind.createEitherKind("bool-truthy");
 function boolTruthy(value) {

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

@@ -12,6 +12,6 @@ export declare function boolTruthy<const GenericValue extends unknown>(value: Ge
 type Either = EitherRight | EitherLeft;
 export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
 export {};

package/dist/either/bool/truthy.mjs

@@ -1,12 +1,12 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { eitherBoolKind } from './base.mjs';
+import { bool } from './create.mjs';
 import { createEitherKind } from '../kind.mjs';
+import { eitherBoolKind } from './base.mjs';
 import { isLeft } from '../left/is.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
-import { bool } from './create.mjs';
 
 const eitherBoolTruthyKind = createEitherKind("bool-truthy");
 function boolTruthy(value) {

package/dist/either/future/create.cjs

@@ -2,10 +2,10 @@
 
 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');
 var is = require('../right/is.cjs');
+var is$1 = require('../left/is.cjs');
 
 const kind = "kind-future-either";
 class Future extends Promise {

package/dist/either/future/create.mjs

@@ -1,9 +1,9 @@
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { isLeft } from '../left/is.mjs';
 import { futureSuccess } from './success.mjs';
 import { futureError } from './error.mjs';
 import { isRight } from '../right/is.mjs';
+import { isLeft } from '../left/is.mjs';
 
 const kind = "kind-future-either";
 class Future extends Promise {

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

@@ -1,4 +1,4 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherLeft } from "./create";
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherLeft> | GenericOutput;
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;

package/dist/either/nullable/empty.cjs

@@ -3,8 +3,8 @@
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
-var create = require('../left/create.cjs');
 var kind = require('../kind.cjs');
+var create = require('../left/create.cjs');
 var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var create$1 = require('./create.cjs');

package/dist/either/nullable/empty.d.ts

@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function nullableEmpty(): EitherNullableEmpty;
 export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
-export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
-export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableEmpty>;
 export {};

package/dist/either/nullable/empty.mjs

@@ -1,8 +1,8 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { left } from '../left/create.mjs';
 import { createEitherKind } from '../kind.mjs';
+import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { nullable } from './create.mjs';

package/dist/either/nullable/filled.d.ts

@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullableFilled<GenericValue>;
 export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableFilled>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
-export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>;
-export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
 export {};

package/dist/either/nullish/empty.d.ts

@@ -13,6 +13,6 @@ export declare function nullishEmpty<const GenericValue extends NullishValue = u
 type Either = EitherRight | EitherLeft;
 export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishEmpty>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>;
-export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
 export {};

package/dist/either/nullish/filled.cjs

@@ -5,10 +5,10 @@ var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
-var create = require('../right/create.cjs');
-var is = require('../right/is.cjs');
 var create$1 = require('./create.cjs');
 var base = require('./base.cjs');
+var create = require('../right/create.cjs');
+var is = require('../right/is.cjs');
 
 const eitherNullishFilledKind = kind.createEitherKind("nullish-filled");
 function nullishFilled(value) {

package/dist/either/nullish/filled.d.ts

@@ -12,6 +12,6 @@ export declare function nullishFilled<const GenericValue extends unknown>(value:
 type Either = EitherRight | EitherLeft;
 export declare function isNullishFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishFilled>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
-export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>;
-export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherNullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
 export {};

package/dist/either/nullish/filled.mjs

@@ -3,10 +3,10 @@ import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { right } from '../right/create.mjs';
-import { isRight } from '../right/is.mjs';
 import { nullish } from './create.mjs';
 import { eitherNullishKind } from './base.mjs';
+import { right } from '../right/create.mjs';
+import { isRight } from '../right/is.mjs';
 
 const eitherNullishFilledKind = createEitherKind("nullish-filled");
 function nullishFilled(value) {

package/dist/either/optional/empty.d.ts

@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function optionalEmpty(): EitherOptionalEmpty;
 export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalEmpty>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
-export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>;
-export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
 export {};