@duplojs/utils 1.1.7 → 1.1.8

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

@@ -1,10 +1,10 @@
 'use strict';
 
-var kind = require('../../../common/kind.cjs');
 var base = require('../../base.cjs');
 var error = require('../../error.cjs');
+var kind = require('../../kind.cjs');
 
-const dataParserStringKind = kind.createKind("data-parser-string");
+const dataParserStringKind = kind.createDataParserKind("string");
 function string(definition) {
     return base.dataParserInit(dataParserStringKind, {
         definition: {

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

@@ -7,7 +7,7 @@ export type DataParserStringCheckers = (DataParserCheckerUrl | DataParserChecker
 export interface DataParserDefinitionString extends DataParserDefinition<DataParserStringCheckers> {
     readonly coerce: boolean;
 }
-export declare const dataParserStringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"data-parser-string", unknown>>;
+export declare const dataParserStringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DataParser/string", unknown>>;
 type _DataParserString<GenericDefinition extends DataParserDefinitionString> = (DataParser<GenericDefinition, string, string> & Kind<typeof dataParserStringKind.definition>);
 export interface DataParserString<GenericDefinition extends DataParserDefinitionString = DataParserDefinitionString> extends _DataParserString<GenericDefinition> {
     addChecker<GenericChecker extends readonly [

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

@@ -1,8 +1,8 @@
-import { createKind } from '../../../common/kind.mjs';
 import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
+import { createDataParserKind } from '../../kind.mjs';
 
-const dataParserStringKind = createKind("data-parser-string");
+const dataParserStringKind = createDataParserKind("string");
 function string(definition) {
     return dataParserInit(dataParserStringKind, {
         definition: {

package/dist/dataParser/parsers/templateLiteral.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var escapeRegExp = require('../../common/escapeRegExp.cjs');
-var kind = require('../../common/kind.cjs');
 var pipe = require('../../common/pipe.cjs');
 var innerPipe = require('../../common/innerPipe.cjs');
 var when$1 = require('../../common/when.cjs');
@@ -22,8 +21,9 @@ var literal = require('./literal.cjs');
 var empty = require('./empty.cjs');
 var nil = require('./nil.cjs');
 var boolean = require('./boolean.cjs');
+var kind = require('../kind.cjs');
 
-const dataParserTemplateLiteralKind = kind.createKind("data-parser-template-literal");
+const dataParserTemplateLiteralKind = kind.createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
     const pattern = pipe.pipe(template, map.map(innerPipe.innerPipe(when.when(isType.isType("string"), (value) => `(?:${escapeRegExp.escapeRegExp(value)})`), when.when(index$2.dataParserNumberKind.has, () => "(:?[0-9]+)"), when.when(index$1.dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.dataParserBooleanKind.has, () => "(?:true|false)"), when.when(nil.dataParserNilKind.has, () => "(?:null)"), when.when(empty.dataParserEmptyKind.has, () => "(?:undefined)"), when.when(literal.dataParserLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp)), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index.dataParserStringKind.has, innerPipe.innerPipe(whenElse.whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe.pipe(dataParser.definition.checkers, map.map((element) => pipe.pipe(element.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""))), join.join("")), () => "(?:[^]*)"))), when.when(dataParserTemplateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive)), join.join(""), (pattern) => new RegExp(`^${pattern}$`));
     return base.dataParserInit(dataParserTemplateLiteralKind, {

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

@@ -39,7 +39,7 @@ export interface DataParserDefinitionTemplateLiteral extends DataParserDefinitio
     readonly template: TemplateLiteralShape;
     readonly pattern: RegExp;
 }
-export declare const dataParserTemplateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-template-literal", unknown>>;
+export declare const dataParserTemplateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/template-literal", unknown>>;
 type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof dataParserTemplateLiteralKind.definition>);
 export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
 }

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -1,5 +1,4 @@
 import { escapeRegExp } from '../../common/escapeRegExp.mjs';
-import { createKind } from '../../common/kind.mjs';
 import { pipe } from '../../common/pipe.mjs';
 import { innerPipe } from '../../common/innerPipe.mjs';
 import { when as when$1 } from '../../common/when.mjs';
@@ -20,8 +19,9 @@ import { dataParserLiteralKind } from './literal.mjs';
 import { dataParserEmptyKind } from './empty.mjs';
 import { dataParserNilKind } from './nil.mjs';
 import { dataParserBooleanKind } from './boolean.mjs';
+import { createDataParserKind } from '../kind.mjs';
 
-const dataParserTemplateLiteralKind = createKind("data-parser-template-literal");
+const dataParserTemplateLiteralKind = createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
     const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(dataParserNumberKind.has, () => "(:?[0-9]+)"), when(dataParserBigIntKind.has, () => "(?:[0-9]+n)"), when(dataParserBooleanKind.has, () => "(?:true|false)"), when(dataParserNilKind.has, () => "(?:null)"), when(dataParserEmptyKind.has, () => "(?:undefined)"), when(dataParserLiteralKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(dataParserStringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(dataParserTemplateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
     return dataParserInit(dataParserTemplateLiteralKind, {

package/dist/dataParser/parsers/transform.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
+var kind = require('../kind.cjs');
 
-const dataParserTransformKind = kind.createKind("data-parser-transform");
+const dataParserTransformKind = kind.createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
     return base.dataParserInit(dataParserTransformKind, {
         definition: {

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

@@ -6,7 +6,7 @@ export interface DataParserDefinitionTransform extends DataParserDefinition<neve
     readonly inner: DataParsers;
     theFunction(input: any, error: DataParserError): unknown;
 }
-export declare const dataParserTransformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-transform", unknown>>;
+export declare const dataParserTransformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/transform", unknown>>;
 type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, Exclude<Awaited<ReturnType<GenericDefinition["theFunction"]>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>, Input<GenericDefinition["inner"]>> & Kind<typeof dataParserTransformKind.definition>);
 export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
 }

package/dist/dataParser/parsers/transform.mjs

@@ -1,8 +1,8 @@
-import { createKind } from '../../common/kind.mjs';
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorPromiseIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
 
-const dataParserTransformKind = createKind("data-parser-transform");
+const dataParserTransformKind = createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
     return dataParserInit(dataParserTransformKind, {
         definition: {

package/dist/dataParser/parsers/tuple.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
+var kind = require('../kind.cjs');
 
-const dataParserTupleKind = kind.createKind("data-parser-tuple");
+const dataParserTupleKind = kind.createDataParserKind("tuple");
 function tuple(shape, definition) {
     return base.dataParserInit(dataParserTupleKind, {
         definition: {

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

@@ -22,7 +22,7 @@ export interface DataParserDefinitionTuple extends DataParserDefinition<DataPars
     readonly shape: TupleShape;
     readonly rest?: DataParsers;
 }
-export declare const dataParserTupleKind: import("../../common").KindHandler<import("../../common").KindDefinition<"data-parser-tuple", unknown>>;
+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>>;

package/dist/dataParser/parsers/tuple.mjs

@@ -1,8 +1,8 @@
-import { createKind } from '../../common/kind.mjs';
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
 
-const dataParserTupleKind = createKind("data-parser-tuple");
+const dataParserTupleKind = createDataParserKind("tuple");
 function tuple(shape, definition) {
     return dataParserInit(dataParserTupleKind, {
         definition: {

package/dist/dataParser/parsers/union.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
+var kind = require('../kind.cjs');
 
-const dataParserUnionKind = kind.createKind("data-parser-union");
+const dataParserUnionKind = kind.createDataParserKind("union");
 function union(options, definition) {
     return base.dataParserInit(dataParserUnionKind, {
         definition: {

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

@@ -5,7 +5,7 @@ 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>>;
+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> {
 }

package/dist/dataParser/parsers/union.mjs

@@ -1,8 +1,8 @@
-import { createKind } from '../../common/kind.mjs';
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
 
-const dataParserUnionKind = createKind("data-parser-union");
+const dataParserUnionKind = createDataParserKind("union");
 function union(options, definition) {
     return dataParserInit(dataParserUnionKind, {
         definition: {

package/dist/dataParser/parsers/unknown.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var base = require('../base.cjs');
+var kind = require('../kind.cjs');
 
-const dataParserUnknownKind = kind.createKind("data-parser-unknown");
+const dataParserUnknownKind = kind.createDataParserKind("unknown");
 function unknown(definition) {
     return base.dataParserInit(dataParserUnknownKind, {
         definition: {

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

@@ -3,7 +3,7 @@ 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>>;
+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> {
 }

package/dist/dataParser/parsers/unknown.mjs

@@ -1,7 +1,7 @@
-import { createKind } from '../../common/kind.mjs';
 import { dataParserInit } from '../base.mjs';
+import { createDataParserKind } from '../kind.mjs';
 
-const dataParserUnknownKind = createKind("data-parser-unknown");
+const dataParserUnknownKind = createDataParserKind("unknown");
 function unknown(definition) {
     return dataParserInit(dataParserUnknownKind, {
         definition: {

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,14 +1,14 @@
 '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.setTo(eitherBoolFalsyKind.setTo(create.left("bool", value)));
 }

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,12 +1,12 @@
-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.setTo(eitherBoolFalsyKind.setTo(left("bool", value)));
 }

package/dist/either/bool/truthy.cjs

@@ -1,14 +1,14 @@
 '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.setTo(eitherBoolTruthyKind.setTo(create.right("bool", value)));
 }

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,12 +1,12 @@
-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.setTo(eitherBoolTruthyKind.setTo(right("bool", value)));
 }

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,10 +1,10 @@
 '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.setTo(eitherFutureErrorKind.setTo(create.left("future", value)));
 }

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,8 +1,8 @@
-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.setTo(eitherFutureErrorKind.setTo(left("future", value)));
 }

package/dist/either/future/success.cjs

@@ -1,10 +1,10 @@
 '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.setTo(eitherFutureSuccessKind.setTo(create.right("future", value)));
 }

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,8 +1,8 @@
-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.setTo(eitherFutureSuccessKind.setTo(right("future", value)));
 }

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>>;

package/dist/either/kind.mjs

@@ -0,0 +1,6 @@
+import { createKindNamespace } from '../common/kind.mjs';
+
+const createEitherKind = createKindNamespace("Either");
+const eitherInformationKind = createEitherKind("information");
+
+export { createEitherKind, eitherInformationKind };

package/dist/either/left/create.cjs

@@ -1,12 +1,11 @@
 'use strict';
 
-var kind = require('../../common/kind.cjs');
 var wrapValue = require('../../common/wrapValue.cjs');
-var base = require('../base.cjs');
+var kind = require('../kind.cjs');
 
-const eitherLeftKind = kind.createKind("either-left");
+const eitherLeftKind = kind.createEitherKind("left");
 function left(information, value = undefined) {
-    return eitherLeftKind.setTo(base.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
+    return eitherLeftKind.setTo(kind.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherLeftKind = eitherLeftKind;

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

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

package/dist/either/left/create.mjs

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