@duplojs/utils 1.1.8 → 1.1.10

package/dist/dataParser/parsers/number/checkers/max.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionNumberMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerNumberMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-number-max", unknown>>;
+export declare const dataParserCheckerNumberMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-max", unknown>>;
 type _DataParserCheckerNumberMax = (Kind<typeof dataParserCheckerNumberMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMax, number>);
 export interface DataParserCheckerNumberMax extends _DataParserCheckerNumberMax {
 }

package/dist/dataParser/parsers/number/checkers/min.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionNumberMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-number-min", unknown>>;
+export declare const dataParserCheckerNumberMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-number-min", unknown>>;
 type _DataParserCheckerNumberMin = (Kind<typeof dataParserCheckerNumberMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionNumberMin, number>);
 export interface DataParserCheckerNumberMin extends _DataParserCheckerNumberMin {
 }

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

@@ -7,7 +7,7 @@ export type DataParserNumberCheckers = (DataParserCheckerInt | DataParserChecker
 export interface DataParserDefinitionNumber extends DataParserDefinition<DataParserNumberCheckers> {
     readonly coerce: boolean;
 }
-export declare const dataParserNumberKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DataParser/number", unknown>>;
+export declare const dataParserNumberKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/number", unknown>>;
 type _DataParserNumber<GenericDefinition extends DataParserDefinitionNumber> = (DataParser<GenericDefinition, number, number> & Kind<typeof dataParserNumberKind.definition>);
 export interface DataParserNumber<GenericDefinition extends DataParserDefinitionNumber = DataParserDefinitionNumber> extends _DataParserNumber<GenericDefinition> {
     addChecker<GenericChecker extends readonly [

package/dist/dataParser/parsers/object.cjs

@@ -6,6 +6,8 @@ var forward = require('../../common/forward.cjs');
 var memo = require('../../common/memo.cjs');
 var filter = require('../../array/filter.cjs');
 var map = require('../../array/map.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');

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

@@ -16,7 +16,7 @@ export interface DataParserDefinitionObject extends DataParserDefinition<never>
         readonly value: DataParsers;
     }[]>;
 }
-export declare const dataParserObjectKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/object", unknown>>;
+export declare const dataParserObjectKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/object", unknown>>;
 type _DataParserObject<GenericDefinition extends DataParserDefinitionObject> = (DataParser<GenericDefinition, DataParserObjectShapeOutput<GenericDefinition["shape"]>, DataParserObjectShapeInput<GenericDefinition["shape"]>> & Kind<typeof dataParserObjectKind.definition>);
 export interface DataParserObject<GenericDefinition extends DataParserDefinitionObject = DataParserDefinitionObject> extends _DataParserObject<GenericDefinition> {
 }

package/dist/dataParser/parsers/object.mjs

@@ -4,6 +4,8 @@ import { forward } from '../../common/forward.mjs';
 import { memo } from '../../common/memo.mjs';
 import { filter } from '../../array/filter.mjs';
 import { map } from '../../array/map.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { dataParserInit, SymbolDataParserError, dataParserKind } from '../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';

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

@@ -4,7 +4,7 @@ import { type DataParsers, type MergeDefinition } from "../../dataParser/types";
 export interface DataParserDefinitionOptional extends DataParserDefinition<never> {
     readonly inner: DataParsers;
 }
-export declare const dataParserOptionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/optional", unknown>>;
+export declare const dataParserOptionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>>;
 type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, Output<GenericDefinition["inner"]> | undefined, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof dataParserOptionalKind.definition>);
 export interface DataParserOptional<GenericDefinition extends DataParserDefinitionOptional = DataParserDefinitionOptional> extends _DataParserOptional<GenericDefinition> {
 }

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

@@ -5,7 +5,7 @@ export interface DataParserDefinitionPipe extends DataParserDefinition<never> {
     readonly input: DataParsers;
     readonly output: DataParsers;
 }
-export declare const dataParserPipeKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/pipe", unknown>>;
+export declare const dataParserPipeKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/pipe", unknown>>;
 type _DataParserPipe<GenericDefinition extends DataParserDefinitionPipe> = (DataParser<GenericDefinition, Output<GenericDefinition["output"]>, Input<GenericDefinition["input"]>> & Kind<typeof dataParserPipeKind.definition>);
 export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPipe = DataParserDefinitionPipe> extends _DataParserPipe<GenericDefinition> {
 }

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

