@duplojs/lang 0.0.0 → 0.0.1-beta.10

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;

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

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

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

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

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

@@ -1,8 +1,10 @@
 const require_theDate = require("../../../chrono/theDate.cjs");
+const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/fundamentalType/defaults/date.ts
-const FundamentalTypeTheDateSymbol = Symbol("FundamentalTypeTheDateSymbol");
-const TheDate = require_base.createFundamentalType(FundamentalTypeTheDateSymbol, (self, data, errorHandler) => data instanceof require_theDate.TheDate ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const dateFundamentalTypeKind = require_kind.createKind("date-fundamental-type");
+const TheDate = require_base.createFundamentalType(dateFundamentalTypeKind, (self, data) => data instanceof require_theDate.TheDate ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheDate = TheDate;
+exports.dateFundamentalTypeKind = dateFundamentalTypeKind;

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

@@ -1,8 +1,8 @@
 import { FundamentalType } from '../base';
 import * as DChrono from '../../../chrono';
-declare const FundamentalTypeTheDateSymbol: unique symbol;
-export type FundamentalTypeTheDateSymbol = typeof FundamentalTypeTheDateSymbol;
-export interface TheDate extends FundamentalType<FundamentalTypeTheDateSymbol, DChrono.TheDate> {
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const dateFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/date-fundamental-type", unknown>>;
+export interface TheDate extends DCommon.Forward<FundamentalType<DChrono.TheDate> & DKind.Kind<typeof dateFundamentalTypeKind>> {
 }
 export declare const TheDate: TheDate;
-export {};

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

@@ -1,6 +1,9 @@
 import { TheDate as TheDate$1 } from "../../../chrono/theDate.mjs";
+import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createFundamentalType } from "../base.mjs";
-const TheDate = createFundamentalType(Symbol("FundamentalTypeTheDateSymbol"), (self, data, errorHandler) => data instanceof TheDate$1 ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol);
+//#region scripts/dataStructure/fundamentalType/defaults/date.ts
+const dateFundamentalTypeKind = createKind("date-fundamental-type");
+const TheDate = createFundamentalType(dateFundamentalTypeKind, (self, data) => data instanceof TheDate$1 ? SuccessSymbol : ErrorSymbol);
 //#endregion
-export { TheDate };
+export { TheDate, dateFundamentalTypeKind };

package/dist/dataStructure/fundamentalType/defaults/null.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/null.ts
-const FundamentalTypeTheNullSymbol = Symbol("FundamentalTypeTheNullSymbol");
-const TheNull = require_base.createFundamentalType(FundamentalTypeTheNullSymbol, (self, data, errorHandler) => data === null ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const nullFundamentalTypeKind = require_kind.createKind("null-fundamental-type");
+const TheNull = require_base.createFundamentalType(nullFundamentalTypeKind, (self, data) => data === null ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheNull = TheNull;
+exports.nullFundamentalTypeKind = nullFundamentalTypeKind;

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

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

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

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

package/dist/dataStructure/fundamentalType/defaults/number.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/number.ts
-const FundamentalTypeTheNumberSymbol = Symbol("FundamentalTypeTheNumberSymbol");
-const TheNumber = require_base.createFundamentalType(FundamentalTypeTheNumberSymbol, (self, data, errorHandler) => typeof data === "number" && isFinite(data) && !isNaN(data) ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const numberFundamentalTypeKind = require_kind.createKind("number-fundamental-type");
+const TheNumber = require_base.createFundamentalType(numberFundamentalTypeKind, (self, data) => typeof data === "number" && isFinite(data) && !isNaN(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheNumber = TheNumber;
+exports.numberFundamentalTypeKind = numberFundamentalTypeKind;

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

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

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

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

package/dist/dataStructure/fundamentalType/defaults/string.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/string.ts
-const FundamentalTypeTheStringSymbol = Symbol("FundamentalTypeTheStringSymbol");
-const TheString = require_base.createFundamentalType(FundamentalTypeTheStringSymbol, (self, data, errorHandler) => typeof data === "string" ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const stringFundamentalTypeKind = require_kind.createKind("string-fundamental-type");
+const TheString = require_base.createFundamentalType(stringFundamentalTypeKind, (self, data) => typeof data === "string" ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheString = TheString;
+exports.stringFundamentalTypeKind = stringFundamentalTypeKind;

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

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

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

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

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

@@ -1,8 +1,10 @@
 const require_theTime = require("../../../chrono/theTime.cjs");
+const require_kind = require("../../kind.cjs");
 const require_resultSymbol = require("../../common/resultSymbol.cjs");
 const require_base = require("../base.cjs");
 //#region scripts/dataStructure/fundamentalType/defaults/time.ts
-const FundamentalTypeTheTimeSymbol = Symbol("FundamentalTypeTheTimeSymbol");
-const TheTime = require_base.createFundamentalType(FundamentalTypeTheTimeSymbol, (self, data, errorHandler) => data instanceof require_theTime.TheTime ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const timeFundamentalTypeKind = require_kind.createKind("time-fundamental-type");
+const TheTime = require_base.createFundamentalType(timeFundamentalTypeKind, (self, data) => data instanceof require_theTime.TheTime ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheTime = TheTime;
+exports.timeFundamentalTypeKind = timeFundamentalTypeKind;

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

@@ -1,8 +1,8 @@
 import { FundamentalType } from '../base';
 import * as DChrono from '../../../chrono';
-declare const FundamentalTypeTheTimeSymbol: unique symbol;
-export type FundamentalTypeTheTimeSymbol = typeof FundamentalTypeTheTimeSymbol;
-export interface TheTime extends FundamentalType<FundamentalTypeTheTimeSymbol, DChrono.TheTime> {
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+export declare const timeFundamentalTypeKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/time-fundamental-type", unknown>>;
+export interface TheTime extends DCommon.Forward<FundamentalType<DChrono.TheTime> & DKind.Kind<typeof timeFundamentalTypeKind>> {
 }
 export declare const TheTime: TheTime;
-export {};

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

@@ -1,6 +1,9 @@
 import { TheTime as TheTime$1 } from "../../../chrono/theTime.mjs";
+import { createKind } from "../../kind.mjs";
 import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
 import { createFundamentalType } from "../base.mjs";
-const TheTime = createFundamentalType(Symbol("FundamentalTypeTheTimeSymbol"), (self, data, errorHandler) => data instanceof TheTime$1 ? SuccessSymbol : errorHandler?.().addIssue(self, data) ?? ErrorSymbol);
+//#region scripts/dataStructure/fundamentalType/defaults/time.ts
+const timeFundamentalTypeKind = createKind("time-fundamental-type");
+const TheTime = createFundamentalType(timeFundamentalTypeKind, (self, data) => data instanceof TheTime$1 ? SuccessSymbol : ErrorSymbol);
 //#endregion
-export { TheTime };
+export { TheTime, timeFundamentalTypeKind };

package/dist/dataStructure/fundamentalType/defaults/undefined.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/undefined.ts
-const FundamentalTypeTheUndefinedSymbol = Symbol("FundamentalTypeTheUndefinedSymbol");
-const TheUndefined = require_base.createFundamentalType(FundamentalTypeTheUndefinedSymbol, (self, data, errorHandler) => data === void 0 ? require_resultSymbol.SuccessSymbol : errorHandler?.().addIssue(self, data) ?? require_resultSymbol.ErrorSymbol);
+const undefinedFundamentalTypeKind = require_kind.createKind("undefined-fundamental-type");
+const TheUndefined = require_base.createFundamentalType(undefinedFundamentalTypeKind, (self, data) => data === void 0 ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol);
 //#endregion
 exports.TheUndefined = TheUndefined;
+exports.undefinedFundamentalTypeKind = undefinedFundamentalTypeKind;

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

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

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

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

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

@@ -1,5 +1,4 @@
 import { FundamentalType } from './base';
-export declare const fundamentalTypeIdentifier: {
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", undefined>>, 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, FundamentalType<symbol, unknown>> extends true ? Extract<import('..').TheBigint, GenericGroupedKind> | Extract<import('..').TheBoolean, GenericGroupedKind> | Extract<import('..').TheDate, GenericGroupedKind> | Extract<import('..').TheNull, GenericGroupedKind> | Extract<import('..').TheNumber, GenericGroupedKind> | Extract<import('..').TheString, GenericGroupedKind> | Extract<import('..').TheTime, GenericGroupedKind> | Extract<import('..').TheUndefined, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", bigint>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", boolean>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheDate>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", null>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", number>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", string>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", import('../../chrono').TheTime>> | import('../../kind').Handler<import('../../kind').Definition<"@DuplojsLangDataStructure/fundamental-type", undefined>>, 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, FundamentalType<symbol, unknown>> extends true ? Extract<import('..').TheBigint, GenericGroupedKind> | Extract<import('..').TheBoolean, GenericGroupedKind> | Extract<import('..').TheDate, GenericGroupedKind> | Extract<import('..').TheNull, GenericGroupedKind> | Extract<import('..').TheNumber, GenericGroupedKind> | Extract<import('..').TheString, GenericGroupedKind> | Extract<import('..').TheTime, GenericGroupedKind> | Extract<import('..').TheUndefined, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-};
+import { FundamentalTypes } from './types';
+import * as DKind from '../../kind';
+export declare const fundamentalTypeIdentifier: DKind.KindIdentifier<FundamentalType<unknown>, FundamentalTypes>;

package/dist/dataStructure/helpers/absolutePath.cjs

@@ -0,0 +1,7 @@
+const require_absolutePath = require("../constraint/defaults/absolutePath.cjs");
+//#region scripts/dataStructure/helpers/absolutePath.ts
+function absolutePath() {
+	return require_absolutePath.AbsolutePathConstraint();
+}
+//#endregion
+exports.absolutePath = absolutePath;

package/dist/dataStructure/helpers/absolutePath.d.ts

@@ -0,0 +1,2 @@
+import { AbsolutePathConstraint } from '../constraint';
+export declare function absolutePath(): AbsolutePathConstraint;

package/dist/dataStructure/helpers/absolutePath.mjs

@@ -0,0 +1,7 @@
+import { AbsolutePathConstraint } from "../constraint/defaults/absolutePath.mjs";
+//#region scripts/dataStructure/helpers/absolutePath.ts
+function absolutePath() {
+	return AbsolutePathConstraint();
+}
+//#endregion
+export { absolutePath };

package/dist/dataStructure/helpers/array.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { ArrayStructure, StructureValue, Structure } from '../structure';
-export declare function array<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericStructure>[]>[] = readonly []>(element: GenericStructure, constraints?: GenericConstraints): ArrayStructure<readonly StructureValue<GenericStructure>[], readonly [...GenericConstraints]>;
+export declare function array<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<readonly StructureValue<GenericStructure>[]>[] = readonly []>(element: GenericStructure, constraints?: GenericConstraints): NoInfer<ArrayStructure<readonly StructureValue<GenericStructure>[], readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/bigint.d.ts

@@ -1,3 +1,3 @@
 import { TypeStructure } from '../structure';
 import { Constraint } from '../constraint';
-export declare function bigint<const GenericConstraints extends readonly Constraint<bigint>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<bigint, readonly [...GenericConstraints]>;
+export declare function bigint<const GenericConstraints extends readonly Constraint<bigint>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<bigint, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/boolean.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-export declare function boolean<const GenericConstraints extends readonly Constraint<boolean>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<boolean, readonly [...GenericConstraints]>;
+export declare function boolean<const GenericConstraints extends readonly Constraint<boolean>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<boolean, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/date.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
 import type * as DChrono from '../../chrono';
-export declare function date<const GenericConstraints extends readonly Constraint<DChrono.TheDate>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<DChrono.TheDate, readonly [...GenericConstraints]>;
+export declare function date<const GenericConstraints extends readonly Constraint<DChrono.TheDate>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<DChrono.TheDate, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/extend.d.ts

@@ -1,3 +1,3 @@
 import { ObjectStructure, ShapeObjectStructureValue, ShapeObjectStructure, StructureInitialValue } from '../structure';
 import type * as DObject from '../../object';
-export declare function extend<GenericObjectStructure extends ObjectStructure, GenericShape extends ShapeObjectStructure>(structure: GenericObjectStructure, shape: GenericShape): ObjectStructure<DObject.AssignObjects<Extract<StructureInitialValue<GenericObjectStructure>, object>, ShapeObjectStructureValue<GenericShape>>, readonly []>;
+export declare function extend<GenericObjectStructure extends ObjectStructure, GenericShape extends ShapeObjectStructure>(structure: GenericObjectStructure, shape: GenericShape): ObjectStructure<DObject.Assign<Extract<StructureInitialValue<GenericObjectStructure>, object>, ShapeObjectStructureValue<GenericShape>>, readonly []>;

package/dist/dataStructure/helpers/index.d.ts

@@ -1,3 +1,4 @@
+export * from './absolutePath';
 export * from './allowedCharacters';
 export * from './array';
 export * from './arrayLengthEqual';
@@ -13,6 +14,8 @@ export * from './greaterThan';
 export * from './greaterThanOrEqual';
 export * from './integer';
 export * from './isNullStructure';
+export * from './isNullable';
+export * from './isOptional';
 export * from './isUndefinedStructure';
 export * from './lazy';
 export * from './lessThan';
@@ -29,21 +32,27 @@ export * from './notZero';
 export * from './null';
 export * from './nullable';
 export * from './number';
+export * from './numberInString';
 export * from './object';
 export * from './odd';
 export * from './optional';
 export * from './partial';
+export * from './path';
 export * from './positive';
 export * from './record';
 export * from './refine';
+export * from './regex';
 export * from './required';
 export * from './safe';
-export * from './string';
+export * from './segmentPath';
 export * from './strictNegative';
 export * from './strictPositive';
+export * from './string';
 export * from './stringLengthEqual';
 export * from './time';
+export * from './trimmed';
 export * from './undefined';
 export * from './union';
+export * from './unwrapLazy';
 export * from './url';
 export * from './uuid';

package/dist/dataStructure/helpers/isNullable.cjs

@@ -0,0 +1,12 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
+const require_union = require("../structure/defaults/union.cjs");
+const require_isNullStructure = require("./isNullStructure.cjs");
+//#region scripts/dataStructure/helpers/isNullable.ts
+function isNullable(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return isNullable(structure.definition.getter.value);
+	if (!require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return require_isNullStructure.isNullStructure(structure);
+	return structure.definition.values.value.some(require_isNullStructure.isNullStructure);
+}
+//#endregion
+exports.isNullable = isNullable;

package/dist/dataStructure/helpers/isNullable.d.ts

@@ -0,0 +1,2 @@
+import { Structure } from '../structure';
+export declare function isNullable(structure: Structure): boolean;

package/dist/dataStructure/helpers/isNullable.mjs

@@ -0,0 +1,12 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
+import { unionStructureKind } from "../structure/defaults/union.mjs";
+import { isNullStructure } from "./isNullStructure.mjs";
+//#region scripts/dataStructure/helpers/isNullable.ts
+function isNullable(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return isNullable(structure.definition.getter.value);
+	if (!structureIdentifier(structure, unionStructureKind)) return isNullStructure(structure);
+	return structure.definition.values.value.some(isNullStructure);
+}
+//#endregion
+export { isNullable };

package/dist/dataStructure/helpers/isOptional.cjs

@@ -0,0 +1,12 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_lazy = require("../structure/defaults/lazy.cjs");
+const require_union = require("../structure/defaults/union.cjs");
+const require_isUndefinedStructure = require("./isUndefinedStructure.cjs");
+//#region scripts/dataStructure/helpers/isOptional.ts
+function isOptional(structure) {
+	if (require_identifier.structureIdentifier(structure, require_lazy.lazyStructureKind)) return isOptional(structure.definition.getter.value);
+	if (!require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return require_isUndefinedStructure.isUndefinedStructure(structure);
+	return structure.definition.values.value.some(require_isUndefinedStructure.isUndefinedStructure);
+}
+//#endregion
+exports.isOptional = isOptional;

package/dist/dataStructure/helpers/isOptional.d.ts

@@ -0,0 +1,2 @@
+import { Structure } from '../structure';
+export declare function isOptional(structure: Structure): boolean;

package/dist/dataStructure/helpers/isOptional.mjs

@@ -0,0 +1,12 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { lazyStructureKind } from "../structure/defaults/lazy.mjs";
+import { unionStructureKind } from "../structure/defaults/union.mjs";
+import { isUndefinedStructure } from "./isUndefinedStructure.mjs";
+//#region scripts/dataStructure/helpers/isOptional.ts
+function isOptional(structure) {
+	if (structureIdentifier(structure, lazyStructureKind)) return isOptional(structure.definition.getter.value);
+	if (!structureIdentifier(structure, unionStructureKind)) return isUndefinedStructure(structure);
+	return structure.definition.values.value.some(isUndefinedStructure);
+}
+//#endregion
+export { isOptional };

package/dist/dataStructure/helpers/lazy.d.ts

@@ -1,3 +1,3 @@
 import { Constraint } from '../constraint';
 import { LazyStructure, StructureValue, Structure } from '../structure';
-export declare function lazy<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[] = readonly []>(getStructure: () => GenericStructure, constraints?: GenericConstraints): LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>;
+export declare function lazy<GenericStructure extends Structure, const GenericConstraints extends readonly Constraint<StructureValue<GenericStructure>>[] = readonly []>(getStructure: () => GenericStructure, constraints?: GenericConstraints): NoInfer<LazyStructure<StructureValue<GenericStructure>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/helpers/null.d.ts

@@ -1,4 +1,4 @@
 import { Constraint } from '../constraint';
 import { TypeStructure } from '../structure';
-declare function nullHelper<const GenericConstraints extends readonly Constraint<null>[] = readonly []>(constraints?: GenericConstraints): TypeStructure<null, readonly [...GenericConstraints]>;
+declare function nullHelper<const GenericConstraints extends readonly Constraint<null>[] = readonly []>(constraints?: GenericConstraints): NoInfer<TypeStructure<null, readonly [...GenericConstraints]>>;
 export { nullHelper as null };

package/dist/dataStructure/helpers/nullable.cjs

@@ -1,12 +1,15 @@
 const require_identifier = require("../structure/identifier.cjs");
 const require_union = require("../structure/defaults/union.cjs");
 const require_isNullStructure = require("./isNullStructure.cjs");
+const require_lazy = require("./lazy.cjs");
 const require_union$1 = require("./union.cjs");
 const require_null = require("./null.cjs");
 //#region scripts/dataStructure/helpers/nullable.ts
 function nullable(structure) {
-	if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.some(require_isNullStructure.isNullStructure) ? require_union$1.union(structure.definition.values) : require_union$1.union([require_null.null(), ...structure.definition.values]);
-	return require_union$1.union([require_null.null(), structure]);
+	return require_union$1.union([require_lazy.lazy(() => {
+		if (require_identifier.structureIdentifier(structure, require_union.unionStructureKind)) return structure.definition.values.value.some(require_isNullStructure.isNullStructure) ? structure : require_union$1.union([require_null.null(), require_union$1.union(structure.definition.values.value)]);
+		return require_union$1.union([require_null.null(), structure]);
+	})]);
 }
 //#endregion
 exports.nullable = nullable;