xdbc 1.0.217 → 1.0.219

package/dist/DBC/DOM.js

@@ -0,0 +1,362 @@
+import { DBC } from "../DBC";
+import { COMPARISON } from "./COMPARISON";
+import { DEFINED } from "./DEFINED";
+import { EQ } from "./EQ";
+import { REGEX } from "./REGEX";
+import { TYPE } from "./TYPE";
+import { UNDEFINED } from "./UNDEFINED";
+// ─── Contract registry ────────────────────────────────────────────────────────
+/**
+ * Maps a `data-xdbc-<key>` attribute suffix to a check function.
+ * Populated by {@link registerDOMContract } and the built-in defaults below.
+ */
+const registry = new Map();
+/**
+ * Registers a check function for a `data-xdbc-<key>` attribute.
+ * Call this before {@link scanDOM } to make a contract available declaratively.
+ *
+ * @param key       The attribute suffix (e.g. `"type"` → `data-xdbc-type`).
+ * @param checkFn   Receives the live field value and the raw attribute string.
+ *                  Return `true` when the value is valid, or a `string` message when it is not.
+ *
+ * @example
+ * ```ts
+ * import { registerDOMContract } from "xdbc/DBC/DOM";
+ * import { MY_CONTRACT } from "./MY_CONTRACT";
+ *
+ * registerDOMContract("my-contract", (value, attr) =>
+ *     MY_CONTRACT.checkAlgorithm(value, attr),
+ * );
+ * ```
+ */
+export function registerDOMContract(key, checkFn) {
+    registry.set(key, checkFn);
+}
+// ─── Built-in registrations ───────────────────────────────────────────────────
+// data-xdbc-regex="^\d*$"
+registerDOMContract("regex", (value, attr) => {
+    let rx;
+    try {
+        rx = new RegExp(attr);
+    }
+    catch (_a) {
+        return `[XDBC] Invalid RegExp pattern: "${attr}"`;
+    }
+    return REGEX.checkAlgorithm(value, rx);
+});
+// data-xdbc-regex-input="^\d*$"  (always validated on every keystroke, regardless of data-xdbc-validate-on)
+registerDOMContract("regex-input", (value, attr) => {
+    let rx;
+    try {
+        rx = new RegExp(attr);
+    }
+    catch (_a) {
+        return `[XDBC] Invalid RegExp pattern: "${attr}"`;
+    }
+    return REGEX.checkAlgorithm(value, rx);
+});
+// data-xdbc-type="string|number"
+registerDOMContract("type", (value, attr) => TYPE.checkAlgorithm(value, attr));
+registerDOMContract("type-input", (value, attr) => TYPE.checkAlgorithm(value, attr));
+// data-xdbc-eq="hello"
+registerDOMContract("eq", (value, attr) => EQ.checkAlgorithm(value, attr, false));
+registerDOMContract("eq-input", (value, attr) => EQ.checkAlgorithm(value, attr, false));
+// data-xdbc-different="forbidden"
+registerDOMContract("different", (value, attr) => EQ.checkAlgorithm(value, attr, true));
+registerDOMContract("different-input", (value, attr) => EQ.checkAlgorithm(value, attr, true));
+// data-xdbc-defined  (attribute presence is enough; value ignored)
+registerDOMContract("defined", (value) => DEFINED.checkAlgorithm(value));
+registerDOMContract("defined-input", (value) => DEFINED.checkAlgorithm(value));
+// data-xdbc-undefined
+registerDOMContract("undefined", (value) => UNDEFINED.checkAlgorithm(value));
+registerDOMContract("undefined-input", (value) => UNDEFINED.checkAlgorithm(value));
+// data-xdbc-greater="5"
+registerDOMContract("greater", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), false, false));
+registerDOMContract("greater-input", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), false, false));
+// data-xdbc-greater-or-equal="5"
+registerDOMContract("greater-or-equal", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), true, false));
+registerDOMContract("greater-or-equal-input", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), true, false));
+// data-xdbc-less="100"
+registerDOMContract("less", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), false, true));
+registerDOMContract("less-input", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), false, true));
+// data-xdbc-less-or-equal="100"
+registerDOMContract("less-or-equal", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), true, true));
+registerDOMContract("less-or-equal-input", (value, attr) => COMPARISON.checkAlgorithm(Number(value), Number(attr), true, true));
+// data-xdbc-or="regex:^\d+$;;type:string;;eq:42"
+// Fragments are separated by ";;". Each fragment is "<contract-key>:<attr-value>",
+// where the split is on the FIRST ":" only, so colons in the value (e.g. regex) are safe.
+// The OR passes as long as at least one fragment passes.
+registerDOMContract("or", (value, attr) => {
+    const fragments = attr.split(";;");
+    const messages = [];
+    for (const fragment of fragments) {
+        const colonIdx = fragment.indexOf(":");
+        const key = colonIdx === -1 ? fragment.trim() : fragment.slice(0, colonIdx).trim();
+        const fragAttr = colonIdx === -1 ? "" : fragment.slice(colonIdx + 1);
+        const checkFn = registry.get(key);
+        if (!checkFn) {
+            console.warn(`[XDBC] data-xdbc-or: unknown contract key "${key}"`);
+            continue;
+        }
+        const result = checkFn(value, fragAttr);
+        if (result === true)
+            return true; // short-circuit on first pass
+        if (typeof result === "string")
+            messages.push(result);
+    }
+    return messages.length > 0
+        ? `Value did not satisfy any of: ${messages.join(" | ")}`
+        : true;
+});
+// data-xdbc-or-input (same fragment syntax as data-xdbc-or, always fires on every keystroke)
+registerDOMContract("or-input", (value, attr) => {
+    const fragments = attr.split(";;");
+    const messages = [];
+    for (const fragment of fragments) {
+        const colonIdx = fragment.indexOf(":");
+        const key = colonIdx === -1 ? fragment.trim() : fragment.slice(0, colonIdx).trim();
+        const fragAttr = colonIdx === -1 ? "" : fragment.slice(colonIdx + 1);
+        const checkFn = registry.get(key);
+        if (!checkFn) {
+            console.warn(`[XDBC] data-xdbc-or-input: unknown contract key "${key}"`);
+            continue;
+        }
+        const result = checkFn(value, fragAttr);
+        if (result === true)
+            return true;
+        if (typeof result === "string")
+            messages.push(result);
+    }
+    return messages.length > 0
+        ? `Value did not satisfy any of: ${messages.join(" | ")}`
+        : true;
+});
+// ─── scanDOM ──────────────────────────────────────────────────────────────────
+/**
+ * Scans the given **root** for `<input>` and `<textarea>` elements marked with the
+ * `data-xdbc` attribute, and binds XDBC contracts to their DOM events (blur by
+ * default; configurable per element via `data-xdbc-validate-on`).
+ *
+ * ### Supported attributes
+ *
+ * | Attribute                  | Example value              | Contract        |
+ * |----------------------------|----------------------------|-----------------|
+ * | `data-xdbc`                | *(path or empty)*          | marker / DBC path |
+ * | `data-xdbc-validate-on`         | `input` \| `blur`           | when to validate default contracts (default: `blur`) |
+ * | `data-xdbc-regex`               | `^[a-z]+\.[a-z]{2,}$`      | {@link REGEX} — validated per `data-xdbc-validate-on` |
+ * | `data-xdbc-regex-input`         | `^[a-zA-Z0-9.\-]*$`        | {@link REGEX} — always on every keystroke |
+ * | `data-xdbc-type`                | `string\|number`            | {@link TYPE}    |
+ * | `data-xdbc-type-input`          | `string\|number`            | {@link TYPE} — always on every keystroke |
+ * | `data-xdbc-eq`                  | `hello`                     | {@link EQ}      |
+ * | `data-xdbc-eq-input`            | `hello`                     | {@link EQ} — always on every keystroke |
+ * | `data-xdbc-different`           | `forbidden`                 | {@link EQ} (inverted) |
+ * | `data-xdbc-different-input`     | `forbidden`                 | {@link EQ} (inverted) — always on every keystroke |
+ * | `data-xdbc-defined`             | *(no value needed)*         | {@link DEFINED} |
+ * | `data-xdbc-defined-input`       | *(no value needed)*         | {@link DEFINED} — always on every keystroke |
+ * | `data-xdbc-undefined`           | *(no value needed)*         | {@link UNDEFINED} |
+ * | `data-xdbc-undefined-input`     | *(no value needed)*         | {@link UNDEFINED} — always on every keystroke |
+ * | `data-xdbc-greater`             | `5`                         | {@link COMPARISON} |
+ * | `data-xdbc-greater-input`       | `5`                         | {@link COMPARISON} — always on every keystroke |
+ * | `data-xdbc-greater-or-equal`    | `5`                         | {@link COMPARISON} |
+ * | `data-xdbc-greater-or-equal-input` | `5`                      | {@link COMPARISON} — always on every keystroke |
+ * | `data-xdbc-less`                | `100`                       | {@link COMPARISON} |
+ * | `data-xdbc-less-input`          | `100`                       | {@link COMPARISON} — always on every keystroke |
+ * | `data-xdbc-less-or-equal`       | `100`                       | {@link COMPARISON} |
+ * | `data-xdbc-less-or-equal-input` | `100`                       | {@link COMPARISON} — always on every keystroke |
+ * | `data-xdbc-or`                  | `regex:^\d+$;;type:string`  | {@link OR} (fragment syntax) |
+ * | `data-xdbc-or-input`            | `regex:^\d+$;;eq:N/A`       | {@link OR} — always on every keystroke |
+ *
+ * Use {@link registerDOMContract } to add further contracts at any time.
+ *
+ * ### OR fragment syntax
+ *
+ * Fragments are separated by `;;`. Each fragment is `<contract-key>:<value>`, where the
+ * split is on the **first** `:` only, so colons inside values (e.g. regex) are safe.
+ * The OR passes as long as **at least one** fragment passes.
+ *
+ * ```html
+ * <!-- digits OR exactly "N/A" -->
+ * <input data-xdbc data-xdbc-or="regex:^\d+$;;eq:N/A" />
+ * ```
+ *
+ * ### Behaviour on infringement
+ *
+ * 1. The element's value is **reverted** to the last accepted state (blocking the invalid input).
+ * 2. The configured DBC instance's infringement settings are honoured — `logToConsole`,
+ *    `onInfringement`, and `throwException` all fire in the usual order. Any throw is caught
+ *    internally so it cannot propagate out of the DOM event handler.
+ *
+ * ### IME / composition awareness
+ *
+ * Validation is suspended during IME composition (e.g. CJK input) and runs once after
+ * `compositionend`, so partially composed characters are never incorrectly rejected.
+ *
+ * @param root  Element or Document to scan (default: `document`).
+ * @returns     A cleanup function that removes all bound event listeners.
+ *
+ * ### Validate-on
+ *
+ * By default all contracts are validated when focus **leaves** the field (`blur`). This lets
+ * users type freely and only enforces the contract on completion. Set
+ * `data-xdbc-validate-on="input"` on an element to revert invalid input on every keystroke.
+ *
+ * ### Progressive + whole-value validation
+ *
+ * Use `data-xdbc-regex-input` alongside `data-xdbc-regex` to apply two different patterns:
+ * one that allows partial input during typing, and one that enforces the full format on blur.
+ * `data-xdbc-regex-input` always fires on every `input` event, regardless of
+ * `data-xdbc-validate-on`.
+ *
+ * ```html
+ * <!-- Only validate full domain format when leaving the field (default blur behaviour) -->
+ * <!-- While typing, only allow characters that could appear in a domain name -->
+ * <input type="text" data-xdbc
+ *        data-xdbc-regex="^[a-zA-Z0-9][a-zA-Z0-9.\-]*\.[a-zA-Z]{2,}$"
+ *        data-xdbc-regex-input="^[a-zA-Z0-9.\-]*$" />
+ *
+ * <!-- Block non-digit keystrokes in real time (explicit input-time validation) -->
+ * <input type="text" data-xdbc data-xdbc-validate-on="input" data-xdbc-regex="^\d*$" />
+ * ```
+ *
+ * @example
+ * ```html
+ * <input type="text" data-xdbc data-xdbc-regex="^[a-zA-Z0-9.\-]*\.[a-zA-Z]{2,}$" />
+ * <input type="text" data-xdbc="MyApp.DBC" data-xdbc-type="string" data-xdbc-greater="0" />
+ * <input type="text" data-xdbc data-xdbc-or="regex:^\d+$;;eq:N/A" />
+ * <textarea data-xdbc data-xdbc-regex="^[\w\s]*$"></textarea>
+ * ```
+ * ```ts
+ * import { scanDOM, registerDOMContract } from "xdbc/DBC/DOM";
+ *
+ * const cleanup = scanDOM();
+ * // later:
+ * cleanup();
+ * ```
+ */
+export function scanDOM(root = document) {
+    var _a, _b;
+    const bound = [];
+    const elements = Array.from(root.querySelectorAll("[data-xdbc]"));
+    for (const el of elements) {
+        const dbcPath = el.dataset.xdbc || "WaXCode.DBC";
+        // Collect contracts: keys ending in "-input" always fire on the input event;
+        // all others respect data-xdbc-validate-on (default: blur).
+        const checksDefault = [];
+        const checksInput = [];
+        for (const [key, checkFn] of registry) {
+            // dataset converts "xdbc-greater-or-equal" → "xdbcGreaterOrEqual" via camelCase.
+            // Build the camelCase key from the registry key.
+            const datasetKey = `xdbc${key
+                .split("-")
+                .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+                .join("")}`;
+            if (datasetKey in el.dataset) {
+                const entry = { checkFn, attrValue: (_a = el.dataset[datasetKey]) !== null && _a !== void 0 ? _a : "" };
+                if (key.endsWith("-input")) {
+                    checksInput.push(entry);
+                }
+                else {
+                    checksDefault.push(entry);
+                }
+            }
+        }
+        if (checksDefault.length === 0 && checksInput.length === 0)
+            continue;
+        const validateOn = ((_b = el.dataset.xdbcValidateOn) !== null && _b !== void 0 ? _b : "blur") === "input" ? "input" : "blur";
+        // lastInputValid: revert target when a -input check fails on a keystroke.
+        //   Updated whenever checksInput passes.
+        // lastBlurValid:  revert target when a blur/default check fails.
+        //   Updated only when all checks (checksInput + checksDefault) pass together.
+        let lastInputValid = el.value;
+        let lastBlurValid = el.value;
+        let composing = false;
+        // Runs checks against the current el.value.
+        // revertTo: the value to restore on failure (pass null to skip revert/report).
+        // Returns true when all checks pass.
+        const runChecks = (checksToRun, revertTo) => {
+            const value = el.value;
+            for (const { checkFn, attrValue } of checksToRun) {
+                const result = checkFn(value, attrValue);
+                if (typeof result === "string") {
+                    if (revertTo !== null) {
+                        el.value = revertTo;
+                        try {
+                            DBC.getRegistered(dbcPath).reportParameterInfringement(result, el, undefined, el.name || el.id || "input", 0, value);
+                        }
+                        catch (_a) {
+                            // swallowed — throwException must not propagate out of a DOM event handler
+                        }
+                    }
+                    return false;
+                }
+            }
+            return true;
+        };
+        // checksInput always runs with revert + report.
+        // checksDefault:
+        //   • When includeDefault is true (blur event or validateOn==="input"):
+        //     runs with full revert + report; on pass commits both lastInputValid and lastBlurValid.
+        //   • When includeDefault is false (input event, blur mode):
+        //     silently probed (no revert, no report) to track the last "fully valid" state
+        //     so the blur listener can always revert to a sensible value.
+        const doValidate = (includeDefault) => {
+            if (!runChecks(checksInput, lastInputValid))
+                return;
+            // checksInput passed → this is a safe keystroke revert target going forward
+            lastInputValid = el.value;
+            if (checksDefault.length === 0) {
+                lastBlurValid = el.value;
+                return;
+            }
+            if (includeDefault) {
+                if (runChecks(checksDefault, lastBlurValid)) {
+                    lastBlurValid = el.value;
+                }
+            }
+            else {
+                // Silent probe: let partial input through but track last fully-valid state
+                if (runChecks(checksDefault, null)) {
+                    lastBlurValid = el.value;
+                }
+            }
+        };
+        const inputListener = () => {
+            if (composing)
+                return;
+            doValidate(validateOn === "input");
+        };
+        const blurListener = checksDefault.length > 0 && validateOn === "blur"
+            ? () => {
+                doValidate(true);
+            }
+            : null;
+        const compositionStartListener = () => {
+            composing = true;
+        };
+        const compositionEndListener = () => {
+            composing = false;
+            doValidate(validateOn === "input");
+        };
+        el.addEventListener("input", inputListener);
+        if (blurListener)
+            el.addEventListener("blur", blurListener);
+        el.addEventListener("compositionstart", compositionStartListener);
+        el.addEventListener("compositionend", compositionEndListener);
+        bound.push({
+            element: el,
+            inputListener,
+            blurListener,
+            compositionStartListener,
+            compositionEndListener,
+        });
+    }
+    return () => {
+        for (const { element, inputListener, blurListener, compositionStartListener, compositionEndListener, } of bound) {
+            element.removeEventListener("input", inputListener);
+            if (blurListener)
+                element.removeEventListener("blur", blurListener);
+            element.removeEventListener("compositionstart", compositionStartListener);
+            element.removeEventListener("compositionend", compositionEndListener);
+        }
+    };
+}

