xdbc 1.0.217 → 1.0.219

package/dist/DBC.js

@@ -0,0 +1,645 @@
+/**
+ * Provides a **D**esign **B**y **C**ontract Framework using decorators.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export 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.`);
+    }
+    /**
+     * Returns the registered {@link DBC } instance at the specified path.
+     * Throws if no instance is registered there.
+     *
+     * @param path The dotted path to look up (default: `"WaXCode.DBC"`). */
+    static getRegistered(path) {
+        return DBC.getDBC(path);
+    }
+    /**
+     * 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, 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;
+    }
+    static ParamvalueProvider(...args) {
+        if (args.length === 1 && typeof args[0] === "function") {
+            // #region Class decorator path
+            const ctor = args[0];
+            const key = `${ctor.name}:undefined`;
+            const WrappedClass = class extends ctor {
+                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: ctor.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";
+        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;
+            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;
+            }
+            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.
+     */
+    static decPostcondition(check, dbc = undefined, path = undefined, hint = undefined) {
+        let dbcInstance;
+        return (target, propertyKey, descriptor) => {
+            const originalMethod = descriptor.value;
+            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(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(checkFn, 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(checkFn, 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(ContractClass, 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, type = "precondition") {
+        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} ✨` : ""}]`;
+        const infringement = new DBC.Infringement(finalMessage);
+        if (this.infringementSettings.logToConsole) {
+            console.log(finalMessage);
+        }
+        if (this.infringementSettings.onInfringement) {
+            this.infringementSettings.onInfringement(infringement, { type, value });
+        }
+        if (this.infringementSettings.throwException) {
+            throw infringement;
+        }
+    }
+    /**
+     * 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, "precondition");
+    }
+    /**
+     * 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, hint, "invariant");
+    }
+    /**
+     * 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, value, hint = undefined) {
+        this.reportInfringement(`[ Return-value "${value}" did not fulfill one of it's contracts: ${message} ]`, method, target, value, path, hint, "postcondition");
+    }
+    /**
+     * Routes an imperative infringement (from {@link tsCheck } or static {@link check } calls) through the
+     * registered DBC instance's {@link infringementSettings }, respecting whether to throw, log, or both.
+     * Falls back to throwing {@link DBC.Infringement } directly if no DBC instance is registered at the
+     * specified path, preserving the pre-existing behaviour for code that does not register a DBC instance.
+     *
+     * @param message	The fully formatted infringement message.
+     * @param dbc		The path to the DBC instance. Defaults to `"WaXCode.DBC"`. */
+    static reportTsCheckInfringement(message, dbc = undefined, value = undefined) {
+        const infringement = new DBC.Infringement(message);
+        let dbcInstance;
+        try {
+            dbcInstance = DBC.getDBC(dbc);
+        }
+        catch (_a) {
+            throw infringement;
+        }
+        if (dbcInstance.infringementSettings.logToConsole) {
+            console.log(message);
+        }
+        if (dbcInstance.infringementSettings.onInfringement) {
+            dbcInstance.infringementSettings.onInfringement(infringement, {
+                type: "precondition",
+                value,
+            });
+        }
+        if (dbcInstance.infringementSettings.throwException) {
+            throw infringement;
+        }
+    }
+    /**
+     * 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,
+    }) {
+        var _a;
+        // #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, onInfringement: undefined };
+        this.infringementSettings = Object.assign(Object.assign({}, infringementSettings), { onInfringement: (_a = infringementSettings.onInfringement) !== null && _a !== void 0 ? _a : undefined });
+        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(".");
+        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);
+        }
+        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 }.
+ */
+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());

package/dist/Demo.d.ts

@@ -16,5 +16,15 @@ export declare class Demo {
     testLESS(input: number): void;
     testLESS_OR_EQUAL(input: number): void;
     testDIFFERENT(input: number): void;
+    testARRAY(x: unknown): void;
+    testPLAIN_OBJECT(x: unknown): void;
+    testDEFINED(x: unknown): void;
+    testUNDEFINED(x: unknown): void;
+    testHasAttribute(el: HTMLElement): void;
+    testIF(x: unknown): void;
+    testOR(x: unknown): void;
+    testJSON_OP(x: unknown): void;
+    testJSON_Parse(x: string): void;
+    testZOD(x: unknown): void;
     static testStaticMethod(message: string, count: number): string;
 }