@duplojs/utils 1.0.7 → 1.1.8

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

@@ -0,0 +1,33 @@
+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 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[]
+] ? [
+    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[]
+] ? [
+    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 DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers> {
+    readonly shape: TupleShape;
+    readonly rest?: DataParsers;
+}
+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 interface DataParserTuple<GenericDefinition extends DataParserDefinitionTuple = DataParserDefinitionTuple> extends _DataParserTuple<GenericDefinition> {
+    addChecker<GenericChecker extends [DataParserTupleCheckers, ...DataParserTupleCheckers[]]>(...args: 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;
+}>>;
+export {};

package/dist/dataParser/parsers/tuple.mjs

@@ -0,0 +1,80 @@
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserTupleKind = createDataParserKind("tuple");
+function tuple(shape, definition) {
+    return dataParserInit(dataParserTupleKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            rest: definition?.rest,
+            shape,
+        },
+    }, {
+        sync: (data, error, self) => {
+            if (!(data instanceof Array)) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                setErrorPath(error, `[${index}]`, currentIndexPath);
+                const result = self.definition.shape[index]?.exec(data[index], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    setErrorPath(error, `[${index}]`, currentIndexPath);
+                    const result = self.definition.rest.exec(data[index], error);
+                    if (result === SymbolDataParserError) {
+                        output = SymbolDataParserError;
+                    }
+                    else if (output !== SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+        async: async (data, error, self) => {
+            if (!(data instanceof Array)) {
+                return SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                setErrorPath(error, `[${index}]`, currentIndexPath);
+                const result = await self.definition.shape[index]?.asyncExec(data[index], error);
+                if (result === SymbolDataParserError) {
+                    output = SymbolDataParserError;
+                }
+                else if (output !== SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition?.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    setErrorPath(error, `[${index}]`, currentIndexPath);
+                    const result = await self.definition.rest.asyncExec(data[index], error);
+                    if (result === SymbolDataParserError) {
+                        output = SymbolDataParserError;
+                    }
+                    else if (output !== SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            popErrorPath(error);
+            return output;
+        },
+    });
+}
+
+export { dataParserTupleKind, tuple };

package/dist/dataParser/parsers/union.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+var kind = require('../kind.cjs');
+
+const dataParserUnionKind = kind.createDataParserKind("union");
+function union(options, definition) {
+    return base.dataParserInit(dataParserUnionKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            options,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = dataParser.exec(data, error$1);
+                if (result !== base.SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return error.SymbolDataParserErrorIssue;
+        },
+        async: async (data, error$1, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = await dataParser.asyncExec(data, error$1);
+                if (result !== base.SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return error.SymbolDataParserErrorIssue;
+        },
+    });
+}
+
+exports.dataParserUnionKind = dataParserUnionKind;
+exports.union = union;

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

@@ -0,0 +1,15 @@
+import { type NeverCoalescing, type Kind } from "../../common";
+import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
+import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
+export type UnionOptions = readonly [DataParsers, ...DataParsers[]];
+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 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, {}> & {
+    options: GenericOptions;
+}>>;
+export {};

package/dist/dataParser/parsers/union.mjs

@@ -0,0 +1,35 @@
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+
+const dataParserUnionKind = createDataParserKind("union");
+function union(options, definition) {
+    return dataParserInit(dataParserUnionKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            options,
+        },
+    }, {
+        sync: (data, error, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = dataParser.exec(data, error);
+                if (result !== SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return SymbolDataParserErrorIssue;
+        },
+        async: async (data, error, self) => {
+            for (const dataParser of self.definition.options) {
+                const result = await dataParser.asyncExec(data, error);
+                if (result !== SymbolDataParserError) {
+                    return result;
+                }
+            }
+            return SymbolDataParserErrorIssue;
+        },
+    });
+}
+
+export { dataParserUnionKind, union };

package/dist/dataParser/parsers/unknown.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var base = require('../base.cjs');
+var kind = require('../kind.cjs');
+
+const dataParserUnknownKind = kind.createDataParserKind("unknown");
+function unknown(definition) {
+    return base.dataParserInit(dataParserUnknownKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+        },
+    }, (data) => data);
+}
+
+exports.dataParserUnknownKind = dataParserUnknownKind;
+exports.unknown = unknown;

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

@@ -0,0 +1,11 @@
+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> {
+}
+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 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, {}>>>;
+export {};

package/dist/dataParser/parsers/unknown.mjs

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

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

@@ -0,0 +1,5 @@
+import { type AnyTuple, type SimplifyTopLevel } from "../../common";
+import { type DataParserChecker, type DataParserDefinition } from "../base";
+export type AddCheckersToDefinition<GenericDefinition extends DataParserDefinition, GenericChecker extends readonly [DataParserChecker, ...DataParserChecker[]]> = SimplifyTopLevel<Omit<GenericDefinition, "checkers"> & {
+    readonly checkers: GenericDefinition["checkers"] extends AnyTuple ? readonly [...GenericDefinition["checkers"], ...GenericChecker] : GenericChecker;
+}>;

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

@@ -0,0 +1,3 @@
+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);

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

@@ -0,0 +1,5 @@
+import { type DataParser } from "../base";
+import type * as AllDataParser from "../parsers";
+export interface DataParserCustom {
+}
+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);

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

@@ -0,0 +1,4 @@
+export * from "./mergeDefinition";
+export * from "./dataParsers";
+export * from "./checkers";
+export * from "./addCheckersToDefinition";

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

@@ -0,0 +1,5 @@
+import { type UnionContain, type SimplifyTopLevel } from "../../common";
+import { type DataParserCheckerDefinition, type DataParserDefinition } from "../base";
+export type MergeDefinition<GenericDefinition extends DataParserDefinition | DataParserCheckerDefinition, GenericPartialDefinition extends Partial<GenericDefinition>> = SimplifyTopLevel<Readonly<GenericPartialDefinition & Omit<GenericDefinition, keyof GenericPartialDefinition | "checkers"> & (UnionContain<keyof GenericPartialDefinition, "checkers"> extends true ? {} : {
+    checkers: readonly [];
+})>> extends infer InferredResult extends GenericDefinition ? InferredResult : never;

package/dist/either/bool/base.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
+var kind = require('../kind.cjs');
 
-const eitherBoolKind = kind.createKind("either-bool");
+const eitherBoolKind = kind.createEitherKind("bool");
 
 exports.eitherBoolKind = eitherBoolKind;

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

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

package/dist/either/bool/base.mjs

@@ -1,5 +1,5 @@
-import { createKind } from '../../common/kind.mjs';
+import { createEitherKind } from '../kind.mjs';
 
-const eitherBoolKind = createKind("either-bool");
+const eitherBoolKind = createEitherKind("bool");
 
 export { eitherBoolKind };

package/dist/either/bool/falsy.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var unwrap = require('../../common/unwrap.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');
-var create$1 = require('./create.cjs');
-var base = require('./base.cjs');
 
-const eitherBoolFalsyKind = kind.createKind("either-bool-falsy");
+const eitherBoolFalsyKind = kind.createEitherKind("bool-falsy");
 function boolFalsy(value = undefined) {
-    return base.eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(create.left("bool", value)));
+    return base.eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(create.left("bool", value)));
 }
 function isBoolFalsy(input) {
     return is.isLeft(input)

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

@@ -1,11 +1,11 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
-import { bool } from "./create";
 import { type Kind } from "../../common/kind";
 import { eitherBoolKind } from "./base";
+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<"@Either/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,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
 import { unwrap } from '../../common/unwrap.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';
-import { bool } from './create.mjs';
-import { eitherBoolKind } from './base.mjs';
 
-const eitherBoolFalsyKind = createKind("either-bool-falsy");
+const eitherBoolFalsyKind = createEitherKind("bool-falsy");
 function boolFalsy(value = undefined) {
-    return eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(left("bool", value)));
+    return eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(left("bool", value)));
 }
 function isBoolFalsy(input) {
     return isLeft(input)

package/dist/either/bool/truthy.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var unwrap = require('../../common/unwrap.cjs');
+var base = require('./base.cjs');
+var kind = require('../kind.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');
-var base = require('./base.cjs');
 
-const eitherBoolTruthyKind = kind.createKind("either-bool-truthy");
+const eitherBoolTruthyKind = kind.createEitherKind("bool-truthy");
 function boolTruthy(value) {
-    return base.eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(create.right("bool", value)));
+    return base.eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(create.right("bool", value)));
 }
 function isBoolTruthy(input) {
     return is.isRight(input)

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

@@ -1,10 +1,10 @@
-import { type EitherRight } from "../right";
-import { bool } from "./create";
-import { type EitherLeft } from "../left";
-import { type Kind } from "../../common/kind";
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
+import { type Kind } from "../../common/kind";
 import { eitherBoolKind } from "./base";
-export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-truthy", unknown>>;
+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>>;
 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,14 +1,14 @@
-import { createKind } from '../../common/kind.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
+import { eitherBoolKind } from './base.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { isLeft } from '../left/is.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
 import { bool } from './create.mjs';
-import { eitherBoolKind } from './base.mjs';
 
-const eitherBoolTruthyKind = createKind("either-bool-truthy");
+const eitherBoolTruthyKind = createEitherKind("bool-truthy");
 function boolTruthy(value) {
-    return eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(right("bool", value)));
+    return eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(right("bool", value)));
 }
 function isBoolTruthy(input) {
     return isRight(input)

package/dist/either/future/base.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
+var kind = require('../kind.cjs');
 
-const eitherFutureKind = kind.createKind("either-future");
+const eitherFutureKind = kind.createEitherKind("future");
 
 exports.eitherFutureKind = eitherFutureKind;

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

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

package/dist/either/future/base.mjs

@@ -1,5 +1,5 @@
-import { createKind } from '../../common/kind.mjs';
+import { createEitherKind } from '../kind.mjs';
 
-const eitherFutureKind = createKind("either-future");
+const eitherFutureKind = createEitherKind("future");
 
 export { eitherFutureKind };

package/dist/either/future/error.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var create = require('../left/create.cjs');
+var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 
-const eitherFutureErrorKind = kind.createKind("either-future-error");
+const eitherFutureErrorKind = kind.createEitherKind("future-error");
 function futureError(value) {
-    return base.eitherFutureKind.addTo(eitherFutureErrorKind.addTo(create.left("future", value)));
+    return base.eitherFutureKind.setTo(eitherFutureErrorKind.setTo(create.left("future", value)));
 }
 
 exports.eitherFutureErrorKind = eitherFutureErrorKind;

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<"@Either/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,10 +1,10 @@
-import { createKind } from '../../common/kind.mjs';
 import { left } from '../left/create.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { eitherFutureKind } from './base.mjs';
 
-const eitherFutureErrorKind = createKind("either-future-error");
+const eitherFutureErrorKind = createEitherKind("future-error");
 function futureError(value) {
-    return eitherFutureKind.addTo(eitherFutureErrorKind.addTo(left("future", value)));
+    return eitherFutureKind.setTo(eitherFutureErrorKind.setTo(left("future", value)));
 }
 
 export { eitherFutureErrorKind, futureError };

package/dist/either/future/success.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
+var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 var create = require('../right/create.cjs');
 
-const eitherFutureSuccessKind = kind.createKind("either-future-success");
+const eitherFutureSuccessKind = kind.createEitherKind("future-success");
 function futureSuccess(value) {
-    return base.eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(create.right("future", value)));
+    return base.eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(create.right("future", value)));
 }
 
 exports.eitherFutureSuccessKind = eitherFutureSuccessKind;

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

