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

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

@@ -0,0 +1,87 @@
+const require_coalescing = require("../../../array/coalescing.cjs");
+const require_join = require("../../../string/join.cjs");
+const require_stringify = require("../../../string/stringify.cjs");
+const require_to = require("../../../string/to.cjs");
+const require_json = require("../codec/defaults/json.cjs");
+const require_string = require("../codec/defaults/string.cjs");
+const require_base = require("./base.cjs");
+//#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 ${require_stringify.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 ${require_to.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 ${require_stringify.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 ${require_join.join(require_coalescing.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 require_base.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 ${require_base.encodeIssueKind.has(issue) ? "encoding" : "decoding"}.`;
+};
+const defaultErrorInterpreterCodecDictionary = [
+	[require_json.codecsJson.definition.bigint, createDefaultCodecErrorMessage("JSON bigint", "a string", "a bigint")],
+	[require_json.codecsJson.definition.date, createDefaultCodecErrorMessage("JSON date", "a string", "a DuploJS date")],
+	[require_json.codecsJson.definition.time, createDefaultCodecErrorMessage("JSON time", "a string", "a DuploJS time")],
+	[require_string.codecsString.definition.bigint, createDefaultCodecErrorMessage("string bigint", "a string", "a bigint")],
+	[require_string.codecsString.definition.boolean, createDefaultCodecErrorMessage("string boolean", "the string \"true\" or \"false\"", "a boolean")],
+	[require_string.codecsString.definition.date, createDefaultCodecErrorMessage("string date", "a string", "a DuploJS date")],
+	[require_string.codecsString.definition.null, createDefaultCodecErrorMessage("string null", "the string \"null\"", "null")],
+	[require_string.codecsString.definition.number, createDefaultCodecErrorMessage("string number", "a string representing a number", "a finite number")],
+	[require_string.codecsString.definition.time, createDefaultCodecErrorMessage("string time", "a string", "a DuploJS time")],
+	[require_string.codecsString.definition.undefined, createDefaultCodecErrorMessage("string undefined", "the string \"undefined\"", "undefined")]
+];
+//#endregion
+exports.defaultErrorInterpreterCodecDictionary = defaultErrorInterpreterCodecDictionary;
+exports.defaultErrorInterpreterDataStructureDictionary = defaultErrorInterpreterDataStructureDictionary;

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/error/interpreter.cjs

@@ -0,0 +1,44 @@
+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}${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_base$1.issueKind.has(issue)) {
+			const source = issue.getSource();
+			const subSource = issue.getSubSource?.();
+			return {
+				...issue,
+				interpretedMessage: {
+					source: source.definition.message,
+					subSource: subSource?.definition.message,
+					interpretedSource: getInterpretedMessageStructure(source, issue),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource, issue)
+				}
+			};
+		}
+		if (require_base$1.encodeIssueKind.has(issue)) return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+		return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+	});
+}
+//#endregion
+exports.createErrorInterpreter = createErrorInterpreter;

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/error/interpreter.mjs

@@ -0,0 +1,44 @@
+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}${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) => {
+		if (issueKind.has(issue)) {
+			const source = issue.getSource();
+			const subSource = issue.getSubSource?.();
+			return {
+				...issue,
+				interpretedMessage: {
+					source: source.definition.message,
+					subSource: subSource?.definition.message,
+					interpretedSource: getInterpretedMessageStructure(source, issue),
+					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource, issue)
+				}
+			};
+		}
+		if (encodeIssueKind.has(issue)) return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+		return {
+			...issue,
+			interpretedMessage: {
+				source: issue.message,
+				interpretedSource: getInterpretedMessageCodec(issue.getSource(), issue)
+			}
+		};
+	});
+}
+//#endregion
+export { createErrorInterpreter };

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/defaults/allowedCharacters.d.ts

@@ -3,11 +3,9 @@ import type * as DCommon from '../../../common';
 import type * as DKind from '../../../kind';
 import * as DString from '../../../string';
 export declare const allowedCharactersConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/allowed-characters-constraint", unknown>>;
-type AllowedCharactersConstraintValue<GenericCharactersRange extends DString.CharactersRange> = string & DCommon.UnionToIntersection<GenericCharactersRange extends any ? DString.AllowedCharacters<GenericCharactersRange> : never>;
 export interface AllowedCharactersConstraintDefinition<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends ConstraintDefinition {
     readonly charactersRange: DCommon.MaybeArray<GenericCharactersRange>;
 }
-export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.Forward<Constraint<string, AllowedCharactersConstraintValue<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
+export interface AllowedCharactersConstraint<GenericCharactersRange extends DString.CharactersRange = DString.CharactersRange> extends DCommon.Forward<Constraint<string, string & DString.AllowedCharacters<GenericCharactersRange>, AllowedCharactersConstraintDefinition<GenericCharactersRange>> & DKind.Kind<typeof allowedCharactersConstraintKind>> {
 }
 export declare const AllowedCharactersConstraint: <GenericCharactersRange extends DString.CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>) => AllowedCharactersConstraint<GenericCharactersRange>;
-export {};

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

@@ -14,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';
@@ -39,17 +41,19 @@ export * from './path';
 export * from './positive';
 export * from './record';
 export * from './refine';
+export * from './regex';
 export * from './required';
 export * from './safe';
 export * from './segmentPath';
-export * from './string';
 export * from './strictNegative';
 export * from './strictPositive';
+export * from './string';
 export * from './stringLengthEqual';
 export * from './time';
 export * from './trimmed';
+export * from './typeStructureIdentifier';
 export * from './undefined';
 export * from './union';
+export * from './unwrapLazy';
 export * from './url';
 export * from './uuid';
-export * from './regex';

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