@duplojs/lang 0.0.1-beta.9 → 0.1.0-beta.1

package/dist/dataStructure/common/error/defaultInterpreter.d.ts

@@ -0,0 +1,60 @@
+import * as DString from '../../../string';
+export declare const defaultErrorInterpreterDataStructureDictionary: {
+    readonly "@DuplojsLangDataStructure/array-structure": () => string;
+    readonly "@DuplojsLangDataStructure/lazy-structure": () => string;
+    readonly "@DuplojsLangDataStructure/non-encodable-string-structure": (source: import('../..').NonEncodableStringStructure) => string;
+    readonly "@DuplojsLangDataStructure/object-structure": () => string;
+    readonly "@DuplojsLangDataStructure/record-structure": () => string;
+    readonly "@DuplojsLangDataStructure/type-structure": () => string;
+    readonly "@DuplojsLangDataStructure/union-structure": () => string;
+    readonly "@DuplojsLangDataStructure/bigint-type": () => string;
+    readonly "@DuplojsLangDataStructure/bigint-literal-type": (source: import('../..').BigintLiteralType<bigint>) => string;
+    readonly "@DuplojsLangDataStructure/boolean-type": () => string;
+    readonly "@DuplojsLangDataStructure/boolean-literal-type": (source: import('../..').BooleanLiteralType<boolean>) => string;
+    readonly "@DuplojsLangDataStructure/date-type": () => string;
+    readonly "@DuplojsLangDataStructure/null-type": () => string;
+    readonly "@DuplojsLangDataStructure/number-type": () => string;
+    readonly "@DuplojsLangDataStructure/number-literal-type": (source: import('../..').NumberLiteralType<number>) => string;
+    readonly "@DuplojsLangDataStructure/string-type": () => string;
+    readonly "@DuplojsLangDataStructure/string-literal-type": (source: import('../..').StringLiteralType<string>) => string;
+    readonly "@DuplojsLangDataStructure/time-type": () => string;
+    readonly "@DuplojsLangDataStructure/undefined-type": () => string;
+    readonly "@DuplojsLangDataStructure/absolute-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/allowed-characters-constraint": (source: import('../..').AllowedCharactersConstraint<DString.CharactersRange>) => string;
+    readonly "@DuplojsLangDataStructure/array-length-equal-constraint": (source: import('../..').ArrayLengthEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/between-than-constraint": (source: import('../..').BetweenThanConstraint<number, number>) => string;
+    readonly "@DuplojsLangDataStructure/between-than-or-equal-constraint": (source: import('../..').BetweenThanOrEqualConstraint<number, number>) => string;
+    readonly "@DuplojsLangDataStructure/email-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/even-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/greater-than-constraint": (source: import('../..').GreaterThanConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source: import('../..').GreaterThanOrEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/integer-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/less-than-constraint": (source: import('../..').LessThanConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/less-than-or-equal-constraint": (source: import('../..').LessThanOrEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/max-characters-constraint": (source: import('../..').MaxCharactersConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/max-elements-constraint": (source: import('../..').MaxElementsConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/min-characters-constraint": (source: import('../..').MinCharactersConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/min-elements-constraint": (source: import('../..').MinElementsConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/multiple-of-constraint": (source: import('../..').MultipleOfConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/negative-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/not-empty-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/not-zero-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/number-in-string-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/odd-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/positive-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/refine-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/regex-constraint": (source: import('../..').RegexConstraint) => string;
+    readonly "@DuplojsLangDataStructure/safe-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/segment-path-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/strict-negative-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/strict-positive-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/string-length-equal-constraint": (source: import('../..').StringLengthEqualConstraint<number>) => string;
+    readonly "@DuplojsLangDataStructure/trimmed-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/url-constraint": () => string;
+    readonly "@DuplojsLangDataStructure/uuid-constraint": () => string;
+    readonly "@DuplojsLangModeling/entity-structure": () => string;
+    readonly "@DuplojsLangModeling/new-type-structure": () => string;
+    readonly "@DuplojsLangModeling/tagged-object-structure": (source: import('../../../modeling').TaggedObjectStructure<import('../../../modeling').ObjectTag<string>>) => string;
+};
+export declare const defaultErrorInterpreterCodecDictionary: [[import('../..').Codec<import('../..').TheBigint, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheDate, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheTime, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheBigint, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheBoolean, "true" | "false">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheDate, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheNull, "null">, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheNumber, string & DString.Number>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheTime, string>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string], [import('../..').Codec<import('../..').TheUndefined, "undefined" | undefined>, (codec: import('../..').Codec, issue: import('../..').EncodeIssue | import('../..').DecodeIssue) => string]];

package/dist/dataStructure/common/error/defaultInterpreter.mjs

@@ -0,0 +1,86 @@
+import { coalescing } from "../../../array/coalescing.mjs";
+import { join } from "../../../string/join.mjs";
+import { stringify } from "../../../string/stringify.mjs";
+import { to } from "../../../string/to.mjs";
+import { codecsJson } from "../codec/defaults/json.mjs";
+import { codecsString } from "../codec/defaults/string.mjs";
+import { encodeIssueKind } from "./base.mjs";
+//#region scripts/dataStructure/common/error/defaultInterpreter.ts
+const defaultErrorInterpreterDataStructureDictionary = {
+	"@DuplojsLangDataStructure/array-structure": () => "Expected an array.",
+	"@DuplojsLangDataStructure/lazy-structure": () => "Expected a value matching the resolved structure.",
+	"@DuplojsLangDataStructure/non-encodable-string-structure": (source) => `Expected ${stringify(source.definition.value)}.`,
+	"@DuplojsLangDataStructure/object-structure": () => "Expected a plain object containing only the defined properties.",
+	"@DuplojsLangDataStructure/record-structure": () => "Expected a plain object matching the record definition.",
+	"@DuplojsLangDataStructure/type-structure": () => "Expected a value matching the configured type.",
+	"@DuplojsLangDataStructure/union-structure": () => "Expected a value matching at least one union member.",
+	"@DuplojsLangDataStructure/bigint-type": () => "Expected a bigint.",
+	"@DuplojsLangDataStructure/bigint-literal-type": (source) => `Expected ${to(source.definition.value)}n.`,
+	"@DuplojsLangDataStructure/boolean-type": () => "Expected a boolean.",
+	"@DuplojsLangDataStructure/boolean-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"@DuplojsLangDataStructure/date-type": () => "Expected a DuploJS date.",
+	"@DuplojsLangDataStructure/null-type": () => "Expected null.",
+	"@DuplojsLangDataStructure/number-type": () => "Expected a finite number.",
+	"@DuplojsLangDataStructure/number-literal-type": (source) => `Expected ${source.definition.value}.`,
+	"@DuplojsLangDataStructure/string-type": () => "Expected a string.",
+	"@DuplojsLangDataStructure/string-literal-type": (source) => `Expected ${stringify(source.definition.value)}.`,
+	"@DuplojsLangDataStructure/time-type": () => "Expected a DuploJS time.",
+	"@DuplojsLangDataStructure/undefined-type": () => "Expected undefined.",
+	"@DuplojsLangDataStructure/absolute-path-constraint": () => "Expected an absolute path.",
+	"@DuplojsLangDataStructure/allowed-characters-constraint": (source) => `Expected a string containing only characters from ${join(coalescing(source.definition.charactersRange), ", ")}.`,
+	"@DuplojsLangDataStructure/array-length-equal-constraint": (source) => `Expected an array containing exactly ${source.definition.length} elements.`,
+	"@DuplojsLangDataStructure/between-than-constraint": (source) => `Expected a number greater than ${source.definition.greater} and less than ${source.definition.less}.`,
+	"@DuplojsLangDataStructure/between-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.greater} and less than or equal to ${source.definition.less}.`,
+	"@DuplojsLangDataStructure/email-constraint": () => "Expected a valid email address.",
+	"@DuplojsLangDataStructure/even-constraint": () => "Expected an even number.",
+	"@DuplojsLangDataStructure/greater-than-constraint": (source) => `Expected a number greater than ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source) => `Expected a number greater than or equal to ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/integer-constraint": () => "Expected an integer.",
+	"@DuplojsLangDataStructure/less-than-constraint": (source) => `Expected a number less than ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/less-than-or-equal-constraint": (source) => `Expected a number less than or equal to ${source.definition.threshold}.`,
+	"@DuplojsLangDataStructure/max-characters-constraint": (source) => `Expected a string containing at most ${source.definition.max} characters.`,
+	"@DuplojsLangDataStructure/max-elements-constraint": (source) => `Expected an array containing at most ${source.definition.max} elements.`,
+	"@DuplojsLangDataStructure/min-characters-constraint": (source) => `Expected a string containing at least ${source.definition.min} characters.`,
+	"@DuplojsLangDataStructure/min-elements-constraint": (source) => `Expected an array containing at least ${source.definition.min} elements.`,
+	"@DuplojsLangDataStructure/multiple-of-constraint": (source) => `Expected a multiple of ${source.definition.multiple}.`,
+	"@DuplojsLangDataStructure/negative-constraint": () => "Expected a number less than or equal to zero.",
+	"@DuplojsLangDataStructure/not-empty-constraint": () => "Expected a non-empty string.",
+	"@DuplojsLangDataStructure/not-zero-constraint": () => "Expected a non-zero number.",
+	"@DuplojsLangDataStructure/number-in-string-constraint": () => "Expected a string representing a number.",
+	"@DuplojsLangDataStructure/odd-constraint": () => "Expected an odd number.",
+	"@DuplojsLangDataStructure/path-constraint": () => "Expected a valid path.",
+	"@DuplojsLangDataStructure/positive-constraint": () => "Expected a number greater than or equal to zero.",
+	"@DuplojsLangDataStructure/refine-constraint": () => "Expected a value satisfying the custom refinement.",
+	"@DuplojsLangDataStructure/regex-constraint": (source) => `Expected a string matching ${source.definition.regex.toString()}.`,
+	"@DuplojsLangDataStructure/safe-constraint": () => "Expected a number strictly between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.",
+	"@DuplojsLangDataStructure/segment-path-constraint": () => "Expected a valid path segment.",
+	"@DuplojsLangDataStructure/strict-negative-constraint": () => "Expected a number less than zero.",
+	"@DuplojsLangDataStructure/strict-positive-constraint": () => "Expected a number greater than zero.",
+	"@DuplojsLangDataStructure/string-length-equal-constraint": (source) => `Expected a string containing exactly ${source.definition.length} characters.`,
+	"@DuplojsLangDataStructure/trimmed-constraint": () => "Expected a string without leading or trailing whitespace.",
+	"@DuplojsLangDataStructure/url-constraint": () => "Expected a valid URL.",
+	"@DuplojsLangDataStructure/uuid-constraint": () => "Expected a valid UUID.",
+	"@DuplojsLangModeling/entity-structure": () => "Expected a valid entity object.",
+	"@DuplojsLangModeling/new-type-structure": () => "Expected a value matching the branded type.",
+	"@DuplojsLangModeling/tagged-object-structure": (source) => `Expected a plain object matching one of the tagged variants of ${source.name}.`
+};
+const createDefaultCodecErrorMessage = (codecName, encodedValueDescription, decodedValueDescription) => (_codec, issue) => {
+	if (issue.from === "predicate") return encodeIssueKind.has(issue) ? `The ${codecName} codec must produce ${encodedValueDescription}.` : `Expected ${encodedValueDescription} for the ${codecName} codec.`;
+	if (issue.from === "encoding") return `The ${codecName} codec could not encode ${decodedValueDescription}.`;
+	if (issue.from === "decoding") return `The ${codecName} codec could not decode the value as ${decodedValueDescription}.`;
+	return `The ${codecName} codec encountered an external error while ${encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+};
+const defaultErrorInterpreterCodecDictionary = [
+	[codecsJson.definition.bigint, createDefaultCodecErrorMessage("JSON bigint", "a string", "a bigint")],
+	[codecsJson.definition.date, createDefaultCodecErrorMessage("JSON date", "a string", "a DuploJS date")],
+	[codecsJson.definition.time, createDefaultCodecErrorMessage("JSON time", "a string", "a DuploJS time")],
+	[codecsString.definition.bigint, createDefaultCodecErrorMessage("string bigint", "a string", "a bigint")],
+	[codecsString.definition.boolean, createDefaultCodecErrorMessage("string boolean", "the string \"true\" or \"false\"", "a boolean")],
+	[codecsString.definition.date, createDefaultCodecErrorMessage("string date", "a string", "a DuploJS date")],
+	[codecsString.definition.null, createDefaultCodecErrorMessage("string null", "the string \"null\"", "null")],
+	[codecsString.definition.number, createDefaultCodecErrorMessage("string number", "a string representing a number", "a finite number")],
+	[codecsString.definition.time, createDefaultCodecErrorMessage("string time", "a string", "a DuploJS time")],
+	[codecsString.definition.undefined, createDefaultCodecErrorMessage("string undefined", "the string \"undefined\"", "undefined")]
+];
+//#endregion
+export { defaultErrorInterpreterCodecDictionary, defaultErrorInterpreterDataStructureDictionary };

package/dist/dataStructure/common/error/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base';
+export * from './interpreter';
+export * from './defaultInterpreter';

package/dist/dataStructure/common/{errorInterpreter.cjs → error/interpreter.cjs}

@@ -1,18 +1,17 @@
-const require_base = require("../../kind/base.cjs");
-const require_entries = require("../../object/entries.cjs");
-const require_entry = require("../../object/entry.cjs");
-const require_map = require("../../array/map.cjs");
-const require_reduce = require("../../array/reduce.cjs");
-const require_pipe = require("../../common/pipe.cjs");
-const require_error = require("./error.cjs");
-//#region scripts/dataStructure/common/errorInterpreter.ts
-const kindNamespaceName = "DuplojsLangDataStructure";
+const require_base = require("../../../kind/base.cjs");
+const require_entries = require("../../../object/entries.cjs");
+const require_entry = require("../../../object/entry.cjs");
+const require_map = require("../../../array/map.cjs");
+const require_reduce = require("../../../array/reduce.cjs");
+const require_pipe = require("../../../common/pipe.cjs");
+const require_base$1 = require("./base.cjs");
+//#region scripts/dataStructure/common/error/interpreter.ts
 function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
-	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}${key}`, value)));
 	const getInterpretedMessageStructure = (structure, issue) => require_reduce.reduce(formattedStructureDictionary, require_reduce.reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure, issue)) : next(void 0));
 	const getInterpretedMessageCodec = (codec, issue) => require_reduce.reduce(codecDictionary, require_reduce.reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message(codec, issue)) : next(void 0));
 	return (error) => require_map.map(error.issues, (issue) => {
-		if (require_error.issueKind.has(issue)) {
+		if (require_base$1.issueKind.has(issue)) {
 			const source = issue.getSource();
 			const subSource = issue.getSubSource?.();
 			return {
@@ -25,7 +24,7 @@ function createErrorInterpreter(structureDictionary = {}, codecDictionary = [])
 				}
 			};
 		}
-		if (require_error.encodeIssueKind.has(issue)) return {
+		if (require_base$1.encodeIssueKind.has(issue)) return {
 			...issue,
 			interpretedMessage: {
 				source: issue.message,

package/dist/dataStructure/common/error/interpreter.d.ts

@@ -0,0 +1,32 @@
+import { Structure, Structures } from '../../structure';
+import { Type, Types } from '../../type';
+import { Constraint, Constraints } from '../../constraint';
+import { Error, DecodeIssue, EncodeIssue, Issue } from './base';
+import { Codec } from '../codec';
+import * as DKind from '../../../kind';
+import * as DCommon from '../../../common';
+export interface InterpretedMessage {
+    source?: string;
+    interpretedSource?: string;
+    subSource?: string;
+    interpretedSubSource?: string;
+}
+export interface InterpretedIssue extends Issue {
+    interpretedMessage: InterpretedMessage;
+}
+export interface InterpretedEncodedIssue extends EncodeIssue {
+    interpretedMessage: InterpretedMessage;
+}
+export interface InterpretedDecodedIssue extends DecodeIssue {
+    interpretedMessage: InterpretedMessage;
+}
+export type InterpretedIssues = (InterpretedIssue | InterpretedEncodedIssue | InterpretedDecodedIssue);
+export type StructureDictionaryParams = DCommon.SimplifyTopLevel<Omit<{
+    [DataStructure in (Types | Structures | Constraints) as DKind.GetName<DataStructure>]?: (structure: DataStructure, issue: Issue) => string;
+}, DKind.GetName<Type> | DKind.GetName<Structure> | DKind.GetName<Constraint>>>;
+export type CodecDictionaryParams = [
+    Codec,
+    (codec: Codec, issue: EncodeIssue | DecodeIssue) => string
+][];
+export declare function createErrorInterpreter(structureDictionary?: StructureDictionaryParams, codecDictionary?: CodecDictionaryParams): (error: Error) => readonly InterpretedIssues[];
+export type ErrorInterpreter = ReturnType<typeof createErrorInterpreter>;

package/dist/dataStructure/common/{errorInterpreter.mjs → error/interpreter.mjs}

@@ -1,14 +1,13 @@
-import { keyKindPrefix } from "../../kind/base.mjs";
-import { entries } from "../../object/entries.mjs";
-import { entry } from "../../object/entry.mjs";
-import { map } from "../../array/map.mjs";
-import { reduce, reduceFrom } from "../../array/reduce.mjs";
-import { pipe } from "../../common/pipe.mjs";
-import { encodeIssueKind, issueKind } from "./error.mjs";
-//#region scripts/dataStructure/common/errorInterpreter.ts
-const kindNamespaceName = "DuplojsLangDataStructure";
+import { keyKindPrefix } from "../../../kind/base.mjs";
+import { entries } from "../../../object/entries.mjs";
+import { entry } from "../../../object/entry.mjs";
+import { map } from "../../../array/map.mjs";
+import { reduce, reduceFrom } from "../../../array/reduce.mjs";
+import { pipe } from "../../../common/pipe.mjs";
+import { encodeIssueKind, issueKind } from "./base.mjs";
+//#region scripts/dataStructure/common/error/interpreter.ts
 function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
-	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
+	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}${key}`, value)));
 	const getInterpretedMessageStructure = (structure, issue) => reduce(formattedStructureDictionary, reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure, issue)) : next(void 0));
 	const getInterpretedMessageCodec = (codec, issue) => reduce(codecDictionary, reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message(codec, issue)) : next(void 0));
 	return (error) => map(error.issues, (issue) => {

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

@@ -1,4 +1,3 @@
 export * from './codec';
 export * from './error';
-export * from './errorInterpreter';
 export * from './resultSymbol';

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

@@ -1,6 +1,7 @@
 import { Constraint } from '../base';
 import type * as DDefaults from "../defaults";
 export interface ConstraintsStore {
+    base: Constraint;
     allowedCharacters: DDefaults.AllowedCharactersConstraint;
     email: DDefaults.EmailConstraint;
     url: DDefaults.UrlConstraint;

package/dist/dataStructure/fundamentalType/types/fundamentalTypes.d.ts

@@ -1,6 +1,7 @@
 import { FundamentalType } from '../base';
 import { TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined } from '../defaults';
 export interface FundamentalTypesStore {
+    base: FundamentalType;
     bigint: TheBigint;
     boolean: TheBoolean;
     date: TheDate;

package/dist/dataStructure/helpers/extend.cjs

@@ -2,7 +2,7 @@ const require_object = require("../structure/defaults/object.cjs");
 //#region scripts/dataStructure/helpers/extend.ts
 function extend(structure, shape) {
 	return require_object.ObjectStructure({
-		...Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, entry.value])),
+		...Object.fromEntries(structure.definition.optimizedShape.value.map((entry) => [entry.key, entry.value])),
 		...shape
 	}, []);
 }

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/extend.mjs

@@ -2,7 +2,7 @@ import { ObjectStructure } from "../structure/defaults/object.mjs";
 //#region scripts/dataStructure/helpers/extend.ts
 function extend(structure, shape) {
 	return ObjectStructure({
-		...Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, entry.value])),
+		...Object.fromEntries(structure.definition.optimizedShape.value.map((entry) => [entry.key, entry.value])),
 		...shape
 	}, []);
 }

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

