@augment-vir/assert 30.8.4 → 31.0.1

package/dist/assertions/equality/entry-equality.js

@@ -1,43 +1,94 @@
 import { stringify } from '@augment-vir/core';
 import { AssertionError } from '../../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../../guard-types/guard-override.js';
-import { strictEquals } from './simple-equality.js';
-function entriesEqual(actual, expected, failureMessage) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!actual || typeof actual !== 'object') {
-        throw new AssertionError(`${stringify(actual)} is not an object.`, failureMessage);
+import { createWaitUntil } from '../../guard-types/wait-until-function.js';
+const assertions = {
+    /**
+     * Asserts that two objects are deeply equal by checking only their top-level values for strict
+     * (non-deep, reference, using
+     * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using))
+     * equality.
+     *
+     * Type guards the first value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.entriesEqual({a: 'a'}, {a: 'a'}); // passes
+     *
+     * assert.entriesEqual({a: {b: 'b'}}, {a: {b: 'b'}}); // fails
+     *
+     * const bExample = {b: 'b'};
+     * assert.entriesEqual({a: bExample}, {a: bExample}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are not equal.
+     * @see
+     * - {@link assert.notEntriesEqual} : the opposite assertion.
+     * - {@link assert.jsonEquals} : another deep equality assertion.
+     * - {@link assert.deepEquals} : the most thorough (but also slow) deep equality assertion.
+     */
+    entriesEqual(actual, expected, failureMessage) {
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    }
-    else if (!expected || typeof expected !== 'object') {
-        throw new AssertionError(`${stringify(expected)} is not an object.`, failureMessage);
-    }
-    const allKeys = Array.from(new Set([
-        ...Reflect.ownKeys(actual),
-        ...Reflect.ownKeys(expected),
-    ]));
-    allKeys.forEach((key) => {
-        const actualValue = actual[key];
-        const expectedValue = expected[key];
-        try {
-            strictEquals(actualValue, expectedValue);
+        if (!actual || typeof actual !== 'object') {
+            throw new AssertionError(`${stringify(actual)} is not an object.`, failureMessage);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         }
-        catch {
-            throw new AssertionError(`Entries are not equal at key '${String(key)}'.`, failureMessage);
+        else if (!expected || typeof expected !== 'object') {
+            throw new AssertionError(`${stringify(expected)} is not an object.`, failureMessage);
         }
-    });
-}
-function notEntriesEqual(actual, expected, failureMessage) {
-    try {
-        entriesEqual(actual, expected);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError('Entries are equal.', failureMessage);
-}
-const assertions = {
-    entriesEqual,
-    notEntriesEqual,
+        const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+        allKeys.forEach((key) => {
+            const actualValue = actual[key];
+            const expectedValue = expected[key];
+            if (actualValue !== expectedValue) {
+                throw new AssertionError(`Entries are not equal at key '${String(key)}'.`, failureMessage);
+            }
+        });
+    },
+    /**
+     * Asserts that two objects are _not_ deeply equal by checking only their top-level values for
+     * strict (non-deep, reference, using
+     * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using))
+     * equality.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.notEntriesEqual({a: 'a'}, {a: 'a'}); // fails
+     *
+     * assert.notEntriesEqual({a: {b: 'b'}}, {a: {b: 'b'}}); // passes
+     *
+     * const bExample = {b: 'b'};
+     * assert.notEntriesEqual({a: bExample}, {a: bExample}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are equal.
+     * @see
+     * - {@link assert.entriesEqual} : the opposite assertion.
+     * - {@link assert.notJsonEquals} : another not deep equality assertion.
+     * - {@link assert.notDeepEquals} : the most thorough (but also slow) not deep equality assertion.
+     */
+    notEntriesEqual(actual, expected, failureMessage) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!actual || typeof actual !== 'object' || !expected || typeof expected !== 'object') {
+            return;
+        }
+        const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+        const valid = allKeys.some((key) => {
+            const actualValue = actual[key];
+            const expectedValue = expected[key];
+            return actualValue !== expectedValue;
+        });
+        if (!valid) {
+            throw new AssertionError('Entries are equal.', failureMessage);
+        }
+    },
 };
 export const entryEqualityGuards = {
     assert: assertions,
@@ -68,7 +119,23 @@ export const entryEqualityGuards = {
          * - {@link check.jsonEquals} : another deep equality check.
          * - {@link check.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        entriesEqual: autoGuard(),
+        entriesEqual(actual, expected) {
+            if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !actual ||
+                typeof actual !== 'object' ||
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                !expected ||
+                typeof expected !== 'object') {
+                return false;
+            }
+            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            return allKeys.every((key) => {
+                const actualValue = actual[key];
+                const expectedValue = expected[key];
+                return actualValue === expectedValue;
+            });
+        },
         /**
          * Checks that two objects are _not_ deeply equal by checking only their top-level values
          * for strict (non-deep, reference, using
@@ -95,7 +162,23 @@ export const entryEqualityGuards = {
          * - {@link check.notJsonEquals} : another not deep equality check.
          * - {@link check.notDeepEquals} : the most thorough (but also slow) not deep equality check.
          */
-        notEntriesEqual: autoGuardSymbol,
+        notEntriesEqual(actual, expected) {
+            if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !actual ||
+                typeof actual !== 'object' ||
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                !expected ||
+                typeof expected !== 'object') {
+                return true;
+            }
+            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            return allKeys.some((key) => {
+                const actualValue = actual[key];
+                const expectedValue = expected[key];
+                return actualValue !== expectedValue;
+            });
+        },
     },
     assertWrap: {
         /**
@@ -126,7 +209,25 @@ export const entryEqualityGuards = {
          * - {@link assertWrap.jsonEquals} : another deep equality assertion.
          * - {@link assertWrap.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        entriesEqual: autoGuard(),
+        entriesEqual(actual, expected, failureMessage) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (!actual || typeof actual !== 'object') {
+                throw new AssertionError(`${stringify(actual)} is not an object.`, failureMessage);
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            }
+            else if (!expected || typeof expected !== 'object') {
+                throw new AssertionError(`${stringify(expected)} is not an object.`, failureMessage);
+            }
+            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            allKeys.forEach((key) => {
+                const actualValue = actual[key];
+                const expectedValue = expected[key];
+                if (actualValue !== expectedValue) {
+                    throw new AssertionError(`Entries are not equal at key '${String(key)}'.`, failureMessage);
+                }
+            });
+            return actual;
+        },
         /**
          * Asserts that two objects are _not_ deeply equal by checking only their top-level values
          * for strict (non-deep, reference, using
@@ -155,7 +256,29 @@ export const entryEqualityGuards = {
          * - {@link assertWrap.notJsonEquals} : another not deep equality assertion.
          * - {@link assertWrap.notDeepEquals} : the most thorough (but also slow) not deep equality assertion.
          */
-        notEntriesEqual: autoGuardSymbol,
+        notEntriesEqual(actual, expected, failureMessage) {
+            if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !actual ||
+                typeof actual !== 'object' ||
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                !expected ||
+                typeof expected !== 'object') {
+                return actual;
+            }
+            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            const valid = allKeys.some((key) => {
+                const actualValue = actual[key];
+                const expectedValue = expected[key];
+                return actualValue !== expectedValue;
+            });
+            if (valid) {
+                return actual;
+            }
+            else {
+                throw new AssertionError('Entries are equal.', failureMessage);
+            }
+        },
     },
     checkWrap: {
         /**
@@ -186,7 +309,29 @@ export const entryEqualityGuards = {
          * - {@link checkWrap.jsonEquals} : another deep equality check.
          * - {@link checkWrap.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        entriesEqual: autoGuard(),
+        entriesEqual(actual, expected) {
+            if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !actual ||
+                typeof actual !== 'object' ||
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                !expected ||
+                typeof expected !== 'object') {
+                return undefined;
+            }
+            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            const valid = allKeys.every((key) => {
+                const actualValue = actual[key];
+                const expectedValue = expected[key];
+                return actualValue === expectedValue;
+            });
+            if (valid) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that two objects are _not_ deeply equal by checking only their top-level values
          * for strict (non-deep, reference, using
@@ -215,7 +360,29 @@ export const entryEqualityGuards = {
          * - {@link checkWrap.notJsonEquals} : another not deep equality check.
          * - {@link checkWrap.notDeepEquals} : the most thorough (but also slow) not deep equality check.
          */
-        notEntriesEqual: autoGuardSymbol,
+        notEntriesEqual(actual, expected) {
+            if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !actual ||
+                typeof actual !== 'object' ||
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                !expected ||
+                typeof expected !== 'object') {
+                return actual;
+            }
+            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            const valid = allKeys.some((key) => {
+                const actualValue = actual[key];
+                const expectedValue = expected[key];
+                return actualValue !== expectedValue;
+            });
+            if (valid) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -252,7 +419,7 @@ export const entryEqualityGuards = {
          * - {@link waitUntil.jsonEquals} : another deep equality assertion.
          * - {@link waitUntil.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        entriesEqual: autoGuard(),
+        entriesEqual: createWaitUntil(assertions.entriesEqual),
         /**
          * Repeatedly calls a callback until its output is _not_ deeply equal to the first input by
          * checking only their top-level values for strict (non-deep, reference, using
@@ -288,6 +455,6 @@ export const entryEqualityGuards = {
          * - {@link waitUntil.notJsonEquals} : another not deep equality assertion.
          * - {@link waitUntil.notDeepEquals} : the most thorough (but also slow) not deep equality assertion.
          */
-        notEntriesEqual: autoGuardSymbol,
+        notEntriesEqual: createWaitUntil(assertions.notEntriesEqual),
     },
 };

package/dist/assertions/equality/json-equality.d.ts

@@ -1,8 +1,5 @@
 import { type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
-import { autoGuardSymbol } from '../../guard-types/guard-override.js';
-import { type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
-declare function jsonEquals<const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined): asserts actual is Expected;
-declare function notJsonEquals(actual: unknown, expected: unknown, failureMessage?: string | undefined): void;
+import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
 export declare const jsonEqualityGuards: {
     assert: {
         /**
@@ -28,7 +25,7 @@ export declare const jsonEqualityGuards: {
          * - {@link assert.entriesEqual} : another deep equality assertion.
          * - {@link assert.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        jsonEquals: typeof jsonEquals;
+        jsonEquals<const Actual, const Expected extends Actual>(this: void, actual: Actual, expected: Expected, failureMessage?: string | undefined): asserts actual is Expected;
         /**
          * Asserts that two values are _not_ deeply equal when stringified into JSON. This may not make
          * any sense if the values are not valid JSON. This internally sorts all given object keys so it
@@ -52,7 +49,7 @@ export declare const jsonEqualityGuards: {
          * - {@link assert.entriesEqual} : another deep equality assertion.
          * - {@link assert.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        notJsonEquals: typeof notJsonEquals;
+        notJsonEquals(this: void, actual: unknown, expected: unknown, failureMessage?: string | undefined): void;
     };
     check: {
         /**
@@ -77,7 +74,7 @@ export declare const jsonEqualityGuards: {
          * - {@link check.entriesEqual} : another deep equality check.
          * - {@link check.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+        jsonEquals<Actual, Expected extends Actual>(this: void, actual: Actual, expected: Expected): actual is Expected;
         /**
          * Checks that two values are _not_ deeply equal when stringified into JSON. This may not
          * make any sense if the values are not valid JSON. This internally sorts all given object
@@ -100,7 +97,7 @@ export declare const jsonEqualityGuards: {
          * - {@link check.entriesEqual} : another deep equality check.
          * - {@link check.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        notJsonEquals: typeof autoGuardSymbol;
+        notJsonEquals(this: void, actual: unknown, expected: unknown): boolean;
     };
     assertWrap: {
         /**
@@ -127,7 +124,7 @@ export declare const jsonEqualityGuards: {
          * - {@link assertWrap.entriesEqual} : another deep equality assertion.
          * - {@link assertWrap.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => NarrowToExpected<Actual, Expected>;
+        jsonEquals<Actual, Expected extends Actual>(this: void, actual: Actual, expected: Expected, failureMessage?: string | undefined): NarrowToExpected<Actual, Expected>;
         /**
          * Asserts that two values are _not_ deeply equal when stringified into JSON. This may not
          * make any sense if the values are not valid JSON. This internally sorts all given object
@@ -152,7 +149,7 @@ export declare const jsonEqualityGuards: {
          * - {@link assertWrap.entriesEqual} : another deep equality assertion.
          * - {@link assertWrap.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        notJsonEquals: typeof autoGuardSymbol;
+        notJsonEquals<Actual>(this: void, actual: Actual, expected: unknown, failureMessage?: string | undefined): Actual;
     };
     checkWrap: {
         /**
@@ -178,7 +175,7 @@ export declare const jsonEqualityGuards: {
          * - {@link checkWrap.entriesEqual} : another deep equality check.
          * - {@link checkWrap.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => NarrowToExpected<Actual, Expected> | undefined;
+        jsonEquals<Actual, Expected extends Actual>(this: void, actual: Actual, expected: Expected): NarrowToExpected<Actual, Expected> | undefined;
         /**
          * Checks that two values are _not_ deeply equal when stringified into JSON. This may not
          * make any sense if the values are not valid JSON. This internally sorts all given object
@@ -202,7 +199,7 @@ export declare const jsonEqualityGuards: {
          * - {@link checkWrap.entriesEqual} : another deep equality check.
          * - {@link checkWrap.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        notJsonEquals: typeof autoGuardSymbol;
+        notJsonEquals<Actual>(this: void, actual: Actual, expected: unknown): Actual | undefined;
     };
     waitUntil: {
         /**
@@ -234,7 +231,7 @@ export declare const jsonEqualityGuards: {
          * - {@link waitUntil.entriesEqual} : another deep equality assertion.
          * - {@link waitUntil.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        jsonEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, Expected>>;
+        jsonEquals: <Actual, Expected extends Actual>(this: void, expected: Expected, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, Expected>>;
         /**
          * Repeatedly calls a callback until its output is _not_ deeply equal to the first input
          * when stringified into JSON. This may not make any sense if the values are not valid JSON.
@@ -265,7 +262,6 @@ export declare const jsonEqualityGuards: {
          * - {@link waitUntil.entriesEqual} : another not deep equality assertion.
          * - {@link waitUntil.deepEquals} : the most thorough (but also slow) not deep equality assertion.
          */
-        notJsonEquals: typeof autoGuardSymbol;
+        notJsonEquals: <Actual>(this: void, expected: unknown, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Actual>;
     };
 };
-export {};

package/dist/assertions/equality/json-equality.js

@@ -1,30 +1,40 @@
 import { extractErrorMessage, } from '@augment-vir/core';
 import { AssertionError } from '../../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../../guard-types/guard-override.js';
+import { createWaitUntil } from '../../guard-types/wait-until-function.js';
 function baseJsonEquals(a, b) {
     return JSON.stringify(a) === JSON.stringify(b);
 }
-function jsonEquals(actual, expected, failureMessage) {
-    try {
-        recursiveJsonEquals(actual, expected);
-    }
-    catch (error) {
-        throw new AssertionError(extractErrorMessage(error), failureMessage);
-    }
-}
-function notJsonEquals(actual, expected, failureMessage) {
-    try {
-        jsonEquals(actual, expected);
-    }
-    catch {
+function recursiveAssertJsonEquals(actual, expected) {
+    if (actual === expected || baseJsonEquals(actual, expected)) {
         return;
     }
-    throw new AssertionError('Values are JSON equal.', failureMessage);
+    if (actual != null &&
+        expected != null &&
+        typeof actual === 'object' &&
+        typeof expected === 'object') {
+        const aKeys = Object.keys(actual).sort();
+        const bKeys = Object.keys(expected).sort();
+        if (aKeys.length !== bKeys.length) {
+            throw new Error('Values are not JSON equal.');
+        }
+        const areKeysEqual = baseJsonEquals(aKeys, bKeys);
+        if (!areKeysEqual) {
+            throw new Error('Values are JSON equal.');
+        }
+        Object.keys(actual).forEach((key) => {
+            try {
+                recursiveAssertJsonEquals(actual[key], expected[key]);
+            }
+            catch (error) {
+                throw new Error(`JSON objects are not equal at key '${key}': ${extractErrorMessage(error)}`);
+            }
+        });
+    }
+    throw new Error('Values are not JSON equal.');
 }
-function recursiveJsonEquals(actual, expected) {
-    const isBaseJsonEqual = baseJsonEquals(actual, expected);
-    if (actual === expected || isBaseJsonEqual) {
-        return;
+function recursiveCheckJsonEquals(actual, expected) {
+    if (actual === expected || baseJsonEquals(actual, expected)) {
+        return true;
     }
     if (actual != null &&
         expected != null &&
@@ -32,26 +42,83 @@ function recursiveJsonEquals(actual, expected) {
         typeof expected === 'object') {
         const aKeys = Object.keys(actual).sort();
         const bKeys = Object.keys(expected).sort();
-        if (aKeys.length || bKeys.length) {
-            const areKeysEqual = baseJsonEquals(aKeys, bKeys);
-            if (!areKeysEqual) {
-                throw new Error('Values are JSON equal.');
-            }
-            Object.keys(actual).forEach((key) => {
-                try {
-                    jsonEquals(actual[key], expected[key]);
-                }
-                catch (error) {
-                    throw new Error(`JSON objects are not equal at key '${key}': ${extractErrorMessage(error)}`);
-                }
-            });
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        const areKeysEqual = baseJsonEquals(aKeys, bKeys);
+        if (!areKeysEqual) {
+            return false;
         }
+        return Object.keys(actual).every((key) => {
+            return recursiveCheckJsonEquals(actual[key], expected[key]);
+        });
     }
-    throw new Error('Values are not JSON equal.');
+    return false;
 }
 const assertions = {
-    jsonEquals,
-    notJsonEquals,
+    /**
+     * Asserts that two values are deeply equal when stringified into JSON. This will fail or may
+     * not make any sense if the values are not valid JSON. This internally sorts all given object
+     * keys so it is insensitive to object key order.
+     *
+     * Type guards the first value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.jsonEquals({a: 'a'}, {a: 'a'}); // passes
+     *
+     * assert.jsonEquals({a: {b: 'b'}}, {a: {b: 'c'}}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are not equal.
+     * @see
+     * - {@link assert.notJsonEquals} : the opposite assertion.
+     * - {@link assert.entriesEqual} : another deep equality assertion.
+     * - {@link assert.deepEquals} : the most thorough (but also slow) deep equality assertion.
+     */
+    jsonEquals(actual, expected, failureMessage) {
+        try {
+            recursiveAssertJsonEquals(actual, expected);
+        }
+        catch (error) {
+            throw new AssertionError(extractErrorMessage(error), failureMessage);
+        }
+    },
+    /**
+     * Asserts that two values are _not_ deeply equal when stringified into JSON. This may not make
+     * any sense if the values are not valid JSON. This internally sorts all given object keys so it
+     * is insensitive to object key order.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.notJsonEquals({a: 'a'}, {a: 'a'}); // fails
+     *
+     * assert.notJsonEquals({a: {b: 'b'}}, {a: {b: 'c'}}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are not equal.
+     * @see
+     * - {@link assert.jsonEquals} : the opposite assertion.
+     * - {@link assert.entriesEqual} : another deep equality assertion.
+     * - {@link assert.deepEquals} : the most thorough (but also slow) deep equality assertion.
+     */
+    notJsonEquals(actual, expected, failureMessage) {
+        try {
+            recursiveAssertJsonEquals(actual, expected);
+        }
+        catch {
+            return;
+        }
+        throw new AssertionError('Values are JSON equal.', failureMessage);
+    },
 };
 export const jsonEqualityGuards = {
     assert: assertions,
@@ -78,7 +145,9 @@ export const jsonEqualityGuards = {
          * - {@link check.entriesEqual} : another deep equality check.
          * - {@link check.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        jsonEquals: autoGuard(),
+        jsonEquals(actual, expected) {
+            return recursiveCheckJsonEquals(actual, expected);
+        },
         /**
          * Checks that two values are _not_ deeply equal when stringified into JSON. This may not
          * make any sense if the values are not valid JSON. This internally sorts all given object
@@ -101,7 +170,9 @@ export const jsonEqualityGuards = {
          * - {@link check.entriesEqual} : another deep equality check.
          * - {@link check.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        notJsonEquals: autoGuardSymbol,
+        notJsonEquals(actual, expected) {
+            return !recursiveCheckJsonEquals(actual, expected);
+        },
     },
     assertWrap: {
         /**
@@ -128,7 +199,15 @@ export const jsonEqualityGuards = {
          * - {@link assertWrap.entriesEqual} : another deep equality assertion.
          * - {@link assertWrap.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        jsonEquals: autoGuard(),
+        jsonEquals(actual, expected, failureMessage) {
+            try {
+                recursiveAssertJsonEquals(actual, expected);
+                return actual;
+            }
+            catch (error) {
+                throw new AssertionError(extractErrorMessage(error), failureMessage);
+            }
+        },
         /**
          * Asserts that two values are _not_ deeply equal when stringified into JSON. This may not
          * make any sense if the values are not valid JSON. This internally sorts all given object
@@ -153,7 +232,15 @@ export const jsonEqualityGuards = {
          * - {@link assertWrap.entriesEqual} : another deep equality assertion.
          * - {@link assertWrap.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        notJsonEquals: autoGuardSymbol,
+        notJsonEquals(actual, expected, failureMessage) {
+            try {
+                recursiveAssertJsonEquals(actual, expected);
+            }
+            catch {
+                return actual;
+            }
+            throw new AssertionError('Values are JSON equal.', failureMessage);
+        },
     },
     checkWrap: {
         /**
@@ -179,7 +266,14 @@ export const jsonEqualityGuards = {
          * - {@link checkWrap.entriesEqual} : another deep equality check.
          * - {@link checkWrap.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        jsonEquals: autoGuard(),
+        jsonEquals(actual, expected) {
+            if (recursiveCheckJsonEquals(actual, expected)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that two values are _not_ deeply equal when stringified into JSON. This may not
          * make any sense if the values are not valid JSON. This internally sorts all given object
@@ -203,7 +297,14 @@ export const jsonEqualityGuards = {
          * - {@link checkWrap.entriesEqual} : another deep equality check.
          * - {@link checkWrap.deepEquals} : the most thorough (but also slow) deep equality check.
          */
-        notJsonEquals: autoGuardSymbol,
+        notJsonEquals(actual, expected) {
+            if (recursiveCheckJsonEquals(actual, expected)) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -235,7 +336,7 @@ export const jsonEqualityGuards = {
          * - {@link waitUntil.entriesEqual} : another deep equality assertion.
          * - {@link waitUntil.deepEquals} : the most thorough (but also slow) deep equality assertion.
          */
-        jsonEquals: autoGuard(),
+        jsonEquals: createWaitUntil(assertions.jsonEquals),
         /**
          * Repeatedly calls a callback until its output is _not_ deeply equal to the first input
          * when stringified into JSON. This may not make any sense if the values are not valid JSON.
@@ -266,6 +367,6 @@ export const jsonEqualityGuards = {
          * - {@link waitUntil.entriesEqual} : another not deep equality assertion.
          * - {@link waitUntil.deepEquals} : the most thorough (but also slow) not deep equality assertion.
          */
-        notJsonEquals: autoGuardSymbol,
+        notJsonEquals: createWaitUntil(assertions.notJsonEquals),
     },
 };