xdbc 1.0.217 → 1.0.218

package/src/DBC/DEFINED.ts

@@ -1,122 +1,117 @@
-import { DBC } from "../DBC";
-/**
- * A {@link DBC } defining that an {@link object }s must be defined thus it's value may not be **null** or **undefined**.
- *
- * @remarks
- * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
-export class DEFINED extends DBC {
-	/**
-	 * Checks if the value **toCheck** is null or undefined.
-	 *
-	 * @param toCheck	The {@link Object } to check.
-	 *
-	 * @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.
-	public static checkAlgorithm(toCheck: any): boolean | string {
-		// biome-ignore lint/suspicious/useValidTypeof: Necessary
-		if (toCheck === undefined || toCheck === null) {
-			return `Value may not be UNDEFINED or NULL but it is ${toCheck === undefined ? "UNDEFINED" : "NULL"}`;
-		}
-
-		return true;
-	}
-	/**
-	 * A parameter-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
-	 * by the tagged parameter.
-	 *
-	 * @param type	See {@link DEFINED.checkAlgorithm }.
-	 * @param path	See {@link DBC.decPrecondition }.
-	 * @param dbc	See {@link DBC.decPrecondition }.
-	 *
-	 * @returns See {@link DBC.decPrecondition }. */
-	public static PRE(
-		path: string | undefined = undefined,
-		hint: string | undefined = undefined,
-		dbc: string | undefined = undefined,
-	): (
-		target: object,
-		methodName: string | symbol | undefined,
-		parameterIndex: number,
-	) => void {
-		return DBC.createPRE(DEFINED.checkAlgorithm, [], dbc, path, hint);
-	}
-	/**
-	 * A method-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
-	 * by the tagged method's returnvalue.
-	 *
-	 * @param type	See {@link DEFINED.checkAlgorithm }.
-	 * @param path	See {@link DBC.Postcondition }.
-	 * @param dbc	See {@link DBC.decPostcondition }.
-	 *
-	 * @returns See {@link DBC.decPostcondition }. */
-	public static POST(
-		type: string,
-		path: string | undefined = undefined,
-		hint: string | undefined = undefined,
-		dbc: string | undefined = undefined,
-	): (
-		target: object,
-		propertyKey: string,
-		descriptor: PropertyDescriptor,
-	) => PropertyDescriptor {
-		return DBC.createPOST(DEFINED.checkAlgorithm, [], dbc, path, hint);
-	}
-	/**
-	 * A field-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
-	 * by the tagged field.
-	 *
-	 * @param type	See {@link DEFINED.checkAlgorithm }.
-	 * @param path	See {@link DBC.decInvariant }.
-	 * @param dbc	See {@link DBC.decInvariant }.
-	 *
-	 * @returns See {@link DBC.decInvariant }. */
-	public static INVARIANT(
-		type: string,
-		path: string | undefined = undefined,
-		hint: string | undefined = undefined,
-		dbc: string | undefined = undefined,
-	) {
-		return DBC.createINVARIANT(DEFINED, [], dbc, path, hint);
-	}
-	// #endregion Condition checking.
-	// #region Referenced Condition checking.
-	//
-	// For usage in dynamic scenarios (like with AE-DBC).
-	//
-	/**
-	 * Invokes the {@link DEFINED.checkAlgorithm } passing the value **toCheck** and the {@link DEFINED.type } .
-	 *
-	 * @param toCheck See {@link DEFINED.checkAlgorithm }.
-	 *
-	 * @returns See {@link DEFINED.checkAlgorithm}. */
-	// biome-ignore lint/suspicious/noExplicitAny: <explanation>
-	public check(toCheck: any) {
-		return DEFINED.checkAlgorithm(toCheck);
-	}
-	/**
-	 * Invokes the {@link DEFINED.checkAlgorithm } passing the value **toCheck** and the {@link DEFINED.type } .
-	 *
-	 * @param toCheck	See {@link DEFINED.checkAlgorithm }.
-	 * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
-	 *
-	 * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link DEFINED }.
-	 *
-	 * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }.*/
-	public static tsCheck<CANDIDATE = unknown>(
-		toCheck: CANDIDATE | undefined | null,
-		hint: string | undefined = undefined,
-		id: string | undefined = undefined,
-		dbc: string | undefined = undefined,
-	): CANDIDATE {
-		const result = DEFINED.checkAlgorithm(toCheck);
-
-		if (result === true) {
-			return toCheck as CANDIDATE;
-		}
-		DBC.reportTsCheckInfringement(
-			`${id ? `(${id}) ` : ""}${result as string}${hint ? ` ✨ ${hint} ✨` : ""}`,
-			dbc,
-		);
-		return toCheck as CANDIDATE;
-	}
-}
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that an {@link object }s must be defined thus it's value may not be **null** or **undefined**.
+ *
+ * @remarks
+ * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
+export class DEFINED extends DBC {
+	/**
+	 * Checks if the value **toCheck** is null or undefined.
+	 *
+	 * @param toCheck	The {@link Object } to check.
+	 *
+	 * @returns TRUE if the value **toCheck** is of the specified **type**, otherwise FALSE. */
+	public static checkAlgorithm(toCheck: any): boolean | string {
+		if (toCheck === undefined || toCheck === null) {
+			return `Value may not be UNDEFINED or NULL but it is ${toCheck === undefined ? "UNDEFINED" : "NULL"}`;
+		}
+		return true;
+	}
+	/**
+	 * A parameter-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+	 * by the tagged parameter.
+	 *
+	 * @param type	See {@link DEFINED.checkAlgorithm }.
+	 * @param path	See {@link DBC.decPrecondition }.
+	 * @param dbc	See {@link DBC.decPrecondition }.
+	 *
+	 * @returns See {@link DBC.decPrecondition }. */
+	public static PRE(
+		path: string | undefined = undefined,
+		hint: string | undefined = undefined,
+		dbc: string | undefined = undefined,
+	): (
+		target: object,
+		methodName: string | symbol | undefined,
+		parameterIndex: number,
+	) => void {
+		return DBC.createPRE(DEFINED.checkAlgorithm, [], dbc, path, hint);
+	}
+	/**
+	 * A method-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+	 * by the tagged method's returnvalue.
+	 *
+	 * @param type	See {@link DEFINED.checkAlgorithm }.
+	 * @param path	See {@link DBC.Postcondition }.
+	 * @param dbc	See {@link DBC.decPostcondition }.
+	 *
+	 * @returns See {@link DBC.decPostcondition }. */
+	public static POST(
+		type: string,
+		path: string | undefined = undefined,
+		hint: string | undefined = undefined,
+		dbc: string | undefined = undefined,
+	): (
+		target: object,
+		propertyKey: string,
+		descriptor: PropertyDescriptor,
+	) => PropertyDescriptor {
+		return DBC.createPOST(DEFINED.checkAlgorithm, [], dbc, path, hint);
+	}
+	/**
+	 * A field-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+	 * by the tagged field.
+	 *
+	 * @param type	See {@link DEFINED.checkAlgorithm }.
+	 * @param path	See {@link DBC.decInvariant }.
+	 * @param dbc	See {@link DBC.decInvariant }.
+	 *
+	 * @returns See {@link DBC.decInvariant }. */
+	public static INVARIANT(
+		type: string,
+		path: string | undefined = undefined,
+		hint: string | undefined = undefined,
+		dbc: string | undefined = undefined,
+	) {
+		return DBC.createINVARIANT(DEFINED, [], dbc, path, hint);
+	}
+	// #endregion Condition checking.
+	// #region Referenced Condition checking.
+	//
+	// For usage in dynamic scenarios (like with AE-DBC).
+	//
+	/**
+	 * Invokes the {@link DEFINED.checkAlgorithm } passing the value **toCheck** and the {@link DEFINED.type } .
+	 *
+	 * @param toCheck See {@link DEFINED.checkAlgorithm }.
+	 *
+	 * @returns See {@link DEFINED.checkAlgorithm}. */
+	public check(toCheck: any) {
+		return DEFINED.checkAlgorithm(toCheck);
+	}
+	/**
+	 * Invokes the {@link DEFINED.checkAlgorithm } passing the value **toCheck** and the {@link DEFINED.type } .
+	 *
+	 * @param toCheck	See {@link DEFINED.checkAlgorithm }.
+	 * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+	 *
+	 * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link DEFINED }.
+	 *
+	 * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }.*/
+	public static tsCheck<CANDIDATE = unknown>(
+		toCheck: CANDIDATE | undefined | null,
+		hint: string | undefined = undefined,
+		id: string | undefined = undefined,
+		dbc: string | undefined = undefined,
+	): CANDIDATE {
+		const result = DEFINED.checkAlgorithm(toCheck);
+		if (result === true) {
+			return toCheck as CANDIDATE;
+		}
+		DBC.reportTsCheckInfringement(
+			`${id ? `(${id}) ` : ""}${result as string}${hint ? ` ✨ ${hint} ✨` : ""}`,
+			dbc,
+		);
+		return toCheck as CANDIDATE;
+	}
+}