@@ -51,6 +51,7 @@ export * from './string';
 export * from './stringLengthEqual';
 export * from './time';
 export * from './trimmed';
+export * from './typeStructureIdentifier';
 export * from './undefined';
 export * from './union';
 export * from './unwrapLazy';

package/dist/dataStructure/helpers/partial.cjs

@@ -14,7 +14,7 @@ function partialStructure(structure) {
 	return require_union$1.union([require_undefined.undefined(), structure]);
 }
 function partial(structure) {
-	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => partialStructure(entry.value))])));
+	return require_object.object(Object.fromEntries(structure.definition.optimizedShape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => partialStructure(entry.value))])));
 }
 //#endregion
 exports.partial = partial;

package/dist/dataStructure/helpers/partial.mjs

@@ -14,7 +14,7 @@ function partialStructure(structure) {
 	return union([undefinedHelper(), structure]);
 }
 function partial(structure) {
-	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, lazy(() => partialStructure(entry.value))])));
+	return object(Object.fromEntries(structure.definition.optimizedShape.value.map((entry) => [entry.key, lazy(() => partialStructure(entry.value))])));
 }
 //#endregion
 export { partial };

package/dist/dataStructure/helpers/required.cjs

@@ -15,7 +15,7 @@ function requiredStructure(structure) {
 	return require_union$1.union(values);
 }
 function required(structure) {
-	return require_object.object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => requiredStructure(entry.value))])));
+	return require_object.object(Object.fromEntries(structure.definition.optimizedShape.value.map((entry) => [entry.key, require_lazy$1.lazy(() => requiredStructure(entry.value))])));
 }
 //#endregion
 exports.required = required;

