xdbc 1.0.73

package/dist/DBC/REGEX.js

@@ -0,0 +1,103 @@
+import { DBC } from "../DBC.js";
+/**
+ * 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) */
+export class REGEX extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the value "toCheck" is complies to the {@link RegExp } "expression".
+     *
+     * @param toCheck		The value that has comply to the {@link RegExp } "expression" for this {@link DBC } to be fulfilled.
+     * @param expression	The {@link RegExp } the one "toCheck" has comply to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value "toCheck" complies with the {@link RegExp } "expression", otherwise FALSE. */
+    static checkAlgorithm(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck, expression) {
+        if (!expression.test(toCheck)) {
+            return `Value has to comply to regular expression "${expression}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param expression	See {@link REGEX.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(expression, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return REGEX.checkAlgorithm(value, expression);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link REGEX.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param expression	See {@link REGEX.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(expression, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition(
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        (value, target, propertyKey) => {
+            return REGEX.checkAlgorithm(value, expression);
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value "toCheck" and {@link EQ.equivalent }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return REGEX.checkAlgorithm(toCheck, this.expression);
+    }
+    /**
+     * Creates this {@link REGEX } by setting the protected property {@link REGEX.expression } used by {@link REGEX.check }.
+     *
+     * @param expression See {@link REGEX.check }. */
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    // #endregion Referenced Condition checking.
+    // #region In-Method checking.
+    /**
+     * Invokes the {@link JSON_OP.checkAlgorithm } passing the value "toCheck" and {@link JSON_OP.expression }.
+     *
+     * @param toCheck		See {@link JSON_OP.checkAlgorithm} }.
+     * @param expression	See {@link JSON_OP.checkAlgorithm} }.
+     */
+    static check(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toCheck, expression) {
+        const checkResult = REGEX.checkAlgorithm(toCheck, expression);
+        if (typeof checkResult === "string") {
+            throw new DBC.Infringement(checkResult);
+        }
+    }
+}
+/** Stores often used {@link RegExp }s. */
+REGEX.stdExp = {
+    property: /^[$_A-Za-z][$_A-Za-z0-9]*$/,
+    url: /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,}))\.?)(?::\d{2,5})?(?:[/?#]\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*\]))*$/,
+};

package/dist/DBC/TYPE.js

@@ -0,0 +1,75 @@
+import { DBC } from "../DBC.js";
+/**
+ * A {@link DBC } defining that the 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) */
+export class TYPE extends DBC {
+    /**
+     * Checks if the value "toCheck" is of the "type" specified.
+     *
+     * @param toCheck	The {@link Object } which'S "type" to check.
+     * @param type		The type the {@link object} "toCheck" has to be of.
+     *
+     * @returns TRUE if the value "toCheck" is of the specified "type", otherwise FALSE. */
+    // biome-ignore lint/suspicious/noExplicitAny: Necessary for dynamic type checking of also UNDEFINED.
+    static checkAlgorithm(toCheck, type) {
+        // biome-ignore lint/suspicious/useValidTypeof: Necessary
+        if (typeof toCheck !== type) {
+            return `Value has to to be of type "${type}" but is of type "${typeof toCheck}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param type	See {@link TYPE.checkAlgorithm }.
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(type, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            return TYPE.checkAlgorithm(value, type);
+        }, dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link TYPE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param type	See {@link TYPE.checkAlgorithm }.
+     * @param path	See {@link DBC.Postcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(type, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decPostcondition((value, target, propertyKey) => {
+            return TYPE.checkAlgorithm(value, type);
+        }, dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link TYPE.checkAlgorithm } passing the value "toCheck" and the {@link TYPE.type } .
+     *
+     * @param toCheck See {@link TYPE.checkAlgorithm }.
+     *
+     * @returns See {@link TYPE.checkAlgorithm}. */
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    check(toCheck) {
+        return TYPE.checkAlgorithm(toCheck, this.type);
+    }
+    /**
+     * Creates this {@link TYPE } by setting the protected property {@link TYPE.type } used by {@link TYPE.check }.
+     *
+     * @param type See {@link TYPE.check }. */
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+}

package/dist/DBC.js

@@ -0,0 +1,240 @@
+/**
+ * Provides a [D]esign [B]y [C]ontract Framework using decorators.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class DBC {
+    /**
+     * Make a request to get the value of a certain parameter of specific method in a specific {@link object }.
+     * That request gets enlisted in {@link paramValueRequests } which is used by {@link ParamvalueProvider} to invoke the
+     * given "receptor" with the parameter value stored in there. Thus a parameter decorator using this method will
+     * not receive any value of the top method is not tagged with {@link ParamvalueProvider}.
+     *
+     * @param target		The {@link object } containing the method with the parameter which's value is requested.
+     * @param methodName	The name of the method with the parameter which's value is requested.
+     * @param index			The index of the parameter which's value is requested.
+     * @param receptor		The method the requested parameter-value shall be passed to when it becomes available. */
+    static requestParamValue(target, methodName, index, 
+    // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+    receptor) {
+        if (DBC.paramValueRequests.has(target)) {
+            if (DBC.paramValueRequests.get(target).has(methodName)) {
+                if (DBC.paramValueRequests.get(target).get(methodName).has(index)) {
+                    DBC.paramValueRequests
+                        .get(target)
+                        .get(methodName)
+                        .get(index)
+                        .push(receptor);
+                }
+                else {
+                    DBC.paramValueRequests
+                        .get(target)
+                        .get(methodName)
+                        .set(index, new Array(receptor));
+                }
+            }
+            else {
+                DBC.paramValueRequests
+                    .get(target)
+                    .set(methodName, new Map([
+                    [index, new Array(receptor)],
+                ]));
+            }
+        }
+        else {
+            DBC.paramValueRequests.set(target, new Map([
+                [
+                    methodName,
+                    new Map([
+                        [index, new Array(receptor)],
+                    ]),
+                ],
+            ]));
+        }
+        return undefined;
+    }
+    /**
+     * A method-decorator factory checking the {@link paramValueRequests } for value-requests of the method's parameter.
+     * When found it will invoke the "receptor" registered there, inter alia by {@link requestParamValue }, with the
+     * parameter's value.
+     *
+     * @param target 		The {@link object } hosting the tagged method as provided by the runtime.
+     * @param propertyKey 	The tagged method's name as provided by the runtime.
+     * @param descriptor 	The {@link PropertyDescriptor } as provided by the runtime.
+     *
+     * @returns The {@link PropertyDescriptor } that was passed by the runtime. */
+    static ParamvalueProvider(target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+        descriptor.value = (...args) => {
+            // #region	Check if a value of one of the method's parameter has been requested and pass it to the
+            //			receptor, if so.
+            if (DBC.paramValueRequests.has(target) &&
+                DBC.paramValueRequests.get(target).has(propertyKey)) {
+                for (const index of DBC.paramValueRequests
+                    .get(target)
+                    .get(propertyKey)
+                    .keys()) {
+                    if (index < args.length) {
+                        for (const receptor of DBC.paramValueRequests
+                            .get(target)
+                            .get(propertyKey)
+                            .get(index)) {
+                            receptor(args[index]);
+                        }
+                    }
+                }
+            }
+            // #endregion 	Check if a value of one of the method's parameter has been requested and pass it to the
+            // 				receptor, if so.
+            // biome-ignore lint/complexity/noThisInStatic: <explanation>
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    }
+    // #endregion Parameter-value requests.
+    // #region Postcondition
+    /**
+     *
+     * @param check
+     * @param dbc
+     * @param path
+     * @returns
+     */
+    static decPostcondition(
+    // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+    check, dbc, path = undefined) {
+        return (target, propertyKey, descriptor) => {
+            const originalMethod = descriptor.value;
+            // biome-ignore lint/suspicious/noExplicitAny: Gotta be any since parameter-values may be undefined.
+            descriptor.value = (...args) => {
+                // biome-ignore lint/complexity/noThisInStatic: <explanation>
+                const result = originalMethod.apply(this, args);
+                const realValue = path
+                    ? path === null || path === void 0 ? void 0 : path.split(".").reduce((accumulator, current) => accumulator[current], result)
+                    : result;
+                const checkResult = check(realValue, target, propertyKey);
+                if (typeof checkResult === "string") {
+                    DBC.resolveDBCPath(window, dbc).reportReturnvalueInfringement(checkResult, target, path, propertyKey, realValue);
+                }
+                return result;
+            };
+            return descriptor;
+        };
+    }
+    // #endregion Postcondition
+    // #region Decorator
+    // #region Parameter
+    /**
+     * 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 path	The dotted path referring to the actual value to check, starting form the specified one.
+     * @param dbc  	See {@link DBC.resolveDBCPath }.
+     *
+     * @returns The  { (target: object, methodName: string | symbol, parameterIndex: number ) => void } invoked by Typescript- */
+    static decPrecondition(check, dbc, path = undefined) {
+        return (target, methodName, parameterIndex) => {
+            DBC.requestParamValue(target, methodName, parameterIndex, (value) => {
+                const realValue = path
+                    ? path === null || path === void 0 ? void 0 : path.split(".").reduce((accumulator, current) => accumulator[current], value)
+                    : value;
+                const result = check(realValue, target, methodName, parameterIndex);
+                if (typeof result === "string") {
+                    DBC.resolveDBCPath(window, dbc).reportParameterInfringement(result, target, path, methodName, parameterIndex, realValue);
+                }
+            });
+        };
+    }
+    /**
+     * Reports a warning.
+     *
+     * @param message The message containing the warning. */
+    reportWarning(message) {
+        if (this.warningSettings.logToConsole) {
+            console.warn(message);
+        }
+    }
+    /**
+     * Reports an infringement according to the {@link infringementSettings } also generating a proper {@link string }-wrapper
+     * for the given "message" & violator.
+     *
+     * @param message	The {@link string } describing the infringement and it's provenience.
+     * @param violator 	The {@link string } describing or naming the violator. */
+    reportInfringement(message, violator, target, path) {
+        const finalMessage = `[ From "${violator}"${path ? `'s member "${path}"` : ""}${typeof target === "function" ? ` in "${target.name}"` : typeof target === "object" && target !== null && typeof target.constructor === "function" ? ` in "${target.constructor.name}"` : ""}: ${message}]`;
+        if (this.infringementSettings.throwException) {
+            throw new DBC.Infringement(finalMessage);
+        }
+        if (this.infringementSettings.logToConsole) {
+            console.log(finalMessage);
+        }
+    }
+    /**
+     * Reports a parameter-infringement according via {@link reportInfringement } also generating a proper {@link string }-wrapper
+     * for the given "message","method", parameter-"index" & value.
+     *
+     * @param message	The {@link string } describing the infringement and it's provenience.
+     * @param method 	The {@link string } describing or naming the violator.
+     * @param index		The index of the parameter within the argument listing.
+     * @param value 	The parameter's value. */
+    reportParameterInfringement(message, target, path, method, index, value) {
+        const properIndex = index + 1;
+        this.reportInfringement(`[ Parameter-value "${value}" of the ${properIndex}${properIndex === 1 ? "st" : properIndex === 2 ? "nd" : properIndex === 3 ? "rd" : "th"} parameter did not fulfill one of it's contracts: ${message}]`, method, target, path);
+    }
+    /**
+     * Reports a returnvalue-infringement according via {@link reportInfringement } also generating a proper {@link string }-wrapper
+     * for the given "message","method" & value.
+     *
+     * @param message	The {@link string } describing the infringement and it's provenience.
+     * @param method 	The {@link string } describing or naming the violator.
+     * @param value		The parameter's value. */
+    reportReturnvalueInfringement(message, target, path, method, 
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    value) {
+        this.reportInfringement(`[ Return-value "${value}" did not fulfill one of it's contracts: ${message}]`, method, target, path);
+    }
+    /**
+     *
+     * @param infringementSettings
+     */
+    constructor(infringementSettings = { throwException: true, logToConsole: false }) {
+        // #endregion Parameter
+        // #endregion Decorator
+        // #region Warning handling.
+        /** Stores settings concerning warnings. */
+        this.warningSettings = { logToConsole: true };
+        // #endregion Warning handling.
+        // #region infringement handling.
+        /** Stores the setting concerning infringements */
+        this.infringementSettings = { throwException: true, logToConsole: false };
+        this.infringementSettings = infringementSettings;
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        if (window.WaXCode === undefined)
+            window.WaXCode = {};
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        window.WaXCode.DBC = this;
+    }
+}
+// #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.
+DBC.resolveDBCPath = (obj, path) => path === null || path === void 0 ? void 0 : path.split(".").reduce((accumulator, current) => accumulator[current], obj);
+new DBC();

package/dist/DBC.min.js

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export class DBC{constructor(){this.g=0}static decPrecondition(t){return(t,e,o)=>{console.log(`X:${DBC.parameterValues.get(t).get(e)}`),console.log(t)}}static log(t,e,o){const n=o.value;return o.value=function(...o){console.log(`Calling ${t.constructor.name}.${e} with arguments: ${JSON.stringify(o)}`);const s=n.apply(this,o);return console.log(`Result: ${s}`),s},o}}DBC.parameterValues=new Map;

package/dist/test.js

@@ -0,0 +1,110 @@
+var __decorate = (this && this.__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 = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { DBC } from "./DBC.js";
+import { REGEX } from "./DBC/REGEX.js";
+import { EQ } from "./DBC/EQ.js";
+import { TYPE } from "./DBC/TYPE.js";
+import { AE } from "./DBC/AE.js";
+import { INSTANCE } from "./DBC/INSTANCE.js";
+export class Calculator {
+    divide(a, b) {
+        console.log(a);
+        return a;
+    }
+    HT(o) { }
+    type(o) { }
+    array(x) { }
+    regex(x) { }
+    index(x) { }
+    instance(candidate) { }
+    range(x) { }
+    // biome-ignore lint/suspicious/noExplicitAny: Test
+    invert(g) {
+        return null;
+    }
+}
+__decorate([
+    REGEX.POST(/xxxx*/g),
+    DBC.ParamvalueProvider,
+    __param(0, REGEX.PRE(/holla*/g)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number]),
+    __metadata("design:returntype", String)
+], Calculator.prototype, "divide", null);
+__decorate([
+    DBC.ParamvalueProvider,
+    __param(0, EQ.PRE("SELECT", true, "tagName")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [HTMLElement]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "HT", null);
+__decorate([
+    DBC.ParamvalueProvider,
+    __param(0, TYPE.PRE("string")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "type", null);
+__decorate([
+    DBC.ParamvalueProvider,
+    __param(0, AE.PRE([new TYPE("string")])),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "array", null);
+__decorate([
+    DBC.ParamvalueProvider,
+    __param(0, AE.PRE(new REGEX(/^(?i:(NOW)|([+-]\d+[dmy]))$/i))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "regex", null);
+__decorate([
+    DBC.ParamvalueProvider,
+    __param(0, AE.PRE(new REGEX(/^\d$/i), 0)),
+    __param(0, AE.PRE(new REGEX(/^(?i:(NOW)|([+-]\d+[dmy]))$/i), 1)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "index", null);
+__decorate([
+    DBC.ParamvalueProvider
+    // biome-ignore lint/suspicious/noExplicitAny: Test
+    ,
+    __param(0, INSTANCE.PRE(Date)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "instance", null);
+__decorate([
+    DBC.ParamvalueProvider,
+    __param(0, AE.PRE([new TYPE("string"), new REGEX(/^abc$/)], 1, 2)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "range", null);
+__decorate([
+    AE.POST(new EQ(null, true), 0),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], Calculator.prototype, "invert", null);
+console.log("s");
+//new Calculator().divide("xxxx", 1);
+//new Calculator().HT(document.createElement("select"));
+//new Calculator().type("10");
+//new Calculator().array([11, "10", "b"]);
+//new Calculator().index(["1a", "+d1m", "-x10y"]);
+//new Calculator().instance(new Date());
+//new Calculator().range([11, "abc", "abc"]);
+new Calculator().invert("");

package/package.json

@@ -0,0 +1,28 @@
+{
+	"version": "1.0.73",
+	"name": "xdbc",
+	"scripts": {
+		"format": "biome format ./src --write",
+		"lint": "biome check ./",
+		"ci": "biome ci ./"
+	},
+	"devDependencies": {
+		"@types/express": "^5.0.1"
+	},
+	"dependencies": {
+		"undici-types": "^7.7.0"
+	},
+	"description": "A Typescript Design by Contract Framework",
+	"main": "test.js",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/CallariS/XDBC.git"
+	},
+	"keywords": ["DbC", "DesignByContract", "Typescript"],
+	"author": "Callari, Salvatore",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/CallariS/XDBC/issues"
+	},
+	"homepage": "https://github.com/CallariS/XDBC#readme"
+}