@@ -17,7 +17,7 @@ export interface DataParserDefinitionRecord extends DataParserDefinition<never>
     readonly key: DataParserRecordKey;
     readonly value: DataParsers;
 }
-export declare const dataParserRecordKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DataParser/record", unknown>>;
+export declare const dataParserRecordKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>>;
 export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers> = Extract<Record<Output<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Output<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
 export type DataParserRecordShapeInput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParsers> = Extract<Record<Input<GenericDataParserKey> extends infer InferredKey extends string | number ? InferredKey : never, Input<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
 type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredOutput ? InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof dataParserRecordKind.definition>);

package/dist/dataParser/parsers/string/checkers/email.d.ts

@@ -4,7 +4,7 @@ export interface DataParserCheckerDefinitionEmail extends DataParserCheckerDefin
     normalize?: boolean;
     pattern: RegExp;
 }
-export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-email", unknown>>;
+export declare const dataParserCheckerEmailKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-email", unknown>>;
 type _DataParserCheckerEmail = (Kind<typeof dataParserCheckerEmailKind.definition> & DataParserChecker<DataParserCheckerDefinitionEmail, string>);
 export interface DataParserCheckerEmail extends _DataParserCheckerEmail {
 }

package/dist/dataParser/parsers/string/checkers/max.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringMax extends DataParserCheckerDefinition {
     max: number;
 }
-export declare const dataParserCheckerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-max", unknown>>;
+export declare const dataParserCheckerStringMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
 type _DataParserCheckerStringMax = (Kind<typeof dataParserCheckerStringMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMax, string>);
 export interface DataParserCheckerStringMax extends _DataParserCheckerStringMax {
 }

package/dist/dataParser/parsers/string/checkers/min.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringMin extends DataParserCheckerDefinition {
     min: number;
 }
-export declare const dataParserCheckerStringMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-min", unknown>>;
+export declare const dataParserCheckerStringMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-min", unknown>>;
 type _DataParserCheckerStringMin = (Kind<typeof dataParserCheckerStringMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringMin, string>);
 export interface DataParserCheckerStringMin extends _DataParserCheckerStringMin {
 }

package/dist/dataParser/parsers/string/checkers/regex.d.ts

@@ -3,7 +3,7 @@ import { type DataParserCheckerDefinition, type DataParserChecker } from "../../
 export interface DataParserCheckerDefinitionStringRegex extends DataParserCheckerDefinition {
     regex: RegExp;
 }
-export declare const dataParserCheckerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-regex", unknown>>;
+export declare const dataParserCheckerStringRegexKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-regex", unknown>>;
 type _DataParserCheckerStringRegex = (Kind<typeof dataParserCheckerStringRegexKind.definition> & DataParserChecker<DataParserCheckerDefinitionStringRegex, string>);
 export interface DataParserCheckerStringRegex extends _DataParserCheckerStringRegex {
 }

package/dist/dataParser/parsers/string/checkers/url.d.ts

@@ -5,7 +5,7 @@ export interface DataParserCheckerDefinitionUrl extends DataParserCheckerDefinit
     protocol?: RegExp;
     normalize?: boolean;
 }
-export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-string-url", unknown>>;
+export declare const dataParserCheckerUrlKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-url", unknown>>;
 type _DataParserCheckerUrl = (Kind<typeof dataParserCheckerUrlKind.definition> & DataParserChecker<DataParserCheckerDefinitionUrl, string>);
 export interface DataParserCheckerUrl extends _DataParserCheckerUrl {
 }

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<"@DataParser/string", unknown>>;
+export declare const dataParserStringKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/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/templateLiteral.cjs