@@ -1,7 +1,7 @@
-import { type EitherRight } from "../right";
 import { type Kind } from "../../common/kind";
 import { eitherFutureKind } from "./base";
-export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-future-success", unknown>>;
+import { type EitherRight } from "../right";
+export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/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,10 +1,10 @@
-import { createKind } from '../../common/kind.mjs';
+import { createEitherKind } from '../kind.mjs';
 import { eitherFutureKind } from './base.mjs';
 import { right } from '../right/create.mjs';
 
-const eitherFutureSuccessKind = createKind("either-future-success");
+const eitherFutureSuccessKind = createEitherKind("future-success");
 function futureSuccess(value) {
-    return eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(right("future", value)));
+    return eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(right("future", value)));
 }
 
 export { eitherFutureSuccessKind, futureSuccess };

package/dist/either/hasInformation.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var base = require('./base.cjs');
+var kind = require('./kind.cjs');
 
 function hasInformation(input, information) {
-    return base.eitherInformationKind.has(input)
-        && base.eitherInformationKind.getValue(input) === information;
+    return kind.eitherInformationKind.has(input)
+        && kind.eitherInformationKind.getValue(input) === information;
 }
 
 exports.hasInformation = hasInformation;

package/dist/either/hasInformation.d.ts

@@ -1,7 +1,7 @@
 import { type Kind } from "../common";
 import { type EitherLeft } from "./left";
 import { type EitherRight } from "./right";
