npm - xdbc - Versions diffs - 1.0.73 - Mend

xdbc 1.0.73

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/.vscode/settings.json ADDED Viewed

@@ -0,0 +1,3 @@
+{
+	"cSpell.words": ["alia", "esign", "ontract", "Paramvalue"]
+}

package/Test.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Load test.js</title>
+</head>
+<body>
+    <h1>Loading test.js Script</h1>
+    <script src="dist/test.js" type="module"></script>
+    <script>
+    </script>
+    <p>Check the browser's developer console (usually opened with F12) for output.</p>
+</body>
+</html>

package/biome.json ADDED Viewed

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "vcs": {
+    "enabled": false,
+    "clientKind": "git",
+    "useIgnoreFile": false
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "ignore": []
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "tab"
+  },
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "parser": {
+      "unsafeParameterDecoratorsEnabled": true
+    },
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  }
+}

package/dist/DBC/AE.js ADDED Viewed

@@ -0,0 +1,163 @@
+import { DBC } from "../DBC.js";
+/**
+ * A {@link DBC } defining that all elements of an {@link object }s have to fulfill
+ * a given {@link object }'s check-method (( toCheck : any ) => boolean | string ).
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class AE extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks each element of the "value"-{@link Array < any >} against the given "condition", if it is one. If it is not
+     * the "value" itself will be checked.
+     *
+     * @param condition	The { check: (toCheck: any) => boolean | string } to check the "value" against.
+     * @param value		Either "value"-{@link Array < any >}, which's elements will be checked, or the value to be
+     * 					checked itself.
+     * @param index		If specified with "idxEnd" being undefined, this {@link Number } will be seen as the index of
+     * 					the value-{@link Array }'s element to check. If value isn't an {@link Array } this parameter
+     * 					will not have any effect.
+     * 					With "idxEnd" not undefined this parameter indicates the beginning of the span of elements to
+     * 					check within the value-{@link Array }.
+     * @param idxEnd	Indicates the last element's index (including) of the span of value-{@link Array } elements to check.
+     * 					Setting this parameter to -1 specifies that all value-{@link Array }'s elements beginning from the
+     * 					specified "index" shall be checked.
+     *
+     * @returns As soon as the "condition" returns a {@link string }, instead of TRUE, the returned string. TRUE if the
+     * 			"condition" never returns a {@link string}. */
+    static checkAlgorithm(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    condition, value, index, idxEnd) {
+        if (Array.isArray(value)) {
+            if (index !== undefined && idxEnd === undefined) {
+                if (index > -1 && index < value.length) {
+                    const result = condition.check(value[index]);
+                    if (typeof result === "string") {
+                        return `Violating-Arrayelement at index "${index}" with value "${value[index]}". ${result}`;
+                    }
+                }
+                return true; // In order for optional parameter to not cause an error if they are omitted.
+            }
+            for (let i = index; i <
+                (idxEnd !== undefined
+                    ? idxEnd !== -1
+                        ? idxEnd + 1
+                        : value.length
+                    : value.length); i++) {
+                const result = condition.check(value[i]);
+                if (result !== true) {
+                    return `Violating-Arrayelement at index ${i}. ${result}`;
+                }
+            }
+        }
+        else {
+            return condition.check(value);
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one
+     * of the "realConditions" to check the tagged parameter-value against with.
+     * When specifying an "index" and the tagged parameter's "value" is an {@link Array }, the "realConditions" apply to the
+     * element at the specified "index".
+     * If the {@link Array } is too short the currently processed { check: (toCheck: any) => boolean | string } of
+     * "realConditions" will be verified to TRUE automatically, considering optional parameters.
+     * If an "index" is specified but the tagged parameter's value isn't an array, the "index" is treated as being undefined.
+     * If "index" is undefined and the tagged parameter's value is an {@link Array } each element of it will be checked
+     * against the "realConditions".
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param dbc				See {@link DBC.decPrecondition }.
+     *
+     * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of "realConditions" returns one.
+     * 			Otherwise TRUE. */
+    static PRE(realConditions, index = undefined, idxEnd = undefined, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            if (Array.isArray(realConditions)) {
+                for (const currentCondition of realConditions) {
+                    const result = AE.checkAlgorithm(currentCondition, value, index, idxEnd);
+                    if (typeof result !== "boolean")
+                        return result;
+                }
+            }
+            else {
+                return AE.checkAlgorithm(
+                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                realConditions, value, index, idxEnd);
+            }
+            return true;
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one
+     * of the "realConditions" to check the tagged method's return-value against with.
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param dbc				See {@link DBC.decPrecondition }.
+     *
+     * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of "realConditions" return one.
+     * 			Otherwise TRUE. */
+    static POST(realConditions, index = undefined, idxEnd = undefined, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition((value, target, propertyKey) => {
+            if (Array.isArray(realConditions)) {
+                for (const currentCondition of realConditions) {
+                    const result = AE.checkAlgorithm(currentCondition, value, index, idxEnd);
+                    if (typeof result !== "boolean")
+                        return result;
+                }
+            }
+            else {
+                return AE.checkAlgorithm(
+                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                realConditions, value, index, idxEnd);
+            }
+            return true;
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like global functions).
+    //
+    /**
+     * Invokes the {@link AE.checkAlgorithm } passing the value "toCheck", {@link AE.equivalent } and {@link EQ.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck) {
+        if (Array.isArray(this.conditions)) {
+            for (const currentCondition of this.conditions) {
+                const result = AE.checkAlgorithm(currentCondition, toCheck, this.index, this.idxEnd);
+                if (typeof result !== "boolean")
+                    return result;
+            }
+        }
+        else {
+            return AE.checkAlgorithm(
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            this.conditions, toCheck, this.index, this.idxEnd);
+        }
+        return true;
+    }
+    /**
+     * Creates this {@link AE } by setting the protected property {@link AE.conditions }, {@link AE.index } and {@link AE.idxEnd } used by {@link AE.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(conditions, index = undefined, idxEnd = undefined) {
+        super();
+        this.conditions = conditions;
+        this.index = index;
+        this.idxEnd = idxEnd;
+    }
+}

package/dist/DBC/EQ.js ADDED Viewed

@@ -0,0 +1,86 @@
+import { DBC } from "../DBC.js";
+/**
+ * A {@link DBC } defining that two {@link object }s gotta be equal.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class EQ extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the value "toCheck" is equal to the specified "equivalent".
+     *
+     * @param toCheck		The value that has to be equal to it's possible "equivalent" for this {@link DBC } to be fulfilled.
+     * @param equivalent	The {@link object } the one "toCheck" has to be equal to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value "toCheck" and the "equivalent" are equal to each other, otherwise FALSE. */
+    static checkAlgorithm(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck, equivalent, invert) {
+        if (!invert && equivalent !== toCheck) {
+            return `Value has to to be equal to "${equivalent}"`;
+        }
+        if (invert && equivalent === toCheck) {
+            return `Value must not to be equal to "${equivalent}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+    equivalent, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return EQ.checkAlgorithm(value, equivalent, invert);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+    equivalent, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition((value, target, propertyKey) => {
+            return EQ.checkAlgorithm(value, equivalent, invert);
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value "toCheck", {@link EQ.equivalent } and {@link EQ.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return EQ.checkAlgorithm(toCheck, this.equivalent, this.invert);
+    }
+    /**
+     * Creates this {@link EQ } by setting the protected property {@link EQ.equivalent } used by {@link EQ.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(
+    // biome-ignore lint/suspicious/noExplicitAny: To be able to match UNDEFINED and NULL.
+    equivalent, invert = false) {
+        super();
+        this.equivalent = equivalent;
+        this.invert = invert;
+    }
+}

package/dist/DBC/INSTANCE.js ADDED Viewed

@@ -0,0 +1,80 @@
+import { DBC } from "../DBC.js";
+/**
+ * A {@link DBC } defining that the an {@link object }s gotta be an instance of a certain {@link INSTANCE.reference }.
+ *
+ * @remarks
+ * Author: 		Salvatore Callari (Callari@WaXCode.net) / 2025
+ * Maintainer:	Salvatore Callari (XDBC@WaXCode.net) */
+export class INSTANCE extends DBC {
+    /**
+     * Checks if the value "toCheck" is complies to the {@link RegExp } "expression".
+     *
+     * @param toCheck	The value that has comply to the {@link RegExp } "expression" for this {@link DBC } to be fulfilled.
+     * @param reference		The {@link RegExp } the one "toCheck" has comply to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value "toCheck" is of the specified "type", otherwise FALSE. */
+    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+    static checkAlgorithm(toCheck, reference) {
+        if (!(toCheck instanceof reference)) {
+            return `Value has to be an instance of "${reference}" but is of type "${typeof toCheck}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+    reference, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return INSTANCE.checkAlgorithm(value, reference);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.Postcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+    reference, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition((value, target, propertyKey) => {
+            return INSTANCE.checkAlgorithm(value, reference);
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value "toCheck" and the {@link INSTANCE.reference } .
+     *
+     * @param toCheck See {@link INSTANCE.checkAlgorithm }.
+     *
+     * @returns See {@link INSTANCE.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return INSTANCE.checkAlgorithm(toCheck, this.reference);
+    }
+    /**
+     * Creates this {@link INSTANCE } by setting the protected property {@link INSTANCE.reference } used by {@link INSTANCE.check }.
+     *
+     * @param reference See {@link INSTANCE.check }. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    constructor(reference) {
+        super();
+        this.reference = reference;
+    }
+}

package/dist/DBC/JSON.OP.js ADDED Viewed

@@ -0,0 +1,121 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } demanding that an {@link object } has specific properties of specific types.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class JSON_OP extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the object "toCheck" has the "necessaryProperties" of necessary type.
+     *
+     * @param toCheck				The {@link object } to check for the necessary properties.
+     * @param necessaryProperties	The { name : string, type : string }s defining the properties and type the {@link object } to
+     * 								check needs to have.
+     * @param checkElements			Indicates if "toCheck" is an iterable object of which all elements have to be checked.
+     * 								Elements will only be checked if "toCheck" is iterable, otherwise "toCheck" itself
+     * 								will be checked.
+     *
+     * @returns TRUE if the value "toCheck" or it's elements, if "checkElements is TRUE, has all "necessaryProperties", otherwise a {@link string } to report the infringement. */
+    static checkAlgorithm(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck, necessaryProperties, checkElements) {
+        if (toCheck === undefined || null) {
+            return `[ UNDEFINED or NULL received instead of object with following properties: ${JSON.stringify(necessaryProperties)} ]`;
+        }
+        for (const property of necessaryProperties)
+            if (checkElements && typeof toCheck[Symbol.iterator] === "function") {
+                for (const element of toCheck) {
+                    if (
+                    // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+                    !element.hasOwnProperty(property.name) ||
+                        // biome-ignore lint/suspicious/useValidTypeof: <explanation>
+                        typeof element[property.name] !== property.type) {
+                        return `[ Object "${JSON.stringify(element)}" in Array "${JSON.stringify(toCheck)}" does not contain the necessary property "${property.name}" of type "${property.type}"]`;
+                    }
+                }
+            }
+            else {
+                if (
+                // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+                !toCheck.hasOwnProperty(property.name) ||
+                    // biome-ignore lint/suspicious/useValidTypeof: <explanation>
+                    typeof toCheck[property.name] !== property.type) {
+                    return `[ Object does not contain the necessary property "${property.name}" of type "${property.type}"]`;
+                }
+            }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(necessaryProperties, checkElements = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return JSON_OP.checkAlgorithm(value, necessaryProperties, checkElements);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(necessaryProperties, checkElements = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition(
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        (value, target, propertyKey) => {
+            return JSON_OP.checkAlgorithm(value, necessaryProperties, checkElements);
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link JSON_OP.checkAlgorithm } passing the value "toCheck", {@link JSON_OP.necessaryProperties } and {@link JSON_OP.checkElements }.
+     *
+     * @param toCheck See {@link JSON_OP.checkAlgorithm }.
+     *
+     * @returns See {@link JSON_OP.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return JSON_OP.checkAlgorithm(toCheck, this.necessaryProperties, this.checkElements);
+    }
+    /**
+     * Creates this {@link JSON_OP } by setting the protected property {@link JSON_OP.necessaryProperties } and {@link checkElements } used by {@link JSON_OP.check }.
+     *
+     * @param necessaryProperties	See {@link JSON_OP.check }.
+     * @param checkElements 		See {@link JSON_OP.check }. */
+    constructor(necessaryProperties, checkElements = false) {
+        super();
+        this.necessaryProperties = necessaryProperties;
+        this.checkElements = checkElements;
+    }
+    // #endregion Referenced Condition checking.
+    // #region In-Method checking.
+    /**
+     * Invokes the {@link JSON_OP.checkAlgorithm } passing the value "toCheck", {@link JSON_OP.necessaryProperties } and {@link JSON_OP.checkElements }.
+     *
+     * @param toCheck				See {@link JSON_OP.checkAlgorithm} }.
+     * @param necessaryProperties	See {@link JSON_OP.checkAlgorithm} }.
+     * @param checkElements			See {@link JSON_OP.checkAlgorithm} }.
+     */
+    static check(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck, necessaryProperties, checkElements = false) {
+        const checkResult = JSON_OP.checkAlgorithm(toCheck, necessaryProperties, checkElements);
+        if (typeof checkResult === "string") {
+            throw new DBC.Infringement(checkResult);
+        }
+    }
+}

package/dist/DBC/JSON.Parse.js ADDED Viewed

@@ -0,0 +1,102 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } demanding that a {@link string } is {@link JSON.parse}able.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class JSON_Parse extends DBC {
+    // #region Condition checking.
+    /**
+     * Tries to {@link JSON.parse } the {@link string } "toCheck" invoking the "receptor" with the result, if so.
+     *
+     * @param toCheck	The {@link string } to be {@link JSON.parse }d.
+     * @param receptor	The ( json : object ) => void to receive the {@link JSON.parse }d {@link string } "toCheck".
+     * 								check needs to have.
+     *
+     * @returns TRUE if the value "toCheck" is a valid JSON, otherwise a {@link string } to report the infringement. */
+    static checkAlgorithm(toCheck, receptor) {
+        // biome-ignore lint/suspicious/noExplicitAny: JSON.parse returns any.
+        let parsed;
+        try {
+            parsed = JSON.parse(toCheck);
+        }
+        catch (X) {
+            return `[ Following string is not a valid JSON: ${toCheck}]`;
+        }
+        if (receptor) {
+            receptor(parsed);
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link JSON_Parse.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param receptor	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(receptor, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return JSON_Parse.checkAlgorithm(value, receptor);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link JSON_Parse.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(receptor, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition(
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        (value, target, propertyKey) => {
+            return JSON_Parse.checkAlgorithm(value, receptor);
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link JSON_Parse.checkAlgorithm } passing the value "toCheck" and {@link JSON_Parse.receptor }.
+     *
+     * @param toCheck See {@link JSON_Parse.checkAlgorithm }.
+     *
+     * @returns See {@link JSON_Parse.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return JSON_Parse.checkAlgorithm(toCheck, this.receptor);
+    }
+    /**
+     * Creates this {@link JSON_Parse } by setting the protected property {@link JSON_Parse.necessaryProperties } and {@link checkElements } used by {@link JSON_Parse.check }.
+     *
+     * @param necessaryProperties	See {@link JSON_Parse.check }.
+     * @param checkElements 		See {@link JSON_Parse.check }. */
+    constructor(receptor) {
+        super();
+        this.receptor = receptor;
+    }
+    // #endregion Referenced Condition checking.
+    // #region In-Method checking.
+    /**
+     * Invokes the {@link JSON_Parse.checkAlgorithm } passing the value "toCheck", {@link JSON_Parse.necessaryProperties } and {@link JSON_Parse.checkElements }.
+     *
+     * @param toCheck				See {@link JSON_Parse.checkAlgorithm} }.
+     * @param necessaryProperties	See {@link JSON_Parse.checkAlgorithm} }.
+     * @param checkElements			See {@link JSON_Parse.checkAlgorithm} }.
+     */
+    static check(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck, receptor) {
+        const checkResult = JSON_Parse.checkAlgorithm(toCheck, receptor);
+        if (typeof checkResult === "string") {
+            throw new DBC.Infringement(checkResult);
+        }
+    }
+}