@@ -8,6 +8,8 @@ var isType = require('../../common/isType.cjs');
 var whenElse = require('../../common/whenElse.cjs');
 var map = require('../../array/map.cjs');
 var join = require('../../array/join.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 require('../../pattern/result.cjs');

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<"@DataParser/template-literal", unknown>>;
+export declare const dataParserTemplateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>>;
 type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof dataParserTemplateLiteralKind.definition>);
 export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
 }

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -6,6 +6,8 @@ import { isType } from '../../common/isType.mjs';
 import { whenElse } from '../../common/whenElse.mjs';
 import { map } from '../../array/map.mjs';
 import { join } from '../../array/join.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import '../../pattern/result.mjs';

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<"@DataParser/transform", unknown>>;
+export declare const dataParserTransformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>>;
 type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, Exclude<Awaited<ReturnType<GenericDefinition["theFunction"]>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>, Input<GenericDefinition["inner"]>> & Kind<typeof dataParserTransformKind.definition>);
 export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
 }

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<"@DataParser/tuple", unknown>>;
+export declare const dataParserTupleKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/tuple", unknown>>;
 type _DataParserTuple<GenericDefinition extends DataParserDefinitionTuple> = (DataParser<GenericDefinition, DataParserTupleShapeOutput<GenericDefinition["shape"], GenericDefinition["rest"]>, DataParserTupleShapeInput<GenericDefinition["shape"], GenericDefinition["rest"]>> & Kind<typeof 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/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<"@DataParser/union", unknown>>;
+export declare const dataParserUnionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>>;
 type _DataParserUnion<GenericDefinition extends DataParserDefinitionUnion> = (DataParser<GenericDefinition, Output<GenericDefinition["options"][number]>, Input<GenericDefinition["options"][number]>> & Kind<typeof dataParserUnionKind.definition>);
 export interface DataParserUnion<GenericDefinition extends DataParserDefinitionUnion = DataParserDefinitionUnion> extends _DataParserUnion<GenericDefinition> {
 }

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<"@DataParser/unknown", unknown>>;
+export declare const dataParserUnknownKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/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/either/bool/base.d.ts

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

package/dist/either/bool/falsy.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var unwrap = require('../../common/unwrap.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 var create$1 = require('./create.cjs');

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

@@ -5,7 +5,7 @@ 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<"@DuplojsUtilsEither/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,4 +1,6 @@
 import { unwrap } from '../../common/unwrap.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { eitherBoolKind } from './base.mjs';
 import { bool } from './create.mjs';

package/dist/either/bool/truthy.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var unwrap = require('../../common/unwrap.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('./base.cjs');
 var kind = require('../kind.cjs');
 var is$1 = require('../left/is.cjs');

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

@@ -4,7 +4,7 @@ import { eitherBoolKind } from "./base";
 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>>;
+export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/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,4 +1,6 @@
 import { unwrap } from '../../common/unwrap.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { eitherBoolKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { isLeft } from '../left/is.mjs';

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

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

package/dist/either/future/create.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var is$1 = require('../left/is.cjs');
 var success = require('./success.cjs');
 var error = require('./error.cjs');

package/dist/either/future/create.mjs

@@ -1,3 +1,5 @@
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { isLeft } from '../left/is.mjs';
 import { futureSuccess } from './success.mjs';
 import { futureError } from './error.mjs';

package/dist/either/future/error.cjs

@@ -2,6 +2,8 @@
 
 var create = require('../left/create.cjs');
 var kind = require('../kind.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('./base.cjs');
 
 const eitherFutureErrorKind = kind.createEitherKind("future-error");

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<"@DuplojsUtilsEither/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,5 +1,7 @@
 import { left } from '../left/create.mjs';
 import { createEitherKind } from '../kind.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { eitherFutureKind } from './base.mjs';
 
 const eitherFutureErrorKind = createEitherKind("future-error");

package/dist/either/future/success.cjs

@@ -2,6 +2,8 @@
 
 var kind = require('../kind.cjs');
 var base = require('./base.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var create = require('../right/create.cjs');
 
 const eitherFutureSuccessKind = kind.createEitherKind("future-success");

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

@@ -1,7 +1,7 @@
 import { type Kind } from "../../common/kind";
 import { eitherFutureKind } from "./base";
 import { type EitherRight } from "../right";
-export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/future-success", unknown>>;
+export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/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,5 +1,7 @@
 import { createEitherKind } from '../kind.mjs';
 import { eitherFutureKind } from './base.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { right } from '../right/create.mjs';
 
 const eitherFutureSuccessKind = createEitherKind("future-success");

package/dist/either/kind.cjs

@@ -1,8 +1,12 @@
 'use strict';
 
 var kind = require('../common/kind.cjs');
+require('../common/globalStore.cjs');
+require('../common/builder.cjs');
 
-const createEitherKind = kind.createKindNamespace("Either");
+const createEitherKind = kind.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsUtilsEither");
 const eitherInformationKind = createEitherKind("information");
 
 exports.createEitherKind = createEitherKind;

package/dist/either/kind.d.ts

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

package/dist/either/kind.mjs

@@ -1,6 +1,10 @@
 import { createKindNamespace } from '../common/kind.mjs';
+import '../common/globalStore.mjs';
+import '../common/builder.mjs';
 
-const createEitherKind = createKindNamespace("Either");
+const createEitherKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsUtilsEither");
 const eitherInformationKind = createEitherKind("information");
 
 export { createEitherKind, eitherInformationKind };

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 "../kind";
-export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/left", unknown>>;
+export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/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/error.d.ts

@@ -1,6 +1,6 @@
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "./create";
-export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/error", unknown>>;
+export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/error", unknown>>;
 type _EitherError<GenericValue extends unknown = unknown> = (EitherLeft<"error", GenericValue> & Kind<typeof eitherErrorKind.definition>);
 export interface EitherError<GenericValue extends unknown = unknown> extends _EitherError<GenericValue> {
 }

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

@@ -1,6 +1,6 @@
 import { type Kind } from "../../common/kind";
 import { type EitherLeft } from "./create";
-export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@Either/fail", unknown>>;
+export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
 type _EitherFail = (EitherLeft<"fail", never> & Kind<typeof eitherFailKind.definition>);
 export interface EitherFail extends _EitherFail {
 }

package/dist/either/left/when.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var unwrap = require('../../common/unwrap.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var is = require('./is.cjs');
 
 function whenIsLeft(...args) {

package/dist/either/left/when.mjs

@@ -1,4 +1,6 @@
 import { unwrap } from '../../common/unwrap.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { isLeft } from './is.mjs';
 
 function whenIsLeft(...args) {

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

@@ -1 +1 @@
-export declare const eitherNullableKind: import("../..").KindHandler<import("../..").KindDefinition<"@Either/nullable", unknown>>;
+export declare const eitherNullableKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/nullable", unknown>>;

package/dist/either/nullable/empty.cjs

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

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

@@ -4,7 +4,7 @@ import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { nullable } from "./create";
 import { eitherNullableKind } from "./base";
-export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/nullable-empty", unknown>>;
+export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-empty", unknown>>;
 type _EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableEmptyKind.definition>);
 export interface EitherNullableEmpty extends _EitherNullableEmpty {
 }

package/dist/either/nullable/empty.mjs

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

package/dist/either/nullable/filled.cjs

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

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

@@ -4,7 +4,7 @@ import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
 import { nullable } from "./create";
 import { eitherNullableKind } from "./base";
-export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/nullable-filled", unknown>>;
+export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullable-filled", unknown>>;
 type _EitherNullableFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullable", GenericValue> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableFilledKind.definition>);
 export interface EitherNullableFilled<GenericValue extends unknown = unknown> extends _EitherNullableFilled<GenericValue> {
 }

package/dist/either/nullable/filled.mjs

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

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

@@ -1 +1 @@
-export declare const eitherNullishKind: import("../..").KindHandler<import("../..").KindDefinition<"@Either/nullish", unknown>>;
+export declare const eitherNullishKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/nullish", unknown>>;

package/dist/either/nullish/empty.cjs

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

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

@@ -5,7 +5,7 @@ import { type EitherRight } from "../right";
 import { nullish } from "./create";
 import { eitherNullishKind } from "./base";
 export type NullishValue = null | undefined;
-export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/nullish-empty", unknown>>;
+export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-empty", unknown>>;
 type _EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = (EitherLeft<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishEmptyKind.definition>);
 export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> extends _EitherNullishEmpty<GenericValue> {
 }

package/dist/either/nullish/empty.mjs

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

package/dist/either/nullish/filled.cjs

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

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

@@ -4,7 +4,7 @@ import { nullish } from "./create";
 import { type Kind } from "../../common/kind";
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { eitherNullishKind } from "./base";
-export declare const eitherNullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@Either/nullish-filled", unknown>>;
+export declare const eitherNullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/nullish-filled", unknown>>;
 type _EitherNullishFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishFilledKind.definition>);
 export interface EitherNullishFilled<GenericValue extends unknown = unknown> extends _EitherNullishFilled<GenericValue> {
 }