-import { eitherInformationKind } from "./base";
+import { eitherInformationKind } from "./kind";
 type Either = EitherRight | EitherLeft;
 export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
 export {};

package/dist/either/hasInformation.mjs

@@ -1,4 +1,4 @@
-import { eitherInformationKind } from './base.mjs';
+import { eitherInformationKind } from './kind.mjs';
 
 function hasInformation(input, information) {
     return eitherInformationKind.has(input)

package/dist/either/index.cjs

@@ -34,7 +34,7 @@ var success$1 = require('./right/success.cjs');
 var when$1 = require('./right/when.cjs');
 var hasInformation = require('./hasInformation.cjs');
 var whenHasInformation = require('./whenHasInformation.cjs');
-var base$5 = require('./base.cjs');
+var kind = require('./kind.cjs');
 
 
 
@@ -105,4 +105,5 @@ exports.success = success$1.success;
 exports.whenIsRight = when$1.whenIsRight;
 exports.hasInformation = hasInformation.hasInformation;
 exports.whenHasInformation = whenHasInformation.whenHasInformation;
-exports.eitherInformationKind = base$5.eitherInformationKind;
+exports.createEitherKind = kind.createEitherKind;
+exports.eitherInformationKind = kind.eitherInformationKind;

package/dist/either/index.d.ts

@@ -7,4 +7,4 @@ export * from "./optional";
 export * from "./right";
 export * from "./hasInformation";
 export * from "./whenHasInformation";
-export * from "./base";
+export * from "./kind";

package/dist/either/index.mjs

@@ -32,4 +32,4 @@ export { eitherSuccessKind, success } from './right/success.mjs';
 export { whenIsRight } from './right/when.mjs';
 export { hasInformation } from './hasInformation.mjs';
 export { whenHasInformation } from './whenHasInformation.mjs';
-export { eitherInformationKind } from './base.mjs';
+export { createEitherKind, eitherInformationKind } from './kind.mjs';

package/dist/either/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const createEitherKind = kind.createKindNamespace("Either");
+const eitherInformationKind = createEitherKind("information");
+
+exports.createEitherKind = createEitherKind;
+exports.eitherInformationKind = eitherInformationKind;

package/dist/either/kind.d.ts

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