package/dist/DBC/EQ/DIFFERENT.js

@@ -0,0 +1,34 @@
+import { EQ } from "../EQ";
+/**
+ * DIFFERENT class for inequality comparisons.
+ *
+ * This class extends EQ and provides methods to check if a value is different (not equal)
+ * from a specified equivalent value. It inverts the equality check by always passing
+ * `true` for the invert parameter to the parent EQ class methods.
+ *
+ * @remarks
+ * The class provides precondition (PRE), postcondition (POST), and invariant (INVARIANT)
+ * checks for Design by Contract programming patterns.
+ *
+ * @see {@link COMPARISON}
+ * @see {@link EQ}
+ */
+export class DIFFERENT extends EQ {
+    /** See {@link EQ.PRE }. Always inverts equality check. */
+    static PRE(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return EQ.PRE(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.POST }. Always inverts equality check. */
+    static POST(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return EQ.POST(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.INVARIANT }. Always inverts equality check. */
+    static INVARIANT(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return EQ.INVARIANT(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.constructor }. */
+    constructor(equivalent) {
+        super(equivalent, true);
+        this.equivalent = equivalent;
+    }
+}

package/dist/DBC/EQ.js

@@ -0,0 +1,101 @@
+import { DBC } from "../DBC";
+/**
+ * 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(toCheck, equivalent, invert) {
+        if (!invert && equivalent !== toCheck) {
+            return `Value has to be equal to "${equivalent}"`;
+        }
+        if (invert && equivalent === toCheck) {
+            return `Value must not 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(equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPRE(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);
+    }
+    /**
+     * 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(equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPOST(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(EQ, [equivalent, invert], dbc, path, hint);
+    }
+    // #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}. */
+    check(toCheck) {
+        return EQ.checkAlgorithm(toCheck, this.equivalent, this.invert);
+    }
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck** and the specified **type** .
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link EQ }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link EQ }.*/
+    static tsCheck(toCheck, equivalent, hint = undefined, id = undefined, dbc = undefined) {
+        const result = EQ.checkAlgorithm(toCheck, equivalent, false);
+        if (result === true) {
+            return toCheck;
+        }
+        DBC.reportTsCheckInfringement(`${id ? `(${id}) ` : ""}${result} ${hint ? `✨ ${hint} ✨` : ""}`, dbc);
+        return toCheck;
+    }
+    /**
+     * Creates this {@link EQ } by setting the protected property {@link EQ.equivalent } used by {@link EQ.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(equivalent, invert = false) {
+        super();
+        this.equivalent = equivalent;
+        this.invert = invert;
+    }
+}

package/dist/DBC/GREATER.js

@@ -0,0 +1,99 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that two {@link object }s gotta be equal.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class GREATER 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(toCheck, equivalent, equalityPermitted, invert) {
+        if (equalityPermitted && !invert && toCheck < equivalent) {
+            return `Value has to to be greater than or equal to "${equivalent}"`;
+        }
+        if (equalityPermitted && invert && toCheck > equivalent) {
+            return `Value must not to be less than or equal to "${equivalent}"`;
+        }
+        if (!equalityPermitted && !invert && toCheck <= equivalent) {
+            return `Value has to to be greater than "${equivalent}"`;
+        }
+        if (!equalityPermitted && invert && toCheck >= equivalent) {
+            return `Value must not to be less than "${equivalent}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link GREATER.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	    See {@link GREATER.checkAlgorithm }.
+     * @param equalityPermitted See {@link GREATER.checkAlgorithm }.
+     * @param path			    See {@link DBC.decPrecondition }.
+     * @param dbc			    See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(equivalent, equalityPermitted = false, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return GREATER.checkAlgorithm(value, equivalent, equalityPermitted, invert);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link GREATER.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	    See {@link GREATER.checkAlgorithm }.
+     * @param equalityPermitted See {@link GREATER.checkAlgorithm }.
+     * @param path			    See {@link DBC.Postcondition }.
+     * @param dbc			    See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(equivalent, equalityPermitted = false, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition((value, target, propertyKey) => {
+            return GREATER.checkAlgorithm(value, equalityPermitted, equivalent, invert);
+        }, dbc, path);
+    }
+    /**
+     * A field-decorator factory using the {@link GREATER.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	    See {@link GREATER.checkAlgorithm }.
+     * @param equalityPermitted See {@link GREATER.checkAlgorithm }.
+     * @param path			    See {@link DBC.decInvariant }.
+     * @param dbc			    See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(equivalent, equalityPermitted = false, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decInvariant([new GREATER(equivalent, equalityPermitted, invert)], path, dbc);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    // #region Dynamic usage.
+    /**
+     * Invokes the {@link GREATER.checkAlgorithm } passing the value **toCheck**, {@link GREATER.equivalent } and {@link GREATER.invert }.
+     *
+     * @param toCheck See {@link GREATER.checkAlgorithm }.
+     *
+     * @returns See {@link GREATER.checkAlgorithm}. */
+    check(toCheck) {
+        return GREATER.checkAlgorithm(toCheck, this.equivalent, this.equalityPermitted, this.invert);
+    }
+    /**
+     * Creates this {@link GREATER } by setting the protected property {@link GREATER.equivalent }, {@link GREATER.equalityPermitted } and {@link GREATER.invert } used by {@link GREATER.check }.
+     *
+     * @param equivalent        See {@link GREATER.check }.
+     * @param equalityPermitted See {@link GREATER.check }.
+     * @param invert            See {@link GREATER.check }. */
+    constructor(equivalent, equalityPermitted = false, invert = false) {
+        super();
+        this.equivalent = equivalent;
+        this.equalityPermitted = equalityPermitted;
+        this.invert = invert;
+    }
+}