@augment-vir/assert 31.9.1 → 31.9.3

package/dist/assertions/boundary.js

@@ -79,8 +79,20 @@ const assertions = {
      *
      * assert.endsWith('ab', 'b'); // passes
      * assert.endsWith('ab', 'a'); // fails
-     * assert.endsWith(['a', 'b'], 'b'); // passes
-     * assert.endsWith(['a', 'b'], 'a'); // fails
+     * assert.endsWith(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'b',
+     * ); // passes
+     * assert.endsWith(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'a',
+     * ); // fails
      * ```
      *
      * @throws {@link AssertionError} If the parent does not end with the child.
@@ -102,8 +114,20 @@ const assertions = {
      *
      * assert.endsWithout('ab', 'b'); // fails
      * assert.endsWithout('ab', 'a'); // passes
-     * assert.endsWithout(['a', 'b'], 'b'); // fails
-     * assert.endsWithout(['a', 'b'], 'a'); // passes
+     * assert.endsWithout(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'b',
+     * ); // fails
+     * assert.endsWithout(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'a',
+     * ); // passes
      * ```
      *
      * @throws {@link AssertionError} If the parent ends with the child.
@@ -125,8 +149,20 @@ const assertions = {
      *
      * assert.startsWith('ab', 'b'); // fails
      * assert.startsWith('ab', 'a'); // passes
-     * assert.startsWith(['a', 'b'], 'b'); // fails
-     * assert.startsWith(['a', 'b'], 'a'); // passes
+     * assert.startsWith(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'b',
+     * ); // fails
+     * assert.startsWith(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'a',
+     * ); // passes
      * ```
      *
      * @throws {@link AssertionError} If the parent does not start with the child.
@@ -148,8 +184,20 @@ const assertions = {
      *
      * assert.startsWith('ab', 'b'); // passes
      * assert.startsWith('ab', 'a'); // fails
-     * assert.startsWith(['a', 'b'], 'b'); // passes
-     * assert.startsWith(['a', 'b'], 'a'); // fails
+     * assert.startsWith(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'b',
+     * ); // passes
+     * assert.startsWith(
+     *     [
+     *         'a',
+     *         'b',
+     *     ],
+     *     'a',
+     * ); // fails
      * ```
      *
      * @throws {@link AssertionError} If the parent does start with the child.
@@ -175,8 +223,20 @@ export const boundaryGuards = {
          *
          * check.endsWith('ab', 'b'); // returns `true`
          * check.endsWith('ab', 'a'); // returns `false`
-         * check.endsWith(['a', 'b'], 'b'); // returns `true`
-         * check.endsWith(['a', 'b'], 'a'); // returns `false`
+         * check.endsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `true`
+         * check.endsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `false`
          * ```
          *
          * @see
@@ -202,8 +262,20 @@ export const boundaryGuards = {
          *
          * check.endsWithout('ab', 'b'); // returns `false`
          * check.endsWithout('ab', 'a'); // returns `true`
-         * check.endsWithout(['a', 'b'], 'b'); // returns `false`
-         * check.endsWithout(['a', 'b'], 'a'); // returns `true`
+         * check.endsWithout(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `false`
+         * check.endsWithout(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `true`
          * ```
          *
          * @see
@@ -229,8 +301,20 @@ export const boundaryGuards = {
          *
          * check.startsWith('ab', 'b'); // returns `false`
          * check.startsWith('ab', 'a'); // returns `true`
-         * check.startsWith(['a', 'b'], 'b'); // returns `false`
-         * check.startsWith(['a', 'b'], 'a'); // returns `true`
+         * check.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `false`
+         * check.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `true`
          * ```
          *
          * @see
@@ -256,8 +340,20 @@ export const boundaryGuards = {
          *
          * check.startsWith('ab', 'b'); // returns `false`
          * check.startsWith('ab', 'a'); // returns `true`
-         * check.startsWith(['a', 'b'], 'b'); // returns `false`
-         * check.startsWith(['a', 'b'], 'a'); // returns `true`
+         * check.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `false`
+         * check.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `true`
          * ```
          *
          * @see
@@ -285,8 +381,20 @@ export const boundaryGuards = {
          *
          * assertWrap.endsWith('ab', 'b'); // returns `'ab'`
          * assertWrap.endsWith('ab', 'a'); // throws an error
-         * assertWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
-         * assertWrap.endsWith(['a', 'b'], 'a'); // throws an error
+         * assertWrap.endsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `['a', 'b']`
+         * assertWrap.endsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // throws an error
          * ```
          *
          * @returns The parent value if it does end with the child.
@@ -320,8 +428,20 @@ export const boundaryGuards = {
          *
          * assertWrap.endsWithout('ab', 'b'); // throws an error
          * assertWrap.endsWithout('ab', 'a'); // returns `'ab'`
-         * assertWrap.endsWithout(['a', 'b'], 'b'); // throws an error
-         * assertWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
+         * assertWrap.endsWithout(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // throws an error
+         * assertWrap.endsWithout(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `['a', 'b']`
          * ```
          *
          * @returns The parent value if it does not end with the child.
@@ -354,8 +474,20 @@ export const boundaryGuards = {
          *
          * assertWrap.startsWith('ab', 'b'); // throws an error
          * assertWrap.startsWith('ab', 'a'); // returns `'ab'`
-         * assertWrap.startsWith(['a', 'b'], 'b'); // throws an error
-         * assertWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
+         * assertWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // throws an error
+         * assertWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `['a', 'b']`
          * ```
          *
          * @returns The parent value if it starts with the child.
@@ -388,8 +520,20 @@ export const boundaryGuards = {
          *
          * assertWrap.startsWith('ab', 'b'); // returns `'ab'`
          * assertWrap.startsWith('ab', 'a'); // throws an error
-         * assertWrap.startsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
-         * assertWrap.startsWith(['a', 'b'], 'a'); // throws an error
+         * assertWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `['a', 'b']`
+         * assertWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // throws an error
          * ```
          *
          * @returns The parent value if it does not start with the child.
@@ -425,8 +569,20 @@ export const boundaryGuards = {
          *
          * checkWrap.endsWith('ab', 'b'); // returns `'ab'`
          * checkWrap.endsWith('ab', 'a'); // returns `undefined`
-         * checkWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
-         * checkWrap.endsWith(['a', 'b'], 'a'); // returns `undefined`
+         * checkWrap.endsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `['a', 'b']`
+         * checkWrap.endsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `undefined`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -464,8 +620,20 @@ export const boundaryGuards = {
          *
          * checkWrap.endsWithout('ab', 'b'); // returns `undefined`
          * checkWrap.endsWithout('ab', 'a'); // returns `'ab'`
-         * checkWrap.endsWithout(['a', 'b'], 'b'); // returns `undefined`
-         * checkWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`
+         * checkWrap.endsWithout(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `undefined`
+         * checkWrap.endsWithout(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `['a', 'b']`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -503,8 +671,20 @@ export const boundaryGuards = {
          *
          * checkWrap.startsWith('ab', 'b'); // returns `undefined`
          * checkWrap.startsWith('ab', 'a'); // returns `'ab'`
-         * checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
-         * checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
+         * checkWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `undefined`
+         * checkWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `['a', 'b']`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -542,8 +722,20 @@ export const boundaryGuards = {
          *
          * checkWrap.startsWith('ab', 'b'); // returns `undefined`
          * checkWrap.startsWith('ab', 'a'); // returns `'ab'`
-         * checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
-         * checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`
+         * checkWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'b',
+         * ); // returns `undefined`
+         * checkWrap.startsWith(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     'a',
+         * ); // returns `['a', 'b']`
          * ```
          *
          * @returns The first value if the check passes, otherwise `undefined`.
@@ -583,8 +775,14 @@ export const boundaryGuards = {
          *
          * await waitUntil.endsWith('b', () => 'ab'); // returns `'ab'`
          * await waitUntil.endsWith('a', () => 'ab'); // throws an error
-         * await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
-         * await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
+         * await waitUntil.endsWith('b', () => [
+         *     'a',
+         *     'b',
+         * ]); // returns `['a', 'b']`
+         * await waitUntil.endsWith('a', () => [
+         *     'a',
+         *     'b',
+         * ]); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -608,8 +806,14 @@ export const boundaryGuards = {
          *
          * await waitUntil.endsWith('b', () => 'ab'); // throws an error
          * await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
-         * await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
-         * await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
+         * await waitUntil.endsWith('b', () => [
+         *     'a',
+         *     'b',
+         * ]); // throws an error
+         * await waitUntil.endsWith('a', () => [
+         *     'a',
+         *     'b',
+         * ]); // returns `['a', 'b']`
          * ```
          *
          * @returns The callback output once it passes.
@@ -633,8 +837,14 @@ export const boundaryGuards = {
          *
          * await waitUntil.endsWith('b', () => 'ab'); // throws an error
          * await waitUntil.endsWith('a', () => 'ab'); // returns `'ab'`
-         * await waitUntil.endsWith('b', () => ['a', 'b']); // throws an error
-         * await waitUntil.endsWith('a', () => ['a', 'b']); // returns `['a', 'b']`
+         * await waitUntil.endsWith('b', () => [
+         *     'a',
+         *     'b',
+         * ]); // throws an error
+         * await waitUntil.endsWith('a', () => [
+         *     'a',
+         *     'b',
+         * ]); // returns `['a', 'b']`
          * ```
          *
          * @returns The callback output once it passes.
@@ -657,8 +867,14 @@ export const boundaryGuards = {
          * ```ts
          * await waitUntil.endsWith('b', () => 'ab'); // returns `'ab'`
          * await waitUntil.endsWith('a', () => 'ab'); // throws an error
-         * await waitUntil.endsWith('b', () => ['a', 'b']); // returns `['a', 'b']`
-         * await waitUntil.endsWith('a', () => ['a', 'b']); // throws an error
+         * await waitUntil.endsWith('b', () => [
+         *     'a',
+         *     'b',
+         * ]); // returns `['a', 'b']`
+         * await waitUntil.endsWith('a', () => [
+         *     'a',
+         *     'b',
+         * ]); // throws an error
          * ```
          *
          * @returns The callback output once it passes.

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

@@ -38,7 +38,10 @@ const assertions = {
         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)]));
+        const allKeys = Array.from(new Set([
+            ...Reflect.ownKeys(actual),
+            ...Reflect.ownKeys(expected),
+        ]));
         allKeys.forEach((key) => {
             const actualValue = actual[key];
             const expectedValue = expected[key];
@@ -79,7 +82,10 @@ const assertions = {
         if (!actual || typeof actual !== 'object' || !expected || typeof expected !== 'object') {
             return;
         }
-        const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+        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];
@@ -129,7 +135,10 @@ export const entryEqualityGuards = {
                 typeof expected !== 'object') {
                 return false;
             }
-            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            const allKeys = Array.from(new Set([
+                ...Reflect.ownKeys(actual),
+                ...Reflect.ownKeys(expected),
+            ]));
             return allKeys.every((key) => {
                 const actualValue = actual[key];
                 const expectedValue = expected[key];
@@ -172,7 +181,10 @@ export const entryEqualityGuards = {
                 typeof expected !== 'object') {
                 return true;
             }
-            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            const allKeys = Array.from(new Set([
+                ...Reflect.ownKeys(actual),
+                ...Reflect.ownKeys(expected),
+            ]));
             return allKeys.some((key) => {
                 const actualValue = actual[key];
                 const expectedValue = expected[key];
@@ -218,7 +230,10 @@ export const entryEqualityGuards = {
             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)]));
+            const allKeys = Array.from(new Set([
+                ...Reflect.ownKeys(actual),
+                ...Reflect.ownKeys(expected),
+            ]));
             allKeys.forEach((key) => {
                 const actualValue = actual[key];
                 const expectedValue = expected[key];
@@ -266,7 +281,10 @@ export const entryEqualityGuards = {
                 typeof expected !== 'object') {
                 return actual;
             }
-            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            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];
@@ -319,7 +337,10 @@ export const entryEqualityGuards = {
                 typeof expected !== 'object') {
                 return undefined;
             }
-            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            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];
@@ -370,7 +391,10 @@ export const entryEqualityGuards = {
                 typeof expected !== 'object') {
                 return actual;
             }
-            const allKeys = Array.from(new Set([...Reflect.ownKeys(actual), ...Reflect.ownKeys(expected)]));
+            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];

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

@@ -11,10 +11,10 @@ type AssertTypeOf<TestingType> = {
     }>['branded']['toEqualTypeOf'];
     matches: ExpectTypeOf<TestingType, {
         positive: true;
-    }>['toMatchTypeOf'];
+    }>['toExtend'];
     notMatches: ExpectTypeOf<TestingType, {
         positive: false;
-    }>['toMatchTypeOf'];
+    }>['toExtend'];
 };
 declare function tsType<Actual>(
 /** Run-time value to type check. */