package/dist/dataStructure/helpers/required.mjs

@@ -15,7 +15,7 @@ function requiredStructure(structure) {
 	return union(values);
 }
 function required(structure) {
-	return object(Object.fromEntries(structure.definition.shape.value.map((entry) => [entry.key, lazy(() => requiredStructure(entry.value))])));
+	return object(Object.fromEntries(structure.definition.optimizedShape.value.map((entry) => [entry.key, lazy(() => requiredStructure(entry.value))])));
 }
 //#endregion
 export { required };

package/dist/dataStructure/helpers/typeStructureIdentifier.cjs

@@ -0,0 +1,14 @@
+const require_identifier = require("../structure/identifier.cjs");
+const require_type = require("../structure/defaults/type.cjs");
+const require_identifier$1 = require("../type/identifier.cjs");
+//#region scripts/dataStructure/helpers/typeStructureIdentifier.ts
+function typeStructureIdentifier(...args) {
+	if (args.length === 1) {
+		const [typeKind] = args;
+		return (structure) => typeStructureIdentifier(structure, typeKind);
+	}
+	const [structure, typeKind] = args;
+	return require_identifier.structureIdentifier(structure, require_type.typeStructureKind) && require_identifier$1.typeIdentifier(structure.definition.type, typeKind);
+}
+//#endregion
+exports.typeStructureIdentifier = typeStructureIdentifier;

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