package/src/DBC/DOM.ts

@@ -0,0 +1,291 @@
+import { DBC } from "../DBC";
+import { COMPARISON } from "./COMPARISON";
+import { DEFINED } from "./DEFINED";
+import { EQ } from "./EQ";
+import { REGEX } from "./REGEX";
+import { TYPE } from "./TYPE";
+import { UNDEFINED } from "./UNDEFINED";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+/** A check function that receives the current field value and the raw attribute string. */
+export type DOMContractCheck = (
+	value: string,
+	attrValue: string,
+) => boolean | string;
+
+type BoundEntry = {
+	element: HTMLInputElement | HTMLTextAreaElement;
+	inputListener: () => void;
+	compositionStartListener: () => void;
+	compositionEndListener: () => void;
+};
+
+// ─── Contract registry ────────────────────────────────────────────────────────
+
+/**
+ * Maps a `data-xdbc-<key>` attribute suffix to a check function.
+ * Populated by {@link registerDOMContract } and the built-in defaults below.
+ */
+const registry = new Map<string, DOMContractCheck>();
+
+/**
+ * Registers a check function for a `data-xdbc-<key>` attribute.
+ * Call this before {@link scanDOM } to make a contract available declaratively.
+ *
+ * @param key       The attribute suffix (e.g. `"type"` → `data-xdbc-type`).
+ * @param checkFn   Receives the live field value and the raw attribute string.
+ *                  Return `true` when the value is valid, or a `string` message when it is not.
+ *
+ * @example
+ * ```ts
+ * import { registerDOMContract } from "xdbc/DBC/DOM";
+ * import { MY_CONTRACT } from "./MY_CONTRACT";
+ *
+ * registerDOMContract("my-contract", (value, attr) =>
+ *     MY_CONTRACT.checkAlgorithm(value, attr),
+ * );
+ * ```
+ */
+export function registerDOMContract(
+	key: string,
+	checkFn: DOMContractCheck,
+): void {
+	registry.set(key, checkFn);
+}
+
+// ─── Built-in registrations ───────────────────────────────────────────────────
+
+// data-xdbc-regex="^\d*$"
+registerDOMContract("regex", (value, attr) => {
+	let rx: RegExp;
+	try {
+		rx = new RegExp(attr);
+	} catch {
+		return `[XDBC] Invalid RegExp pattern: "${attr}"`;
+	}
+	return REGEX.checkAlgorithm(value, rx);
+});
+
+// data-xdbc-type="string|number"
+registerDOMContract("type", (value, attr) => TYPE.checkAlgorithm(value, attr));
+
+// data-xdbc-eq="hello"
+registerDOMContract("eq", (value, attr) =>
+	EQ.checkAlgorithm(value, attr as unknown as object, false),
+);
+
+// data-xdbc-different="forbidden"
+registerDOMContract("different", (value, attr) =>
+	EQ.checkAlgorithm(value, attr as unknown as object, true),
+);
+
+// data-xdbc-defined  (attribute presence is enough; value ignored)
+registerDOMContract("defined", (value) => DEFINED.checkAlgorithm(value));
+
+// data-xdbc-undefined
+registerDOMContract("undefined", (value) => UNDEFINED.checkAlgorithm(value));
+
+// data-xdbc-greater="5"
+registerDOMContract("greater", (value, attr) =>
+	COMPARISON.checkAlgorithm(Number(value), Number(attr), false, false),
+);
+
+// data-xdbc-greater-or-equal="5"
+registerDOMContract("greater-or-equal", (value, attr) =>
+	COMPARISON.checkAlgorithm(Number(value), Number(attr), true, false),
+);
+
+// data-xdbc-less="100"
+registerDOMContract("less", (value, attr) =>
+	COMPARISON.checkAlgorithm(Number(value), Number(attr), false, true),
+);
+
+// data-xdbc-less-or-equal="100"
+registerDOMContract("less-or-equal", (value, attr) =>
+	COMPARISON.checkAlgorithm(Number(value), Number(attr), true, true),
+);
+
+// data-xdbc-or="regex:^\d+$;;type:string;;eq:42"
+// Fragments are separated by ";;". Each fragment is "<contract-key>:<attr-value>",
+// where the split is on the FIRST ":" only, so colons in the value (e.g. regex) are safe.
+// The OR passes as long as at least one fragment passes.
+registerDOMContract("or", (value, attr) => {
+	const fragments = attr.split(";;");
+	const messages: string[] = [];
+	for (const fragment of fragments) {
+		const colonIdx = fragment.indexOf(":");
+		const key =
+			colonIdx === -1 ? fragment.trim() : fragment.slice(0, colonIdx).trim();
+		const fragAttr = colonIdx === -1 ? "" : fragment.slice(colonIdx + 1);
+		const checkFn = registry.get(key);
+		if (!checkFn) {
+			console.warn(`[XDBC] data-xdbc-or: unknown contract key "${key}"`);
+			continue;
+		}
+		const result = checkFn(value, fragAttr);
+		if (result === true) return true; // short-circuit on first pass
+		if (typeof result === "string") messages.push(result);
+	}
+	return messages.length > 0
+		? `Value did not satisfy any of: ${messages.join(" | ")}`
+		: true;
+});
+
+// ─── scanDOM ──────────────────────────────────────────────────────────────────
+
+/**
+ * Scans the given **root** for `<input>` and `<textarea>` elements marked with the
+ * `data-xdbc` attribute, and binds XDBC contracts to their `input` events (covering
+ * keyboard, paste, IME / mobile on-screen keyboard, voice input, and autofill).
+ *
+ * ### Supported attributes
+ *
+ * | Attribute                  | Example value              | Contract        |
+ * |----------------------------|----------------------------|-----------------|
+ * | `data-xdbc`                | *(path or empty)*          | marker / DBC path |
+ * | `data-xdbc-regex`          | `^\d*$`                    | {@link REGEX}   |
+ * | `data-xdbc-type`           | `string\|number`           | {@link TYPE}    |
+ * | `data-xdbc-eq`             | `hello`                    | {@link EQ}      |
+ * | `data-xdbc-different`      | `forbidden`                | {@link EQ} (inverted) |
+ * | `data-xdbc-defined`        | *(no value needed)*        | {@link DEFINED} |
+ * | `data-xdbc-undefined`      | *(no value needed)*        | {@link UNDEFINED} |
+ * | `data-xdbc-greater`        | `5`                        | {@link COMPARISON} |
+ * | `data-xdbc-greater-or-equal` | `5`                      | {@link COMPARISON} |
+ * | `data-xdbc-less`           | `100`                      | {@link COMPARISON} |
+ * | `data-xdbc-less-or-equal`  | `100`                      | {@link COMPARISON} |
+ * | `data-xdbc-or`             | `regex:^\d+$;;type:string` | {@link OR} (fragment syntax) |
+ *
+ * Use {@link registerDOMContract } to add further contracts at any time.
+ *
+ * ### OR fragment syntax
+ *
+ * Fragments are separated by `;;`. Each fragment is `<contract-key>:<value>`, where the
+ * split is on the **first** `:` only, so colons inside values (e.g. regex) are safe.
+ * The OR passes as long as **at least one** fragment passes.
+ *
+ * ```html
+ * <!-- digits OR exactly "N/A" -->
+ * <input data-xdbc data-xdbc-or="regex:^\d+$;;eq:N/A" />
+ * ```
+ *
+ * ### Behaviour on infringement
+ *
+ * 1. The element's value is **reverted** to the last accepted state (blocking the invalid input).
+ * 2. The configured DBC instance's infringement settings are honoured — `logToConsole`,
+ *    `onInfringement`, and `throwException` all fire in the usual order. Any throw is caught
+ *    internally so it cannot propagate out of the DOM event handler.
+ *
+ * ### IME / composition awareness
+ *
+ * Validation is suspended during IME composition (e.g. CJK input) and runs once after
+ * `compositionend`, so partially composed characters are never incorrectly rejected.
+ *
+ * @param root  Element or Document to scan (default: `document`).
+ * @returns     A cleanup function that removes all bound event listeners.
+ *
+ * @example
+ * ```html
+ * <input type="text" data-xdbc data-xdbc-regex="^\d*$" />
+ * <input type="text" data-xdbc="MyApp.DBC" data-xdbc-type="string" data-xdbc-greater="0" />
+ * <input type="text" data-xdbc data-xdbc-or="regex:^\d+$;;eq:N/A" />
+ * <textarea data-xdbc data-xdbc-regex="^[\w\s]*$"></textarea>
+ * ```
+ * ```ts
+ * import { scanDOM, registerDOMContract } from "xdbc/DBC/DOM";
+ *
+ * const cleanup = scanDOM();
+ * // later:
+ * cleanup();
+ * ```
+ */
+export function scanDOM(root: Element | Document = document): () => void {
+	const bound: BoundEntry[] = [];
+
+	const elements = Array.from(
+		root.querySelectorAll<HTMLInputElement | HTMLTextAreaElement>(
+			"[data-xdbc]",
+		),
+	);
+
+	for (const el of elements) {
+		const dbcPath = el.dataset.xdbc || "WaXCode.DBC";
+
+		// Collect every registered contract that has a corresponding attribute on this element.
+		const checks: Array<{ checkFn: DOMContractCheck; attrValue: string }> = [];
+		for (const [key, checkFn] of registry) {
+			// dataset converts "xdbc-greater-or-equal" → "xdbcGreaterOrEqual" via camelCase.
+			// Build the camelCase key from the registry key.
+			const datasetKey = `xdbc${key
+				.split("-")
+				.map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+				.join("")}`;
+			if (datasetKey in el.dataset) {
+				checks.push({ checkFn, attrValue: el.dataset[datasetKey] ?? "" });
+			}
+		}
+
+		if (checks.length === 0) continue;
+
+		let lastValid = el.value;
+		let composing = false;
+
+		const inputListener = () => {
+			if (composing) return;
+			const value = el.value;
+			for (const { checkFn, attrValue } of checks) {
+				const result = checkFn(value, attrValue);
+				if (typeof result === "string") {
+					el.value = lastValid;
+					try {
+						DBC.getRegistered(dbcPath).reportParameterInfringement(
+							result,
+							el,
+							undefined,
+							el.name || el.id || "input",
+							0,
+							value,
+						);
+					} catch {
+						// swallowed — throwException must not propagate out of a DOM event handler
+					}
+					return; // stop checking further contracts once one fails
+				}
+			}
+			lastValid = value;
+		};
+
+		const compositionStartListener = () => {
+			composing = true;
+		};
+
+		const compositionEndListener = () => {
+			composing = false;
+			inputListener();
+		};
+
+		el.addEventListener("input", inputListener);
+		el.addEventListener("compositionstart", compositionStartListener);
+		el.addEventListener("compositionend", compositionEndListener);
+
+		bound.push({
+			element: el,
+			inputListener,
+			compositionStartListener,
+			compositionEndListener,
+		});
+	}
+
+	return () => {
+		for (const {
+			element,
+			inputListener,
+			compositionStartListener,
+			compositionEndListener,
+		} of bound) {
+			element.removeEventListener("input", inputListener);
+			element.removeEventListener("compositionstart", compositionStartListener);
+			element.removeEventListener("compositionend", compositionEndListener);
+		}
+	};
+}

package/src/DBC/EQ/DIFFERENT.ts

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