@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.10

package/dist/dataStructure/constraint/defaults/path.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { is } from "../../../path/is.mjs";
+//#region scripts/dataStructure/constraint/defaults/path.ts
+const pathConstraintKind = createKind("path-constraint");
+const PathConstraint = createConstraint(pathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => is(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { PathConstraint, pathConstraintKind };

package/dist/dataStructure/constraint/defaults/positive.cjs

@@ -5,7 +5,7 @@ const require_isPositive = require("../../../number/isPositive.cjs");
 //#region scripts/dataStructure/constraint/defaults/positive.ts
 const positiveConstraintKind = require_kind.createKind("positive-constraint");
 const PositiveConstraint = require_base.createConstraint(positiveConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isPositive.isPositive(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isPositive.isPositive(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/positive.d.ts

@@ -5,6 +5,6 @@ import * as DNumber from '../../../number';
 export declare const positiveConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/positive-constraint", unknown>>;
 export interface PositiveConstraintDefinition extends ConstraintDefinition {
 }
-export interface PositiveConstraint extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.Positive, PositiveConstraintDefinition> & DKind.Kind<typeof positiveConstraintKind>> {
+export interface PositiveConstraint extends DCommon.Forward<Constraint<number, number & DNumber.Positive, PositiveConstraintDefinition> & DKind.Kind<typeof positiveConstraintKind>> {
 }
 export declare const PositiveConstraint: () => PositiveConstraint;

package/dist/dataStructure/constraint/defaults/positive.mjs

@@ -5,7 +5,7 @@ import { isPositive } from "../../../number/isPositive.mjs";
 //#region scripts/dataStructure/constraint/defaults/positive.ts
 const positiveConstraintKind = createKind("positive-constraint");
 const PositiveConstraint = createConstraint(positiveConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isPositive(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isPositive(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/refine.cjs

@@ -4,7 +4,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/refine.ts
 const refineConstraintKind = require_kind.createKind("refine-constraint");
 const RefineConstraint = require_base.createConstraint(refineConstraintKind, ({ init }) => (refine) => init({ refine }, {
-	executeCheck: (self, data, errorHandler) => self.definition.refine(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => self.definition.refine(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/refine.d.ts

@@ -5,6 +5,6 @@ export declare const refineConstraintKind: DKind.Handler<DKind.Definition<"@Dupl
 export interface RefineConstraintDefinition<GenericInput extends unknown = unknown> extends ConstraintDefinition {
     refine(data: GenericInput): boolean;
 }
-export interface RefineConstraint<GenericInput extends unknown = unknown, GenericPredicate extends GenericInput = GenericInput> extends DCommon.UnionToIntersection<Constraint<GenericInput, GenericPredicate, RefineConstraintDefinition<GenericInput>> & DKind.Kind<typeof refineConstraintKind>> {
+export interface RefineConstraint<GenericInput extends unknown = unknown, GenericPredicate extends GenericInput = GenericInput> extends DCommon.Forward<Constraint<GenericInput, GenericPredicate, RefineConstraintDefinition<GenericInput>> & DKind.Kind<typeof refineConstraintKind>> {
 }
 export declare const RefineConstraint: <GenericInput extends unknown, GenericPredicate extends GenericInput = GenericInput>(refine: (((data: GenericInput) => data is GenericPredicate) | ((data: GenericInput) => boolean))) => RefineConstraint<GenericInput, GenericPredicate>;

package/dist/dataStructure/constraint/defaults/refine.mjs

@@ -4,7 +4,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/refine.ts
 const refineConstraintKind = createKind("refine-constraint");
 const RefineConstraint = createConstraint(refineConstraintKind, ({ init }) => (refine) => init({ refine }, {
-	executeCheck: (self, data, errorHandler) => self.definition.refine(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => self.definition.refine(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/regex.cjs

@@ -0,0 +1,13 @@
+const require_test = require("../../../string/test.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/dataStructure/constraint/defaults/regex.ts
+const regexConstraintKind = require_kind.createKind("regex-constraint");
+const RegexConstraint = require_base.createConstraint(regexConstraintKind, ({ init }) => (regex) => init({ regex }, {
+	executeCheck: (self, data) => require_test.test(data, self.definition.regex) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.RegexConstraint = RegexConstraint;
+exports.regexConstraintKind = regexConstraintKind;

package/dist/dataStructure/constraint/defaults/regex.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const regexConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/regex-constraint", unknown>>;
+export interface RegexConstraintDefinition extends ConstraintDefinition {
+    readonly regex: RegExp;
+}
+export interface RegexConstraint extends DCommon.Forward<Constraint<string, string, RegexConstraintDefinition> & DKind.Kind<typeof regexConstraintKind>> {
+}
+export declare const RegexConstraint: (regex: RegExp) => RegexConstraint;

package/dist/dataStructure/constraint/defaults/regex.mjs

@@ -0,0 +1,12 @@
+import { test } from "../../../string/test.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+//#region scripts/dataStructure/constraint/defaults/regex.ts
+const regexConstraintKind = createKind("regex-constraint");
+const RegexConstraint = createConstraint(regexConstraintKind, ({ init }) => (regex) => init({ regex }, {
+	executeCheck: (self, data) => test(data, self.definition.regex) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { RegexConstraint, regexConstraintKind };

package/dist/dataStructure/constraint/defaults/safe.cjs

@@ -5,7 +5,7 @@ const require_isSafe = require("../../../number/isSafe.cjs");
 //#region scripts/dataStructure/constraint/defaults/safe.ts
 const safeConstraintKind = require_kind.createKind("safe-constraint");
 const SafeConstraint = require_base.createConstraint(safeConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isSafe.isSafe(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isSafe.isSafe(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/safe.d.ts

@@ -5,6 +5,6 @@ import * as DNumber from '../../../number';
 export declare const safeConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/safe-constraint", unknown>>;
 export interface SafeConstraintDefinition extends ConstraintDefinition {
 }
-export interface SafeConstraint extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.Safe, SafeConstraintDefinition> & DKind.Kind<typeof safeConstraintKind>> {
+export interface SafeConstraint extends DCommon.Forward<Constraint<number, number & DNumber.Safe, SafeConstraintDefinition> & DKind.Kind<typeof safeConstraintKind>> {
 }
 export declare const SafeConstraint: () => SafeConstraint;

package/dist/dataStructure/constraint/defaults/safe.mjs

@@ -5,7 +5,7 @@ import { isSafe } from "../../../number/isSafe.mjs";
 //#region scripts/dataStructure/constraint/defaults/safe.ts
 const safeConstraintKind = createKind("safe-constraint");
 const SafeConstraint = createConstraint(safeConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isSafe(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isSafe(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/segmentPath.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_isSegment = require("../../../path/isSegment.cjs");
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = require_kind.createKind("segment-path-constraint");
+const SegmentPathConstraint = require_base.createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isSegment.isSegment(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.SegmentPathConstraint = SegmentPathConstraint;
+exports.segmentPathConstraintKind = segmentPathConstraintKind;

package/dist/dataStructure/constraint/defaults/segmentPath.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const segmentPathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/segment-path-constraint", unknown>>;
+export interface SegmentPathConstraintDefinition extends ConstraintDefinition {
+}
+export interface SegmentPathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Segment, SegmentPathConstraintDefinition> & DKind.Kind<typeof segmentPathConstraintKind>> {
+}
+export declare const SegmentPathConstraint: () => SegmentPathConstraint;

package/dist/dataStructure/constraint/defaults/segmentPath.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { isSegment } from "../../../path/isSegment.mjs";
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = createKind("segment-path-constraint");
+const SegmentPathConstraint = createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isSegment(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { SegmentPathConstraint, segmentPathConstraintKind };

package/dist/dataStructure/constraint/defaults/strictNegative.cjs

@@ -5,7 +5,7 @@ const require_isStrictNegative = require("../../../number/isStrictNegative.cjs")
 //#region scripts/dataStructure/constraint/defaults/strictNegative.ts
 const strictNegativeConstraintKind = require_kind.createKind("strict-negative-constraint");
 const StrictNegativeConstraint = require_base.createConstraint(strictNegativeConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isStrictNegative.isStrictNegative(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isStrictNegative.isStrictNegative(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/strictNegative.d.ts

@@ -5,6 +5,6 @@ import * as DNumber from '../../../number';
 export declare const strictNegativeConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/strict-negative-constraint", unknown>>;
 export interface StrictNegativeConstraintDefinition extends ConstraintDefinition {
 }
-export interface StrictNegativeConstraint extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.StrictNegative, StrictNegativeConstraintDefinition> & DKind.Kind<typeof strictNegativeConstraintKind>> {
+export interface StrictNegativeConstraint extends DCommon.Forward<Constraint<number, number & DNumber.StrictNegative, StrictNegativeConstraintDefinition> & DKind.Kind<typeof strictNegativeConstraintKind>> {
 }
 export declare const StrictNegativeConstraint: () => StrictNegativeConstraint;

package/dist/dataStructure/constraint/defaults/strictNegative.mjs

@@ -5,7 +5,7 @@ import { isStrictNegative } from "../../../number/isStrictNegative.mjs";
 //#region scripts/dataStructure/constraint/defaults/strictNegative.ts
 const strictNegativeConstraintKind = createKind("strict-negative-constraint");
 const StrictNegativeConstraint = createConstraint(strictNegativeConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isStrictNegative(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isStrictNegative(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/strictPositive.cjs

@@ -5,7 +5,7 @@ const require_isStrictPositive = require("../../../number/isStrictPositive.cjs")
 //#region scripts/dataStructure/constraint/defaults/strictPositive.ts
 const strictPositiveConstraintKind = require_kind.createKind("strict-positive-constraint");
 const StrictPositiveConstraint = require_base.createConstraint(strictPositiveConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => require_isStrictPositive.isStrictPositive(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (_self, data) => require_isStrictPositive.isStrictPositive(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/strictPositive.d.ts

@@ -5,6 +5,6 @@ import * as DNumber from '../../../number';
 export declare const strictPositiveConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/strict-positive-constraint", unknown>>;
 export interface StrictPositiveConstraintDefinition extends ConstraintDefinition {
 }
-export interface StrictPositiveConstraint extends DCommon.UnionToIntersection<Constraint<number, number & DNumber.StrictPositive, StrictPositiveConstraintDefinition> & DKind.Kind<typeof strictPositiveConstraintKind>> {
+export interface StrictPositiveConstraint extends DCommon.Forward<Constraint<number, number & DNumber.StrictPositive, StrictPositiveConstraintDefinition> & DKind.Kind<typeof strictPositiveConstraintKind>> {
 }
 export declare const StrictPositiveConstraint: () => StrictPositiveConstraint;

package/dist/dataStructure/constraint/defaults/strictPositive.mjs

@@ -5,7 +5,7 @@ import { isStrictPositive } from "../../../number/isStrictPositive.mjs";
 //#region scripts/dataStructure/constraint/defaults/strictPositive.ts
 const strictPositiveConstraintKind = createKind("strict-positive-constraint");
 const StrictPositiveConstraint = createConstraint(strictPositiveConstraintKind, ({ init }) => () => init({}, {
-	executeCheck: (self, data, errorHandler) => isStrictPositive(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (_self, data) => isStrictPositive(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/stringLengthEqual.cjs

@@ -6,7 +6,7 @@ const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/stringLengthEqual.ts
 const stringLengthEqualConstraintKind = require_kind.createKind("string-length-equal-constraint");
 const StringLengthEqualConstraint = require_base.createConstraint(stringLengthEqualConstraintKind, ({ init }) => (length) => init({ length }, {
-	executeCheck: (self, data, errorHandler) => require_lengthEqual.lengthEqual(data, require_forward.forward(self.definition.length)) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+	executeCheck: (self, data) => require_lengthEqual.lengthEqual(data, require_forward.forward(self.definition.length)) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/stringLengthEqual.d.ts

@@ -6,6 +6,6 @@ export declare const stringLengthEqualConstraintKind: DKind.Handler<DKind.Defini
 export interface StringLengthEqualConstraintDefinition<GenericLength extends number = number> extends ConstraintDefinition {
     readonly length: GenericLength;
 }
-export interface StringLengthEqualConstraint<GenericLength extends number = number> extends DCommon.UnionToIntersection<Constraint<string, string & DString.LengthEqual<GenericLength>, StringLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof stringLengthEqualConstraintKind>> {
+export interface StringLengthEqualConstraint<GenericLength extends number = number> extends DCommon.Forward<Constraint<string, string & DString.LengthEqual<GenericLength>, StringLengthEqualConstraintDefinition<GenericLength>> & DKind.Kind<typeof stringLengthEqualConstraintKind>> {
 }
 export declare const StringLengthEqualConstraint: <GenericLength extends number>(length: GenericLength) => StringLengthEqualConstraint<GenericLength>;

package/dist/dataStructure/constraint/defaults/stringLengthEqual.mjs

@@ -6,7 +6,7 @@ import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/stringLengthEqual.ts
 const stringLengthEqualConstraintKind = createKind("string-length-equal-constraint");
 const StringLengthEqualConstraint = createConstraint(stringLengthEqualConstraintKind, ({ init }) => (length) => init({ length }, {
-	executeCheck: (self, data, errorHandler) => lengthEqual(data, forward(self.definition.length)) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+	executeCheck: (self, data) => lengthEqual(data, forward(self.definition.length)) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/trimmed.cjs

@@ -0,0 +1,13 @@
+const require_is = require("../../../string/trim/is.cjs");
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/dataStructure/constraint/defaults/trimmed.ts
+const trimmedConstraintKind = require_kind.createKind("trimmed-constraint");
+const TrimmedConstraint = require_base.createConstraint(trimmedConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_is.isTrimmed(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.TrimmedConstraint = TrimmedConstraint;
+exports.trimmedConstraintKind = trimmedConstraintKind;

package/dist/dataStructure/constraint/defaults/trimmed.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DString from '../../../string';
+export declare const trimmedConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/trimmed-constraint", unknown>>;
+export interface TrimmedConstraintDefinition extends ConstraintDefinition {
+}
+export interface TrimmedConstraint extends DCommon.Forward<Constraint<string, string & DString.Trimmed, TrimmedConstraintDefinition> & DKind.Kind<typeof trimmedConstraintKind>> {
+}
+export declare const TrimmedConstraint: () => TrimmedConstraint;

package/dist/dataStructure/constraint/defaults/trimmed.mjs

@@ -0,0 +1,12 @@
+import { isTrimmed } from "../../../string/trim/is.mjs";
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+//#region scripts/dataStructure/constraint/defaults/trimmed.ts
+const trimmedConstraintKind = createKind("trimmed-constraint");
+const TrimmedConstraint = createConstraint(trimmedConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isTrimmed(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { TrimmedConstraint, trimmedConstraintKind };

package/dist/dataStructure/constraint/defaults/url.cjs

@@ -4,8 +4,8 @@ const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/url.ts
 const urlConstraintKind = require_kind.createKind("url-constraint");
-const UrlConstraint = require_base.createConstraint(urlConstraintKind, ({ init }) => (params) => init({ params }, {
-	executeCheck: (self, data, errorHandler) => require_isUrl.isUrl(data, self.definition.params) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+const UrlConstraint = require_base.createConstraint(urlConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isUrl.isUrl(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/url.d.ts

@@ -4,8 +4,7 @@ import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const urlConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/url-constraint", unknown>>;
 export interface UrlConstraintDefinition extends ConstraintDefinition {
-    readonly params?: DString.IsUrlParams;
 }
-export interface UrlConstraint extends DCommon.UnionToIntersection<Constraint<string, string & DString.Url, UrlConstraintDefinition> & DKind.Kind<typeof urlConstraintKind>> {
+export interface UrlConstraint extends DCommon.Forward<Constraint<string, string & DString.Url, UrlConstraintDefinition> & DKind.Kind<typeof urlConstraintKind>> {
 }
-export declare const UrlConstraint: (params?: DString.IsUrlParams) => UrlConstraint;
+export declare const UrlConstraint: () => UrlConstraint;

package/dist/dataStructure/constraint/defaults/url.mjs

@@ -4,8 +4,8 @@ import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/url.ts
 const urlConstraintKind = createKind("url-constraint");
-const UrlConstraint = createConstraint(urlConstraintKind, ({ init }) => (params) => init({ params }, {
-	executeCheck: (self, data, errorHandler) => isUrl(data, self.definition.params) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+const UrlConstraint = createConstraint(urlConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isUrl(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion

package/dist/dataStructure/constraint/defaults/uuid.cjs

@@ -4,12 +4,10 @@ const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/constraint/defaults/uuid.ts
 const uuidConstraintKind = require_kind.createKind("uuid-constraint");
-const uuidRegex = require_isUuid.uuidRegex;
-const UuidConstraint = require_base.createConstraint(uuidConstraintKind, ({ init }) => () => init({ regex: uuidRegex }, {
-	executeCheck: (self, data, errorHandler) => require_isUuid.isUuid(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol,
+const UuidConstraint = require_base.createConstraint(uuidConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isUuid.isUuid(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion
 exports.UuidConstraint = UuidConstraint;
 exports.uuidConstraintKind = uuidConstraintKind;
-exports.uuidRegex = uuidRegex;

package/dist/dataStructure/constraint/defaults/uuid.d.ts

@@ -4,9 +4,7 @@ import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const uuidConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/uuid-constraint", unknown>>;
 export interface UuidConstraintDefinition extends ConstraintDefinition {
-    readonly regex: RegExp;
 }
-export interface UuidConstraint extends DCommon.UnionToIntersection<Constraint<string, string & DString.Uuid, UuidConstraintDefinition> & DKind.Kind<typeof uuidConstraintKind>> {
+export interface UuidConstraint extends DCommon.Forward<Constraint<string, string & DString.Uuid, UuidConstraintDefinition> & DKind.Kind<typeof uuidConstraintKind>> {
 }
-export declare const uuidRegex: RegExp;
 export declare const UuidConstraint: () => UuidConstraint;

package/dist/dataStructure/constraint/defaults/uuid.mjs

@@ -1,13 +1,12 @@
-import { isUuid, uuidRegex as uuidRegex$1 } from "../../../string/isUuid.mjs";
+import { isUuid } from "../../../string/isUuid.mjs";
 import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createConstraint } from "../base.mjs";
 //#region scripts/dataStructure/constraint/defaults/uuid.ts
 const uuidConstraintKind = createKind("uuid-constraint");
-const uuidRegex = uuidRegex$1;
-const UuidConstraint = createConstraint(uuidConstraintKind, ({ init }) => () => init({ regex: uuidRegex }, {
-	executeCheck: (self, data, errorHandler) => isUuid(data) ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol,
+const UuidConstraint = createConstraint(uuidConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isUuid(data) ? SuccessSymbol : ErrorSymbol,
 	isAsynchronous: () => false
 }));
 //#endregion
-export { UuidConstraint, uuidConstraintKind, uuidRegex };
+export { UuidConstraint, uuidConstraintKind };

package/dist/dataStructure/constraint/identifier.d.ts

@@ -1,5 +1,4 @@
 import { Constraint } from './base';
-export declare const constraintIdentifier: {
-    <GenericKindHandler extends import('../../kind').GetHandler<import('..').EmailConstraint> | import('../../kind').GetHandler<import('..').EvenConstraint> | import('../../kind').GetHandler<import('..').IntegerConstraint> | import('../../kind').GetHandler<import('..').NegativeConstraint> | import('../../kind').GetHandler<import('..').NotEmptyConstraint> | import('../../kind').GetHandler<import('..').NotZeroConstraint> | import('../../kind').GetHandler<import('..').OddConstraint> | import('../../kind').GetHandler<import('..').PositiveConstraint> | import('../../kind').GetHandler<import('..').SafeConstraint> | import('../../kind').GetHandler<import('..').StrictNegativeConstraint> | import('../../kind').GetHandler<import('..').StrictPositiveConstraint> | import('../../kind').GetHandler<import('..').UrlConstraint> | import('../../kind').GetHandler<import('..').UuidConstraint> | import('../../kind').GetHandler<import('..').AllowedCharactersConstraint<import('../../string').CharactersRange>> | import('../../kind').GetHandler<import('..').ArrayLengthEqualConstraint<number>> | import('../../kind').GetHandler<import('..').BetweenThanConstraint<number, number>> | import('../../kind').GetHandler<import('..').BetweenThanOrEqualConstraint<number, number>> | import('../../kind').GetHandler<import('..').GreaterThanConstraint<number>> | import('../../kind').GetHandler<import('..').GreaterThanOrEqualConstraint<number>> | import('../../kind').GetHandler<import('..').LessThanConstraint<number>> | import('../../kind').GetHandler<import('..').LessThanOrEqualConstraint<number>> | import('../../kind').GetHandler<import('..').MaxCharactersConstraint<number>> | import('../../kind').GetHandler<import('..').MaxElementsConstraint<number>> | import('../../kind').GetHandler<import('..').MinElementsConstraint<number>> | import('../../kind').GetHandler<import('..').MultipleOfConstraint<number>> | import('../../kind').GetHandler<import('..').StringLengthEqualConstraint<number>> | import('../../kind').GetHandler<import('..').MinCharactersConstraint<number>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import('../..').UnionContain<GenericInput, Constraint<unknown, unknown, import('..').ConstraintDefinition>> extends true ? Extract<import('..').EmailConstraint, GenericGroupedKind> | Extract<import('..').EvenConstraint, GenericGroupedKind> | Extract<import('..').IntegerConstraint, GenericGroupedKind> | Extract<import('..').NegativeConstraint, GenericGroupedKind> | Extract<import('..').NotEmptyConstraint, GenericGroupedKind> | Extract<import('..').NotZeroConstraint, GenericGroupedKind> | Extract<import('..').OddConstraint, GenericGroupedKind> | Extract<import('..').PositiveConstraint, GenericGroupedKind> | Extract<import('..').SafeConstraint, GenericGroupedKind> | Extract<import('..').StrictNegativeConstraint, GenericGroupedKind> | Extract<import('..').StrictPositiveConstraint, GenericGroupedKind> | Extract<import('..').UrlConstraint, GenericGroupedKind> | Extract<import('..').UuidConstraint, GenericGroupedKind> | Extract<import('..').AllowedCharactersConstraint<import('../../string').CharactersRange>, GenericGroupedKind> | Extract<import('..').ArrayLengthEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').BetweenThanConstraint<number, number>, GenericGroupedKind> | Extract<import('..').BetweenThanOrEqualConstraint<number, number>, GenericGroupedKind> | Extract<import('..').GreaterThanConstraint<number>, GenericGroupedKind> | Extract<import('..').GreaterThanOrEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').LessThanConstraint<number>, GenericGroupedKind> | Extract<import('..').LessThanOrEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').MaxCharactersConstraint<number>, GenericGroupedKind> | Extract<import('..').MaxElementsConstraint<number>, GenericGroupedKind> | Extract<import('..').MinElementsConstraint<number>, GenericGroupedKind> | Extract<import('..').MultipleOfConstraint<number>, GenericGroupedKind> | Extract<import('..').StringLengthEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').MinCharactersConstraint<number>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').GetHandler<import('..').EmailConstraint> | import('../../kind').GetHandler<import('..').EvenConstraint> | import('../../kind').GetHandler<import('..').IntegerConstraint> | import('../../kind').GetHandler<import('..').NegativeConstraint> | import('../../kind').GetHandler<import('..').NotEmptyConstraint> | import('../../kind').GetHandler<import('..').NotZeroConstraint> | import('../../kind').GetHandler<import('..').OddConstraint> | import('../../kind').GetHandler<import('..').PositiveConstraint> | import('../../kind').GetHandler<import('..').SafeConstraint> | import('../../kind').GetHandler<import('..').StrictNegativeConstraint> | import('../../kind').GetHandler<import('..').StrictPositiveConstraint> | import('../../kind').GetHandler<import('..').UrlConstraint> | import('../../kind').GetHandler<import('..').UuidConstraint> | import('../../kind').GetHandler<import('..').AllowedCharactersConstraint<import('../../string').CharactersRange>> | import('../../kind').GetHandler<import('..').ArrayLengthEqualConstraint<number>> | import('../../kind').GetHandler<import('..').BetweenThanConstraint<number, number>> | import('../../kind').GetHandler<import('..').BetweenThanOrEqualConstraint<number, number>> | import('../../kind').GetHandler<import('..').GreaterThanConstraint<number>> | import('../../kind').GetHandler<import('..').GreaterThanOrEqualConstraint<number>> | import('../../kind').GetHandler<import('..').LessThanConstraint<number>> | import('../../kind').GetHandler<import('..').LessThanOrEqualConstraint<number>> | import('../../kind').GetHandler<import('..').MaxCharactersConstraint<number>> | import('../../kind').GetHandler<import('..').MaxElementsConstraint<number>> | import('../../kind').GetHandler<import('..').MinElementsConstraint<number>> | import('../../kind').GetHandler<import('..').MultipleOfConstraint<number>> | import('../../kind').GetHandler<import('..').StringLengthEqualConstraint<number>> | import('../../kind').GetHandler<import('..').MinCharactersConstraint<number>>, GenericInput extends unknown, GenericGroupedKind extends import('../..').UnionToIntersection<GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<string, unknown>> ? import('../../kind').Kind<GenericKindHandler, GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import('../..').UnionContain<GenericInput, Constraint<unknown, unknown, import('..').ConstraintDefinition>> extends true ? Extract<import('..').EmailConstraint, GenericGroupedKind> | Extract<import('..').EvenConstraint, GenericGroupedKind> | Extract<import('..').IntegerConstraint, GenericGroupedKind> | Extract<import('..').NegativeConstraint, GenericGroupedKind> | Extract<import('..').NotEmptyConstraint, GenericGroupedKind> | Extract<import('..').NotZeroConstraint, GenericGroupedKind> | Extract<import('..').OddConstraint, GenericGroupedKind> | Extract<import('..').PositiveConstraint, GenericGroupedKind> | Extract<import('..').SafeConstraint, GenericGroupedKind> | Extract<import('..').StrictNegativeConstraint, GenericGroupedKind> | Extract<import('..').StrictPositiveConstraint, GenericGroupedKind> | Extract<import('..').UrlConstraint, GenericGroupedKind> | Extract<import('..').UuidConstraint, GenericGroupedKind> | Extract<import('..').AllowedCharactersConstraint<import('../../string').CharactersRange>, GenericGroupedKind> | Extract<import('..').ArrayLengthEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').BetweenThanConstraint<number, number>, GenericGroupedKind> | Extract<import('..').BetweenThanOrEqualConstraint<number, number>, GenericGroupedKind> | Extract<import('..').GreaterThanConstraint<number>, GenericGroupedKind> | Extract<import('..').GreaterThanOrEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').LessThanConstraint<number>, GenericGroupedKind> | Extract<import('..').LessThanOrEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').MaxCharactersConstraint<number>, GenericGroupedKind> | Extract<import('..').MaxElementsConstraint<number>, GenericGroupedKind> | Extract<import('..').MinElementsConstraint<number>, GenericGroupedKind> | Extract<import('..').MultipleOfConstraint<number>, GenericGroupedKind> | Extract<import('..').StringLengthEqualConstraint<number>, GenericGroupedKind> | Extract<import('..').MinCharactersConstraint<number>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-};
+import { Constraints } from './types';
+import * as DKind from '../../kind';
+export declare const constraintIdentifier: DKind.KindIdentifier<Constraint<unknown, unknown, import('..').ConstraintDefinition>, Constraints>;

package/dist/dataStructure/constraint/types/constraints.d.ts

@@ -2,31 +2,38 @@ import { Constraint } from '../base';
 import type * as DDefaults from "../defaults";
 export interface ConstraintsStore {
     allowedCharacters: DDefaults.AllowedCharactersConstraint;
-    arrayLengthEqual: DDefaults.ArrayLengthEqualConstraint;
-    betweenThan: DDefaults.BetweenThanConstraint;
-    betweenThanOrEqual: DDefaults.BetweenThanOrEqualConstraint;
     email: DDefaults.EmailConstraint;
-    even: DDefaults.EvenConstraint;
-    greaterThan: DDefaults.GreaterThanConstraint;
-    greaterThanOrEqual: DDefaults.GreaterThanOrEqualConstraint;
-    integer: DDefaults.IntegerConstraint;
-    lessThan: DDefaults.LessThanConstraint;
-    lessThanOrEqual: DDefaults.LessThanOrEqualConstraint;
+    url: DDefaults.UrlConstraint;
+    uuid: DDefaults.UuidConstraint;
+    trimmed: DDefaults.TrimmedConstraint;
+    notEmpty: DDefaults.NotEmptyConstraint;
+    regex: DDefaults.RegexConstraint;
+    minCharacters: DDefaults.MinCharactersConstraint;
     maxCharacters: DDefaults.MaxCharactersConstraint;
-    maxElements: DDefaults.MaxElementsConstraint;
+    numberInString: DDefaults.NumberInStringConstraint;
+    stringLengthEqual: DDefaults.StringLengthEqualConstraint;
     minElements: DDefaults.MinElementsConstraint;
+    maxElements: DDefaults.MaxElementsConstraint;
+    arrayLengthEqual: DDefaults.ArrayLengthEqualConstraint;
+    integer: DDefaults.IntegerConstraint;
+    even: DDefaults.EvenConstraint;
     multipleOf: DDefaults.MultipleOfConstraint;
     negative: DDefaults.NegativeConstraint;
-    notEmpty: DDefaults.NotEmptyConstraint;
     notZero: DDefaults.NotZeroConstraint;
     odd: DDefaults.OddConstraint;
     positive: DDefaults.PositiveConstraint;
     safe: DDefaults.SafeConstraint;
     strictNegative: DDefaults.StrictNegativeConstraint;
     strictPositive: DDefaults.StrictPositiveConstraint;
-    stringLengthEqual: DDefaults.StringLengthEqualConstraint;
-    stringMin: DDefaults.MinCharactersConstraint;
-    url: DDefaults.UrlConstraint;
-    uuid: DDefaults.UuidConstraint;
+    betweenThan: DDefaults.BetweenThanConstraint;
+    betweenThanOrEqual: DDefaults.BetweenThanOrEqualConstraint;
+    greaterThan: DDefaults.GreaterThanConstraint;
+    greaterThanOrEqual: DDefaults.GreaterThanOrEqualConstraint;
+    lessThan: DDefaults.LessThanConstraint;
+    lessThanOrEqual: DDefaults.LessThanOrEqualConstraint;
+    absolutePath: DDefaults.AbsolutePathConstraint;
+    path: DDefaults.PathConstraint;
+    segmentPath: DDefaults.SegmentPathConstraint;
+    refine: DDefaults.RefineConstraint;
 }
 export type Constraints = Extract<ConstraintsStore[keyof ConstraintsStore], Constraint>;

package/dist/dataStructure/fundamentalType/base.cjs

@@ -1,9 +1,9 @@
 //#region scripts/dataStructure/fundamentalType/base.ts
 const fundamentalTypeKind = require("../kind.cjs").createKind("fundamental-type");
-function createFundamentalType(symbol, executeCheck) {
+function createFundamentalType(kindHandler, executeCheck) {
 	const self = {
-		symbol,
-		executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+		executeCheck: (data) => executeCheck(self, data),
+		[kindHandler.runTimeKey]: null,
 		[fundamentalTypeKind.runTimeKey]: null
 	};
 	return self;

package/dist/dataStructure/fundamentalType/base.d.ts

@@ -1,9 +1,8 @@
-import { SuccessSymbol, ErrorSymbol, GetErrorHandler } from '../common';
+import { SuccessSymbol, ErrorSymbol } from '../common';
 import type * as DCommon from '../../common';
 import type * as DKind from '../../kind';
 export declare const fundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/fundamental-type", unknown>>;
-export interface FundamentalType<GenericSymbol extends symbol = symbol, IncludedType extends unknown = unknown> extends DKind.Kind<typeof fundamentalTypeKind, IncludedType> {
-    symbol: GenericSymbol;
-    executeCheck(data: unknown, errorHandler?: GetErrorHandler): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
+export interface FundamentalType<IncludedType extends unknown = unknown> extends DKind.Kind<typeof fundamentalTypeKind, IncludedType> {
+    executeCheck(data: unknown): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
 }
-export declare function createFundamentalType<GenericFundamentalType extends FundamentalType>(symbol: GenericFundamentalType["symbol"], executeCheck: (self: GenericFundamentalType, data: unknown, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>): GenericFundamentalType;
+export declare function createFundamentalType<GenericFundamentalType extends FundamentalType>(kindHandler: Exclude<DKind.GetHandler<GenericFundamentalType>, typeof fundamentalTypeKind>, executeCheck: (self: GenericFundamentalType, data: unknown) => DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>): GenericFundamentalType;

package/dist/dataStructure/fundamentalType/base.mjs

@@ -1,10 +1,10 @@
 import { createKind } from "../kind.mjs";
 //#region scripts/dataStructure/fundamentalType/base.ts
 const fundamentalTypeKind = createKind("fundamental-type");
-function createFundamentalType(symbol, executeCheck) {
+function createFundamentalType(kindHandler, executeCheck) {
 	const self = {
-		symbol,
-		executeCheck: (data, errorHandler) => executeCheck(self, data, errorHandler),
+		executeCheck: (data) => executeCheck(self, data),
+		[kindHandler.runTimeKey]: null,
 		[fundamentalTypeKind.runTimeKey]: null
 	};
 	return self;

package/dist/dataStructure/fundamentalType/defaults/bigint.cjs

@@ -1,7 +1,9 @@
+const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/fundamentalType/defaults/bigint.ts
-const FundamentalTypeTheBigintSymbol = Symbol("FundamentalTypeTheBigintSymbol");
-const TheBigint = require_base.createFundamentalType(FundamentalTypeTheBigintSymbol, (self, data, errorHandler) => typeof data === "bigint" ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const bigintFundamentalTypeKind = require_kind.createKind("bigint-fundamental-type");
+const TheBigint = require_base.createFundamentalType(bigintFundamentalTypeKind, (self, data) => typeof data === "bigint" ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheBigint = TheBigint;
+exports.bigintFundamentalTypeKind = bigintFundamentalTypeKind;

package/dist/dataStructure/fundamentalType/defaults/bigint.d.ts

@@ -1,7 +1,7 @@
 import { FundamentalType } from '../base';
-declare const FundamentalTypeTheBigintSymbol: unique symbol;
-export type FundamentalTypeTheBigintSymbol = typeof FundamentalTypeTheBigintSymbol;
-export interface TheBigint extends FundamentalType<FundamentalTypeTheBigintSymbol, bigint> {
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const bigintFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/bigint-fundamental-type", unknown>>;
+export interface TheBigint extends DCommon.Forward<FundamentalType<bigint> & DKind.Kind<typeof bigintFundamentalTypeKind>> {
 }
 export declare const TheBigint: TheBigint;
-export {};

package/dist/dataStructure/fundamentalType/defaults/bigint.mjs

@@ -1,5 +1,8 @@
+import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createFundamentalType } from "../base.mjs";
-const TheBigint = createFundamentalType(Symbol("FundamentalTypeTheBigintSymbol"), (self, data, errorHandler) => typeof data === "bigint" ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol);
+//#region scripts/dataStructure/fundamentalType/defaults/bigint.ts
+const bigintFundamentalTypeKind = createKind("bigint-fundamental-type");
+const TheBigint = createFundamentalType(bigintFundamentalTypeKind, (self, data) => typeof data === "bigint" ? SuccessSymbol : ErrorSymbol);
 //#endregion
-export { TheBigint };
+export { TheBigint, bigintFundamentalTypeKind };

package/dist/dataStructure/fundamentalType/defaults/boolean.cjs

@@ -1,7 +1,9 @@
+const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/fundamentalType/defaults/boolean.ts
-const FundamentalTypeTheBooleanSymbol = Symbol("FundamentalTypeTheBooleanSymbol");
-const TheBoolean = require_base.createFundamentalType(FundamentalTypeTheBooleanSymbol, (self, data, errorHandler) => typeof data === "boolean" ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const booleanFundamentalTypeKind = require_kind.createKind("boolean-fundamental-type");
+const TheBoolean = require_base.createFundamentalType(booleanFundamentalTypeKind, (self, data) => typeof data === "boolean" ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheBoolean = TheBoolean;
+exports.booleanFundamentalTypeKind = booleanFundamentalTypeKind;