@@ -0,0 +1,6 @@
+import { TypeStructure, Structure } from '../structure';
+import { TypeValue, typeIdentifier, Types } from '../type';
+import type * as DKind from '../../kind';
+import type * as DArray from '../../array';
+export declare function typeStructureIdentifier<GenericTypeKindHandler extends DArray.Unwrap<Parameters<typeof typeIdentifier>[1]>>(typeKind: GenericTypeKindHandler | GenericTypeKindHandler[]): (structure: Structure) => structure is TypeStructure<TypeValue<Extract<Types, DKind.Kind<GenericTypeKindHandler>>>>;
+export declare function typeStructureIdentifier<GenericTypeKindHandler extends DArray.Unwrap<Parameters<typeof typeIdentifier>[1]>>(structure: Structure, typeKind: GenericTypeKindHandler | GenericTypeKindHandler[]): structure is TypeStructure<TypeValue<Extract<Types, DKind.Kind<GenericTypeKindHandler>>>>;

package/dist/dataStructure/helpers/typeStructureIdentifier.mjs

@@ -0,0 +1,14 @@
+import { structureIdentifier } from "../structure/identifier.mjs";
+import { typeStructureKind } from "../structure/defaults/type.mjs";
+import { typeIdentifier } from "../type/identifier.mjs";
+//#region scripts/dataStructure/helpers/typeStructureIdentifier.ts
+function typeStructureIdentifier(...args) {
+	if (args.length === 1) {
+		const [typeKind] = args;
+		return (structure) => typeStructureIdentifier(structure, typeKind);
+	}
+	const [structure, typeKind] = args;
+	return structureIdentifier(structure, typeStructureKind) && typeIdentifier(structure.definition.type, typeKind);
+}
+//#endregion
+export { typeStructureIdentifier };

