xdbc 1.0.93 → 1.0.95

package/dist/bundle.js

@@ -0,0 +1,1329 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./src/DBC.ts":
+/*!********************!*\
+  !*** ./src/DBC.ts ***!
+  \********************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DBC: () => (/* binding */ DBC)
+/* harmony export */ });
+/**
+ * Provides a **D**esign **B**y **C**ontract Framework using decorators.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+class DBC {
+    /**
+     * Make a request to get the value of a certain parameter of specific method in a specific {@link object }.
+     * That request gets enlisted in {@link paramValueRequests } which is used by {@link ParamvalueProvider} to invoke the
+     * given "receptor" with the parameter value stored in there. Thus a parameter decorator using this method will
+     * not receive any value of the top method is not tagged with {@link ParamvalueProvider}.
+     *
+     * @param target		The {@link object } containing the method with the parameter which's value is requested.
+     * @param methodName	The name of the method with the parameter which's value is requested.
+     * @param index			The index of the parameter which's value is requested.
+     * @param receptor		The method the requested parameter-value shall be passed to when it becomes available. */
+    static requestParamValue(target, methodName, index, 
+    // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+    receptor) {
+        if (DBC.paramValueRequests.has(target)) {
+            if (DBC.paramValueRequests.get(target).has(methodName)) {
+                if (DBC.paramValueRequests.get(target).get(methodName).has(index)) {
+                    DBC.paramValueRequests
+                        .get(target)
+                        .get(methodName)
+                        .get(index)
+                        .push(receptor);
+                }
+                else {
+                    DBC.paramValueRequests
+                        .get(target)
+                        .get(methodName)
+                        .set(index, new Array(receptor));
+                }
+            }
+            else {
+                DBC.paramValueRequests
+                    .get(target)
+                    .set(methodName, new Map([
+                    [index, new Array(receptor)],
+                ]));
+            }
+        }
+        else {
+            DBC.paramValueRequests.set(target, new Map([
+                [
+                    methodName,
+                    new Map([
+                        [index, new Array(receptor)],
+                    ]),
+                ],
+            ]));
+        }
+        return undefined;
+    }
+    /**
+     * A method-decorator factory checking the {@link paramValueRequests } for value-requests of the method's parameter thus
+     * also usable on setters.
+     * When found it will invoke the "receptor" registered there, inter alia by {@link requestParamValue }, with the
+     * parameter's value.
+     *
+     * @param target 		The {@link object } hosting the tagged method as provided by the runtime.
+     * @param propertyKey 	The tagged method's name as provided by the runtime.
+     * @param descriptor 	The {@link PropertyDescriptor } as provided by the runtime.
+     *
+     * @returns The {@link PropertyDescriptor } that was passed by the runtime. */
+    static ParamvalueProvider(target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+        descriptor.value = (...args) => {
+            // #region	Check if a value of one of the method's parameter has been requested and pass it to the
+            //			receptor, if so.
+            if (DBC.paramValueRequests.has(target) &&
+                DBC.paramValueRequests.get(target).has(propertyKey)) {
+                for (const index of DBC.paramValueRequests
+                    .get(target)
+                    .get(propertyKey)
+                    .keys()) {
+                    if (index < args.length) {
+                        for (const receptor of DBC.paramValueRequests
+                            .get(target)
+                            .get(propertyKey)
+                            .get(index)) {
+                            receptor(args[index]);
+                        }
+                    }
+                }
+            }
+            // #endregion 	Check if a value of one of the method's parameter has been requested and pass it to the
+            // 				receptor, if so.
+            // biome-ignore lint/complexity/noThisInStatic: Necessary.
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    }
+    // #endregion Parameter-value requests.
+    // #region Invariant
+    /**
+     * A property-decorator factory serving as a **D**esign **B**y **C**ontract Invariant.
+     * Since the value must be initialized or set according to the specified **contracts** the value will only be checked
+     * when assigning it.
+     *
+     * @param contracts The {@link DBC }-Contracts the value shall uphold.
+     *
+     * @throws 	A {@link DBC.Infringement } whenever the property is tried to be set to a value that does not comply to the
+     * 			specified **contracts**, by the returned method.*/
+    static decInvariant(contracts, path = undefined, dbc = "WaXCode.DBC") {
+        return (target, propertyKey) => {
+            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+            let value;
+            // #region Replace original property.
+            Object.defineProperty(target, propertyKey, {
+                set(newValue) {
+                    const realValue = path ? DBC.resolve(newValue, path) : newValue;
+                    // #region Check if all "contracts" are fulfilled.
+                    for (const contract of contracts) {
+                        const result = contract.check(realValue);
+                        if (typeof result === "string") {
+                            DBC.resolveDBCPath(window, dbc).reportFieldInfringement(result, target, path, propertyKey, realValue);
+                        }
+                    }
+                    // #endregion Check if all "contracts" are fulfilled.
+                    value = newValue;
+                },
+                enumerable: true,
+                configurable: true,
+            });
+            // #endregion Replace original property.
+        };
+    }
+    // #endregion Invariant
+    // #region Postcondition
+    /**
+     * A method decorator factory checking the result of a method whenever it is invoked thus also usable on getters.
+     *
+     * @param check	The **(toCheck: any, object, string) => boolean | string** to use for checking.
+     * @param dbc	See {@link DBC.resolveDBCPath }.
+     * @param path	The dotted path referring to the actual value to check, starting form the specified one.
+     *
+     * @returns The **( target : object, propertyKey : string, descriptor : PropertyDescriptor ) : PropertyDescriptor**
+     * 			invoked by Typescript.
+     */
+    static decPostcondition(
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+    check, dbc, path = undefined) {
+        return (target, propertyKey, descriptor) => {
+            const originalMethod = descriptor.value;
+            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+            descriptor.value = (...args) => {
+                // biome-ignore lint/complexity/noThisInStatic: <explanation>
+                const result = originalMethod.apply(this, args);
+                const realValue = path ? DBC.resolve(result, path) : result;
+                const checkResult = check(realValue, target, propertyKey);
+                if (typeof checkResult === "string") {
+                    DBC.resolveDBCPath(window, dbc).reportReturnvalueInfringement(checkResult, target, path, propertyKey, realValue);
+                }
+                return result;
+            };
+            return descriptor;
+        };
+    }
+    // #endregion Postcondition
+    // #region Decorator
+    // #region Precondition
+    /**
+     * A parameter-decorator factory that requests the tagged parameter's value passing it to the provided
+     * "check"-method when the value becomes available.
+     *
+     * @param check	The "( unknown ) => void" to be invoked along with the tagged parameter's value as soon
+     * 				as it becomes available.
+     * @param dbc  	See {@link DBC.resolveDBCPath }.
+     * @param path	The dotted path referring to the actual value to check, starting form the specified one.
+     *
+     * @returns The **(target: object, methodName: string | symbol, parameterIndex: number ) => void** invoked by Typescript- */
+    static decPrecondition(check, dbc, path = undefined) {
+        return (target, methodName, parameterIndex) => {
+            DBC.requestParamValue(target, methodName, parameterIndex, (value) => {
+                const realValue = path ? DBC.resolve(value, path) : value;
+                const result = check(realValue, target, methodName, parameterIndex);
+                if (typeof result === "string") {
+                    DBC.resolveDBCPath(window, dbc).reportParameterInfringement(result, target, path, methodName, parameterIndex, realValue);
+                }
+            });
+        };
+    }
+    /**
+     * Reports a warning.
+     *
+     * @param message The message containing the warning. */
+    reportWarning(message) {
+        if (this.warningSettings.logToConsole) {
+            console.warn(message);
+        }
+    }
+    /**
+     * Reports an infringement according to the {@link infringementSettings } also generating a proper {@link string }-wrapper
+     * for the given "message" & violator.
+     *
+     * @param message	The {@link string } describing the infringement and it's provenience.
+     * @param violator 	The {@link string } describing or naming the violator. */
+    reportInfringement(message, violator, target, path) {
+        const finalMessage = `[ From "${violator}"${path ? `'s member "${path}"` : ""}${typeof target === "function" ? ` in "${target.name}"` : typeof target === "object" && target !== null && typeof target.constructor === "function" ? ` in "${target.constructor.name}"` : ""}: ${message}]`;
+        if (this.infringementSettings.throwException) {
+            throw new DBC.Infringement(finalMessage);
+        }
+        if (this.infringementSettings.logToConsole) {
+            console.log(finalMessage);
+        }
+    }
+    /**
+     * Reports a parameter-infringement via {@link reportInfringement } also generating a proper {@link string }-wrapper
+     * for the given "message","method", parameter-"index" & value.
+     *
+     * @param message	The {@link string } describing the infringement and it's provenience.
+     * @param method 	The {@link string } describing or naming the violator.
+     * @param index		The index of the parameter within the argument listing.
+     * @param value 	The parameter's value. */
+    reportParameterInfringement(message, target, path, method, index, value) {
+        const properIndex = index + 1;
+        this.reportInfringement(`[ Parameter-value "${value}" of the ${properIndex}${properIndex === 1 ? "st" : properIndex === 2 ? "nd" : properIndex === 3 ? "rd" : "th"} parameter did not fulfill one of it's contracts: ${message}]`, method, target, path);
+    }
+    /**
+     * Reports a field-infringement via {@link reportInfringement } also generating a proper {@link string }-wrapper
+     * for the given **message** & **name**.
+     *
+     * @param message	A {@link string } describing the infringement and it's provenience.
+     * @param key 		The property key.
+     * @param path		The dotted-path {@link string } that leads to the value not fulfilling the contract starting from
+     * 					the tagged one.
+     * @param value		The value not fulfilling a contract. */
+    reportFieldInfringement(message, target, path, key, value) {
+        this.reportInfringement(`[ New value for "${key}"${path === undefined ? "" : `.${path}`} with value "${value}" did not fulfill one of it's contracts: ${message}]`, key, target, path);
+    }
+    /**
+     * Reports a returnvalue-infringement according via {@link reportInfringement } also generating a proper {@link string }-wrapper
+     * for the given "message","method" & value.
+     *
+     * @param message	The {@link string } describing the infringement and it's provenience.
+     * @param method 	The {@link string } describing or naming the violator.
+     * @param value		The parameter's value. */
+    reportReturnvalueInfringement(message, target, path, method, 
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    value) {
+        this.reportInfringement(`[ Return-value "${value}" did not fulfill one of it's contracts: ${message}]`, method, target, path);
+    }
+    /**
+     * Constructs this {@link DBC } by setting the {@link DBC.infringementSettings }, define the **WaXCode** namespace in
+     * **window** if not yet available and setting the property **DBC** in there to the instance of this {@link DBC }.
+     *
+     * @param infringementSettings See {@link DBC.infringementSettings }. */
+    constructor(infringementSettings = { throwException: true, logToConsole: false }) {
+        // #endregion Precondition
+        // #endregion Decorator
+        // #region Warning handling.
+        /** Stores settings concerning warnings. */
+        this.warningSettings = { logToConsole: true };
+        // #endregion Warning handling.
+        // #region infringement handling.
+        /** Stores the settings concerning infringements */
+        this.infringementSettings = { throwException: true, logToConsole: false };
+        this.infringementSettings = infringementSettings;
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        if (window.WaXCode === undefined)
+            window.WaXCode = {};
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        window.WaXCode.DBC = this;
+    }
+    /**
+     *
+     */
+    static resolve(toResolveFrom, path) {
+        if (!toResolveFrom || typeof path !== "string") {
+            return undefined;
+        }
+        const parts = path.replace(/\[(['"]?)(.*?)\1\]/g, ".$2").split("."); // Handle indexers
+        let current = toResolveFrom;
+        for (const part of parts) {
+            if (current === null || typeof current === "undefined") {
+                return undefined;
+            }
+            const methodMatch = part.match(/(\w+)\((.*)\)/);
+            if (methodMatch) {
+                const methodName = methodMatch[1];
+                const argsStr = methodMatch[2];
+                const args = argsStr.split(",").map((arg) => arg.trim()); // Simple argument parsing
+                if (typeof current[methodName] === "function") {
+                    current = current[methodName].apply(current, args);
+                }
+                else {
+                    return undefined; // Method not found or not a function
+                }
+            }
+            else {
+                current = current[part];
+            }
+        }
+        return current;
+    }
+}
+// #region Parameter-value requests.
+/** Stores all request for parameter values registered by {@link decPrecondition }. */
+DBC.paramValueRequests = new Map();
+// #region Classes
+// #region Errors
+/** An {@link Error } to be thrown whenever an infringement is detected. */
+DBC.Infringement = class extends Error {
+    /**
+     * Constructs this {@link Error } by tagging the specified message-{@link string } as an XDBC-Infringement.
+     *
+     * @param message The {@link string } describing the infringement. */
+    constructor(message) {
+        super(`[ XDBC Infringement ${message}]`);
+    }
+};
+// #endregion Errors
+// #endregion Classes
+// #endregion infringement handling.
+/**
+ * Resolves the specified dotted {@link string }-path to a {@link DBC }.
+ *
+ * @param obj 	The {@link object } to start resolving from.
+ * @param path 	The dotted {@link string }-path leading to the {@link DBC }.
+ *
+ * @returns The requested {@link DBC }.
+ */
+DBC.resolveDBCPath = (obj, path) => path === null || path === void 0 ? void 0 : path.split(".").reduce((accumulator, current) => accumulator[current], obj);
+// Set the main instance with standard **DBC.infringementSettings**.
+new DBC();
+
+
+/***/ }),
+
+/***/ "./src/DBC/AE.ts":
+/*!***********************!*\
+  !*** ./src/DBC/AE.ts ***!
+  \***********************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   AE: () => (/* binding */ AE)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DBC */ "./src/DBC.ts");
+
+/**
+ * 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) */
+class AE extends _DBC__WEBPACK_IMPORTED_MODULE_0__.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(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.
+            }
+            const ending = idxEnd !== undefined
+                ? idxEnd !== -1
+                    ? idxEnd + 1
+                    : value.length
+                : value.length;
+            for (let i = index ? index : 0; i < ending; 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__WEBPACK_IMPORTED_MODULE_0__.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(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__WEBPACK_IMPORTED_MODULE_0__.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);
+    }
+    /**
+     * A field-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged field.
+     *
+     * @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.decInvariant }.
+     * @param dbc				See {@link DBC.decInvariant }.
+     *
+     * @returns	See {@link DBC.decInvariant }. */
+    static INVARIANT(realConditions, index = undefined, idxEnd = undefined, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decInvariant([new AE(realConditions, index, idxEnd)], path, dbc);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like global functions).
+    //
+    /**
+     * Invokes the {@link AE.checkAlgorithm } with all {@link AE.conditions } and the {@link object } {@link toCheck },
+     * {@link AE.index } & {@link AE.idxEnd }.
+     *
+     * @param toCheck See {@link AE.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(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;
+    }
+}
+
+
+/***/ }),
+
+/***/ "./src/DBC/EQ.ts":
+/*!***********************!*\
+  !*** ./src/DBC/EQ.ts ***!
+  \***********************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   EQ: () => (/* binding */ EQ)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DBC */ "./src/DBC.ts");
+
+/**
+ * A {@link DBC } defining that two {@link object }s gotta be equal.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+class EQ extends _DBC__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.DBC.decPostcondition((value, target, propertyKey) => {
+            return EQ.checkAlgorithm(value, equivalent, invert);
+        }, dbc, path);
+    }
+    /**
+     * 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(
+    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+    equivalent, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decInvariant([new EQ(equivalent, invert)], path, dbc);
+    }
+    // #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: Necessary to check against NULL & UNDEFINED.
+    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;
+    }
+}
+
+
+/***/ }),
+
+/***/ "./src/DBC/INSTANCE.ts":
+/*!*****************************!*\
+  !*** ./src/DBC/INSTANCE.ts ***!
+  \*****************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   INSTANCE: () => (/* binding */ INSTANCE)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DBC */ "./src/DBC.ts");
+
+/**
+ * A {@link DBC } defining that the an {@link object }s gotta be an instance of a certain {@link INSTANCE.reference }.
+ *
+ * @remarks
+ * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
+class INSTANCE extends _DBC__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.DBC.decPostcondition((value, target, propertyKey) => {
+            return INSTANCE.checkAlgorithm(value, reference);
+        }, dbc, path);
+    }
+    /**
+     * A field-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.decInvariant }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+    reference, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decInvariant([new INSTANCE(reference)], path, dbc);
+    }
+    // #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;
+    }
+}
+
+
+/***/ }),
+
+/***/ "./src/DBC/REGEX.ts":
+/*!**************************!*\
+  !*** ./src/DBC/REGEX.ts ***!
+  \**************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   REGEX: () => (/* binding */ REGEX)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DBC */ "./src/DBC.ts");
+
+/**
+ * A {@link DBC } providing {@link REGEX }-contracts and standard {@link RegExp } for common use cases in {@link REGEX.stdExp }.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+class REGEX extends _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC {
+    // #region Condition checking.
+    /**
+     * 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 expression	The {@link RegExp } the one **toCheck** has comply to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value **toCheck** complies with the {@link RegExp } **expression**, otherwise FALSE. */
+    static checkAlgorithm(toCheck, expression) {
+        if (!expression.test(toCheck)) {
+            return `Value has to comply to regular expression "${expression}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param expression	See {@link REGEX.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(expression, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return REGEX.checkAlgorithm(value, expression);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param expression	See {@link REGEX.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(expression, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decPostcondition((value, target, propertyKey) => {
+            return REGEX.checkAlgorithm(value, expression);
+        }, dbc, path);
+    }
+    /**
+     * A field-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param expression	See {@link REGEX.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(expression, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decInvariant([new REGEX(expression)], path, dbc);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link REGEX.checkAlgorithm } passing the value **toCheck** and {@link REGEX.equivalent }.
+     *
+     * @param toCheck See {@link REGEX.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck) {
+        return REGEX.checkAlgorithm(toCheck, this.expression);
+    }
+    /**
+     * Creates this {@link REGEX } by setting the protected property {@link REGEX.expression } used by {@link REGEX.check }.
+     *
+     * @param expression See {@link REGEX.check }. */
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    // #endregion Referenced Condition checking.
+    // #region In-Method checking.
+    /**
+     * Invokes the {@link REGEX.checkAlgorithm } passing the value **toCheck** and {@link REGEX.expression }.
+     *
+     * @param toCheck		See {@link REGEX.checkAlgorithm}.
+     * @param expression	See {@link REGEX.checkAlgorithm}.
+     */
+    static check(toCheck, expression) {
+        const checkResult = REGEX.checkAlgorithm(toCheck, expression);
+        if (typeof checkResult === "string") {
+            throw new _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.Infringement(checkResult);
+        }
+    }
+}
+/** Stores often used {@link RegExp }s. */
+REGEX.stdExp = {
+    htmlAttributeName: /^[a-zA-Z_:][a-zA-Z0-9_.:-]*$/,
+    eMail: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/i,
+    property: /^[$_A-Za-z][$_A-Za-z0-9]*$/,
+    url: /^(?:(?:http:|https?|ftp):\/\/)?(?:\S+(?::\S*)?@)?(?:localhost|(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,})(?::\d{2,5})?(?:\/(?:[\w\-\.]*\/)*[\w\-\.]+(?:\?\S*)?(?:#\S*)?)?$/i,
+    keyPath: /^([a-zA-Z_$][a-zA-Z0-9_$]*\.)*[a-zA-Z_$][a-zA-Z0-9_$]*$/,
+    date: /^\d{1,4}[.\/-]\d{1,2}[.\/-]\d{1,4}$/i,
+    dateFormat: /^((D{1,2}[./-]M{1,2}[./-]Y{1,4})|(M{1,2}[./-]D{1,2}[./-]Y{1,4})|Y{1,4}[./-]D{1,2}[./-]M{1,2}|(Y{1,4}[./-]M{1,2}[./-]D{1,2}))$/i,
+    cssSelector: /^(?:\*|#[\w-]+|\.[\w-]+|(?:[\w-]+|\*)(?::(?:[\w-]+(?:\([\w-]+\))?)+)?(?:\[(?:[\w-]+(?:(?:=|~=|\|=|\*=|\$=|\^=)\s*(?:"[^"]*"|'[^']*'|[\w-]+)\s*)?)?\])+|\[\s*[\w-]+\s*=\s*(?:"[^"]*"|'[^']*'|[\w-]+)\s*\])(?:,\s*(?:\*|#[\w-]+|\.[\w-]+|(?:[\w-]+|\*)(?::(?:[\w-]+(?:\([\w-]+\))?)+)?(?:\[(?:[\w-]+(?:(?:=|~=|\|=|\*=|\$=|\^=)\s*(?:"[^"]*"|'[^']*'|[\w-]+)\s*)?)?\])+|\[\s*[\w-]+\s*=\s*(?:"[^"]*"|'[^']*'|[\w-]+)\s*\]))*$/,
+};
+
+
+/***/ }),
+
+/***/ "./src/DBC/TYPE.ts":
+/*!*************************!*\
+  !*** ./src/DBC/TYPE.ts ***!
+  \*************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   TYPE: () => (/* binding */ TYPE)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DBC */ "./src/DBC.ts");
+
+/**
+ * A {@link DBC } defining that an {@link object }s gotta be of certain {@link TYPE.type }.
+ *
+ * @remarks
+ * Author: 		Salvatore Callari (Callari@WaXCode.net) / 2025
+ * Maintainer:	Salvatore Callari (XDBC@WaXCode.net) */
+class TYPE extends _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC {
+    /**
+     * Checks if the value **toCheck** is of the **type** specified.
+     *
+     * @param toCheck	The {@link Object } which's **type** to check.
+     * @param type		The type the {@link object} **toCheck** has to be of.
+     *
+     * @returns TRUE if the value **toCheck** is of the specified **type**, otherwise FALSE. */
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic type checking of also UNDEFINED.
+    static checkAlgorithm(toCheck, type) {
+        // biome-ignore lint/suspicious/useValidTypeof: Necessary
+        if (typeof toCheck !== type) {
+            return `Value has to to be of type "${type}" but is of type "${typeof toCheck}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param type	See {@link TYPE.checkAlgorithm }.
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(type, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return TYPE.checkAlgorithm(value, type);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param type	See {@link TYPE.checkAlgorithm }.
+     * @param path	See {@link DBC.Postcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(type, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decPostcondition((value, target, propertyKey) => {
+            return TYPE.checkAlgorithm(value, type);
+        }, dbc, path);
+    }
+    /**
+     * A field-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param type	See {@link TYPE.checkAlgorithm }.
+     * @param path	See {@link DBC.decInvariant }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(type, path = undefined, dbc = "WaXCode.DBC") {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decInvariant([new TYPE(type)], path, dbc);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link TYPE.checkAlgorithm } passing the value **toCheck** and the {@link TYPE.type } .
+     *
+     * @param toCheck See {@link TYPE.checkAlgorithm }.
+     *
+     * @returns See {@link TYPE.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return TYPE.checkAlgorithm(toCheck, this.type);
+    }
+    /**
+     * Creates this {@link TYPE } by setting the protected property {@link TYPE.type } used by {@link TYPE.check }.
+     *
+     * @param type See {@link TYPE.check }. */
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+}
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+/*!*********************!*\
+  !*** ./src/Demo.ts ***!
+  \*********************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Demo: () => (/* binding */ Demo)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DBC */ "./src/DBC.ts");
+/* harmony import */ var _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./DBC/REGEX */ "./src/DBC/REGEX.ts");
+/* harmony import */ var _DBC_EQ__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./DBC/EQ */ "./src/DBC/EQ.ts");
+/* harmony import */ var _DBC_TYPE__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./DBC/TYPE */ "./src/DBC/TYPE.ts");
+/* harmony import */ var _DBC_AE__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./DBC/AE */ "./src/DBC/AE.ts");
+/* harmony import */ var _DBC_INSTANCE__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./DBC/INSTANCE */ "./src/DBC/INSTANCE.ts");
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+
+
+
+
+
+
+/** Demonstrative use of **D**esign **B**y **C**ontract Decorators */
+class Demo {
+    constructor() {
+        // #region Check Property Decorator
+        this.testProperty = "a";
+        // #endregion Check AE Index
+    }
+    // #endregion Check Property Decorator
+    // #region Check Parameter. & Returnvalue Decorator
+    testParamvalueAndReturnvalue(a) {
+        return `xxxx${a}`;
+    }
+    // #endregion Check Parameter. & Returnvalue Decorator
+    // #region Check Returnvalue Decorator
+    testReturnvalue(a) {
+        return a;
+    }
+    // #endregion Check Returnvalue Decorator
+    // #region Check EQ-DBC & Path to property of Parameter-value
+    testEQAndPath(o) { }
+    // #endregion Check EQ-DBC & Path to property of Parameter-value
+    // #region Check EQ-DBC & Path to property of Parameter-value with Inversion
+    testEQAndPathWithInversion(o) { }
+    // #endregion Check EQ-DBC & Path to property of Parameter-value with Inversion
+    // #region Check TYPE
+    testTYPE(o) { }
+    // #endregion Check TYPE
+    // #region Check AE
+    testAE(x) { }
+    // #endregion Check AE
+    // #region Check REGEX with AE
+    testREGEXWithAE(x) { }
+    // #endregion Check REGEX with AE
+    // #region Check INSTANCE
+    testINSTANCE(candidate) { }
+    // #endregion Check INSTANCE
+    // #region Check AE Range
+    testAERange(x) { }
+    // #endregion Check AE Range
+    // #region Check AE Index
+    testAEIndex(x) { }
+}
+__decorate([
+    _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX.INVARIANT(/^a$/),
+    __metadata("design:type", Object)
+], Demo.prototype, "testProperty", void 0);
+__decorate([
+    _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX.POST(/^xxxx.*$/),
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX.PRE(/holla*/g)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], Demo.prototype, "testParamvalueAndReturnvalue", null);
+__decorate([
+    _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX.POST(/^xxxx.*$/),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], Demo.prototype, "testReturnvalue", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_EQ__WEBPACK_IMPORTED_MODULE_2__.EQ.PRE("SELECT", false, "tagName")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [HTMLElement]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testEQAndPath", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_EQ__WEBPACK_IMPORTED_MODULE_2__.EQ.PRE("SELECT", true, "tagName")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [HTMLElement]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testEQAndPathWithInversion", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_TYPE__WEBPACK_IMPORTED_MODULE_3__.TYPE.PRE("string")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testTYPE", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_AE__WEBPACK_IMPORTED_MODULE_4__.AE.PRE([new _DBC_TYPE__WEBPACK_IMPORTED_MODULE_3__.TYPE("string")])),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testAE", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_AE__WEBPACK_IMPORTED_MODULE_4__.AE.PRE(new _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX(/^(?i:(NOW)|([+-]\d+[dmy]))$/i))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testREGEXWithAE", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider
+    // biome-ignore lint/suspicious/noExplicitAny: Test
+    ,
+    __param(0, _DBC_INSTANCE__WEBPACK_IMPORTED_MODULE_5__.INSTANCE.PRE(Date)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testINSTANCE", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_AE__WEBPACK_IMPORTED_MODULE_4__.AE.PRE([new _DBC_TYPE__WEBPACK_IMPORTED_MODULE_3__.TYPE("string"), new _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX(/^abc$/)], 1, 2)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testAERange", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_AE__WEBPACK_IMPORTED_MODULE_4__.AE.PRE([new _DBC_TYPE__WEBPACK_IMPORTED_MODULE_3__.TYPE("string"), new _DBC_REGEX__WEBPACK_IMPORTED_MODULE_1__.REGEX(/^abc$/)], 1)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testAEIndex", null);
+const demo = new Demo();
+try {
+    demo.testProperty = "abd";
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INVARIANT Infringement", "OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testProperty = "a";
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("INVARIANT OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+demo.testParamvalueAndReturnvalue("holla");
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("PARAMETER- & RETURNVALUE OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testParamvalueAndReturnvalue("yyyy");
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("PARAMETER- & RETURNVALUE Infringement", "OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testReturnvalue("xxxx");
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("RETURNVALUE OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testReturnvalue("yyyy");
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("RETURNVALUE Infringement", "OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testEQAndPath(document.createElement("select"));
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("EQ with Path Infringement OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testEQAndPathWithInversion(document.createElement("select"));
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("EQ with Path and Inversion Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testTYPE("x");
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("TYPE OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testTYPE(0);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("TYPE Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testAE(["11", "10", "b"]);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("AE OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testAE(["11", 11, "b"]);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("AE Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testREGEXWithAE(["+1d", "NOW", "-10y"]);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("REGEX with AE OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testREGEXWithAE(["+1d", "+5d", "-x10y"]);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("REGEX with AE Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testINSTANCE(new Date());
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("INSTANCE OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testINSTANCE(demo);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INSTANCE Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testAERange([11, "abc", "abc"]);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("AE Range OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testAERange([11, "abc", /a/g]);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("AE Range Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testAEIndex([11, "abc", "abc"]);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("AE Index OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testAEIndex(["11", 12, "/a/g"]);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("AE Index Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+
+})();
+
+/******/ })()
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"bundle.js","mappings":";;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACO;AACP;AACA,gGAAgG,cAAc;AAC9G,sCAAsC,2BAA2B,kBAAkB,0BAA0B;AAC7G;AACA,mEAAmE,yBAAyB;AAC5F;AACA,2BAA2B,eAAe;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,2BAA2B;AAC3E;AACA,iFAAiF,yBAAyB;AAC1G;AACA;AACA,4BAA4B,eAAe;AAC3C;AACA,+BAA+B,2BAA2B;AAC1D;AACA,qBAAqB,2BAA2B;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,WAAW;AACxC;AACA,mBAAmB,yBAAyB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,0BAA0B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,0BAA0B;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA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AAe,qCAAG;AAClB;AACA,SAAS;AACT;AACA;AACA,4CAA4C,4BAA4B,2BAA2B,YAAY;AAC/G;AACA;AACA,wBAAwB,2BAA2B;AACnD,wBAAwB,wBAAwB;AAChD,uBAAuB,wBAAwB;AAC/C;AACA,qBAAqB,wBAAwB;AAC7C;AACA,eAAe,qCAAG;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,4BAA4B,uCAAuC,kBAAkB;AACzG;AACA,2BAA2B,2BAA2B;AACtD;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa,mCAAmC,kBAAkB,SAAS,kBAAkB;AAClH;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;;;;;;;UCtFA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCtBA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA;;;;;WCPA;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;;;;;;;;;;;;;;;;ACNA,kBAAkB,SAAI,IAAI,SAAI;AAC9B;AACA;AACA,6CAA6C,QAAQ;AACrD;AACA;AACA,kBAAkB,SAAI,IAAI,SAAI;AAC9B;AACA;AACA,eAAe,SAAI,IAAI,SAAI;AAC3B,oCAAoC;AACpC;AAC4B;AACQ;AACN;AACI;AACJ;AACY;AAC1C;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,EAAE;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,6CAAK;AACT;AACA;AACA;AACA,IAAI,6CAAK;AACT,IAAI,qCAAG;AACP,eAAe,6CAAK;AACpB;AACA;AACA;AACA;AACA;AACA,IAAI,6CAAK;AACT;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE;AACjB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE;AACjB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,2CAAI;AACnB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE,UAAU,2CAAI;AAC/B;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE,SAAS,6CAAK;AAC/B;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP;AACA;AACA,eAAe,mDAAQ;AACvB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE,UAAU,2CAAI,gBAAgB,6CAAK;AACpD;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE,UAAU,2CAAI,gBAAgB,6CAAK;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sources":["webpack://xdbc/./src/DBC.ts","webpack://xdbc/./src/DBC/AE.ts","webpack://xdbc/./src/DBC/EQ.ts","webpack://xdbc/./src/DBC/INSTANCE.ts","webpack://xdbc/./src/DBC/REGEX.ts","webpack://xdbc/./src/DBC/TYPE.ts","webpack://xdbc/webpack/bootstrap","webpack://xdbc/webpack/runtime/define property getters","webpack://xdbc/webpack/runtime/hasOwnProperty shorthand","webpack://xdbc/webpack/runtime/make namespace object","webpack://xdbc/./src/Demo.ts"],"sourcesContent":["/**\n * Provides a **D**esign **B**y **C**ontract Framework using decorators.\n *\n * @remarks\n * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */\nexport class DBC {\n    /**\n     * Make a request to get the value of a certain parameter of specific method in a specific {@link object }.\n     * That request gets enlisted in {@link paramValueRequests } which is used by {@link ParamvalueProvider} to invoke the\n     * given \"receptor\" with the parameter value stored in there. Thus a parameter decorator using this method will\n     * not receive any value of the top method is not tagged with {@link ParamvalueProvider}.\n     *\n     * @param target\t\tThe {@link object } containing the method with the parameter which's value is requested.\n     * @param methodName\tThe name of the method with the parameter which's value is requested.\n     * @param index\t\t\tThe index of the parameter which's value is requested.\n     * @param receptor\t\tThe method the requested parameter-value shall be passed to when it becomes available. */\n    static requestParamValue(target, methodName, index, \n    // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.\n    receptor) {\n        if (DBC.paramValueRequests.has(target)) {\n            if (DBC.paramValueRequests.get(target).has(methodName)) {\n                if (DBC.paramValueRequests.get(target).get(methodName).has(index)) {\n                    DBC.paramValueRequests\n                        .get(target)\n                        .get(methodName)\n                        .get(index)\n                        .push(receptor);\n                }\n                else {\n                    DBC.paramValueRequests\n                        .get(target)\n                        .get(methodName)\n                        .set(index, new Array(receptor));\n                }\n            }\n            else {\n                DBC.paramValueRequests\n                    .get(target)\n                    .set(methodName, new Map([\n                    [index, new Array(receptor)],\n                ]));\n            }\n        }\n        else {\n            DBC.paramValueRequests.set(target, new Map([\n                [\n                    methodName,\n                    new Map([\n                        [index, new Array(receptor)],\n                    ]),\n                ],\n            ]));\n        }\n        return undefined;\n    }\n    /**\n     * A method-decorator factory checking the {@link paramValueRequests } for value-requests of the method's parameter thus\n     * also usable on setters.\n     * When found it will invoke the \"receptor\" registered there, inter alia by {@link requestParamValue }, with the\n     * parameter's value.\n     *\n     * @param target \t\tThe {@link object } hosting the tagged method as provided by the runtime.\n     * @param propertyKey \tThe tagged method's name as provided by the runtime.\n     * @param descriptor \tThe {@link PropertyDescriptor } as provided by the runtime.\n     *\n     * @returns The {@link PropertyDescriptor } that was passed by the runtime. */\n    static ParamvalueProvider(target, propertyKey, descriptor) {\n        const originalMethod = descriptor.value;\n        // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.\n        descriptor.value = (...args) => {\n            // #region\tCheck if a value of one of the method's parameter has been requested and pass it to the\n            //\t\t\treceptor, if so.\n            if (DBC.paramValueRequests.has(target) &&\n                DBC.paramValueRequests.get(target).has(propertyKey)) {\n                for (const index of DBC.paramValueRequests\n                    .get(target)\n                    .get(propertyKey)\n                    .keys()) {\n                    if (index < args.length) {\n                        for (const receptor of DBC.paramValueRequests\n                            .get(target)\n                            .get(propertyKey)\n                            .get(index)) {\n                            receptor(args[index]);\n                        }\n                    }\n                }\n            }\n            // #endregion \tCheck if a value of one of the method's parameter has been requested and pass it to the\n            // \t\t\t\treceptor, if so.\n            // biome-ignore lint/complexity/noThisInStatic: Necessary.\n            return originalMethod.apply(this, args);\n        };\n        return descriptor;\n    }\n    // #endregion Parameter-value requests.\n    // #region Invariant\n    /**\n     * A property-decorator factory serving as a **D**esign **B**y **C**ontract Invariant.\n     * Since the value must be initialized or set according to the specified **contracts** the value will only be checked\n     * when assigning it.\n     *\n     * @param contracts The {@link DBC }-Contracts the value shall uphold.\n     *\n     * @throws \tA {@link DBC.Infringement } whenever the property is tried to be set to a value that does not comply to the\n     * \t\t\tspecified **contracts**, by the returned method.*/\n    static decInvariant(contracts, path = undefined, dbc = \"WaXCode.DBC\") {\n        return (target, propertyKey) => {\n            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.\n            let value;\n            // #region Replace original property.\n            Object.defineProperty(target, propertyKey, {\n                set(newValue) {\n                    const realValue = path ? DBC.resolve(newValue, path) : newValue;\n                    // #region Check if all \"contracts\" are fulfilled.\n                    for (const contract of contracts) {\n                        const result = contract.check(realValue);\n                        if (typeof result === \"string\") {\n                            DBC.resolveDBCPath(window, dbc).reportFieldInfringement(result, target, path, propertyKey, realValue);\n                        }\n                    }\n                    // #endregion Check if all \"contracts\" are fulfilled.\n                    value = newValue;\n                },\n                enumerable: true,\n                configurable: true,\n            });\n            // #endregion Replace original property.\n        };\n    }\n    // #endregion Invariant\n    // #region Postcondition\n    /**\n     * A method decorator factory checking the result of a method whenever it is invoked thus also usable on getters.\n     *\n     * @param check\tThe **(toCheck: any, object, string) => boolean | string** to use for checking.\n     * @param dbc\tSee {@link DBC.resolveDBCPath }.\n     * @param path\tThe dotted path referring to the actual value to check, starting form the specified one.\n     *\n     * @returns The **( target : object, propertyKey : string, descriptor : PropertyDescriptor ) : PropertyDescriptor**\n     * \t\t\tinvoked by Typescript.\n     */\n    static decPostcondition(\n    // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.\n    check, dbc, path = undefined) {\n        return (target, propertyKey, descriptor) => {\n            const originalMethod = descriptor.value;\n            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.\n            descriptor.value = (...args) => {\n                // biome-ignore lint/complexity/noThisInStatic: <explanation>\n                const result = originalMethod.apply(this, args);\n                const realValue = path ? DBC.resolve(result, path) : result;\n                const checkResult = check(realValue, target, propertyKey);\n                if (typeof checkResult === \"string\") {\n                    DBC.resolveDBCPath(window, dbc).reportReturnvalueInfringement(checkResult, target, path, propertyKey, realValue);\n                }\n                return result;\n            };\n            return descriptor;\n        };\n    }\n    // #endregion Postcondition\n    // #region Decorator\n    // #region Precondition\n    /**\n     * A parameter-decorator factory that requests the tagged parameter's value passing it to the provided\n     * \"check\"-method when the value becomes available.\n     *\n     * @param check\tThe \"( unknown ) => void\" to be invoked along with the tagged parameter's value as soon\n     * \t\t\t\tas it becomes available.\n     * @param dbc  \tSee {@link DBC.resolveDBCPath }.\n     * @param path\tThe dotted path referring to the actual value to check, starting form the specified one.\n     *\n     * @returns The **(target: object, methodName: string | symbol, parameterIndex: number ) => void** invoked by Typescript- */\n    static decPrecondition(check, dbc, path = undefined) {\n        return (target, methodName, parameterIndex) => {\n            DBC.requestParamValue(target, methodName, parameterIndex, (value) => {\n                const realValue = path ? DBC.resolve(value, path) : value;\n                const result = check(realValue, target, methodName, parameterIndex);\n                if (typeof result === \"string\") {\n                    DBC.resolveDBCPath(window, dbc).reportParameterInfringement(result, target, path, methodName, parameterIndex, realValue);\n                }\n            });\n        };\n    }\n    /**\n     * Reports a warning.\n     *\n     * @param message The message containing the warning. */\n    reportWarning(message) {\n        if (this.warningSettings.logToConsole) {\n            console.warn(message);\n        }\n    }\n    /**\n     * Reports an infringement according to the {@link infringementSettings } also generating a proper {@link string }-wrapper\n     * for the given \"message\" & violator.\n     *\n     * @param message\tThe {@link string } describing the infringement and it's provenience.\n     * @param violator \tThe {@link string } describing or naming the violator. */\n    reportInfringement(message, violator, target, path) {\n        const finalMessage = `[ From \"${violator}\"${path ? `'s member \"${path}\"` : \"\"}${typeof target === \"function\" ? ` in \"${target.name}\"` : typeof target === \"object\" && target !== null && typeof target.constructor === \"function\" ? ` in \"${target.constructor.name}\"` : \"\"}: ${message}]`;\n        if (this.infringementSettings.throwException) {\n            throw new DBC.Infringement(finalMessage);\n        }\n        if (this.infringementSettings.logToConsole) {\n            console.log(finalMessage);\n        }\n    }\n    /**\n     * Reports a parameter-infringement via {@link reportInfringement } also generating a proper {@link string }-wrapper\n     * for the given \"message\",\"method\", parameter-\"index\" & value.\n     *\n     * @param message\tThe {@link string } describing the infringement and it's provenience.\n     * @param method \tThe {@link string } describing or naming the violator.\n     * @param index\t\tThe index of the parameter within the argument listing.\n     * @param value \tThe parameter's value. */\n    reportParameterInfringement(message, target, path, method, index, value) {\n        const properIndex = index + 1;\n        this.reportInfringement(`[ Parameter-value \"${value}\" of the ${properIndex}${properIndex === 1 ? \"st\" : properIndex === 2 ? \"nd\" : properIndex === 3 ? \"rd\" : \"th\"} parameter did not fulfill one of it's contracts: ${message}]`, method, target, path);\n    }\n    /**\n     * Reports a field-infringement via {@link reportInfringement } also generating a proper {@link string }-wrapper\n     * for the given **message** & **name**.\n     *\n     * @param message\tA {@link string } describing the infringement and it's provenience.\n     * @param key \t\tThe property key.\n     * @param path\t\tThe dotted-path {@link string } that leads to the value not fulfilling the contract starting from\n     * \t\t\t\t\tthe tagged one.\n     * @param value\t\tThe value not fulfilling a contract. */\n    reportFieldInfringement(message, target, path, key, value) {\n        this.reportInfringement(`[ New value for \"${key}\"${path === undefined ? \"\" : `.${path}`} with value \"${value}\" did not fulfill one of it's contracts: ${message}]`, key, target, path);\n    }\n    /**\n     * Reports a returnvalue-infringement according via {@link reportInfringement } also generating a proper {@link string }-wrapper\n     * for the given \"message\",\"method\" & value.\n     *\n     * @param message\tThe {@link string } describing the infringement and it's provenience.\n     * @param method \tThe {@link string } describing or naming the violator.\n     * @param value\t\tThe parameter's value. */\n    reportReturnvalueInfringement(message, target, path, method, \n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    value) {\n        this.reportInfringement(`[ Return-value \"${value}\" did not fulfill one of it's contracts: ${message}]`, method, target, path);\n    }\n    /**\n     * Constructs this {@link DBC } by setting the {@link DBC.infringementSettings }, define the **WaXCode** namespace in\n     * **window** if not yet available and setting the property **DBC** in there to the instance of this {@link DBC }.\n     *\n     * @param infringementSettings See {@link DBC.infringementSettings }. */\n    constructor(infringementSettings = { throwException: true, logToConsole: false }) {\n        // #endregion Precondition\n        // #endregion Decorator\n        // #region Warning handling.\n        /** Stores settings concerning warnings. */\n        this.warningSettings = { logToConsole: true };\n        // #endregion Warning handling.\n        // #region infringement handling.\n        /** Stores the settings concerning infringements */\n        this.infringementSettings = { throwException: true, logToConsole: false };\n        this.infringementSettings = infringementSettings;\n        // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n        if (window.WaXCode === undefined)\n            window.WaXCode = {};\n        // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n        window.WaXCode.DBC = this;\n    }\n    /**\n     *\n     */\n    static resolve(toResolveFrom, path) {\n        if (!toResolveFrom || typeof path !== \"string\") {\n            return undefined;\n        }\n        const parts = path.replace(/\\[(['\"]?)(.*?)\\1\\]/g, \".$2\").split(\".\"); // Handle indexers\n        let current = toResolveFrom;\n        for (const part of parts) {\n            if (current === null || typeof current === \"undefined\") {\n                return undefined;\n            }\n            const methodMatch = part.match(/(\\w+)\\((.*)\\)/);\n            if (methodMatch) {\n                const methodName = methodMatch[1];\n                const argsStr = methodMatch[2];\n                const args = argsStr.split(\",\").map((arg) => arg.trim()); // Simple argument parsing\n                if (typeof current[methodName] === \"function\") {\n                    current = current[methodName].apply(current, args);\n                }\n                else {\n                    return undefined; // Method not found or not a function\n                }\n            }\n            else {\n                current = current[part];\n            }\n        }\n        return current;\n    }\n}\n// #region Parameter-value requests.\n/** Stores all request for parameter values registered by {@link decPrecondition }. */\nDBC.paramValueRequests = new Map();\n// #region Classes\n// #region Errors\n/** An {@link Error } to be thrown whenever an infringement is detected. */\nDBC.Infringement = class extends Error {\n    /**\n     * Constructs this {@link Error } by tagging the specified message-{@link string } as an XDBC-Infringement.\n     *\n     * @param message The {@link string } describing the infringement. */\n    constructor(message) {\n        super(`[ XDBC Infringement ${message}]`);\n    }\n};\n// #endregion Errors\n// #endregion Classes\n// #endregion infringement handling.\n/**\n * Resolves the specified dotted {@link string }-path to a {@link DBC }.\n *\n * @param obj \tThe {@link object } to start resolving from.\n * @param path \tThe dotted {@link string }-path leading to the {@link DBC }.\n *\n * @returns The requested {@link DBC }.\n */\nDBC.resolveDBCPath = (obj, path) => path === null || path === void 0 ? void 0 : path.split(\".\").reduce((accumulator, current) => accumulator[current], obj);\n// Set the main instance with standard **DBC.infringementSettings**.\nnew DBC();\n","import { DBC } from \"../DBC\";\n/**\n * A {@link DBC } defining that all elements of an {@link object }s have to fulfill\n * a given {@link object }'s check-method (**( toCheck : any ) => boolean | string**).\n *\n * @remarks\n * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */\nexport class AE extends DBC {\n    // #region Condition checking.\n    /**\n     * Checks each element of the **value**-{@link Array < any >} against the given **condition**, if it is one. If it is not\n     * the **value** itself will be checked.\n     *\n     * @param condition\tThe { check: (toCheck: any) => boolean | string } to check the **value** against.\n     * @param value\t\tEither **value**-{@link Array < any >}, which's elements will be checked, or the value to be\n     * \t\t\t\t\tchecked itself.\n     * @param index\t\tIf specified with **idxEnd** being undefined, this {@link Number } will be seen as the index of\n     * \t\t\t\t\tthe value-{@link Array }'s element to check. If value isn't an {@link Array } this parameter\n     * \t\t\t\t\twill not have any effect.\n     * \t\t\t\t\tWith **idxEnd** not undefined this parameter indicates the beginning of the span of elements to\n     * \t\t\t\t\tcheck within the value-{@link Array }.\n     * @param idxEnd\tIndicates the last element's index (including) of the span of value-{@link Array } elements to check.\n     * \t\t\t\t\tSetting this parameter to -1 specifies that all value-{@link Array }'s elements beginning from the\n     * \t\t\t\t\tspecified **index** shall be checked.\n     *\n     * @returns As soon as the **condition** returns a {@link string }, instead of TRUE, the returned string. TRUE if the\n     * \t\t\t**condition** never returns a {@link string}. */\n    static checkAlgorithm(condition, value, index, idxEnd) {\n        if (Array.isArray(value)) {\n            if (index !== undefined && idxEnd === undefined) {\n                if (index > -1 && index < value.length) {\n                    const result = condition.check(value[index]);\n                    if (typeof result === \"string\") {\n                        return `Violating-Arrayelement at index \"${index}\" with value \"${value[index]}\". ${result}`;\n                    }\n                }\n                return true; // In order for optional parameter to not cause an error if they are omitted.\n            }\n            const ending = idxEnd !== undefined\n                ? idxEnd !== -1\n                    ? idxEnd + 1\n                    : value.length\n                : value.length;\n            for (let i = index ? index : 0; i < ending; i++) {\n                const result = condition.check(value[i]);\n                if (result !== true) {\n                    return `Violating-Arrayelement at index ${i}. ${result}`;\n                }\n            }\n        }\n        else {\n            return condition.check(value);\n        }\n        return true;\n    }\n    /**\n     * A parameter-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one\n     * of the **realConditions** to check the tagged parameter-value against with.\n     * When specifying an **index** and the tagged parameter's **value** is an {@link Array }, the **realConditions** apply to the\n     * element at the specified **index**.\n     * If the {@link Array } is too short the currently processed { check: (toCheck: any) => boolean | string } of\n     * **realConditions** will be verified to TRUE automatically, considering optional parameters.\n     * If an **index** is specified but the tagged parameter's value isn't an array, the **index** is treated as being undefined.\n     * If **index** is undefined and the tagged parameter's value is an {@link Array } each element of it will be checked\n     * against the **realConditions**.\n     *\n     * @param realConditions\tEither one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value\n     * \t\t\t\t\t\t\tagainst with.\n     * @param index\t\t\t\tSee the {@link AE.checkAlgorithm }.\n     * @param idxEnd\t\t\tSee the {@link AE.checkAlgorithm }.\n     * @param path\t\t\t\tSee {@link DBC.decPrecondition }.\n     * @param dbc\t\t\t\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns\tA {@link string } as soon as one { check: (toCheck: any) => boolean | string } of **realConditions** returns one.\n     * \t\t\tOtherwise TRUE. */\n    static PRE(realConditions, index = undefined, idxEnd = undefined, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {\n            if (Array.isArray(realConditions)) {\n                for (const currentCondition of realConditions) {\n                    const result = AE.checkAlgorithm(currentCondition, value, index, idxEnd);\n                    if (typeof result !== \"boolean\")\n                        return result;\n                }\n            }\n            else {\n                return AE.checkAlgorithm(realConditions, value, index, idxEnd);\n            }\n            return true;\n        }, dbc, path);\n    }\n    /**\n     * A method-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one\n     * of the **realConditions** to check the tagged method's return-value against with.\n     *\n     * @param realConditions\tEither one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value\n     * \t\t\t\t\t\t\tagainst with.\n     * @param index\t\t\t\tSee the {@link AE.checkAlgorithm }.\n     * @param idxEnd\t\t\tSee the {@link AE.checkAlgorithm }.\n     * @param path\t\t\t\tSee {@link DBC.decPrecondition }.\n     * @param dbc\t\t\t\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns\tA {@link string } as soon as one { check: (toCheck: any) => boolean | string } of **realConditions** return one.\n     * \t\t\tOtherwise TRUE. */\n    static POST(realConditions, index = undefined, idxEnd = undefined, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPostcondition((value, target, propertyKey) => {\n            if (Array.isArray(realConditions)) {\n                for (const currentCondition of realConditions) {\n                    const result = AE.checkAlgorithm(currentCondition, value, index, idxEnd);\n                    if (typeof result !== \"boolean\")\n                        return result;\n                }\n            }\n            else {\n                return AE.checkAlgorithm(\n                // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n                realConditions, value, index, idxEnd);\n            }\n            return true;\n        }, dbc, path);\n    }\n    /**\n     * A field-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one\n     * of the **realConditions** to check the tagged field.\n     *\n     * @param realConditions\tEither one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value\n     * \t\t\t\t\t\t\tagainst with.\n     * @param index\t\t\t\tSee the {@link AE.checkAlgorithm }.\n     * @param idxEnd\t\t\tSee the {@link AE.checkAlgorithm }.\n     * @param path\t\t\t\tSee {@link DBC.decInvariant }.\n     * @param dbc\t\t\t\tSee {@link DBC.decInvariant }.\n     *\n     * @returns\tSee {@link DBC.decInvariant }. */\n    static INVARIANT(realConditions, index = undefined, idxEnd = undefined, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decInvariant([new AE(realConditions, index, idxEnd)], path, dbc);\n    }\n    // #endregion Condition checking.\n    // #region Referenced Condition checking.\n    //\n    // For usage in dynamic scenarios (like global functions).\n    //\n    /**\n     * Invokes the {@link AE.checkAlgorithm } with all {@link AE.conditions } and the {@link object } {@link toCheck },\n     * {@link AE.index } & {@link AE.idxEnd }.\n     *\n     * @param toCheck See {@link AE.checkAlgorithm }.\n     *\n     * @returns See {@link EQ.checkAlgorithm}. */\n    check(toCheck) {\n        if (Array.isArray(this.conditions)) {\n            for (const currentCondition of this.conditions) {\n                const result = AE.checkAlgorithm(currentCondition, toCheck, this.index, this.idxEnd);\n                if (typeof result !== \"boolean\")\n                    return result;\n            }\n        }\n        else {\n            return AE.checkAlgorithm(\n            // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n            this.conditions, toCheck, this.index, this.idxEnd);\n        }\n        return true;\n    }\n    /**\n     * Creates this {@link AE } by setting the protected property {@link AE.conditions }, {@link AE.index } and {@link AE.idxEnd } used by {@link AE.check }.\n     *\n     * @param equivalent See {@link EQ.check }. */\n    constructor(conditions, index = undefined, idxEnd = undefined) {\n        super();\n        this.conditions = conditions;\n        this.index = index;\n        this.idxEnd = idxEnd;\n    }\n}\n","import { DBC } from \"../DBC\";\n/**\n * A {@link DBC } defining that two {@link object }s gotta be equal.\n *\n * @remarks\n * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */\nexport class EQ extends DBC {\n    // #region Condition checking.\n    /**\n     * Checks if the value **toCheck** is equal to the specified **equivalent**.\n     *\n     * @param toCheck\t\tThe value that has to be equal to it's possible **equivalent** for this {@link DBC } to be fulfilled.\n     * @param equivalent\tThe {@link object } the one **toCheck** has to be equal to in order for this {@link DBC } to be\n     * \t\t\t\t\t\tfulfilled.\n     *\n     * @returns TRUE if the value **toCheck** and the **equivalent** are equal to each other, otherwise FALSE. */\n    static checkAlgorithm(\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    toCheck, equivalent, invert) {\n        if (!invert && equivalent !== toCheck) {\n            return `Value has to to be equal to \"${equivalent}\"`;\n        }\n        if (invert && equivalent === toCheck) {\n            return `Value must not to be equal to \"${equivalent}\"`;\n        }\n        return true;\n    }\n    /**\n     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged parameter.\n     *\n     * @param equivalent\tSee {@link EQ.checkAlgorithm }.\n     * @param path\t\t\tSee {@link DBC.decPrecondition }.\n     * @param dbc\t\t\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns See {@link DBC.decPrecondition }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.\n    equivalent, invert = false, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {\n            return EQ.checkAlgorithm(value, equivalent, invert);\n        }, dbc, path);\n    }\n    /**\n     * A method-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged method's returnvalue.\n     *\n     * @param equivalent\tSee {@link EQ.checkAlgorithm }.\n     * @param path\t\t\tSee {@link DBC.Postcondition }.\n     * @param dbc\t\t\tSee {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.\n    equivalent, invert = false, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPostcondition((value, target, propertyKey) => {\n            return EQ.checkAlgorithm(value, equivalent, invert);\n        }, dbc, path);\n    }\n    /**\n     * A field-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged field.\n     *\n     * @param equivalent\tSee {@link EQ.checkAlgorithm }.\n     * @param path\t\t\tSee {@link DBC.decInvariant }.\n     * @param dbc\t\t\tSee {@link DBC.decInvariant }.\n     *\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.\n    equivalent, invert = false, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decInvariant([new EQ(equivalent, invert)], path, dbc);\n    }\n    // #endregion Condition checking.\n    // #region Referenced Condition checking.\n    //\n    // For usage in dynamic scenarios (like with AE-DBC).\n    //\n    /**\n     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck**, {@link EQ.equivalent } and {@link EQ.invert }.\n     *\n     * @param toCheck See {@link EQ.checkAlgorithm }.\n     *\n     * @returns See {@link EQ.checkAlgorithm}. */\n    // biome-ignore lint/suspicious/noExplicitAny: Necessary to check against NULL & UNDEFINED.\n    check(toCheck) {\n        return EQ.checkAlgorithm(toCheck, this.equivalent, this.invert);\n    }\n    /**\n     * Creates this {@link EQ } by setting the protected property {@link EQ.equivalent } used by {@link EQ.check }.\n     *\n     * @param equivalent See {@link EQ.check }. */\n    constructor(\n    // biome-ignore lint/suspicious/noExplicitAny: To be able to match UNDEFINED and NULL.\n    equivalent, invert = false) {\n        super();\n        this.equivalent = equivalent;\n        this.invert = invert;\n    }\n}\n","import { DBC } from \"../DBC\";\n/**\n * A {@link DBC } defining that the an {@link object }s gotta be an instance of a certain {@link INSTANCE.reference }.\n *\n * @remarks\n * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */\nexport class INSTANCE extends DBC {\n    /**\n     * Checks if the value **toCheck** is complies to the {@link RegExp } **expression**.\n     *\n     * @param toCheck\tThe value that has comply to the {@link RegExp } **expression** for this {@link DBC } to be fulfilled.\n     * @param reference\tThe {@link RegExp } the one **toCheck** has comply to in order for this {@link DBC } to be\n     * \t\t\t\t\tfulfilled.\n     *\n     * @returns TRUE if the value **toCheck** is of the specified **type**, otherwise FALSE. */\n    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an \"instanceof\" check.\n    static checkAlgorithm(toCheck, reference) {\n        if (!(toCheck instanceof reference)) {\n            return `Value has to be an instance of \"${reference}\" but is of type \"${typeof toCheck}\"`;\n        }\n        return true;\n    }\n    /**\n     * A parameter-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged parameter.\n     *\n     * @param reference\tSee {@link INSTANCE.checkAlgorithm }.\n     * @param path\tSee {@link DBC.decPrecondition }.\n     * @param dbc\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns See {@link DBC.decPrecondition }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an \"instanceof\" check.\n    reference, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {\n            return INSTANCE.checkAlgorithm(value, reference);\n        }, dbc, path);\n    }\n    /**\n     * A method-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged method's returnvalue.\n     *\n     * @param reference\tSee {@link INSTANCE.checkAlgorithm }.\n     * @param path\tSee {@link DBC.Postcondition }.\n     * @param dbc\tSee {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an \"instanceof\" check.\n    reference, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPostcondition((value, target, propertyKey) => {\n            return INSTANCE.checkAlgorithm(value, reference);\n        }, dbc, path);\n    }\n    /**\n     * A field-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged method's returnvalue.\n     *\n     * @param reference\tSee {@link INSTANCE.checkAlgorithm }.\n     * @param path\tSee {@link DBC.decInvariant }.\n     * @param dbc\tSee {@link DBC.decInvariant }.\n     *\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an \"instanceof\" check.\n    reference, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decInvariant([new INSTANCE(reference)], path, dbc);\n    }\n    // #endregion Condition checking.\n    // #region Referenced Condition checking.\n    //\n    // For usage in dynamic scenarios (like with AE-DBC).\n    //\n    /**\n     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .\n     *\n     * @param toCheck See {@link INSTANCE.checkAlgorithm }.\n     *\n     * @returns See {@link INSTANCE.checkAlgorithm}. */\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    check(toCheck) {\n        return INSTANCE.checkAlgorithm(toCheck, this.reference);\n    }\n    /**\n     * Creates this {@link INSTANCE } by setting the protected property {@link INSTANCE.reference } used by {@link INSTANCE.check }.\n     *\n     * @param reference See {@link INSTANCE.check }. */\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    constructor(reference) {\n        super();\n        this.reference = reference;\n    }\n}\n","import { DBC } from \"../DBC\";\n/**\n * A {@link DBC } providing {@link REGEX }-contracts and standard {@link RegExp } for common use cases in {@link REGEX.stdExp }.\n *\n * @remarks\n * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */\nexport class REGEX extends DBC {\n    // #region Condition checking.\n    /**\n     * Checks if the value **toCheck** is complies to the {@link RegExp } **expression**.\n     *\n     * @param toCheck\t\tThe value that has comply to the {@link RegExp } **expression** for this {@link DBC } to be fulfilled.\n     * @param expression\tThe {@link RegExp } the one **toCheck** has comply to in order for this {@link DBC } to be\n     * \t\t\t\t\t\tfulfilled.\n     *\n     * @returns TRUE if the value **toCheck** complies with the {@link RegExp } **expression**, otherwise FALSE. */\n    static checkAlgorithm(toCheck, expression) {\n        if (!expression.test(toCheck)) {\n            return `Value has to comply to regular expression \"${expression}\"`;\n        }\n        return true;\n    }\n    /**\n     * A parameter-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged parameter.\n     *\n     * @param expression\tSee {@link REGEX.checkAlgorithm }.\n     * @param path\t\t\tSee {@link DBC.decPrecondition }.\n     * @param dbc\t\t\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns See {@link DBC.decPrecondition }. */\n    static PRE(expression, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {\n            return REGEX.checkAlgorithm(value, expression);\n        }, dbc, path);\n    }\n    /**\n     * A method-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged method's returnvalue.\n     *\n     * @param expression\tSee {@link REGEX.checkAlgorithm }.\n     * @param path\t\t\tSee {@link DBC.Postcondition }.\n     * @param dbc\t\t\tSee {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(expression, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPostcondition((value, target, propertyKey) => {\n            return REGEX.checkAlgorithm(value, expression);\n        }, dbc, path);\n    }\n    /**\n     * A field-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged field.\n     *\n     * @param expression\tSee {@link REGEX.checkAlgorithm }.\n     * @param path\t\t\tSee {@link DBC.decInvariant }.\n     * @param dbc\t\t\tSee {@link DBC.decInvariant }.\n     *\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(expression, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decInvariant([new REGEX(expression)], path, dbc);\n    }\n    // #endregion Condition checking.\n    // #region Referenced Condition checking.\n    //\n    // For usage in dynamic scenarios (like with AE-DBC).\n    //\n    /**\n     * Invokes the {@link REGEX.checkAlgorithm } passing the value **toCheck** and {@link REGEX.equivalent }.\n     *\n     * @param toCheck See {@link REGEX.checkAlgorithm }.\n     *\n     * @returns See {@link EQ.checkAlgorithm}. */\n    check(toCheck) {\n        return REGEX.checkAlgorithm(toCheck, this.expression);\n    }\n    /**\n     * Creates this {@link REGEX } by setting the protected property {@link REGEX.expression } used by {@link REGEX.check }.\n     *\n     * @param expression See {@link REGEX.check }. */\n    constructor(expression) {\n        super();\n        this.expression = expression;\n    }\n    // #endregion Referenced Condition checking.\n    // #region In-Method checking.\n    /**\n     * Invokes the {@link REGEX.checkAlgorithm } passing the value **toCheck** and {@link REGEX.expression }.\n     *\n     * @param toCheck\t\tSee {@link REGEX.checkAlgorithm}.\n     * @param expression\tSee {@link REGEX.checkAlgorithm}.\n     */\n    static check(toCheck, expression) {\n        const checkResult = REGEX.checkAlgorithm(toCheck, expression);\n        if (typeof checkResult === \"string\") {\n            throw new DBC.Infringement(checkResult);\n        }\n    }\n}\n/** Stores often used {@link RegExp }s. */\nREGEX.stdExp = {\n    htmlAttributeName: /^[a-zA-Z_:][a-zA-Z0-9_.:-]*$/,\n    eMail: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/i,\n    property: /^[$_A-Za-z][$_A-Za-z0-9]*$/,\n    url: /^(?:(?:http:|https?|ftp):\\/\\/)?(?:\\S+(?::\\S*)?@)?(?:localhost|(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,})(?::\\d{2,5})?(?:\\/(?:[\\w\\-\\.]*\\/)*[\\w\\-\\.]+(?:\\?\\S*)?(?:#\\S*)?)?$/i,\n    keyPath: /^([a-zA-Z_$][a-zA-Z0-9_$]*\\.)*[a-zA-Z_$][a-zA-Z0-9_$]*$/,\n    date: /^\\d{1,4}[.\\/-]\\d{1,2}[.\\/-]\\d{1,4}$/i,\n    dateFormat: /^((D{1,2}[./-]M{1,2}[./-]Y{1,4})|(M{1,2}[./-]D{1,2}[./-]Y{1,4})|Y{1,4}[./-]D{1,2}[./-]M{1,2}|(Y{1,4}[./-]M{1,2}[./-]D{1,2}))$/i,\n    cssSelector: /^(?:\\*|#[\\w-]+|\\.[\\w-]+|(?:[\\w-]+|\\*)(?::(?:[\\w-]+(?:\\([\\w-]+\\))?)+)?(?:\\[(?:[\\w-]+(?:(?:=|~=|\\|=|\\*=|\\$=|\\^=)\\s*(?:\"[^\"]*\"|'[^']*'|[\\w-]+)\\s*)?)?\\])+|\\[\\s*[\\w-]+\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[\\w-]+)\\s*\\])(?:,\\s*(?:\\*|#[\\w-]+|\\.[\\w-]+|(?:[\\w-]+|\\*)(?::(?:[\\w-]+(?:\\([\\w-]+\\))?)+)?(?:\\[(?:[\\w-]+(?:(?:=|~=|\\|=|\\*=|\\$=|\\^=)\\s*(?:\"[^\"]*\"|'[^']*'|[\\w-]+)\\s*)?)?\\])+|\\[\\s*[\\w-]+\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[\\w-]+)\\s*\\]))*$/,\n};\n","import { DBC } from \"../DBC\";\n/**\n * A {@link DBC } defining that an {@link object }s gotta be of certain {@link TYPE.type }.\n *\n * @remarks\n * Author: \t\tSalvatore Callari (Callari@WaXCode.net) / 2025\n * Maintainer:\tSalvatore Callari (XDBC@WaXCode.net) */\nexport class TYPE extends DBC {\n    /**\n     * Checks if the value **toCheck** is of the **type** specified.\n     *\n     * @param toCheck\tThe {@link Object } which's **type** to check.\n     * @param type\t\tThe type the {@link object} **toCheck** has to be of.\n     *\n     * @returns TRUE if the value **toCheck** is of the specified **type**, otherwise FALSE. */\n    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic type checking of also UNDEFINED.\n    static checkAlgorithm(toCheck, type) {\n        // biome-ignore lint/suspicious/useValidTypeof: Necessary\n        if (typeof toCheck !== type) {\n            return `Value has to to be of type \"${type}\" but is of type \"${typeof toCheck}\"`;\n        }\n        return true;\n    }\n    /**\n     * A parameter-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged parameter.\n     *\n     * @param type\tSee {@link TYPE.checkAlgorithm }.\n     * @param path\tSee {@link DBC.decPrecondition }.\n     * @param dbc\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns See {@link DBC.decPrecondition }. */\n    static PRE(type, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {\n            return TYPE.checkAlgorithm(value, type);\n        }, dbc, path);\n    }\n    /**\n     * A method-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged method's returnvalue.\n     *\n     * @param type\tSee {@link TYPE.checkAlgorithm }.\n     * @param path\tSee {@link DBC.Postcondition }.\n     * @param dbc\tSee {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(type, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decPostcondition((value, target, propertyKey) => {\n            return TYPE.checkAlgorithm(value, type);\n        }, dbc, path);\n    }\n    /**\n     * A field-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged field.\n     *\n     * @param type\tSee {@link TYPE.checkAlgorithm }.\n     * @param path\tSee {@link DBC.decInvariant }.\n     * @param dbc\tSee {@link DBC.decInvariant }.\n     *\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(type, path = undefined, dbc = \"WaXCode.DBC\") {\n        return DBC.decInvariant([new TYPE(type)], path, dbc);\n    }\n    // #endregion Condition checking.\n    // #region Referenced Condition checking.\n    //\n    // For usage in dynamic scenarios (like with AE-DBC).\n    //\n    /**\n     * Invokes the {@link TYPE.checkAlgorithm } passing the value **toCheck** and the {@link TYPE.type } .\n     *\n     * @param toCheck See {@link TYPE.checkAlgorithm }.\n     *\n     * @returns See {@link TYPE.checkAlgorithm}. */\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    check(toCheck) {\n        return TYPE.checkAlgorithm(toCheck, this.type);\n    }\n    /**\n     * Creates this {@link TYPE } by setting the protected property {@link TYPE.type } used by {@link TYPE.check }.\n     *\n     * @param type See {@link TYPE.check }. */\n    constructor(type) {\n        super();\n        this.type = type;\n    }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nimport { DBC } from \"./DBC\";\nimport { REGEX } from \"./DBC/REGEX\";\nimport { EQ } from \"./DBC/EQ\";\nimport { TYPE } from \"./DBC/TYPE\";\nimport { AE } from \"./DBC/AE\";\nimport { INSTANCE } from \"./DBC/INSTANCE\";\n/** Demonstrative use of **D**esign **B**y **C**ontract Decorators */\nexport class Demo {\n    constructor() {\n        // #region Check Property Decorator\n        this.testProperty = \"a\";\n        // #endregion Check AE Index\n    }\n    // #endregion Check Property Decorator\n    // #region Check Parameter. & Returnvalue Decorator\n    testParamvalueAndReturnvalue(a) {\n        return `xxxx${a}`;\n    }\n    // #endregion Check Parameter. & Returnvalue Decorator\n    // #region Check Returnvalue Decorator\n    testReturnvalue(a) {\n        return a;\n    }\n    // #endregion Check Returnvalue Decorator\n    // #region Check EQ-DBC & Path to property of Parameter-value\n    testEQAndPath(o) { }\n    // #endregion Check EQ-DBC & Path to property of Parameter-value\n    // #region Check EQ-DBC & Path to property of Parameter-value with Inversion\n    testEQAndPathWithInversion(o) { }\n    // #endregion Check EQ-DBC & Path to property of Parameter-value with Inversion\n    // #region Check TYPE\n    testTYPE(o) { }\n    // #endregion Check TYPE\n    // #region Check AE\n    testAE(x) { }\n    // #endregion Check AE\n    // #region Check REGEX with AE\n    testREGEXWithAE(x) { }\n    // #endregion Check REGEX with AE\n    // #region Check INSTANCE\n    testINSTANCE(candidate) { }\n    // #endregion Check INSTANCE\n    // #region Check AE Range\n    testAERange(x) { }\n    // #endregion Check AE Range\n    // #region Check AE Index\n    testAEIndex(x) { }\n}\n__decorate([\n    REGEX.INVARIANT(/^a$/),\n    __metadata(\"design:type\", Object)\n], Demo.prototype, \"testProperty\", void 0);\n__decorate([\n    REGEX.POST(/^xxxx.*$/),\n    DBC.ParamvalueProvider,\n    __param(0, REGEX.PRE(/holla*/g)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [String]),\n    __metadata(\"design:returntype\", String)\n], Demo.prototype, \"testParamvalueAndReturnvalue\", null);\n__decorate([\n    REGEX.POST(/^xxxx.*$/),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [String]),\n    __metadata(\"design:returntype\", String)\n], Demo.prototype, \"testReturnvalue\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, EQ.PRE(\"SELECT\", false, \"tagName\")),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [HTMLElement]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testEQAndPath\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, EQ.PRE(\"SELECT\", true, \"tagName\")),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [HTMLElement]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testEQAndPathWithInversion\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, TYPE.PRE(\"string\")),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Object]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testTYPE\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, AE.PRE([new TYPE(\"string\")])),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Array]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testAE\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, AE.PRE(new REGEX(/^(?i:(NOW)|([+-]\\d+[dmy]))$/i))),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Array]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testREGEXWithAE\", null);\n__decorate([\n    DBC.ParamvalueProvider\n    // biome-ignore lint/suspicious/noExplicitAny: Test\n    ,\n    __param(0, INSTANCE.PRE(Date)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Object]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testINSTANCE\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, AE.PRE([new TYPE(\"string\"), new REGEX(/^abc$/)], 1, 2)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Array]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testAERange\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, AE.PRE([new TYPE(\"string\"), new REGEX(/^abc$/)], 1)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Array]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testAEIndex\", null);\nconst demo = new Demo();\ntry {\n    demo.testProperty = \"abd\";\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INVARIANT Infringement\", \"OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testProperty = \"a\";\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"INVARIANT OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ndemo.testParamvalueAndReturnvalue(\"holla\");\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"PARAMETER- & RETURNVALUE OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testParamvalueAndReturnvalue(\"yyyy\");\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"PARAMETER- & RETURNVALUE Infringement\", \"OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testReturnvalue(\"xxxx\");\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"RETURNVALUE OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testReturnvalue(\"yyyy\");\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"RETURNVALUE Infringement\", \"OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testEQAndPath(document.createElement(\"select\"));\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"EQ with Path Infringement OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testEQAndPathWithInversion(document.createElement(\"select\"));\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"EQ with Path and Inversion Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testTYPE(\"x\");\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"TYPE OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testTYPE(0);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"TYPE Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testAE([\"11\", \"10\", \"b\"]);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"AE OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testAE([\"11\", 11, \"b\"]);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"AE Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testREGEXWithAE([\"+1d\", \"NOW\", \"-10y\"]);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"REGEX with AE OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testREGEXWithAE([\"+1d\", \"+5d\", \"-x10y\"]);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"REGEX with AE Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testINSTANCE(new Date());\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"INSTANCE OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testINSTANCE(demo);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INSTANCE Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testAERange([11, \"abc\", \"abc\"]);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"AE Range OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testAERange([11, \"abc\", /a/g]);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"AE Range Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testAEIndex([11, \"abc\", \"abc\"]);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"AE Index OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testAEIndex([\"11\", 12, \"/a/g\"]);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"AE Index Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\n"],"names":[],"sourceRoot":""}