xdbc 1.0.211 → 1.0.213

package/dist/bundle.js

@@ -0,0 +1,2297 @@
+/******/ (() => { // 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 {
+    /** Evicts the oldest entry if the cache exceeds the maximum size. */
+    static evictIfNeeded(cache) {
+        if (cache.size > DBC.MAX_CACHE_SIZE) {
+            const oldest = cache.keys().next().value;
+            if (oldest !== undefined)
+                cache.delete(oldest);
+        }
+    }
+    static getHost() {
+        return typeof window !== "undefined" ? window : globalThis;
+    }
+    static getDBC(dbc) {
+        if (dbc instanceof DBC)
+            return dbc;
+        const path = dbc !== null && dbc !== void 0 ? dbc : "WaXCode.DBC";
+        if (DBC.dbcCache.has(path)) {
+            return DBC.dbcCache.get(path);
+        }
+        const resolved = DBC.resolveDBCPath(DBC.getHost(), path);
+        if (resolved) {
+            DBC.evictIfNeeded(DBC.dbcCache);
+            DBC.dbcCache.set(path, resolved);
+            return resolved;
+        }
+        throw new Error(`[XDBC] DBC instance not found at path "${path}". Ensure a DBC instance is registered there.`);
+    }
+    /**
+     * Generate a unique key for storing parameter value requests.
+     * Format: "ClassName:methodName"
+     */
+    static getRequestKey(target, methodName) {
+        var _a;
+        const className = typeof target === "function"
+            ? target.name
+            : ((_a = target.constructor) === null || _a === void 0 ? void 0 : _a.name) || "Unknown";
+        return `${className}:${String(methodName)}`;
+    }
+    /**
+     * 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) {
+        var _a;
+        const key = DBC.getRequestKey(target, methodName);
+        if (DBC.paramValueRequests.has(key)) {
+            const paramMap = DBC.paramValueRequests.get(key);
+            if (paramMap.has(index)) {
+                (_a = paramMap.get(index)) === null || _a === void 0 ? void 0 : _a.push(receptor);
+            }
+            else {
+                paramMap.set(index, new Array(receptor));
+            }
+        }
+        else {
+            DBC.paramValueRequests.set(key, new Map([
+                [index, new Array(receptor)],
+            ]));
+        }
+        return undefined;
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: Must handle both method and class decorator signatures
+    static ParamvalueProvider(...args) {
+        if (args.length === 1 && typeof args[0] === "function") {
+            // #region Class decorator path
+            // biome-ignore lint/suspicious/noExplicitAny: Must accept any constructor signature
+            const constructor = args[0];
+            const key = `${constructor.name}:undefined`;
+            // biome-ignore lint/suspicious/noExplicitAny: Must accept any constructor signature
+            const WrappedClass = class extends constructor {
+                // biome-ignore lint/suspicious/noExplicitAny: Must accept any constructor signature
+                constructor(...ctorArgs) {
+                    if (DBC.paramValueRequests.has(key)) {
+                        const paramMap = DBC.paramValueRequests.get(key);
+                        for (const index of paramMap.keys()) {
+                            if (index < ctorArgs.length) {
+                                for (const receptor of paramMap.get(index)) {
+                                    receptor(ctorArgs[index]);
+                                }
+                            }
+                        }
+                    }
+                    super(...ctorArgs);
+                }
+            };
+            Object.defineProperty(WrappedClass, "name", { value: constructor.name });
+            return WrappedClass;
+            // #endregion Class decorator path
+        }
+        // #region Method decorator path
+        const [target, propertyKey, descriptor] = args;
+        const originalMethod = descriptor.value;
+        const isStatic = typeof target === "function";
+        // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+        descriptor.value = function (...methodArgs) {
+            // #region   Check if a value of one of the method's parameter has been requested and pass it to the
+            //           receptor, if so.
+            const actualTarget = isStatic ? this : this.constructor;
+            const key = DBC.getRequestKey(actualTarget, propertyKey);
+            if (DBC.paramValueRequests.has(key)) {
+                const paramMap = DBC.paramValueRequests.get(key);
+                for (const index of paramMap.keys()) {
+                    if (index < methodArgs.length) {
+                        for (const receptor of paramMap.get(index)) {
+                            receptor(methodArgs[index]);
+                        }
+                    }
+                }
+            }
+            else {
+                console.warn("No parameter value requests found for key:", key);
+            }
+            // #endregion	Check if a value of one of the method's parameter has been requested and pass it to the
+            //              receptor, if so.
+            return originalMethod.apply(this, methodArgs);
+        };
+        return descriptor;
+        // #endregion Method decorator path
+    }
+    // #endregion Parameter-value requests.
+    // #region Class
+    /**
+     * A property-decorator factory serving as a **D**esign **B**y **C**ontract Invariant.
+     * This invariant aims to check the instance of the class not the value to be get or set.
+     *
+     * @param contracts The {@link DBC }-Contracts the value shall uphold.
+     *
+     * @throws 	A {@link DBC.Infringement } whenever the property is tried to be get or set without the instance of it's class
+     * 			fulfilling the specified **contracts**. */
+    static decClassInvariant(contracts, path = undefined, dbc = "WaXCode.DBC") {
+        let dbcInstance;
+        return (target, propertyKey, descriptor) => {
+            if (!dbcInstance)
+                dbcInstance = DBC.getDBC(dbc);
+            if (!dbcInstance.executionSettings.checkInvariants) {
+                return;
+            }
+            const originalSetter = descriptor.set;
+            const originalGetter = descriptor.get;
+            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+            let value;
+            // #region Replace original property.
+            Object.defineProperty(target, propertyKey, {
+                get() {
+                    if (!(dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.executionSettings.checkInvariants)) {
+                        return;
+                    }
+                    const realValue = path ? DBC.resolve(this, path) : this;
+                    // #region Check if all "contracts" are fulfilled.
+                    for (const contract of contracts) {
+                        const result = contract.check(realValue);
+                        if (typeof result === "string") {
+                            dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.reportFieldInfringement(result, target, path, propertyKey, realValue);
+                        }
+                    }
+                    // #endregion Check if all "contracts" are fulfilled.
+                    return originalGetter ? originalGetter[propertyKey] : value;
+                },
+                set(newValue) {
+                    if (!(dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.executionSettings.checkInvariants)) {
+                        return;
+                    }
+                    const realValue = path ? DBC.resolve(this, path) : this;
+                    // #region Check if all "contracts" are fulfilled.
+                    for (const contract of contracts) {
+                        const result = contract.check(realValue);
+                        if (typeof result === "string") {
+                            dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.reportFieldInfringement(result, target, path, propertyKey, realValue);
+                        }
+                    }
+                    // #endregion Check if all "contracts" are fulfilled.
+                    value = newValue;
+                },
+                enumerable: true,
+                configurable: true,
+            });
+            // #endregion Replace original property.
+        };
+    }
+    // #endregion Class
+    // #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 = undefined, hint = undefined) {
+        let dbcInstance;
+        return (target, propertyKey) => {
+            if (!dbcInstance)
+                dbcInstance = DBC.getDBC(dbc);
+            if (!dbcInstance.executionSettings.checkInvariants) {
+                return;
+            }
+            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+            let value;
+            // #region Replace original property.
+            Object.defineProperty(target, propertyKey, {
+                set(newValue) {
+                    if (!(dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.executionSettings.checkInvariants)) {
+                        return;
+                    }
+                    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") {
+                            dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.reportFieldInfringement(result, target, path, propertyKey, realValue, hint);
+                        }
+                    }
+                    // #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.
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+    static decPostcondition(
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+    check, dbc = undefined, path = undefined, hint = undefined) {
+        let dbcInstance;
+        return (target, propertyKey, descriptor) => {
+            const originalMethod = descriptor.value;
+            // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.
+            descriptor.value = (...args) => {
+                if (!dbcInstance)
+                    dbcInstance = DBC.getDBC(dbc);
+                if (!dbcInstance.executionSettings.checkPostconditions) {
+                    return;
+                }
+                // 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") {
+                    dbcInstance.reportReturnvalueInfringement(checkResult, target, path, propertyKey, realValue, hint);
+                }
+                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.
+     * 				May contain :: to separate multiple paths.
+     *
+     * @returns The **(target: object, methodName: string | symbol, parameterIndex: number ) => void** invoked by Typescript- */
+    static decPrecondition(
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary to check any parameter value
+    check, dbc = undefined, path = undefined, hint = undefined) {
+        const paths = path ? path.replace(/ /g, "").split("::") : [undefined];
+        let dbcInstance;
+        return (target, methodName, parameterIndex) => {
+            DBC.requestParamValue(target, methodName, parameterIndex, (value) => {
+                if (!dbcInstance)
+                    dbcInstance = DBC.getDBC(dbc);
+                if (!dbcInstance.executionSettings.checkPreconditions) {
+                    return;
+                }
+                for (const singlePath of paths) {
+                    const realValue = singlePath
+                        ? DBC.resolve(value, singlePath)
+                        : value;
+                    const result = check(realValue, target, methodName, parameterIndex);
+                    if (typeof result === "string") {
+                        dbcInstance.reportParameterInfringement(result, target, singlePath, methodName, parameterIndex, realValue, hint);
+                    }
+                }
+            });
+        };
+    }
+    // #endregion Precondition
+    // #endregion Decorator
+    // #region Contract Factory Helpers
+    /**
+     * Creates a PRE decorator from a checkAlgorithm function and its bound arguments.
+     * Reduces boilerplate across contract classes.
+     *
+     * @param checkFn  A function that takes (value, ...boundArgs) and returns true or an error string.
+     * @param boundArgs The arguments to bind to the check function after the value.
+     * @param dbc      See {@link DBC.decPrecondition}.
+     * @param path     See {@link DBC.decPrecondition}.
+     * @param hint     See {@link DBC.decPrecondition}.
+     */
+    static createPRE(
+    // biome-ignore lint/suspicious/noExplicitAny: Must accept any checkAlgorithm signature
+    checkFn, 
+    // biome-ignore lint/suspicious/noExplicitAny: Arguments vary per contract
+    boundArgs, dbc, path, hint) {
+        return DBC.decPrecondition((value, _target, _methodName, _parameterIndex) => {
+            return checkFn(value, ...boundArgs);
+        }, dbc, path, hint);
+    }
+    /**
+     * Creates a POST decorator from a checkAlgorithm function and its bound arguments.
+     *
+     * @param checkFn  A function that takes (value, ...boundArgs) and returns true or an error string.
+     * @param boundArgs The arguments to bind to the check function after the value.
+     * @param dbc      See {@link DBC.decPostcondition}.
+     * @param path     See {@link DBC.decPostcondition}.
+     * @param hint     See {@link DBC.decPostcondition}.
+     */
+    static createPOST(
+    // biome-ignore lint/suspicious/noExplicitAny: Must accept any checkAlgorithm signature
+    checkFn, 
+    // biome-ignore lint/suspicious/noExplicitAny: Arguments vary per contract
+    boundArgs, dbc, path, hint) {
+        return DBC.decPostcondition((value, _target, _propertyKey) => {
+            return checkFn(value, ...boundArgs);
+        }, dbc, path, hint);
+    }
+    /**
+     * Creates an INVARIANT decorator from a contract constructor and its bound arguments.
+     *
+     * @param ContractClass A class with a constructor that produces an object with a `check` method.
+     * @param ctorArgs      The arguments to pass to the contract constructor.
+     * @param dbc           See {@link DBC.decInvariant}.
+     * @param path          See {@link DBC.decInvariant}.
+     * @param hint          See {@link DBC.decInvariant}.
+     */
+    static createINVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: Must accept any contract constructor
+    ContractClass, 
+    // biome-ignore lint/suspicious/noExplicitAny: Arguments vary per contract
+    ctorArgs, dbc, path, hint) {
+        return DBC.decInvariant([new ContractClass(...ctorArgs)], path, dbc, hint);
+    }
+    /**
+     * Reports a warning.
+     *
+     * @param message The message containing the warning. */
+    reportWarning(message) {
+        if (this.warningSettings.logToConsole) {
+            console.warn(message);
+        }
+    }
+    /** Sanitizes a value for safe inclusion in error messages. */
+    static sanitize(value) {
+        const str = typeof value === "string" ? value : String(value);
+        return str.replace(/[<>&"']/g, (ch) => {
+            switch (ch) {
+                case "<":
+                    return "&lt;";
+                case ">":
+                    return "&gt;";
+                case "&":
+                    return "&amp;";
+                case '"':
+                    return "&quot;";
+                case "'":
+                    return "&#39;";
+                default:
+                    return ch;
+            }
+        });
+    }
+    /**
+     * 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, value, path, hint = undefined) {
+        const safeViolator = DBC.sanitize(violator);
+        const targetName = typeof target === "function"
+            ? DBC.sanitize(target.name)
+            : typeof target === "object" &&
+                target !== null &&
+                typeof target.constructor === "function"
+                ? DBC.sanitize(target.constructor.name)
+                : DBC.sanitize(target);
+        const finalMessage = `[ From "${safeViolator}" in "${targetName}"${path ? ` > "${DBC.sanitize(path)}"` : ""}: ${message} ${hint ? `✨ ${hint} ✨` : ""}]`;
+        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, hint = undefined) {
+        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, value, path, hint);
+    }
+    /**
+     * 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, hint = undefined) {
+        this.reportInfringement(`[ New value for "${key}"${path === undefined ? "" : `.${path}`} with value "${value}" did not fulfill one of it's contracts: ${message} ]`, key, target, value, 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, hint = undefined) {
+        this.reportInfringement(`[ Return-value "${value}" did not fulfill one of it's contracts: ${message} ]`, method, target, value, path, hint);
+    }
+    /**
+     * Constructs this {@link DBC } without mounting it on the global namespace.
+     * Use {@link DBC.register } to make the instance available at a specific path on globalThis.
+     *
+     * @param infringementSettings 	See {@link DBC.infringementSettings }.
+     * @param executionSettings		See {@link DBC.executionSettings }. */
+    constructor(infringementSettings = { throwException: true, logToConsole: false }, executionSettings = {
+        checkPreconditions: true,
+        checkPostconditions: true,
+        checkInvariants: true,
+    }) {
+        // #endregion Contract Factory Helpers
+        // #region Execution Handling
+        /** Stores settings concerning the execution of checks. */
+        this.executionSettings = {
+            checkPreconditions: true,
+            checkPostconditions: true,
+            checkInvariants: true,
+        };
+        // #endregion Execution Handling
+        // #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;
+        this.executionSettings = executionSettings;
+    }
+    /**
+     * Registers a {@link DBC } instance at the specified dotted path on globalThis (or window),
+     * making it available for decorator resolution via string paths.
+     *
+     * @param instance	The {@link DBC } instance to register.
+     * @param path		The dotted path to register at (default: `"WaXCode.DBC"`). */
+    static register(instance, path = "WaXCode.DBC") {
+        const segments = path.split(".");
+        // biome-ignore lint/suspicious/noExplicitAny: Must walk dynamic global namespace.
+        let obj = DBC.getHost();
+        for (let i = 0; i < segments.length - 1; i++) {
+            if (obj[segments[i]] === undefined)
+                obj[segments[i]] = {};
+            obj = obj[segments[i]];
+        }
+        obj[segments[segments.length - 1]] = instance;
+        DBC.dbcCache.set(path, instance);
+    }
+    /**
+     * Executes a callback with an isolated {@link DBC } instance temporarily registered at the default path.
+     * The previous instance (if any) is restored after the callback completes — even if it throws.
+     * Useful for test isolation.
+     *
+     * @param fn The callback receiving the isolated {@link DBC } instance. */
+    static isolated(fn) {
+        const saved = DBC.dbcCache.get("WaXCode.DBC");
+        const testDbc = new DBC();
+        DBC.register(testDbc);
+        try {
+            fn(testDbc);
+        }
+        finally {
+            if (saved) {
+                DBC.register(saved);
+            }
+            else {
+                DBC.dbcCache.delete("WaXCode.DBC");
+            }
+        }
+    }
+    /**
+     * Resolves the desired {@link object } out a given one **toResolveFrom** using the specified **path**.
+     *
+     * @param toResolveFrom The {@link object } starting to resolve from.
+     * @param path			The dotted path-{@link string }.
+     * 						This string uses ., [...], and () to represent accessing nested properties,
+     * 						array elements/object keys, and calling methods, respectively, mimicking JavaScript syntax to navigate
+     * 						an object's structure. Code, e.g. something like a.b( 1 as number ).c, will not be executed and
+     * 						thus make the retrieval fail.
+     *
+     * @returns The requested {@link object }, NULL or UNDEFINED. */
+    static resolve(toResolveFrom, path) {
+        if (!toResolveFrom || typeof path !== "string") {
+            return undefined;
+        }
+        // Security: block prototype pollution paths
+        const dangerousTokens = ["__proto__", "constructor", "prototype"];
+        const cachedParts = DBC.pathTokenCache.get(path);
+        const parts = cachedParts !== null && cachedParts !== void 0 ? cachedParts : path.replace(/\[(['"]?)(.*?)\1\]/g, ".$2").split(".");
+        if (!cachedParts) {
+            // Validate tokens before caching
+            for (const part of parts) {
+                const tokenName = part.replace(/\(.*\)$/, "");
+                if (dangerousTokens.indexOf(tokenName) >= 0) {
+                    throw new Error(`[XDBC] Path "${path}" contains forbidden token "${tokenName}".`);
+                }
+            }
+            DBC.evictIfNeeded(DBC.pathTokenCache);
+            DBC.pathTokenCache.set(path, parts);
+        }
+        // biome-ignore lint/suspicious/noExplicitAny: Must traverse arbitrary object graphs
+        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());
+                if (typeof current[methodName] === "function") {
+                    current = current[methodName].apply(current, args);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else {
+                if (typeof window !== "undefined" &&
+                    typeof HTMLElement !== "undefined" &&
+                    current instanceof HTMLElement &&
+                    part.startsWith("@")) {
+                    current = current.getAttribute(part.slice(1));
+                }
+                else if (typeof current === "object" &&
+                    current !== null &&
+                    part in current) {
+                    current = current[part];
+                }
+                else if (typeof window !== "undefined" &&
+                    typeof HTMLElement !== "undefined" &&
+                    current instanceof HTMLElement) {
+                    current = undefined;
+                }
+                else {
+                    current = undefined;
+                }
+            }
+        }
+        return current;
+    }
+}
+// #region Internal caches.
+DBC.MAX_CACHE_SIZE = 1000;
+DBC.dbcCache = new Map();
+DBC.pathTokenCache = new Map();
+// #endregion Internal caches.
+// #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 }.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: Must traverse arbitrary object graphs
+DBC.resolveDBCPath = (obj, path) => path === null || path === void 0 ? void 0 : path.split(".").reduce((accumulator, current) => accumulator[current], obj);
+// Register the default instance with standard settings.
+DBC.register(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 hint				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, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.decPrecondition((
+        // biome-ignore lint/suspicious/noExplicitAny: Must match DBC.decPrecondition signature
+        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, hint);
+    }
+    /**
+     * 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 hint				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, hint = undefined, dbc = undefined) {
+        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, hint);
+    }
+    /**
+     * 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 hint				See {@link DBC.decInvariant }.
+     * @param dbc				See {@link DBC.decInvariant }.
+     *
+     * @returns	See {@link DBC.decInvariant }. */
+    static INVARIANT(realConditions, index = undefined, idxEnd = undefined, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createINVARIANT(AE, [realConditions, index, idxEnd], dbc, path, hint);
+    }
+    // #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}. */
+    // biome-ignore lint/suspicious/noExplicitAny: Must match DBC factory signature
+    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/COMPARISON.ts"
+/*!*******************************!*\
+  !*** ./src/DBC/COMPARISON.ts ***!
+  \*******************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   COMPARISON: () => (/* binding */ COMPARISON)
+/* harmony export */ });
+/* harmony import */ var _DBC__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DBC */ "./src/DBC.ts");
+
+/**
+ * A {@link DBC } defining a comparison between two {@link object }s.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+class COMPARISON extends _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC {
+    // #region Condition checking.
+    /**
+     * Does a comparison between the {@link object } **toCheck** and the **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. */
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic comparison
+    static checkAlgorithm(toCheck, equivalent, equalityPermitted, invert) {
+        if (equalityPermitted && !invert && toCheck < equivalent) {
+            return `Value has to be greater than or equal to "${equivalent}"`;
+        }
+        if (equalityPermitted && invert && toCheck > equivalent) {
+            return `Value has to be less than or equal to "${equivalent}"`;
+        }
+        if (!equalityPermitted && !invert && toCheck <= equivalent) {
+            return `Value has to be greater than "${equivalent}"`;
+        }
+        if (!equalityPermitted && invert && toCheck >= equivalent) {
+            return `Value has to be less than "${equivalent}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	    See {@link COMPARISON.checkAlgorithm }.
+     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.
+     * @param path			    See {@link DBC.decPrecondition }.
+     * @param hint				See {@link DBC.decPrecondition }.
+     * @param dbc			    See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPRE(COMPARISON.checkAlgorithm, [equivalent, equalityPermitted, invert], dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	    See {@link COMPARISON.checkAlgorithm }.
+     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.
+     * @param path			    See {@link DBC.Postcondition }.
+     * @param hint				See {@link DBC.decPostcondition }.
+     * @param dbc			    See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPOST(COMPARISON.checkAlgorithm, [equivalent, equalityPermitted, invert], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	    See {@link COMPARISON.checkAlgorithm }.
+     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.
+     * @param path			    See {@link DBC.decInvariant }.
+     * @param hint				See {@link DBC.decInvariant }.
+     * @param dbc			    See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createINVARIANT(COMPARISON, [equivalent, equalityPermitted, invert], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    // #region Dynamic usage.
+    /**
+     * Invokes the {@link COMPARISON.checkAlgorithm } passing the value **toCheck**, {@link COMPARISON.equivalent } and {@link COMPARISON.invert }.
+     *
+     * @param toCheck See {@link COMPARISON.checkAlgorithm }.
+     *
+     * @returns See {@link COMPARISON.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic comparison
+    check(toCheck) {
+        return COMPARISON.checkAlgorithm(toCheck, this.equivalent, this.equalityPermitted, this.invert);
+    }
+    /**
+     * Creates this {@link COMPARISON } by setting the protected property {@link COMPARISON.equivalent }, {@link COMPARISON.equalityPermitted } and {@link COMPARISON.invert } used by {@link COMPARISON.check }.
+     *
+     * @param equivalent        See {@link COMPARISON.check }.
+     * @param equalityPermitted See {@link COMPARISON.check }.
+     * @param invert            See {@link COMPARISON.check }. */
+    constructor(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false) {
+        super();
+        this.equivalent = equivalent;
+        this.equalityPermitted = equalityPermitted;
+        this.invert = invert;
+    }
+}
+
+
+/***/ },
+
+/***/ "./src/DBC/COMPARISON/GREATER.ts"
+/*!***************************************!*\
+  !*** ./src/DBC/COMPARISON/GREATER.ts ***!
+  \***************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   GREATER: () => (/* binding */ GREATER)
+/* harmony export */ });
+/* harmony import */ var _COMPARISON__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../COMPARISON */ "./src/DBC/COMPARISON.ts");
+
+/** See {@link COMPARISON }. */
+class GREATER extends _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON {
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.PRE(equivalent, false, false, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.POST }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.POST(equivalent, false, false, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.INVARIANT(equivalent, false, false, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.constructor }. */
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    constructor(equivalent) {
+        super(equivalent, false, false);
+        this.equivalent = equivalent;
+    }
+}
+
+
+/***/ },
+
+/***/ "./src/DBC/COMPARISON/GREATER_OR_EQUAL.ts"
+/*!************************************************!*\
+  !*** ./src/DBC/COMPARISON/GREATER_OR_EQUAL.ts ***!
+  \************************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   GREATER_OR_EQUAL: () => (/* binding */ GREATER_OR_EQUAL)
+/* harmony export */ });
+/* harmony import */ var _COMPARISON__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../COMPARISON */ "./src/DBC/COMPARISON.ts");
+
+/** See {@link COMPARISON }. */
+class GREATER_OR_EQUAL extends _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON {
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.PRE(equivalent, true, false, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.POST }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.POST(equivalent, true, false, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.INVARIANT(equivalent, true, false, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.constructor }. */
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    constructor(equivalent) {
+        super(equivalent, true, false);
+        this.equivalent = equivalent;
+    }
+}
+
+
+/***/ },
+
+/***/ "./src/DBC/COMPARISON/LESS.ts"
+/*!************************************!*\
+  !*** ./src/DBC/COMPARISON/LESS.ts ***!
+  \************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   LESS: () => (/* binding */ LESS)
+/* harmony export */ });
+/* harmony import */ var _COMPARISON__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../COMPARISON */ "./src/DBC/COMPARISON.ts");
+
+/** See {@link COMPARISON }. */
+class LESS extends _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON {
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.PRE(equivalent, false, true, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.POST }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.POST(equivalent, false, true, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.INVARIANT(equivalent, false, true, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.constructor }. */
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    constructor(equivalent) {
+        super(equivalent, false, true);
+        this.equivalent = equivalent;
+    }
+}
+
+
+/***/ },
+
+/***/ "./src/DBC/COMPARISON/LESS_OR_EQUAL.ts"
+/*!*********************************************!*\
+  !*** ./src/DBC/COMPARISON/LESS_OR_EQUAL.ts ***!
+  \*********************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   LESS_OR_EQUAL: () => (/* binding */ LESS_OR_EQUAL)
+/* harmony export */ });
+/* harmony import */ var _COMPARISON__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../COMPARISON */ "./src/DBC/COMPARISON.ts");
+
+/** See {@link COMPARISON }. */
+class LESS_OR_EQUAL extends _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON {
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.PRE(equivalent, true, true, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.POST }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.POST(equivalent, true, true, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _COMPARISON__WEBPACK_IMPORTED_MODULE_0__.COMPARISON.INVARIANT(equivalent, true, true, path, hint, dbc);
+    }
+    /** See {@link COMPARISON.constructor }. */
+    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value
+    constructor(equivalent) {
+        super(equivalent, true, true);
+        this.equivalent = equivalent;
+    }
+}
+
+
+/***/ },
+
+/***/ "./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 be equal to "${equivalent}"`;
+        }
+        if (invert && equivalent === toCheck) {
+            return `Value must not be equal to "${equivalent}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(
+    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+    equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPRE(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(
+    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+    equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPOST(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(
+    // biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+    equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createINVARIANT(EQ, [equivalent, invert], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck**, {@link EQ.equivalent } and {@link EQ.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary to check against NULL & UNDEFINED.
+    check(toCheck) {
+        return EQ.checkAlgorithm(toCheck, this.equivalent, this.invert);
+    }
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck** and the specified **type** .
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link EQ }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link EQ }.*/
+    static tsCheck(toCheck, equivalent, hint = undefined, id = undefined) {
+        const result = EQ.checkAlgorithm(toCheck, equivalent, false);
+        if (result) {
+            return toCheck;
+        }
+        throw new _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.Infringement(`${id ? `(${id}) ` : ""}${result} ${hint ? `✨ ${hint} ✨` : ""}`);
+    }
+    /**
+     * 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/EQ/DIFFERENT.ts"
+/*!*********************************!*\
+  !*** ./src/DBC/EQ/DIFFERENT.ts ***!
+  \*********************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DIFFERENT: () => (/* binding */ DIFFERENT)
+/* harmony export */ });
+/* harmony import */ var _EQ__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../EQ */ "./src/DBC/EQ.ts");
+
+/**
+ * DIFFERENT class for inequality comparisons.
+ *
+ * This class extends EQ and provides methods to check if a value is different (not equal)
+ * from a specified equivalent value. It inverts the equality check by always passing
+ * `true` for the invert parameter to the parent EQ class methods.
+ *
+ * @remarks
+ * The class provides precondition (PRE), postcondition (POST), and invariant (INVARIANT)
+ * checks for Design by Contract programming patterns.
+ *
+ * @see {@link COMPARISON}
+ * @see {@link EQ}
+ */
+class DIFFERENT extends _EQ__WEBPACK_IMPORTED_MODULE_0__.EQ {
+    /** See {@link EQ.PRE }. Always inverts equality check. */
+    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature
+    static PRE(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _EQ__WEBPACK_IMPORTED_MODULE_0__.EQ.PRE(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.POST }. Always inverts equality check. */
+    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature
+    static POST(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _EQ__WEBPACK_IMPORTED_MODULE_0__.EQ.POST(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.INVARIANT }. Always inverts equality check. */
+    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature
+    static INVARIANT(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return _EQ__WEBPACK_IMPORTED_MODULE_0__.EQ.INVARIANT(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.constructor }. */
+    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature
+    constructor(equivalent) {
+        super(equivalent, true);
+        this.equivalent = equivalent;
+    }
+}
+
+
+/***/ },
+
+/***/ "./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 an instance of the specified **reference**.
+     *
+     * @param toCheck	The value that has to be an instance of the **reference** in order for this {@link DBC }
+     * 					to be fulfilled.
+     * @param reference	The {@link object } the one **toCheck** has to be an instance of.
+     *
+     * @returns TRUE if the value **toCheck** is is an instance of the *reference**, **undefined** or **null**, otherwise FALSE. */
+    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+    static checkAlgorithm(toCheck, ...references) {
+        if (toCheck === null || toCheck === undefined) {
+            return true;
+        }
+        for (const ref of references) {
+            if (toCheck instanceof ref) {
+                return true;
+            }
+        }
+        return `Value has to be an instance of "${references.map((ref) => ref.name || ref).join(", ")}" but is of type "${typeof toCheck}"`;
+    }
+    /**
+     * 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, hint = undefined, dbc = undefined) {
+        const refs = Array.isArray(reference) ? reference : [reference];
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPRE(INSTANCE.checkAlgorithm, refs, dbc, path, hint);
+    }
+    /**
+     * 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, hint = undefined, dbc = undefined) {
+        const refs = Array.isArray(reference) ? reference : [reference];
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPOST(INSTANCE.checkAlgorithm, refs, dbc, path, hint);
+    }
+    /**
+     * 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, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createINVARIANT(INSTANCE, [reference], dbc, path, hint);
+    }
+    // #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 Array.isArray(this.reference)
+            ? INSTANCE.checkAlgorithm(toCheck, ...this.reference)
+            : INSTANCE.checkAlgorithm(toCheck, this.reference);
+    }
+    /**
+     * Type-safe check that validates if a value is an instance of a specified reference.
+     *
+     * @param toCheck 	The value to check for instance validity.
+     * @param reference	The {@link object } the one **toCheck** has to be an instance of.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** if it fulfills this {@link INSTANCE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link INSTANCE }. */
+    static tsCheck(toCheck, reference, hint = undefined, id = undefined) {
+        return INSTANCE.tsCheckMulti(toCheck, [reference], hint, id);
+    }
+    /**
+     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .
+     *
+     * @param toCheck 	See {@link INSTANCE.checkAlgorithm }.
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link INSTANCE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }. */
+    static tsCheckMulti(toCheck, references, hint = undefined, id = undefined) {
+        const result = INSTANCE.checkAlgorithm(toCheck, ...references);
+        if (result === true) {
+            return toCheck;
+        }
+        throw new _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.Infringement(`${id ? `(${id}) ` : ""}${result} ${hint ? `✨ ${hint} ✨` : ""}`);
+    }
+    /**
+     * 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 {
+    static get stdExp() {
+        if (!REGEX._stdExp) {
+            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: /^(?:https?|ftp):\/\/[^\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*\]))*$/,
+                boolean: /^(TRUE|FALSE)$/i,
+                colorCodeHEX: /^#([A-Fa-f\d]{3,4}|[A-Fa-f\d]{6}|[A-Fa-f\d]{8})$/i,
+                simpleHotkey: /^((Alt|Ctrl|Shift|Meta)\+)+[a-z\d]$/i,
+                bcp47: /^(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4}|[a-z]{5,8})(?:-[a-z]{4})?(?:-[a-z]{2}|-[0-9]{3})?(?:-[a-z0-9]{5,8}|-[0-9][a-z0-9]{3})*(?:-[0-9a-wy-z](?:-[a-z0-9]{2,8})+)*(?:-x(?:-[a-z0-9]{1,8})+)?$|^x(?:-[a-z0-9]{1,8})+$/i,
+            };
+        }
+        return REGEX._stdExp;
+    }
+    // #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 (toCheck === undefined || toCheck === null || toCheck === "")
+            return true;
+        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, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPRE(REGEX.checkAlgorithm, [expression], dbc, path, hint);
+    }
+    /**
+     * 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 }.
+     * @param hint			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(expression, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPOST(REGEX.checkAlgorithm, [expression], dbc, path, hint);
+    }
+    /**
+     * 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 }.
+     * @param hint			See {@link DBC.decInvariant }.
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(expression, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createINVARIANT(REGEX, [expression], dbc, path, hint);
+    }
+    // #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);
+    }
+    /**
+     * Type-safe check that validates a value against a regular expression and returns it as the specified type.
+     *
+     * @param toCheck		The value to check against the regular expression.
+     * @param expression	The regular expression to validate against.
+     * @param hint			Optional hint message to include in the error if validation fails.
+     * @param id			Optional identifier to include in the error message.
+     *
+     * @returns The validated value cast to the CANDIDATE type.
+     *
+     * @throws {@link DBC.Infringement} if the value does not match the regular expression. */
+    static tsCheck(toCheck, expression, hint = undefined, id = undefined) {
+        const result = REGEX.checkAlgorithm(toCheck, expression);
+        if (result) {
+            return toCheck;
+        }
+        throw new _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.Infringement(`${id ? `(${id}) ` : ""}${result}${hint ? ` ✨ ${hint} ✨` : ""}`);
+    }
+    /**
+     * 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);
+        }
+    }
+}
+
+
+/***/ },
+
+/***/ "./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. Can be a single type or multiple types separated by "|".
+     *
+     * @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) {
+        if (toCheck === undefined || toCheck === null)
+            return true;
+        const types = type.split("|").map((t) => t.trim());
+        const actualType = typeof toCheck;
+        // #region Check if the actual type matches at least one of the specified types
+        // biome-ignore lint/suspicious/useValidTypeof: Necessary
+        const isValid = types.some((t) => actualType === t);
+        if (!isValid) {
+            if (types.length === 1) {
+                return `Value has to be of type "${type}" but is of type "${actualType}"`;
+            }
+            return `Value has to be of type "${types.join(" | ")}" but is of type "${actualType}"`;
+        }
+        // #endregion Check if the actual type matches at least one of the specified types
+        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	A ::-separated list of dotted paths to check. Each path points to a property within the parameter value.
+     * 				Undefined properties are skipped. See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(type, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPRE(TYPE.checkAlgorithm, [type], dbc, path, hint);
+    }
+    /**
+     * 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	A ::-separated list of dotted paths to check. Each path points to a property within the parameter value.
+     * 				Undefined properties are skipped. See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(type, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createPOST(TYPE.checkAlgorithm, [type], dbc, path, hint);
+    }
+    /**
+     * 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	A ::-separated list of dotted paths to check. Each path points to a property within the parameter value.
+     * 				Undefined properties are skipped. See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(type, path = undefined, hint = undefined, dbc = undefined) {
+        return _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.createINVARIANT(TYPE, [type], dbc, path, hint);
+    }
+    // #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);
+    }
+    /**
+     * Invokes the {@link TYPE.checkAlgorithm } passing the value **toCheck** and the {@link TYPE.type } .
+     *
+     * @param toCheck	See {@link TYPE.checkAlgorithm }.
+     * @param type		See {@link TYPE.checkAlgorithm }.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link TYPE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link TYPE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }. */
+    static tsCheck(toCheck, type, hint = undefined, id = undefined) {
+        const result = TYPE.checkAlgorithm(toCheck, type);
+        if (result === true) {
+            return toCheck;
+        }
+        throw new _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.Infringement(`${id ? `(${id}) ` : ""}${result}${hint ? ` ✨ ${hint} ✨` : ""}`);
+    }
+    /**
+     * 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
+/******/ 		if (!(moduleId in __webpack_modules__)) {
+/******/ 			delete __webpack_module_cache__[moduleId];
+/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 			e.code = 'MODULE_NOT_FOUND';
+/******/ 			throw e;
+/******/ 		}
+/******/ 		__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_AE__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./DBC/AE */ "./src/DBC/AE.ts");
+/* harmony import */ var _DBC_COMPARISON_GREATER__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./DBC/COMPARISON/GREATER */ "./src/DBC/COMPARISON/GREATER.ts");
+/* harmony import */ var _DBC_COMPARISON_GREATER_OR_EQUAL__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./DBC/COMPARISON/GREATER_OR_EQUAL */ "./src/DBC/COMPARISON/GREATER_OR_EQUAL.ts");
+/* harmony import */ var _DBC_COMPARISON_LESS__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./DBC/COMPARISON/LESS */ "./src/DBC/COMPARISON/LESS.ts");
+/* harmony import */ var _DBC_COMPARISON_LESS_OR_EQUAL__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./DBC/COMPARISON/LESS_OR_EQUAL */ "./src/DBC/COMPARISON/LESS_OR_EQUAL.ts");
+/* harmony import */ var _DBC_EQ__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./DBC/EQ */ "./src/DBC/EQ.ts");
+/* harmony import */ var _DBC_EQ_DIFFERENT__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./DBC/EQ/DIFFERENT */ "./src/DBC/EQ/DIFFERENT.ts");
+/* harmony import */ var _DBC_INSTANCE__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./DBC/INSTANCE */ "./src/DBC/INSTANCE.ts");
+/* harmony import */ var _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./DBC/REGEX */ "./src/DBC/REGEX.ts");
+/* harmony import */ var _DBC_TYPE__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./DBC/TYPE */ "./src/DBC/TYPE.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 Static Method with ParamvalueProvider
+    }
+    // #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) { }
+    // #endregion Check AE Index
+    // #region Check Comparison
+    testGREATER(input) { }
+    testGREATER_OR_EQUAL(input) { }
+    testLESS(input) { }
+    testLESS_OR_EQUAL(input) { }
+    testDIFFERENT(input) { }
+    // #endregion Check Comparison
+    // #region Check Static Method with ParamvalueProvider
+    static testStaticMethod(message, count) {
+        return `${message} repeated ${count} times`;
+    }
+}
+__decorate([
+    _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__.REGEX.INVARIANT(/^a$/),
+    __metadata("design:type", Object)
+], Demo.prototype, "testProperty", void 0);
+__decorate([
+    _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__.REGEX.POST(/^xxxx.*$/),
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__.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_9__.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_6__.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_6__.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_10__.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_1__.AE.PRE([new _DBC_TYPE__WEBPACK_IMPORTED_MODULE_10__.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_1__.AE.PRE(new _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__.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_8__.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_1__.AE.PRE([new _DBC_TYPE__WEBPACK_IMPORTED_MODULE_10__.TYPE("string"), new _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__.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_1__.AE.PRE([new _DBC_TYPE__WEBPACK_IMPORTED_MODULE_10__.TYPE("string"), new _DBC_REGEX__WEBPACK_IMPORTED_MODULE_9__.REGEX(/^abc$/)], 1)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testAEIndex", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_COMPARISON_GREATER__WEBPACK_IMPORTED_MODULE_2__.GREATER.PRE(2)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testGREATER", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_COMPARISON_GREATER_OR_EQUAL__WEBPACK_IMPORTED_MODULE_3__.GREATER_OR_EQUAL.PRE(2)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testGREATER_OR_EQUAL", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_COMPARISON_LESS__WEBPACK_IMPORTED_MODULE_4__.LESS.PRE(20)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testLESS", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_COMPARISON_LESS_OR_EQUAL__WEBPACK_IMPORTED_MODULE_5__.LESS_OR_EQUAL.PRE(20)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testLESS_OR_EQUAL", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_EQ_DIFFERENT__WEBPACK_IMPORTED_MODULE_7__.DIFFERENT.PRE(20)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], Demo.prototype, "testDIFFERENT", null);
+__decorate([
+    _DBC__WEBPACK_IMPORTED_MODULE_0__.DBC.ParamvalueProvider,
+    __param(0, _DBC_TYPE__WEBPACK_IMPORTED_MODULE_10__.TYPE.PRE("string")),
+    __param(1, _DBC_TYPE__WEBPACK_IMPORTED_MODULE_10__.TYPE.PRE("number")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number]),
+    __metadata("design:returntype", String)
+], Demo, "testStaticMethod", 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("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testGREATER(11);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("GREATER OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testGREATER(2);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("GREATER Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testGREATER_OR_EQUAL(2);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("GREATER_OR_EQUAL OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testGREATER_OR_EQUAL(1);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("GREATER_OR_EQUAL Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testLESS(10);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("LESS OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testLESS(20);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("LESS Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testLESS_OR_EQUAL(20);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("LESS OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testLESS_OR_EQUAL(21);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("LESS_OR_EQUAL Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+demo.testDIFFERENT(21);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("DIFFERENT OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    demo.testDIFFERENT(20);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("DIFFERENT Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+// #region Inactivity Checks
+window.WaXCode.DBC.executionSettings.checkPreconditions = false;
+try {
+    demo.testLESS_OR_EQUAL(21);
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INACTIVE PRECONDITIONS OK");
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INACTIVE PRECONDITIONS FAILED");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+window.WaXCode.DBC.executionSettings.checkPostconditions = false;
+try {
+    demo.testReturnvalue("qqqqq");
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INACTIVE POSTCONDITIONS OK");
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INACTIVE POSTCONDITIONS FAILED");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+window.WaXCode.DBC.executionSettings.checkInvariants = false;
+try {
+    demo.testProperty = "b";
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INACTIVE INVARIANTS OK");
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("INACTIVE INVARIANTS FAILED");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+// #endregion Inactivity Checks
+// Re-enable all checks for subsequent tests
+window.WaXCode.DBC.executionSettings.checkPreconditions = true;
+window.WaXCode.DBC.executionSettings.checkPostconditions = true;
+window.WaXCode.DBC.executionSettings.checkInvariants = true;
+// #region Static Method Test
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("TESTING STATIC METHOD WITH PARAMVALUEPROVIDER");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+Demo.testStaticMethod("Hello", 3);
+console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+console.log("STATIC METHOD OK");
+console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+try {
+    Demo.testStaticMethod("Hello", "not a number");
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("STATIC METHOD Infringement OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+try {
+    Demo.testStaticMethod(123, 5);
+}
+catch (X) {
+    console.log("⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄");
+    console.log("STATIC METHOD Infringement (first param) OK");
+    console.log(X);
+    console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+}
+// #endregion Static Method Test
+
+})();
+
+/******/ })()
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"bundle.js","mappings":";;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,KAAK;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,UAAU,GAAG,mBAAmB;AAClD;AACA;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,2BAA2B,iBAAiB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,yBAAyB;AACnF;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,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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;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;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;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,0BAA0B;AACnD;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,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,0BAA0B;AACtD,4BAA4B,0BAA0B;AACtD,4BAA4B,0BAA0B;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,2BAA2B;AACvD,4BAA4B,2BAA2B;AACvD,4BAA4B,2BAA2B;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,uBAAuB;AACxD,iCAAiC,uBAAuB;AACxD,iCAAiC,uBAAuB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA,gCAAgC;AAChC;AACA,iCAAiC;AACjC;AACA,kCAAkC;AAClC;AACA,iCAAiC;AACjC;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,iDAAiD,6BAA6B,0BAA0B,cAAc;AACtH;AACA;AACA,2BAA2B,eAAe;AAC1C,6BAA6B,eAAe;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,aAAa,QAAQ,WAAW,GAAG,cAAc,mBAAmB,QAAQ,IAAI,SAAS,EAAE,YAAY,MAAM,QAAQ;AAC7J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,2BAA2B,0BAA0B,cAAc;AAChH;AACA;AACA,2BAA2B,eAAe;AAC1C,2BAA2B,eAAe;AAC1C;AACA;AACA;AACA;AACA,sDAAsD,MAAM,WAAW,YAAY,EAAE,uFAAuF,mDAAmD,SAAS;AACxO;AACA;AACA,yCAAyC,2BAA2B,0BAA0B,cAAc;AAC5G;AACA;AACA,yBAAyB,eAAe;AACxC;AACA,qCAAqC,eAAe;AACpD;AACA;AACA;AACA,oDAAoD,IAAI,GAAG,8BAA8B,KAAK,GAAG,cAAc,MAAM,2CAA2C,SAAS;AACzK;AACA;AACA,yDAAyD,2BAA2B,0BAA0B,cAAc;AAC5H;AACA;AACA,2BAA2B,eAAe;AAC1C,2BAA2B,eAAe;AAC1C;AACA;AACA;AACA;AACA,mDAAmD,MAAM,2CAA2C,SAAS;AAC7G;AACA;AACA,wBAAwB,YAAY;AACpC,YAAY,qBAAqB;AACjC;AACA,yCAAyC,gCAAgC;AACzE,sCAAsC,6BAA6B;AACnE,yCAAyC,2CAA2C;AACpF;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA,oBAAoB,YAAY;AAChC;AACA;AACA,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA,wBAAwB,yBAAyB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,YAAY;AACzD;AACA;AACA;AACA,sDAAsD,YAAY;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,eAAe;AAC5C;AACA,iCAAiC,eAAe;AAChD,sCAAsC,cAAc;AACpD;AACA;AACA;AACA;AACA;AACA,+BAA+B,cAAc;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,KAAK,8BAA8B,UAAU;AACjG;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,2DAA2D,uBAAuB;AAClF;AACA;AACA;AACA,QAAQ,cAAc;AACtB;AACA;AACA,wBAAwB,cAAc,kCAAkC,eAAe;AACvF;AACA,2BAA2B,eAAe;AAC1C;AACA,qCAAqC,QAAQ;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,cAAc,YAAY,WAAW;AACvE;AACA,oBAAoB,eAAe;AACnC,4BAA4B,cAAc,sBAAsB,WAAW;AAC3E;AACA,2BAA2B,WAAW;AACtC;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACznB6B;AAC7B;AACA,MAAM,YAAY,kCAAkC,cAAc;AAClE,YAAY,cAAc;AAC1B;AACA;AACA;AACO,iBAAiB,qCAAG;AAC3B;AACA;AACA,6CAA6C,qBAAqB;AAClE;AACA;AACA,8BAA8B,4CAA4C;AAC1E,uCAAuC,oBAAoB;AAC3D;AACA,yEAAyE,eAAe;AACxF,uBAAuB,aAAa,wCAAwC,cAAc;AAC1F;AACA;AACA,oCAAoC,aAAa;AACjD,0FAA0F,cAAc;AACxG,mEAAmE,aAAa;AAChF;AACA;AACA,wDAAwD,cAAc;AACtE,yCAAyC,aAAa;AACtD;AACA;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/C;AACA;AACA;AACA;AACA;AACA,oBAAoB,4BAA4B,uCAAuC,kBAAkB;AACzG;AACA,2BAA2B,2BAA2B;AACtD,yBAAyB,2BAA2B;AACpD,iCAAiC,eAAe;AAChD,qBAAqB,eAAe,kBAAkB,aAAa,SAAS,wBAAwB;AACpG;AACA,oEAAoE,YAAY;AAChF;AACA,kBAAkB,yBAAyB,wDAAwD,eAAe;AAClH;AACA;AACA;AACA;AACA;AACA,kBAAkB,qCAAG,iBAAiB,SAAS,GAAG,SAAS,EAAE,OAAO,EAAE,aAAa,MAAM,QAAQ;AACjG;AACA;AACA,qBAAqB,aAAa,mCAAmC,kBAAkB,SAAS,kBAAkB;AAClH;AACA,wBAAwB,kBAAkB;AAC1C;AACA;AACA;AACA;AACA;;;;;;;UCjHA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;UACA;;;;;WC5BA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA,E;;;;;WCPA,wF;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D,E;;;;;;;;;;;;;;;;;;;;;;;;;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;AACE;AACqB;AACkB;AACxB;AACkB;AACjC;AACiB;AACL;AACN;AACF;AAClC;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,SAAS,WAAW,OAAO;AAC7C;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,4CAAI;AACnB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE,UAAU,4CAAI;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,4CAAI,gBAAgB,6CAAK;AACpD;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,uCAAE,UAAU,4CAAI,gBAAgB,6CAAK;AACpD;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,4DAAO;AACtB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,8EAAgB;AAC/B;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,sDAAI;AACnB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,wEAAa;AAC5B;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,wDAAS;AACxB;AACA;AACA;AACA;AACA;AACA,IAAI,qCAAG;AACP,eAAe,4CAAI;AACnB,eAAe,4CAAI;AACnB;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;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;AACA;AACA;AACA","sources":["webpack://xdbc/./src/DBC.ts","webpack://xdbc/./src/DBC/AE.ts","webpack://xdbc/./src/DBC/COMPARISON.ts","webpack://xdbc/./src/DBC/COMPARISON/GREATER.ts","webpack://xdbc/./src/DBC/COMPARISON/GREATER_OR_EQUAL.ts","webpack://xdbc/./src/DBC/COMPARISON/LESS.ts","webpack://xdbc/./src/DBC/COMPARISON/LESS_OR_EQUAL.ts","webpack://xdbc/./src/DBC/EQ.ts","webpack://xdbc/./src/DBC/EQ/DIFFERENT.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    /** Evicts the oldest entry if the cache exceeds the maximum size. */\n    static evictIfNeeded(cache) {\n        if (cache.size > DBC.MAX_CACHE_SIZE) {\n            const oldest = cache.keys().next().value;\n            if (oldest !== undefined)\n                cache.delete(oldest);\n        }\n    }\n    static getHost() {\n        return typeof window !== \"undefined\" ? window : globalThis;\n    }\n    static getDBC(dbc) {\n        if (dbc instanceof DBC)\n            return dbc;\n        const path = dbc !== null && dbc !== void 0 ? dbc : \"WaXCode.DBC\";\n        if (DBC.dbcCache.has(path)) {\n            return DBC.dbcCache.get(path);\n        }\n        const resolved = DBC.resolveDBCPath(DBC.getHost(), path);\n        if (resolved) {\n            DBC.evictIfNeeded(DBC.dbcCache);\n            DBC.dbcCache.set(path, resolved);\n            return resolved;\n        }\n        throw new Error(`[XDBC] DBC instance not found at path \"${path}\". Ensure a DBC instance is registered there.`);\n    }\n    /**\n     * Generate a unique key for storing parameter value requests.\n     * Format: \"ClassName:methodName\"\n     */\n    static getRequestKey(target, methodName) {\n        var _a;\n        const className = typeof target === \"function\"\n            ? target.name\n            : ((_a = target.constructor) === null || _a === void 0 ? void 0 : _a.name) || \"Unknown\";\n        return `${className}:${String(methodName)}`;\n    }\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        var _a;\n        const key = DBC.getRequestKey(target, methodName);\n        if (DBC.paramValueRequests.has(key)) {\n            const paramMap = DBC.paramValueRequests.get(key);\n            if (paramMap.has(index)) {\n                (_a = paramMap.get(index)) === null || _a === void 0 ? void 0 : _a.push(receptor);\n            }\n            else {\n                paramMap.set(index, new Array(receptor));\n            }\n        }\n        else {\n            DBC.paramValueRequests.set(key, new Map([\n                [index, new Array(receptor)],\n            ]));\n        }\n        return undefined;\n    }\n    // biome-ignore lint/suspicious/noExplicitAny: Must handle both method and class decorator signatures\n    static ParamvalueProvider(...args) {\n        if (args.length === 1 && typeof args[0] === \"function\") {\n            // #region Class decorator path\n            // biome-ignore lint/suspicious/noExplicitAny: Must accept any constructor signature\n            const constructor = args[0];\n            const key = `${constructor.name}:undefined`;\n            // biome-ignore lint/suspicious/noExplicitAny: Must accept any constructor signature\n            const WrappedClass = class extends constructor {\n                // biome-ignore lint/suspicious/noExplicitAny: Must accept any constructor signature\n                constructor(...ctorArgs) {\n                    if (DBC.paramValueRequests.has(key)) {\n                        const paramMap = DBC.paramValueRequests.get(key);\n                        for (const index of paramMap.keys()) {\n                            if (index < ctorArgs.length) {\n                                for (const receptor of paramMap.get(index)) {\n                                    receptor(ctorArgs[index]);\n                                }\n                            }\n                        }\n                    }\n                    super(...ctorArgs);\n                }\n            };\n            Object.defineProperty(WrappedClass, \"name\", { value: constructor.name });\n            return WrappedClass;\n            // #endregion Class decorator path\n        }\n        // #region Method decorator path\n        const [target, propertyKey, descriptor] = args;\n        const originalMethod = descriptor.value;\n        const isStatic = typeof target === \"function\";\n        // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.\n        descriptor.value = function (...methodArgs) {\n            // #region   Check if a value of one of the method's parameter has been requested and pass it to the\n            //           receptor, if so.\n            const actualTarget = isStatic ? this : this.constructor;\n            const key = DBC.getRequestKey(actualTarget, propertyKey);\n            if (DBC.paramValueRequests.has(key)) {\n                const paramMap = DBC.paramValueRequests.get(key);\n                for (const index of paramMap.keys()) {\n                    if (index < methodArgs.length) {\n                        for (const receptor of paramMap.get(index)) {\n                            receptor(methodArgs[index]);\n                        }\n                    }\n                }\n            }\n            else {\n                console.warn(\"No parameter value requests found for key:\", key);\n            }\n            // #endregion\tCheck if a value of one of the method's parameter has been requested and pass it to the\n            //              receptor, if so.\n            return originalMethod.apply(this, methodArgs);\n        };\n        return descriptor;\n        // #endregion Method decorator path\n    }\n    // #endregion Parameter-value requests.\n    // #region Class\n    /**\n     * A property-decorator factory serving as a **D**esign **B**y **C**ontract Invariant.\n     * This invariant aims to check the instance of the class not the value to be get or set.\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 get or set without the instance of it's class\n     * \t\t\tfulfilling the specified **contracts**. */\n    static decClassInvariant(contracts, path = undefined, dbc = \"WaXCode.DBC\") {\n        let dbcInstance;\n        return (target, propertyKey, descriptor) => {\n            if (!dbcInstance)\n                dbcInstance = DBC.getDBC(dbc);\n            if (!dbcInstance.executionSettings.checkInvariants) {\n                return;\n            }\n            const originalSetter = descriptor.set;\n            const originalGetter = descriptor.get;\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                get() {\n                    if (!(dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.executionSettings.checkInvariants)) {\n                        return;\n                    }\n                    const realValue = path ? DBC.resolve(this, path) : this;\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                            dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.reportFieldInfringement(result, target, path, propertyKey, realValue);\n                        }\n                    }\n                    // #endregion Check if all \"contracts\" are fulfilled.\n                    return originalGetter ? originalGetter[propertyKey] : value;\n                },\n                set(newValue) {\n                    if (!(dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.executionSettings.checkInvariants)) {\n                        return;\n                    }\n                    const realValue = path ? DBC.resolve(this, path) : this;\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                            dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.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 Class\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 = undefined, hint = undefined) {\n        let dbcInstance;\n        return (target, propertyKey) => {\n            if (!dbcInstance)\n                dbcInstance = DBC.getDBC(dbc);\n            if (!dbcInstance.executionSettings.checkInvariants) {\n                return;\n            }\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                    if (!(dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.executionSettings.checkInvariants)) {\n                        return;\n                    }\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                            dbcInstance === null || dbcInstance === void 0 ? void 0 : dbcInstance.reportFieldInfringement(result, target, path, propertyKey, realValue, hint);\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    // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.\n    static decPostcondition(\n    // biome-ignore lint/suspicious/noExplicitAny: Necessary to intercept UNDEFINED and NULL.\n    check, dbc = undefined, path = undefined, hint = undefined) {\n        let dbcInstance;\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                if (!dbcInstance)\n                    dbcInstance = DBC.getDBC(dbc);\n                if (!dbcInstance.executionSettings.checkPostconditions) {\n                    return;\n                }\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                    dbcInstance.reportReturnvalueInfringement(checkResult, target, path, propertyKey, realValue, hint);\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     * \t\t\t\tMay contain :: to separate multiple paths.\n     *\n     * @returns The **(target: object, methodName: string | symbol, parameterIndex: number ) => void** invoked by Typescript- */\n    static decPrecondition(\n    // biome-ignore lint/suspicious/noExplicitAny: Necessary to check any parameter value\n    check, dbc = undefined, path = undefined, hint = undefined) {\n        const paths = path ? path.replace(/ /g, \"\").split(\"::\") : [undefined];\n        let dbcInstance;\n        return (target, methodName, parameterIndex) => {\n            DBC.requestParamValue(target, methodName, parameterIndex, (value) => {\n                if (!dbcInstance)\n                    dbcInstance = DBC.getDBC(dbc);\n                if (!dbcInstance.executionSettings.checkPreconditions) {\n                    return;\n                }\n                for (const singlePath of paths) {\n                    const realValue = singlePath\n                        ? DBC.resolve(value, singlePath)\n                        : value;\n                    const result = check(realValue, target, methodName, parameterIndex);\n                    if (typeof result === \"string\") {\n                        dbcInstance.reportParameterInfringement(result, target, singlePath, methodName, parameterIndex, realValue, hint);\n                    }\n                }\n            });\n        };\n    }\n    // #endregion Precondition\n    // #endregion Decorator\n    // #region Contract Factory Helpers\n    /**\n     * Creates a PRE decorator from a checkAlgorithm function and its bound arguments.\n     * Reduces boilerplate across contract classes.\n     *\n     * @param checkFn  A function that takes (value, ...boundArgs) and returns true or an error string.\n     * @param boundArgs The arguments to bind to the check function after the value.\n     * @param dbc      See {@link DBC.decPrecondition}.\n     * @param path     See {@link DBC.decPrecondition}.\n     * @param hint     See {@link DBC.decPrecondition}.\n     */\n    static createPRE(\n    // biome-ignore lint/suspicious/noExplicitAny: Must accept any checkAlgorithm signature\n    checkFn, \n    // biome-ignore lint/suspicious/noExplicitAny: Arguments vary per contract\n    boundArgs, dbc, path, hint) {\n        return DBC.decPrecondition((value, _target, _methodName, _parameterIndex) => {\n            return checkFn(value, ...boundArgs);\n        }, dbc, path, hint);\n    }\n    /**\n     * Creates a POST decorator from a checkAlgorithm function and its bound arguments.\n     *\n     * @param checkFn  A function that takes (value, ...boundArgs) and returns true or an error string.\n     * @param boundArgs The arguments to bind to the check function after the value.\n     * @param dbc      See {@link DBC.decPostcondition}.\n     * @param path     See {@link DBC.decPostcondition}.\n     * @param hint     See {@link DBC.decPostcondition}.\n     */\n    static createPOST(\n    // biome-ignore lint/suspicious/noExplicitAny: Must accept any checkAlgorithm signature\n    checkFn, \n    // biome-ignore lint/suspicious/noExplicitAny: Arguments vary per contract\n    boundArgs, dbc, path, hint) {\n        return DBC.decPostcondition((value, _target, _propertyKey) => {\n            return checkFn(value, ...boundArgs);\n        }, dbc, path, hint);\n    }\n    /**\n     * Creates an INVARIANT decorator from a contract constructor and its bound arguments.\n     *\n     * @param ContractClass A class with a constructor that produces an object with a `check` method.\n     * @param ctorArgs      The arguments to pass to the contract constructor.\n     * @param dbc           See {@link DBC.decInvariant}.\n     * @param path          See {@link DBC.decInvariant}.\n     * @param hint          See {@link DBC.decInvariant}.\n     */\n    static createINVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: Must accept any contract constructor\n    ContractClass, \n    // biome-ignore lint/suspicious/noExplicitAny: Arguments vary per contract\n    ctorArgs, dbc, path, hint) {\n        return DBC.decInvariant([new ContractClass(...ctorArgs)], path, dbc, hint);\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    /** Sanitizes a value for safe inclusion in error messages. */\n    static sanitize(value) {\n        const str = typeof value === \"string\" ? value : String(value);\n        return str.replace(/[<>&\"']/g, (ch) => {\n            switch (ch) {\n                case \"<\":\n                    return \"&lt;\";\n                case \">\":\n                    return \"&gt;\";\n                case \"&\":\n                    return \"&amp;\";\n                case '\"':\n                    return \"&quot;\";\n                case \"'\":\n                    return \"&#39;\";\n                default:\n                    return ch;\n            }\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, value, path, hint = undefined) {\n        const safeViolator = DBC.sanitize(violator);\n        const targetName = typeof target === \"function\"\n            ? DBC.sanitize(target.name)\n            : typeof target === \"object\" &&\n                target !== null &&\n                typeof target.constructor === \"function\"\n                ? DBC.sanitize(target.constructor.name)\n                : DBC.sanitize(target);\n        const finalMessage = `[ From \"${safeViolator}\" in \"${targetName}\"${path ? ` > \"${DBC.sanitize(path)}\"` : \"\"}: ${message} ${hint ? `✨ ${hint} ✨` : \"\"}]`;\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, hint = undefined) {\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, value, path, hint);\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, hint = undefined) {\n        this.reportInfringement(`[ New value for \"${key}\"${path === undefined ? \"\" : `.${path}`} with value \"${value}\" did not fulfill one of it's contracts: ${message} ]`, key, target, value, 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, hint = undefined) {\n        this.reportInfringement(`[ Return-value \"${value}\" did not fulfill one of it's contracts: ${message} ]`, method, target, value, path, hint);\n    }\n    /**\n     * Constructs this {@link DBC } without mounting it on the global namespace.\n     * Use {@link DBC.register } to make the instance available at a specific path on globalThis.\n     *\n     * @param infringementSettings \tSee {@link DBC.infringementSettings }.\n     * @param executionSettings\t\tSee {@link DBC.executionSettings }. */\n    constructor(infringementSettings = { throwException: true, logToConsole: false }, executionSettings = {\n        checkPreconditions: true,\n        checkPostconditions: true,\n        checkInvariants: true,\n    }) {\n        // #endregion Contract Factory Helpers\n        // #region Execution Handling\n        /** Stores settings concerning the execution of checks. */\n        this.executionSettings = {\n            checkPreconditions: true,\n            checkPostconditions: true,\n            checkInvariants: true,\n        };\n        // #endregion Execution Handling\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        this.executionSettings = executionSettings;\n    }\n    /**\n     * Registers a {@link DBC } instance at the specified dotted path on globalThis (or window),\n     * making it available for decorator resolution via string paths.\n     *\n     * @param instance\tThe {@link DBC } instance to register.\n     * @param path\t\tThe dotted path to register at (default: `\"WaXCode.DBC\"`). */\n    static register(instance, path = \"WaXCode.DBC\") {\n        const segments = path.split(\".\");\n        // biome-ignore lint/suspicious/noExplicitAny: Must walk dynamic global namespace.\n        let obj = DBC.getHost();\n        for (let i = 0; i < segments.length - 1; i++) {\n            if (obj[segments[i]] === undefined)\n                obj[segments[i]] = {};\n            obj = obj[segments[i]];\n        }\n        obj[segments[segments.length - 1]] = instance;\n        DBC.dbcCache.set(path, instance);\n    }\n    /**\n     * Executes a callback with an isolated {@link DBC } instance temporarily registered at the default path.\n     * The previous instance (if any) is restored after the callback completes — even if it throws.\n     * Useful for test isolation.\n     *\n     * @param fn The callback receiving the isolated {@link DBC } instance. */\n    static isolated(fn) {\n        const saved = DBC.dbcCache.get(\"WaXCode.DBC\");\n        const testDbc = new DBC();\n        DBC.register(testDbc);\n        try {\n            fn(testDbc);\n        }\n        finally {\n            if (saved) {\n                DBC.register(saved);\n            }\n            else {\n                DBC.dbcCache.delete(\"WaXCode.DBC\");\n            }\n        }\n    }\n    /**\n     * Resolves the desired {@link object } out a given one **toResolveFrom** using the specified **path**.\n     *\n     * @param toResolveFrom The {@link object } starting to resolve from.\n     * @param path\t\t\tThe dotted path-{@link string }.\n     * \t\t\t\t\t\tThis string uses ., [...], and () to represent accessing nested properties,\n     * \t\t\t\t\t\tarray elements/object keys, and calling methods, respectively, mimicking JavaScript syntax to navigate\n     * \t\t\t\t\t\tan object's structure. Code, e.g. something like a.b( 1 as number ).c, will not be executed and\n     * \t\t\t\t\t\tthus make the retrieval fail.\n     *\n     * @returns The requested {@link object }, NULL or UNDEFINED. */\n    static resolve(toResolveFrom, path) {\n        if (!toResolveFrom || typeof path !== \"string\") {\n            return undefined;\n        }\n        // Security: block prototype pollution paths\n        const dangerousTokens = [\"__proto__\", \"constructor\", \"prototype\"];\n        const cachedParts = DBC.pathTokenCache.get(path);\n        const parts = cachedParts !== null && cachedParts !== void 0 ? cachedParts : path.replace(/\\[(['\"]?)(.*?)\\1\\]/g, \".$2\").split(\".\");\n        if (!cachedParts) {\n            // Validate tokens before caching\n            for (const part of parts) {\n                const tokenName = part.replace(/\\(.*\\)$/, \"\");\n                if (dangerousTokens.indexOf(tokenName) >= 0) {\n                    throw new Error(`[XDBC] Path \"${path}\" contains forbidden token \"${tokenName}\".`);\n                }\n            }\n            DBC.evictIfNeeded(DBC.pathTokenCache);\n            DBC.pathTokenCache.set(path, parts);\n        }\n        // biome-ignore lint/suspicious/noExplicitAny: Must traverse arbitrary object graphs\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());\n                if (typeof current[methodName] === \"function\") {\n                    current = current[methodName].apply(current, args);\n                }\n                else {\n                    return undefined;\n                }\n            }\n            else {\n                if (typeof window !== \"undefined\" &&\n                    typeof HTMLElement !== \"undefined\" &&\n                    current instanceof HTMLElement &&\n                    part.startsWith(\"@\")) {\n                    current = current.getAttribute(part.slice(1));\n                }\n                else if (typeof current === \"object\" &&\n                    current !== null &&\n                    part in current) {\n                    current = current[part];\n                }\n                else if (typeof window !== \"undefined\" &&\n                    typeof HTMLElement !== \"undefined\" &&\n                    current instanceof HTMLElement) {\n                    current = undefined;\n                }\n                else {\n                    current = undefined;\n                }\n            }\n        }\n        return current;\n    }\n}\n// #region Internal caches.\nDBC.MAX_CACHE_SIZE = 1000;\nDBC.dbcCache = new Map();\nDBC.pathTokenCache = new Map();\n// #endregion Internal caches.\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 */\n// biome-ignore lint/suspicious/noExplicitAny: Must traverse arbitrary object graphs\nDBC.resolveDBCPath = (obj, path) => path === null || path === void 0 ? void 0 : path.split(\".\").reduce((accumulator, current) => accumulator[current], obj);\n// Register the default instance with standard settings.\nDBC.register(new 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 hint\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, hint = undefined, dbc = undefined) {\n        return DBC.decPrecondition((\n        // biome-ignore lint/suspicious/noExplicitAny: Must match DBC.decPrecondition signature\n        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, hint);\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 hint\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, hint = undefined, dbc = undefined) {\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, hint);\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 hint\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, hint = undefined, dbc = undefined) {\n        return DBC.createINVARIANT(AE, [realConditions, index, idxEnd], dbc, path, hint);\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    // biome-ignore lint/suspicious/noExplicitAny: Must match DBC factory signature\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 a comparison between two {@link object }s.\n *\n * @remarks\n * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */\nexport class COMPARISON extends DBC {\n    // #region Condition checking.\n    /**\n     * Does a comparison between the {@link object } **toCheck** and the **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    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic comparison\n    static checkAlgorithm(toCheck, equivalent, equalityPermitted, invert) {\n        if (equalityPermitted && !invert && toCheck < equivalent) {\n            return `Value has to be greater than or equal to \"${equivalent}\"`;\n        }\n        if (equalityPermitted && invert && toCheck > equivalent) {\n            return `Value has to be less than or equal to \"${equivalent}\"`;\n        }\n        if (!equalityPermitted && !invert && toCheck <= equivalent) {\n            return `Value has to be greater than \"${equivalent}\"`;\n        }\n        if (!equalityPermitted && invert && toCheck >= equivalent) {\n            return `Value has to be less than \"${equivalent}\"`;\n        }\n        return true;\n    }\n    /**\n     * A parameter-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged parameter.\n     *\n     * @param equivalent\t    See {@link COMPARISON.checkAlgorithm }.\n     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.\n     * @param path\t\t\t    See {@link DBC.decPrecondition }.\n     * @param hint\t\t\t\tSee {@link DBC.decPrecondition }.\n     * @param dbc\t\t\t    See {@link DBC.decPrecondition }.\n     *\n     * @returns See {@link DBC.decPrecondition }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createPRE(COMPARISON.checkAlgorithm, [equivalent, equalityPermitted, invert], dbc, path, hint);\n    }\n    /**\n     * A method-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged method's returnvalue.\n     *\n     * @param equivalent\t    See {@link COMPARISON.checkAlgorithm }.\n     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.\n     * @param path\t\t\t    See {@link DBC.Postcondition }.\n     * @param hint\t\t\t\tSee {@link DBC.decPostcondition }.\n     * @param dbc\t\t\t    See {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createPOST(COMPARISON.checkAlgorithm, [equivalent, equalityPermitted, invert], dbc, path, hint);\n    }\n    /**\n     * A field-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled\n     * by the tagged field.\n     *\n     * @param equivalent\t    See {@link COMPARISON.checkAlgorithm }.\n     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.\n     * @param path\t\t\t    See {@link DBC.decInvariant }.\n     * @param hint\t\t\t\tSee {@link DBC.decInvariant }.\n     * @param dbc\t\t\t    See {@link DBC.decInvariant }.\n     *\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createINVARIANT(COMPARISON, [equivalent, equalityPermitted, invert], dbc, path, hint);\n    }\n    // #endregion Condition checking.\n    // #region Referenced Condition checking.\n    // #region Dynamic usage.\n    /**\n     * Invokes the {@link COMPARISON.checkAlgorithm } passing the value **toCheck**, {@link COMPARISON.equivalent } and {@link COMPARISON.invert }.\n     *\n     * @param toCheck See {@link COMPARISON.checkAlgorithm }.\n     *\n     * @returns See {@link COMPARISON.checkAlgorithm}. */\n    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic comparison\n    check(toCheck) {\n        return COMPARISON.checkAlgorithm(toCheck, this.equivalent, this.equalityPermitted, this.invert);\n    }\n    /**\n     * Creates this {@link COMPARISON } by setting the protected property {@link COMPARISON.equivalent }, {@link COMPARISON.equalityPermitted } and {@link COMPARISON.invert } used by {@link COMPARISON.check }.\n     *\n     * @param equivalent        See {@link COMPARISON.check }.\n     * @param equalityPermitted See {@link COMPARISON.check }.\n     * @param invert            See {@link COMPARISON.check }. */\n    constructor(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false) {\n        super();\n        this.equivalent = equivalent;\n        this.equalityPermitted = equalityPermitted;\n        this.invert = invert;\n    }\n}\n","import { COMPARISON } from \"../COMPARISON\";\n/** See {@link COMPARISON }. */\nexport class GREATER extends COMPARISON {\n    /** See {@link COMPARISON.PRE }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.PRE(equivalent, false, false, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.POST }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.POST(equivalent, false, false, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.INVARIANT }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.INVARIANT(equivalent, false, false, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.constructor }. */\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    constructor(equivalent) {\n        super(equivalent, false, false);\n        this.equivalent = equivalent;\n    }\n}\n","import { COMPARISON } from \"../COMPARISON\";\n/** See {@link COMPARISON }. */\nexport class GREATER_OR_EQUAL extends COMPARISON {\n    /** See {@link COMPARISON.PRE }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.PRE(equivalent, true, false, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.POST }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.POST(equivalent, true, false, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.INVARIANT }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.INVARIANT(equivalent, true, false, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.constructor }. */\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    constructor(equivalent) {\n        super(equivalent, true, false);\n        this.equivalent = equivalent;\n    }\n}\n","import { COMPARISON } from \"../COMPARISON\";\n/** See {@link COMPARISON }. */\nexport class LESS extends COMPARISON {\n    /** See {@link COMPARISON.PRE }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.PRE(equivalent, false, true, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.POST }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.POST(equivalent, false, true, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.INVARIANT }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.INVARIANT(equivalent, false, true, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.constructor }. */\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    constructor(equivalent) {\n        super(equivalent, false, true);\n        this.equivalent = equivalent;\n    }\n}\n","import { COMPARISON } from \"../COMPARISON\";\n/** See {@link COMPARISON }. */\nexport class LESS_OR_EQUAL extends COMPARISON {\n    /** See {@link COMPARISON.PRE }. */\n    static PRE(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.PRE(equivalent, true, true, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.POST }. */\n    static POST(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.POST(equivalent, true, true, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.INVARIANT }. */\n    static INVARIANT(\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    equivalent, equalityPermitted = false, invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return COMPARISON.INVARIANT(equivalent, true, true, path, hint, dbc);\n    }\n    /** See {@link COMPARISON.constructor }. */\n    // biome-ignore lint/suspicious/noExplicitAny: Comparison target can be any numeric value\n    constructor(equivalent) {\n        super(equivalent, true, true);\n        this.equivalent = equivalent;\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 be equal to \"${equivalent}\"`;\n        }\n        if (invert && equivalent === toCheck) {\n            return `Value must not 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, hint = undefined, dbc = undefined) {\n        return DBC.createPRE(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);\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, hint = undefined, dbc = undefined) {\n        return DBC.createPOST(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);\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, hint = undefined, dbc = undefined) {\n        return DBC.createINVARIANT(EQ, [equivalent, invert], dbc, path, hint);\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     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck** and the specified **type** .\n     *\n     * @param toCheck See {@link EQ.checkAlgorithm }.\n     *\n     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link EQ }.\n     *\n     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link EQ }.*/\n    static tsCheck(toCheck, equivalent, hint = undefined, id = undefined) {\n        const result = EQ.checkAlgorithm(toCheck, equivalent, false);\n        if (result) {\n            return toCheck;\n        }\n        throw new DBC.Infringement(`${id ? `(${id}) ` : \"\"}${result} ${hint ? `✨ ${hint} ✨` : \"\"}`);\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 { EQ } from \"../EQ\";\n/**\n * DIFFERENT class for inequality comparisons.\n *\n * This class extends EQ and provides methods to check if a value is different (not equal)\n * from a specified equivalent value. It inverts the equality check by always passing\n * `true` for the invert parameter to the parent EQ class methods.\n *\n * @remarks\n * The class provides precondition (PRE), postcondition (POST), and invariant (INVARIANT)\n * checks for Design by Contract programming patterns.\n *\n * @see {@link COMPARISON}\n * @see {@link EQ}\n */\nexport class DIFFERENT extends EQ {\n    /** See {@link EQ.PRE }. Always inverts equality check. */\n    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature\n    static PRE(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return EQ.PRE(equivalent, true, path, hint, dbc);\n    }\n    /** See {@link EQ.POST }. Always inverts equality check. */\n    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature\n    static POST(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return EQ.POST(equivalent, true, path, hint, dbc);\n    }\n    /** See {@link EQ.INVARIANT }. Always inverts equality check. */\n    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature\n    static INVARIANT(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {\n        return EQ.INVARIANT(equivalent, true, path, hint, dbc);\n    }\n    /** See {@link EQ.constructor }. */\n    // biome-ignore lint/suspicious/noExplicitAny: Must match parent signature\n    constructor(equivalent) {\n        super(equivalent, true);\n        this.equivalent = equivalent;\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 an instance of the specified **reference**.\n     *\n     * @param toCheck\tThe value that has to be an instance of the **reference** in order for this {@link DBC }\n     * \t\t\t\t\tto be fulfilled.\n     * @param reference\tThe {@link object } the one **toCheck** has to be an instance of.\n     *\n     * @returns TRUE if the value **toCheck** is is an instance of the *reference**, **undefined** or **null**, otherwise FALSE. */\n    // biome-ignore lint/suspicious/noExplicitAny: In order to perform an \"instanceof\" check.\n    static checkAlgorithm(toCheck, ...references) {\n        if (toCheck === null || toCheck === undefined) {\n            return true;\n        }\n        for (const ref of references) {\n            if (toCheck instanceof ref) {\n                return true;\n            }\n        }\n        return `Value has to be an instance of \"${references.map((ref) => ref.name || ref).join(\", \")}\" but is of type \"${typeof toCheck}\"`;\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, hint = undefined, dbc = undefined) {\n        const refs = Array.isArray(reference) ? reference : [reference];\n        return DBC.createPRE(INSTANCE.checkAlgorithm, refs, dbc, path, hint);\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, hint = undefined, dbc = undefined) {\n        const refs = Array.isArray(reference) ? reference : [reference];\n        return DBC.createPOST(INSTANCE.checkAlgorithm, refs, dbc, path, hint);\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, hint = undefined, dbc = undefined) {\n        return DBC.createINVARIANT(INSTANCE, [reference], dbc, path, hint);\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 Array.isArray(this.reference)\n            ? INSTANCE.checkAlgorithm(toCheck, ...this.reference)\n            : INSTANCE.checkAlgorithm(toCheck, this.reference);\n    }\n    /**\n     * Type-safe check that validates if a value is an instance of a specified reference.\n     *\n     * @param toCheck \tThe value to check for instance validity.\n     * @param reference\tThe {@link object } the one **toCheck** has to be an instance of.\n     * @param hint\t\tAn optional {@link string } providing extra information in case of an infringement.\n     * @param id\t\tA {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.\n     *\n     * @returns The **CANDIDATE** **toCheck** if it fulfills this {@link INSTANCE }.\n     *\n     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link INSTANCE }. */\n    static tsCheck(toCheck, reference, hint = undefined, id = undefined) {\n        return INSTANCE.tsCheckMulti(toCheck, [reference], hint, id);\n    }\n    /**\n     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .\n     *\n     * @param toCheck \tSee {@link INSTANCE.checkAlgorithm }.\n     * @param reference\tSee {@link INSTANCE.checkAlgorithm }.\n     * @param hint\t\tAn optional {@link string } providing extra information in case of an infringement.\n     * @param id\t\tA {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.\n     *\n     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link INSTANCE }.\n     *\n     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }. */\n    static tsCheckMulti(toCheck, references, hint = undefined, id = undefined) {\n        const result = INSTANCE.checkAlgorithm(toCheck, ...references);\n        if (result === true) {\n            return toCheck;\n        }\n        throw new DBC.Infringement(`${id ? `(${id}) ` : \"\"}${result} ${hint ? `✨ ${hint} ✨` : \"\"}`);\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    static get stdExp() {\n        if (!REGEX._stdExp) {\n            REGEX._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: /^(?:https?|ftp):\\/\\/[^\\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                boolean: /^(TRUE|FALSE)$/i,\n                colorCodeHEX: /^#([A-Fa-f\\d]{3,4}|[A-Fa-f\\d]{6}|[A-Fa-f\\d]{8})$/i,\n                simpleHotkey: /^((Alt|Ctrl|Shift|Meta)\\+)+[a-z\\d]$/i,\n                bcp47: /^(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4}|[a-z]{5,8})(?:-[a-z]{4})?(?:-[a-z]{2}|-[0-9]{3})?(?:-[a-z0-9]{5,8}|-[0-9][a-z0-9]{3})*(?:-[0-9a-wy-z](?:-[a-z0-9]{2,8})+)*(?:-x(?:-[a-z0-9]{1,8})+)?$|^x(?:-[a-z0-9]{1,8})+$/i,\n            };\n        }\n        return REGEX._stdExp;\n    }\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 (toCheck === undefined || toCheck === null || toCheck === \"\")\n            return true;\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, hint = undefined, dbc = undefined) {\n        return DBC.createPRE(REGEX.checkAlgorithm, [expression], dbc, path, hint);\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     * @param hint\t\t\tSee {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(expression, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createPOST(REGEX.checkAlgorithm, [expression], dbc, path, hint);\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     * @param hint\t\t\tSee {@link DBC.decInvariant }.\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(expression, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createINVARIANT(REGEX, [expression], dbc, path, hint);\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     * Type-safe check that validates a value against a regular expression and returns it as the specified type.\n     *\n     * @param toCheck\t\tThe value to check against the regular expression.\n     * @param expression\tThe regular expression to validate against.\n     * @param hint\t\t\tOptional hint message to include in the error if validation fails.\n     * @param id\t\t\tOptional identifier to include in the error message.\n     *\n     * @returns The validated value cast to the CANDIDATE type.\n     *\n     * @throws {@link DBC.Infringement} if the value does not match the regular expression. */\n    static tsCheck(toCheck, expression, hint = undefined, id = undefined) {\n        const result = REGEX.checkAlgorithm(toCheck, expression);\n        if (result) {\n            return toCheck;\n        }\n        throw new DBC.Infringement(`${id ? `(${id}) ` : \"\"}${result}${hint ? ` ✨ ${hint} ✨` : \"\"}`);\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","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. Can be a single type or multiple types separated by \"|\".\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        if (toCheck === undefined || toCheck === null)\n            return true;\n        const types = type.split(\"|\").map((t) => t.trim());\n        const actualType = typeof toCheck;\n        // #region Check if the actual type matches at least one of the specified types\n        // biome-ignore lint/suspicious/useValidTypeof: Necessary\n        const isValid = types.some((t) => actualType === t);\n        if (!isValid) {\n            if (types.length === 1) {\n                return `Value has to be of type \"${type}\" but is of type \"${actualType}\"`;\n            }\n            return `Value has to be of type \"${types.join(\" | \")}\" but is of type \"${actualType}\"`;\n        }\n        // #endregion Check if the actual type matches at least one of the specified types\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\tA ::-separated list of dotted paths to check. Each path points to a property within the parameter value.\n     * \t\t\t\tUndefined properties are skipped. See {@link DBC.decPrecondition }.\n     * @param dbc\tSee {@link DBC.decPrecondition }.\n     *\n     * @returns See {@link DBC.decPrecondition }. */\n    static PRE(type, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createPRE(TYPE.checkAlgorithm, [type], dbc, path, hint);\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\tA ::-separated list of dotted paths to check. Each path points to a property within the parameter value.\n     * \t\t\t\tUndefined properties are skipped. See {@link DBC.decPrecondition }.\n     * @param dbc\tSee {@link DBC.decPostcondition }.\n     *\n     * @returns See {@link DBC.decPostcondition }. */\n    static POST(type, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createPOST(TYPE.checkAlgorithm, [type], dbc, path, hint);\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\tA ::-separated list of dotted paths to check. Each path points to a property within the parameter value.\n     * \t\t\t\tUndefined properties are skipped. See {@link DBC.decPrecondition }.\n     * @param dbc\tSee {@link DBC.decInvariant }.\n     *\n     * @returns See {@link DBC.decInvariant }. */\n    static INVARIANT(type, path = undefined, hint = undefined, dbc = undefined) {\n        return DBC.createINVARIANT(TYPE, [type], dbc, path, hint);\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     * Invokes the {@link TYPE.checkAlgorithm } passing the value **toCheck** and the {@link TYPE.type } .\n     *\n     * @param toCheck\tSee {@link TYPE.checkAlgorithm }.\n     * @param type\t\tSee {@link TYPE.checkAlgorithm }.\n     * @param hint\t\tAn optional {@link string } providing extra information in case of an infringement.\n     * @param id\t\tA {@link string } identifying this {@link TYPE } via the {@link DBC.Infringement }-Message.\n     *\n     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link TYPE }.\n     *\n     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }. */\n    static tsCheck(toCheck, type, hint = undefined, id = undefined) {\n        const result = TYPE.checkAlgorithm(toCheck, type);\n        if (result === true) {\n            return toCheck;\n        }\n        throw new DBC.Infringement(`${id ? `(${id}) ` : \"\"}${result}${hint ? ` ✨ ${hint} ✨` : \"\"}`);\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\tif (!(moduleId in __webpack_modules__)) {\n\t\tdelete __webpack_module_cache__[moduleId];\n\t\tvar e = new Error(\"Cannot find module '\" + moduleId + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\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 { AE } from \"./DBC/AE\";\nimport { GREATER } from \"./DBC/COMPARISON/GREATER\";\nimport { GREATER_OR_EQUAL } from \"./DBC/COMPARISON/GREATER_OR_EQUAL\";\nimport { LESS } from \"./DBC/COMPARISON/LESS\";\nimport { LESS_OR_EQUAL } from \"./DBC/COMPARISON/LESS_OR_EQUAL\";\nimport { EQ } from \"./DBC/EQ\";\nimport { DIFFERENT } from \"./DBC/EQ/DIFFERENT\";\nimport { INSTANCE } from \"./DBC/INSTANCE\";\nimport { REGEX } from \"./DBC/REGEX\";\nimport { TYPE } from \"./DBC/TYPE\";\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 Static Method with ParamvalueProvider\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    // #endregion Check AE Index\n    // #region Check Comparison\n    testGREATER(input) { }\n    testGREATER_OR_EQUAL(input) { }\n    testLESS(input) { }\n    testLESS_OR_EQUAL(input) { }\n    testDIFFERENT(input) { }\n    // #endregion Check Comparison\n    // #region Check Static Method with ParamvalueProvider\n    static testStaticMethod(message, count) {\n        return `${message} repeated ${count} times`;\n    }\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);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, GREATER.PRE(2)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Number]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testGREATER\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, GREATER_OR_EQUAL.PRE(2)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Number]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testGREATER_OR_EQUAL\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, LESS.PRE(20)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Number]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testLESS\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, LESS_OR_EQUAL.PRE(20)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Number]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testLESS_OR_EQUAL\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, DIFFERENT.PRE(20)),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Number]),\n    __metadata(\"design:returntype\", void 0)\n], Demo.prototype, \"testDIFFERENT\", null);\n__decorate([\n    DBC.ParamvalueProvider,\n    __param(0, TYPE.PRE(\"string\")),\n    __param(1, TYPE.PRE(\"number\")),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [String, Number]),\n    __metadata(\"design:returntype\", String)\n], Demo, \"testStaticMethod\", 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}\ndemo.testGREATER(11);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"GREATER OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testGREATER(2);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"GREATER Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testGREATER_OR_EQUAL(2);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"GREATER_OR_EQUAL OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testGREATER_OR_EQUAL(1);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"GREATER_OR_EQUAL Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testLESS(10);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"LESS OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testLESS(20);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"LESS Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testLESS_OR_EQUAL(20);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"LESS OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testLESS_OR_EQUAL(21);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"LESS_OR_EQUAL Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ndemo.testDIFFERENT(21);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"DIFFERENT OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    demo.testDIFFERENT(20);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"DIFFERENT Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\n// #region Inactivity Checks\nwindow.WaXCode.DBC.executionSettings.checkPreconditions = false;\ntry {\n    demo.testLESS_OR_EQUAL(21);\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INACTIVE PRECONDITIONS OK\");\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INACTIVE PRECONDITIONS FAILED\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\nwindow.WaXCode.DBC.executionSettings.checkPostconditions = false;\ntry {\n    demo.testReturnvalue(\"qqqqq\");\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INACTIVE POSTCONDITIONS OK\");\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INACTIVE POSTCONDITIONS FAILED\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\nwindow.WaXCode.DBC.executionSettings.checkInvariants = false;\ntry {\n    demo.testProperty = \"b\";\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INACTIVE INVARIANTS OK\");\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"INACTIVE INVARIANTS FAILED\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\n// #endregion Inactivity Checks\n// Re-enable all checks for subsequent tests\nwindow.WaXCode.DBC.executionSettings.checkPreconditions = true;\nwindow.WaXCode.DBC.executionSettings.checkPostconditions = true;\nwindow.WaXCode.DBC.executionSettings.checkInvariants = true;\n// #region Static Method Test\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"TESTING STATIC METHOD WITH PARAMVALUEPROVIDER\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\nDemo.testStaticMethod(\"Hello\", 3);\nconsole.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\nconsole.log(\"STATIC METHOD OK\");\nconsole.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\ntry {\n    Demo.testStaticMethod(\"Hello\", \"not a number\");\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"STATIC METHOD Infringement OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\ntry {\n    Demo.testStaticMethod(123, 5);\n}\ncatch (X) {\n    console.log(\"⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄⌄\");\n    console.log(\"STATIC METHOD Infringement (first param) OK\");\n    console.log(X);\n    console.log(\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\");\n}\n// #endregion Static Method Test\n"],"names":[],"sourceRoot":""}