package/dist/dataStructure/index.cjs

@@ -14,9 +14,10 @@ const require_undefined = require("./fundamentalType/defaults/undefined.cjs");
 const require_identifier = require("./fundamentalType/identifier.cjs");
 const require_json = require("./common/codec/defaults/json.cjs");
 const require_string$1 = require("./common/codec/defaults/string.cjs");
-const require_error = require("./common/error.cjs");
-const require_errorInterpreter = require("./common/errorInterpreter.cjs");
-const require_base$2 = require("./constraint/base.cjs");
+const require_base$2 = require("./common/error/base.cjs");
+const require_interpreter = require("./common/error/interpreter.cjs");
+const require_defaultInterpreter = require("./common/error/defaultInterpreter.cjs");
+const require_base$3 = require("./constraint/base.cjs");
 const require_absolutePath = require("./constraint/defaults/absolutePath.cjs");
 const require_allowedCharacters = require("./constraint/defaults/allowedCharacters.cjs");
 const require_arrayLengthEqual = require("./constraint/defaults/arrayLengthEqual.cjs");
@@ -54,7 +55,7 @@ const require_regex = require("./constraint/defaults/regex.cjs");
 const require_identifier$1 = require("./constraint/identifier.cjs");
 const require_absolutePath$1 = require("./helpers/absolutePath.cjs");
 const require_allowedCharacters$1 = require("./helpers/allowedCharacters.cjs");
