@duplojs/utils 1.0.7 → 1.1.7

package/dist/dataParser/parsers/tuple.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserTupleKind = kind.createKind("data-parser-tuple");
+function tuple(shape, definition) {
+    return base.dataParserInit(dataParserTupleKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            rest: definition?.rest,
+            shape,
+        },
+    }, {
+        sync: (data, error$1, self) => {
+            if (!(data instanceof Array)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error$1.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                const result = self.definition.shape[index]?.exec(data[index], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                    const result = self.definition.rest.exec(data[index], error$1);
+                    if (result === base.SymbolDataParserError) {
+                        output = base.SymbolDataParserError;
+                    }
+                    else if (output !== base.SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+        async: async (data, error$1, self) => {
+            if (!(data instanceof Array)) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            let output = [];
+            const currentIndexPath = error$1.currentPath.length;
+            for (let index = 0; index < self.definition.shape.length; index++) {
+                error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                const result = await self.definition.shape[index]?.asyncExec(data[index], error$1);
+                if (result === base.SymbolDataParserError) {
+                    output = base.SymbolDataParserError;
+                }
+                else if (output !== base.SymbolDataParserError) {
+                    output.push(result);
+                }
+            }
+            if (self.definition?.rest) {
+                for (let index = self.definition.shape.length; index < data.length; index++) {
+                    error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
+                    const result = await self.definition.rest.asyncExec(data[index], error$1);
+                    if (result === base.SymbolDataParserError) {
+                        output = base.SymbolDataParserError;
+                    }
+                    else if (output !== base.SymbolDataParserError) {
+                        output.push(result);
+                    }
+                }
+            }
+            error.popErrorPath(error$1);
+            return output;
+        },
+    });
+}
+
+exports.dataParserTupleKind = dataParserTupleKind;
+exports.tuple = tuple;

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<"data-parser-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 { createKind } from '../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+
+const dataParserTupleKind = createKind("data-parser-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 kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+
+const dataParserUnionKind = kind.createKind("data-parser-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<"data-parser-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 { createKind } from '../../common/kind.mjs';
+import { dataParserInit, SymbolDataParserError } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+
+const dataParserUnionKind = createKind("data-parser-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 kind = require('../../common/kind.cjs');
+var base = require('../base.cjs');
+
+const dataParserUnknownKind = kind.createKind("data-parser-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<"data-parser-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 { createKind } from '../../common/kind.mjs';
+import { dataParserInit } from '../base.mjs';
+
+const dataParserUnknownKind = createKind("data-parser-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/falsy.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherBoolFalsyKind = kind.createKind("either-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.mjs

@@ -8,7 +8,7 @@ import { eitherBoolKind } from './base.mjs';
 
 const eitherBoolFalsyKind = createKind("either-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

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherBoolTruthyKind = kind.createKind("either-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.mjs

@@ -8,7 +8,7 @@ import { eitherBoolKind } from './base.mjs';
 
 const eitherBoolTruthyKind = createKind("either-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/error.cjs

@@ -6,7 +6,7 @@ var base = require('./base.cjs');
 
 const eitherFutureErrorKind = kind.createKind("either-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.mjs

@@ -4,7 +4,7 @@ import { eitherFutureKind } from './base.mjs';
 
 const eitherFutureErrorKind = createKind("either-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

@@ -6,7 +6,7 @@ var create = require('../right/create.cjs');
 
 const eitherFutureSuccessKind = kind.createKind("either-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.mjs

@@ -4,7 +4,7 @@ import { right } from '../right/create.mjs';
 
 const eitherFutureSuccessKind = createKind("either-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/left/create.cjs

@@ -6,7 +6,7 @@ var base = require('../base.cjs');
 
 const eitherLeftKind = kind.createKind("either-left");
 function left(information, value = undefined) {
-    return eitherLeftKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+    return eitherLeftKind.setTo(base.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherLeftKind = eitherLeftKind;

package/dist/either/left/create.mjs

@@ -4,7 +4,7 @@ import { eitherInformationKind } from '../base.mjs';
 
 const eitherLeftKind = createKind("either-left");
 function left(information, value = undefined) {
-    return eitherLeftKind.addTo(eitherInformationKind.addTo(wrapValue(value), information));
+    return eitherLeftKind.setTo(eitherInformationKind.setTo(wrapValue(value), information));
 }
 
 export { eitherLeftKind, left };

package/dist/either/left/error.cjs

@@ -5,7 +5,7 @@ var create = require('./create.cjs');
 
 const eitherErrorKind = kind.createKind("either-error");
 function error(value) {
-    return eitherErrorKind.addTo(create.left("error", value));
+    return eitherErrorKind.setTo(create.left("error", value));
 }
 
 exports.eitherErrorKind = eitherErrorKind;

package/dist/either/left/error.mjs

@@ -3,7 +3,7 @@ import { left } from './create.mjs';
 
 const eitherErrorKind = createKind("either-error");
 function error(value) {
-    return eitherErrorKind.addTo(left("error", value));
+    return eitherErrorKind.setTo(left("error", value));
 }
 
 export { eitherErrorKind, error };

package/dist/either/left/fail.cjs

@@ -5,7 +5,7 @@ var create = require('./create.cjs');
 
 const eitherFailKind = kind.createKind("either-fail");
 function fail() {
-    return eitherFailKind.addTo(create.left("fail", undefined));
+    return eitherFailKind.setTo(create.left("fail", undefined));
 }
 
 exports.eitherFailKind = eitherFailKind;

package/dist/either/left/fail.mjs

@@ -3,7 +3,7 @@ import { left } from './create.mjs';
 
 const eitherFailKind = createKind("either-fail");
 function fail() {
-    return eitherFailKind.addTo(left("fail", undefined));
+    return eitherFailKind.setTo(left("fail", undefined));
 }
 
 export { eitherFailKind, fail };

package/dist/either/nullable/empty.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullableEmptyKind = kind.createKind("either-nullable-empty");
 function nullableEmpty() {
-    return base.eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(create.left("nullable", null)));
+    return base.eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(create.left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return is.isLeft(input)

package/dist/either/nullable/empty.mjs

@@ -8,7 +8,7 @@ import { eitherNullableKind } from './base.mjs';
 
 const eitherNullableEmptyKind = createKind("either-nullable-empty");
 function nullableEmpty() {
-    return eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(left("nullable", null)));
+    return eitherNullableKind.setTo(eitherNullableEmptyKind.setTo(left("nullable", null)));
 }
 function isNullableEmpty(input) {
     return isLeft(input)

package/dist/either/nullable/filled.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullableFilledKind = kind.createKind("either-nullable-filled");
 function nullableFilled(value) {
-    return base.eitherNullableKind.addTo(eitherNullableFilledKind.addTo(create.right("nullable", value)));
+    return base.eitherNullableKind.setTo(eitherNullableFilledKind.setTo(create.right("nullable", value)));
 }
 function isNullableFilled(input) {
     return is.isRight(input)

package/dist/either/nullable/filled.mjs

@@ -8,7 +8,7 @@ import { eitherNullableKind } from './base.mjs';
 
 const eitherNullableFilledKind = createKind("either-nullable-filled");
 function nullableFilled(value) {
-    return eitherNullableKind.addTo(eitherNullableFilledKind.addTo(right("nullable", value)));
+    return eitherNullableKind.setTo(eitherNullableFilledKind.setTo(right("nullable", value)));
 }
 function isNullableFilled(input) {
     return isRight(input)

package/dist/either/nullish/empty.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullishEmptyKind = kind.createKind("either-nullish-empty");
 function nullishEmpty(value = undefined) {
-    return base.eitherNullishKind.addTo(eitherNullishEmptyKind.addTo(create.left("nullish", value)));
+    return base.eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(create.left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return is.isLeft(input)

package/dist/either/nullish/empty.mjs

@@ -8,7 +8,7 @@ import { eitherNullishKind } from './base.mjs';
 
 const eitherNullishEmptyKind = createKind("either-nullish-empty");
 function nullishEmpty(value = undefined) {
-    return eitherNullishKind.addTo(eitherNullishEmptyKind.addTo(left("nullish", value)));
+    return eitherNullishKind.setTo(eitherNullishEmptyKind.setTo(left("nullish", value)));
 }
 function isNullishEmpty(input) {
     return isLeft(input)

package/dist/either/nullish/filled.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherNullishFilledKind = kind.createKind("either-nullish-filled");
 function nullishFilled(value) {
-    return base.eitherNullishKind.addTo(eitherNullishFilledKind.addTo(create.right("nullish", value)));
+    return base.eitherNullishKind.setTo(eitherNullishFilledKind.setTo(create.right("nullish", value)));
 }
 function isNullishFilled(input) {
     return is.isRight(input)

package/dist/either/nullish/filled.mjs

@@ -8,7 +8,7 @@ import { eitherNullishKind } from './base.mjs';
 
 const eitherNullishFilledKind = createKind("either-nullish-filled");
 function nullishFilled(value) {
-    return eitherNullishKind.addTo(eitherNullishFilledKind.addTo(right("nullish", value)));
+    return eitherNullishKind.setTo(eitherNullishFilledKind.setTo(right("nullish", value)));
 }
 function isNullishFilled(input) {
     return isRight(input)

package/dist/either/optional/empty.cjs

@@ -9,7 +9,7 @@ var base = require('./base.cjs');
 
 const eitherOptionalEmptyKind = kind.createKind("either-optional-empty");
 function optionalEmpty() {
-    return base.eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(create.left("optional", undefined)));
+    return base.eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(create.left("optional", undefined)));
 }
 function isOptionalEmpty(input) {
     return is.isLeft(input)

package/dist/either/optional/empty.mjs

@@ -7,7 +7,7 @@ import { eitherOptionalKind } from './base.mjs';
 
 const eitherOptionalEmptyKind = createKind("either-optional-empty");
 function optionalEmpty() {
-    return eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(left("optional", undefined)));
+    return eitherOptionalKind.setTo(eitherOptionalEmptyKind.setTo(left("optional", undefined)));
 }
 function isOptionalEmpty(input) {
     return isLeft(input)

package/dist/either/optional/filled.cjs

@@ -10,7 +10,7 @@ var base = require('./base.cjs');
 
 const eitherOptionalFilledKind = kind.createKind("either-optional-filled");
 function optionalFilled(value) {
-    return base.eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(create.right("optional", value)));
+    return base.eitherOptionalKind.setTo(eitherOptionalFilledKind.setTo(create.right("optional", value)));
 }
 function isOptionalFilled(input) {
     return is.isRight(input)