-const require_base$3 = require("./structure/base.cjs");
+const require_base$4 = require("./structure/base.cjs");
 const require_array = require("./structure/defaults/array.cjs");
 const require_identifier$2 = require("./structure/identifier.cjs");
 const require_lazy = require("./structure/defaults/lazy.cjs");
@@ -62,7 +63,7 @@ const require_nonEncodableString = require("./structure/defaults/nonEncodableStr
 const require_object = require("./structure/defaults/object.cjs");
 const require_union = require("./structure/defaults/union.cjs");
 const require_type = require("./structure/defaults/type.cjs");
-const require_base$4 = require("./type/base.cjs");
+const require_base$5 = require("./type/base.cjs");
 const require_bigint$1 = require("./type/defaults/bigint.cjs");
 const require_bigintLiteral = require("./type/defaults/bigintLiteral.cjs");
 const require_boolean$1 = require("./type/defaults/boolean.cjs");
@@ -130,6 +131,7 @@ const require_string$3 = require("./helpers/string.cjs");
 const require_stringLengthEqual$1 = require("./helpers/stringLengthEqual.cjs");
 const require_time$2 = require("./helpers/time.cjs");
 const require_trimmed$1 = require("./helpers/trimmed.cjs");
+const require_typeStructureIdentifier = require("./helpers/typeStructureIdentifier.cjs");
 const require_unwrapLazy = require("./helpers/unwrapLazy.cjs");
 const require_url$1 = require("./helpers/url.cjs");
 const require_uuid$1 = require("./helpers/uuid.cjs");
@@ -145,9 +147,11 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	BigintType: () => require_bigint$1.BigintType,
 	BooleanLiteralType: () => require_booleanLiteral.BooleanLiteralType,
 	BooleanType: () => require_boolean$1.BooleanType,
-	ConstraintBase: () => require_base$2.ConstraintBase,
+	ConstraintBase: () => require_base$3.ConstraintBase,
 	DateType: () => require_date$1.DateType,
 	EmailConstraint: () => require_email.EmailConstraint,
+	Error: () => require_base$2.Error,
+	ErrorPromise: () => require_base$2.ErrorPromise,
 	ErrorSymbol: () => require_resultSymbol.ErrorSymbol,
 	EvenConstraint: () => require_even.EvenConstraint,
 	GreaterThanConstraint: () => require_greaterThan.GreaterThanConstraint,
@@ -183,7 +187,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	StringLengthEqualConstraint: () => require_stringLengthEqual.StringLengthEqualConstraint,
 	StringLiteralType: () => require_stringLiteral.StringLiteralType,
 	StringType: () => require_string$2.StringType,
-	StructureClass: () => require_base$3.StructureClass,
+	StructureClass: () => require_base$4.StructureClass,
 	SuccessSymbol: () => require_resultSymbol.SuccessSymbol,
 	TheBigint: () => require_bigint.TheBigint,
 	TheBoolean: () => require_boolean.TheBoolean,
@@ -225,24 +229,26 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	codecsKind: () => require_base.codecsKind,
 	codecsString: () => require_string$1.codecsString,
 	constraintIdentifier: () => require_identifier$1.constraintIdentifier,
-	constraintKind: () => require_base$2.constraintKind,
+	constraintKind: () => require_base$3.constraintKind,
 	createCodec: () => require_base.createCodec,
 	createCodecs: () => require_base.createCodecs,
-	createConstraint: () => require_base$2.createConstraint,
-	createErrorHandler: () => require_error.createErrorHandler,
-	createErrorInterpreter: () => require_errorInterpreter.createErrorInterpreter,
+	createConstraint: () => require_base$3.createConstraint,
+	createErrorHandler: () => require_base$2.createErrorHandler,
+	createErrorInterpreter: () => require_interpreter.createErrorInterpreter,
 	createFundamentalType: () => require_base$1.createFundamentalType,
-	createGetErrorHandler: () => require_error.createGetErrorHandler,
+	createGetErrorHandler: () => require_base$2.createGetErrorHandler,
 	createKind: () => require_kind.createKind,
-	createStructure: () => require_base$3.createStructure,
-	createType: () => require_base$4.createType,
+	createStructure: () => require_base$4.createStructure,
+	createType: () => require_base$5.createType,
 	date: () => require_date$2.date,
 	dateFundamentalTypeKind: () => require_date.dateFundamentalTypeKind,
 	dateTypeKind: () => require_date$1.dateTypeKind,
-	decodeIssueKind: () => require_error.decodeIssueKind,
+	decodeIssueKind: () => require_base$2.decodeIssueKind,
+	defaultErrorInterpreterCodecDictionary: () => require_defaultInterpreter.defaultErrorInterpreterCodecDictionary,
+	defaultErrorInterpreterDataStructureDictionary: () => require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary,
 	email: () => require_email$1.email,
 	emailConstraintKind: () => require_email.emailConstraintKind,
-	encodeIssueKind: () => require_error.encodeIssueKind,
+	encodeIssueKind: () => require_base$2.encodeIssueKind,
 	even: () => require_even$1.even,
 	evenConstraintKind: () => require_even.evenConstraintKind,
 	extend: () => require_extend.extend,
@@ -258,7 +264,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	isNullable: () => require_isNullable.isNullable,
 	isOptional: () => require_isOptional.isOptional,
 	isUndefinedStructure: () => require_isUndefinedStructure.isUndefinedStructure,
-	issueKind: () => require_error.issueKind,
+	issueKind: () => require_base$2.issueKind,
 	lazy: () => require_lazy$1.lazy,
 	lazyStructureKind: () => require_lazy.lazyStructureKind,
 	lessThan: () => require_lessThan$1.lessThan,
@@ -325,14 +331,15 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	stringLiteralTypeKind: () => require_stringLiteral.stringLiteralTypeKind,
 	stringTypeKind: () => require_string$2.stringTypeKind,
 	structureIdentifier: () => require_identifier$2.structureIdentifier,
-	structureKind: () => require_base$3.structureKind,
+	structureKind: () => require_base$4.structureKind,
 	time: () => require_time$2.time,
 	timeFundamentalTypeKind: () => require_time.timeFundamentalTypeKind,
 	timeTypeKind: () => require_time$1.timeTypeKind,
 	trimmed: () => require_trimmed$1.trimmed,
 	trimmedConstraintKind: () => require_trimmed.trimmedConstraintKind,
 	typeIdentifier: () => require_identifier$3.typeIdentifier,
-	typeKind: () => require_base$4.typeKind,
+	typeKind: () => require_base$5.typeKind,
+	typeStructureIdentifier: () => require_typeStructureIdentifier.typeStructureIdentifier,
 	typeStructureKind: () => require_type.typeStructureKind,
 	undefined: () => require_undefined$2.undefined,
 	undefinedFundamentalTypeKind: () => require_undefined.undefinedFundamentalTypeKind,
@@ -356,9 +363,11 @@ exports.BigintLiteralType = require_bigintLiteral.BigintLiteralType;
 exports.BigintType = require_bigint$1.BigintType;
 exports.BooleanLiteralType = require_booleanLiteral.BooleanLiteralType;
 exports.BooleanType = require_boolean$1.BooleanType;
-exports.ConstraintBase = require_base$2.ConstraintBase;
+exports.ConstraintBase = require_base$3.ConstraintBase;
 exports.DateType = require_date$1.DateType;
 exports.EmailConstraint = require_email.EmailConstraint;
+exports.Error = require_base$2.Error;
+exports.ErrorPromise = require_base$2.ErrorPromise;
 exports.ErrorSymbol = require_resultSymbol.ErrorSymbol;
 exports.EvenConstraint = require_even.EvenConstraint;
 exports.GreaterThanConstraint = require_greaterThan.GreaterThanConstraint;
@@ -394,7 +403,7 @@ exports.StrictPositiveConstraint = require_strictPositive.StrictPositiveConstrai
 exports.StringLengthEqualConstraint = require_stringLengthEqual.StringLengthEqualConstraint;
 exports.StringLiteralType = require_stringLiteral.StringLiteralType;
 exports.StringType = require_string$2.StringType;
-exports.StructureClass = require_base$3.StructureClass;
+exports.StructureClass = require_base$4.StructureClass;
 exports.SuccessSymbol = require_resultSymbol.SuccessSymbol;
 exports.TheBigint = require_bigint.TheBigint;
 exports.TheBoolean = require_boolean.TheBoolean;
@@ -436,17 +445,17 @@ exports.codecsJson = require_json.codecsJson;
 exports.codecsKind = require_base.codecsKind;
 exports.codecsString = require_string$1.codecsString;
 exports.constraintIdentifier = require_identifier$1.constraintIdentifier;
-exports.constraintKind = require_base$2.constraintKind;
+exports.constraintKind = require_base$3.constraintKind;
 exports.createCodec = require_base.createCodec;
 exports.createCodecs = require_base.createCodecs;
-exports.createConstraint = require_base$2.createConstraint;
-exports.createErrorHandler = require_error.createErrorHandler;
-exports.createErrorInterpreter = require_errorInterpreter.createErrorInterpreter;
+exports.createConstraint = require_base$3.createConstraint;
+exports.createErrorHandler = require_base$2.createErrorHandler;
+exports.createErrorInterpreter = require_interpreter.createErrorInterpreter;
 exports.createFundamentalType = require_base$1.createFundamentalType;
-exports.createGetErrorHandler = require_error.createGetErrorHandler;
+exports.createGetErrorHandler = require_base$2.createGetErrorHandler;
 exports.createKind = require_kind.createKind;
-exports.createStructure = require_base$3.createStructure;
-exports.createType = require_base$4.createType;
+exports.createStructure = require_base$4.createStructure;
+exports.createType = require_base$5.createType;
 Object.defineProperty(exports, "dataStructure_exports", {
 	enumerable: true,
 	get: function() {
@@ -456,10 +465,12 @@ Object.defineProperty(exports, "dataStructure_exports", {
 exports.date = require_date$2.date;
 exports.dateFundamentalTypeKind = require_date.dateFundamentalTypeKind;
 exports.dateTypeKind = require_date$1.dateTypeKind;
-exports.decodeIssueKind = require_error.decodeIssueKind;
+exports.decodeIssueKind = require_base$2.decodeIssueKind;
+exports.defaultErrorInterpreterCodecDictionary = require_defaultInterpreter.defaultErrorInterpreterCodecDictionary;
+exports.defaultErrorInterpreterDataStructureDictionary = require_defaultInterpreter.defaultErrorInterpreterDataStructureDictionary;
 exports.email = require_email$1.email;
 exports.emailConstraintKind = require_email.emailConstraintKind;
-exports.encodeIssueKind = require_error.encodeIssueKind;
+exports.encodeIssueKind = require_base$2.encodeIssueKind;
 exports.even = require_even$1.even;
 exports.evenConstraintKind = require_even.evenConstraintKind;
 exports.extend = require_extend.extend;
@@ -475,7 +486,7 @@ exports.isNullStructure = require_isNullStructure.isNullStructure;
 exports.isNullable = require_isNullable.isNullable;
 exports.isOptional = require_isOptional.isOptional;
 exports.isUndefinedStructure = require_isUndefinedStructure.isUndefinedStructure;
-exports.issueKind = require_error.issueKind;
+exports.issueKind = require_base$2.issueKind;
 exports.lazy = require_lazy$1.lazy;
 exports.lazyStructureKind = require_lazy.lazyStructureKind;
 exports.lessThan = require_lessThan$1.lessThan;
@@ -542,14 +553,15 @@ exports.stringLengthEqualConstraintKind = require_stringLengthEqual.stringLength
 exports.stringLiteralTypeKind = require_stringLiteral.stringLiteralTypeKind;
 exports.stringTypeKind = require_string$2.stringTypeKind;
 exports.structureIdentifier = require_identifier$2.structureIdentifier;
-exports.structureKind = require_base$3.structureKind;
+exports.structureKind = require_base$4.structureKind;
 exports.time = require_time$2.time;
 exports.timeFundamentalTypeKind = require_time.timeFundamentalTypeKind;
 exports.timeTypeKind = require_time$1.timeTypeKind;
 exports.trimmed = require_trimmed$1.trimmed;
 exports.trimmedConstraintKind = require_trimmed.trimmedConstraintKind;
 exports.typeIdentifier = require_identifier$3.typeIdentifier;
-exports.typeKind = require_base$4.typeKind;
+exports.typeKind = require_base$5.typeKind;
+exports.typeStructureIdentifier = require_typeStructureIdentifier.typeStructureIdentifier;
 exports.typeStructureKind = require_type.typeStructureKind;
 exports.undefined = require_undefined$2.undefined;
 exports.undefinedFundamentalTypeKind = require_undefined.undefinedFundamentalTypeKind;