velocious 1.0.428 → 1.0.430

package/build/src/testing/expect-utils.d.ts

@@ -1,42 +1,48 @@
 /**
- * @param {unknown} value - Value.
- * @returns {{__velociousMatcher: string, value: unknown}} - Matcher wrapper.
+ * Runs array containing.
+ * @param {?} value - Value.
+ * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
  */
 export function arrayContaining(value: unknown): {
     __velociousMatcher: string;
     value: unknown;
 };
 /**
- * @param {unknown} value - Value.
+ * Runs is array containing.
+ * @param {?} value - Value.
  * @returns {boolean} - Whether arrayContaining matcher.
  */
 export function isArrayContaining(value: unknown): boolean;
 /**
- * @param {unknown} value - Value.
+ * Runs is object containing.
+ * @param {?} value - Value.
  * @returns {boolean} - Whether objectContaining matcher.
  */
 export function isObjectContaining(value: unknown): boolean;
 /**
- * @param {unknown} actual - Actual value.
- * @param {any[]} expected - Expected values.
- * @returns {{matches: boolean, differences: Record<string, unknown[]>}} - Match result.
+ * Runs match array containing.
+ * @param {?} actual - Actual value.
+ * @param {Array<?>} expected - Expected values.
+ * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
  */
-export function matchArrayContaining(actual: unknown, expected: any[]): {
+export function matchArrayContaining(actual: unknown, expected: Array<unknown>): {
     matches: boolean;
-    differences: Record<string, unknown[]>;
+    differences: Record<string, Array<unknown>>;
 };
 /**
- * @param {unknown} actual - Actual value.
- * @param {Record<string, any> | any[]} expected - Expected value.
- * @returns {{matches: boolean, differences: Record<string, unknown[]>}} - Match result.
+ * Runs match object.
+ * @param {?} actual - Actual value.
+ * @param {Record<string, ?> | Array<?>} expected - Expected value.
+ * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
  */
-export function matchObject(actual: unknown, expected: Record<string, any> | any[]): {
+export function matchObject(actual: unknown, expected: Record<string, unknown> | Array<unknown>): {
     matches: boolean;
-    differences: Record<string, unknown[]>;
+    differences: Record<string, Array<unknown>>;
 };
 /**
- * @param {unknown} value - Value.
- * @returns {{__velociousMatcher: string, value: unknown}} - Matcher wrapper.
+ * Runs object containing.
+ * @param {?} value - Value.
+ * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
  */
 export function objectContaining(value: unknown): {
     __velociousMatcher: string;

package/build/src/testing/expect-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expect-utils.d.ts","sourceRoot":"","sources":["../../../src/testing/expect-utils.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH,uCAHW,OAAO,GACL;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,CAWxD;AAUD;;;GAGG;AACH,yCAHW,OAAO,GACL,OAAO,CAInB;AAED;;;GAGG;AACH,0CAHW,OAAO,GACL,OAAO,CAInB;AAiHD;;;;GAIG;AACH,6CAJW,OAAO,YACP,GAAG,EAAE,GACH;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAA;CAAC,CAuDtE;AA3ED;;;;GAIG;AACH,oCAJW,OAAO,YACP,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,GACzB;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAA;CAAC,CAYtE;AAnKD;;;GAGG;AACH,wCAHW,OAAO,GACL;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,CAWxD"}
+{"version":3,"file":"expect-utils.d.ts","sourceRoot":"","sources":["../../../src/testing/expect-utils.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,uCAHW,OAAC,GACC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAC,CAAA;CAAC,CAWlD;AAWD;;;;GAIG;AACH,yCAHW,OAAC,GACC,OAAO,CAMnB;AAED;;;;GAIG;AACH,0CAHW,OAAC,GACC,OAAO,CAMnB;AAiID;;;;;GAKG;AACH,6CAJW,OAAC,YACD,KAAK,CAAC,OAAC,CAAC,GACN;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAC,CAAC,CAAC,CAAA;CAAC,CA6DrE;AArFD;;;;;GAKG;AACH,oCAJW,OAAC,YACD,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GAAG,KAAK,CAAC,OAAC,CAAC,GAC1B;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAC,CAAC,CAAC,CAAA;CAAC,CAcrE;AA5LD;;;;GAIG;AACH,wCAHW,OAAC,GACC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAC,CAAA;CAAC,CAWlD"}

package/build/src/testing/expect-utils.js

@@ -1,8 +1,9 @@
 // @ts-check
 import { anythingDifferent } from "set-state-compare/build/diff-utils.js";
 /**
- * @param {unknown} value - Value.
- * @returns {{__velociousMatcher: string, value: unknown}} - Matcher wrapper.
+ * Runs object containing.
+ * @param {?} value - Value.
+ * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
  */
 function objectContaining(value) {
     if (value === null || typeof value !== "object") {
@@ -14,8 +15,9 @@ function objectContaining(value) {
     };
 }
 /**
- * @param {unknown} value - Value.
- * @returns {{__velociousMatcher: string, value: unknown}} - Matcher wrapper.
+ * Runs array containing.
+ * @param {?} value - Value.
+ * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
  */
 function arrayContaining(value) {
     if (!Array.isArray(value)) {
@@ -27,28 +29,36 @@ function arrayContaining(value) {
     };
 }
 /**
- * @param {unknown} value - Value.
+ * Runs is object like.
+ * @param {?} value - Value.
  * @returns {boolean} - Whether object-like.
  */
 function isObjectLike(value) {
     return value !== null && typeof value === "object";
 }
 /**
- * @param {unknown} value - Value.
+ * Runs is array containing.
+ * @param {?} value - Value.
  * @returns {boolean} - Whether arrayContaining matcher.
  */
 function isArrayContaining(value) {
-    return !!value && typeof value === "object" && ( /** @type {any} */(value)).__velociousMatcher === "arrayContaining";
+    return !!value && typeof value === "object" && ( /**
+                                                     * Narrows the runtime value to the documented type.
+                                                      @type {?} */(value)).__velociousMatcher === "arrayContaining";
 }
 /**
- * @param {unknown} value - Value.
+ * Runs is object containing.
+ * @param {?} value - Value.
  * @returns {boolean} - Whether objectContaining matcher.
  */
 function isObjectContaining(value) {
-    return !!value && typeof value === "object" && ( /** @type {any} */(value)).__velociousMatcher === "objectContaining";
+    return !!value && typeof value === "object" && ( /**
+                                                     * Narrows the runtime value to the documented type.
+                                                      @type {?} */(value)).__velociousMatcher === "objectContaining";
 }
 /**
- * @param {unknown} value - Value.
+ * Runs is plain object.
+ * @param {?} value - Value.
  * @returns {boolean} - Whether plain object.
  */
 function isPlainObject(value) {
@@ -58,8 +68,9 @@ function isPlainObject(value) {
     return prototype === Object.prototype || prototype === null;
 }
 /**
- * @param {unknown} actual - Actual value.
- * @param {unknown} expected - Expected value.
+ * Runs values equal.
+ * @param {?} actual - Actual value.
+ * @param {?} expected - Expected value.
  * @returns {boolean} - Whether values are equal.
  */
 function valuesEqual(actual, expected) {
@@ -72,19 +83,26 @@ function valuesEqual(actual, expected) {
     return Object.is(actual, expected);
 }
 /**
- * @param {unknown} actual - Actual value.
- * @param {unknown} expected - Expected value.
+ * Runs collect match differences.
+ * @param {?} actual - Actual value.
+ * @param {?} expected - Expected value.
  * @param {string} path - Path.
- * @param {Record<string, unknown[]>} differences - Differences.
+ * @param {Record<string, Array<?>>} differences - Differences.
  * @returns {void} - No return value.
  */
 function collectMatchDifferences(actual, expected, path, differences) {
     if (isObjectContaining(expected)) {
-        collectMatchDifferences(actual, /** @type {any} */ (expected).value, path, differences);
+        collectMatchDifferences(actual, /**
+                                         * Narrows the runtime value to the documented type.
+                                          @type {?} */ (expected).value, path, differences);
         return;
     }
     if (isArrayContaining(expected)) {
-        const { matches } = matchArrayContaining(actual, /** @type {any[]} */ ( /** @type {any} */(expected).value));
+        const { matches } = matchArrayContaining(actual, /**
+                                                        * Narrows the runtime value to the documented type.
+                                                         @type {Array<?>} */ ( /**
+                              * Narrows the runtime value to the documented type.
+                               @type {?} */(expected).value));
         if (!matches) {
             differences[path || "$"] = [expected, actual];
         }
@@ -106,8 +124,12 @@ function collectMatchDifferences(actual, expected, path, differences) {
             differences[path || "$"] = [expected, actual];
             return;
         }
-        const expectedObject = /** @type {Record<string, unknown>} */ (expected);
-        const actualObject = /** @type {Record<string, unknown>} */ (actual);
+        const expectedObject = /**
+                                * Narrows the runtime value to the documented type.
+                                 @type {Record<string, ?>} */ (expected);
+        const actualObject = /**
+                              * Narrows the runtime value to the documented type.
+                               @type {Record<string, ?>} */ (actual);
         for (const key of Object.keys(expectedObject)) {
             const nextPath = path ? `${path}.${key}` : key;
             if (!Object.prototype.hasOwnProperty.call(actualObject, key)) {
@@ -123,12 +145,15 @@ function collectMatchDifferences(actual, expected, path, differences) {
     }
 }
 /**
- * @param {unknown} actual - Actual value.
- * @param {Record<string, any> | any[]} expected - Expected value.
- * @returns {{matches: boolean, differences: Record<string, unknown[]>}} - Match result.
+ * Runs match object.
+ * @param {?} actual - Actual value.
+ * @param {Record<string, ?> | Array<?>} expected - Expected value.
+ * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
  */
 function matchObject(actual, expected) {
-    /** @type {Record<string, unknown[]>} */
+    /**
+     * Differences.
+      @type {Record<string, Array<?>>} */
     const differences = {};
     collectMatchDifferences(actual, expected, "", differences);
     return {
@@ -137,12 +162,15 @@ function matchObject(actual, expected) {
     };
 }
 /**
- * @param {unknown} actual - Actual value.
- * @param {any[]} expected - Expected values.
- * @returns {{matches: boolean, differences: Record<string, unknown[]>}} - Match result.
+ * Runs match array containing.
+ * @param {?} actual - Actual value.
+ * @param {Array<?>} expected - Expected values.
+ * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
  */
 function matchArrayContaining(actual, expected) {
-    /** @type {Record<string, unknown[]>} */
+    /**
+     * Differences.
+      @type {Record<string, Array<?>>} */
     const differences = {};
     if (!Array.isArray(actual)) {
         differences["$"] = [expected, actual];
@@ -155,7 +183,9 @@ function matchArrayContaining(actual, expected) {
             if (usedIndexes.has(i))
                 continue;
             if (isObjectContaining(expectedItem)) {
-                const { matches } = matchObject(actual[i], /** @type {any} */ (expectedItem).value);
+                const { matches } = matchObject(actual[i], /**
+                                                          * Narrows the runtime value to the documented type.
+                                                           @type {?} */ (expectedItem).value);
                 if (matches) {
                     matchedIndex = i;
                     break;
@@ -163,7 +193,9 @@ function matchArrayContaining(actual, expected) {
                 continue;
             }
             if (isArrayContaining(expectedItem)) {
-                const { matches } = matchArrayContaining(actual[i], /** @type {any} */ (expectedItem).value);
+                const { matches } = matchArrayContaining(actual[i], /**
+                                                                   * Narrows the runtime value to the documented type.
+                                                                    @type {?} */ (expectedItem).value);
                 if (matches) {
                     matchedIndex = i;
                     break;
@@ -189,4 +221,4 @@ function matchArrayContaining(actual, expected) {
     };
 }
 export { arrayContaining, isArrayContaining, isObjectContaining, matchArrayContaining, matchObject, objectContaining };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expect-utils.js","sourceRoot":"","sources":["../../../src/testing/expect-utils.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {anythingDifferent} from \"set-state-compare/build/diff-utils.js\"\n\n/**\n * @param {unknown} value - Value.\n * @returns {{__velociousMatcher: string, value: unknown}} - Matcher wrapper.\n */\nfunction objectContaining(value) {\n  if (value === null || typeof value !== \"object\") {\n    throw new Error(`Expected object but got ${typeof value}`)\n  }\n\n  return {\n    __velociousMatcher: \"objectContaining\",\n    value\n  }\n}\n\n/**\n * @param {unknown} value - Value.\n * @returns {{__velociousMatcher: string, value: unknown}} - Matcher wrapper.\n */\nfunction arrayContaining(value) {\n  if (!Array.isArray(value)) {\n    throw new Error(`Expected array but got ${typeof value}`)\n  }\n\n  return {\n    __velociousMatcher: \"arrayContaining\",\n    value\n  }\n}\n\n/**\n * @param {unknown} value - Value.\n * @returns {boolean} - Whether object-like.\n */\nfunction isObjectLike(value) {\n  return value !== null && typeof value === \"object\"\n}\n\n/**\n * @param {unknown} value - Value.\n * @returns {boolean} - Whether arrayContaining matcher.\n */\nfunction isArrayContaining(value) {\n  return !!value && typeof value === \"object\" && (/** @type {any} */ (value)).__velociousMatcher === \"arrayContaining\"\n}\n\n/**\n * @param {unknown} value - Value.\n * @returns {boolean} - Whether objectContaining matcher.\n */\nfunction isObjectContaining(value) {\n  return !!value && typeof value === \"object\" && (/** @type {any} */ (value)).__velociousMatcher === \"objectContaining\"\n}\n\n/**\n * @param {unknown} value - Value.\n * @returns {boolean} - Whether plain object.\n */\nfunction isPlainObject(value) {\n  if (!value || typeof value !== \"object\") return false\n\n  const prototype = Object.getPrototypeOf(value)\n\n  return prototype === Object.prototype || prototype === null\n}\n\n/**\n * @param {unknown} actual - Actual value.\n * @param {unknown} expected - Expected value.\n * @returns {boolean} - Whether values are equal.\n */\nfunction valuesEqual(actual, expected) {\n  if (actual instanceof Date && expected instanceof Date) {\n    return actual.getTime() === expected.getTime()\n  }\n\n  if (actual instanceof RegExp && expected instanceof RegExp) {\n    return actual.source === expected.source && actual.flags === expected.flags\n  }\n\n  return Object.is(actual, expected)\n}\n\n/**\n * @param {unknown} actual - Actual value.\n * @param {unknown} expected - Expected value.\n * @param {string} path - Path.\n * @param {Record<string, unknown[]>} differences - Differences.\n * @returns {void} - No return value.\n */\nfunction collectMatchDifferences(actual, expected, path, differences) {\n  if (isObjectContaining(expected)) {\n    collectMatchDifferences(actual, /** @type {any} */ (expected).value, path, differences)\n    return\n  }\n\n  if (isArrayContaining(expected)) {\n    const {matches} = matchArrayContaining(actual, /** @type {any[]} */ (/** @type {any} */ (expected).value))\n\n    if (!matches) {\n      differences[path || \"$\"] = [expected, actual]\n    }\n\n    return\n  }\n\n  if (Array.isArray(expected)) {\n    if (!Array.isArray(actual)) {\n      differences[path || \"$\"] = [expected, actual]\n      return\n    }\n\n    for (let i = 0; i < expected.length; i++) {\n      const nextPath = `${path}[${i}]`\n      collectMatchDifferences(actual[i], expected[i], nextPath, differences)\n    }\n\n    return\n  }\n\n  if (isPlainObject(expected)) {\n    if (!isObjectLike(actual)) {\n      differences[path || \"$\"] = [expected, actual]\n      return\n    }\n\n    const expectedObject = /** @type {Record<string, unknown>} */ (expected)\n    const actualObject = /** @type {Record<string, unknown>} */ (actual)\n\n    for (const key of Object.keys(expectedObject)) {\n      const nextPath = path ? `${path}.${key}` : key\n\n      if (!Object.prototype.hasOwnProperty.call(actualObject, key)) {\n        differences[nextPath] = [expectedObject[key], undefined]\n        continue\n      }\n\n      collectMatchDifferences(actualObject[key], expectedObject[key], nextPath, differences)\n    }\n\n    return\n  }\n\n  if (!valuesEqual(actual, expected)) {\n    differences[path || \"$\"] = [expected, actual]\n  }\n}\n\n/**\n * @param {unknown} actual - Actual value.\n * @param {Record<string, any> | any[]} expected - Expected value.\n * @returns {{matches: boolean, differences: Record<string, unknown[]>}} - Match result.\n */\nfunction matchObject(actual, expected) {\n  /** @type {Record<string, unknown[]>} */\n  const differences = {}\n\n  collectMatchDifferences(actual, expected, \"\", differences)\n\n  return {\n    matches: Object.keys(differences).length === 0,\n    differences\n  }\n}\n\n/**\n * @param {unknown} actual - Actual value.\n * @param {any[]} expected - Expected values.\n * @returns {{matches: boolean, differences: Record<string, unknown[]>}} - Match result.\n */\nfunction matchArrayContaining(actual, expected) {\n  /** @type {Record<string, unknown[]>} */\n  const differences = {}\n\n  if (!Array.isArray(actual)) {\n    differences[\"$\"] = [expected, actual]\n    return {matches: false, differences}\n  }\n\n  const usedIndexes = new Set()\n\n  for (const expectedItem of expected) {\n    let matchedIndex = -1\n\n    for (let i = 0; i < actual.length; i++) {\n      if (usedIndexes.has(i)) continue\n\n      if (isObjectContaining(expectedItem)) {\n        const {matches} = matchObject(actual[i], /** @type {any} */ (expectedItem).value)\n        if (matches) {\n          matchedIndex = i\n          break\n        }\n        continue\n      }\n\n      if (isArrayContaining(expectedItem)) {\n        const {matches} = matchArrayContaining(actual[i], /** @type {any} */ (expectedItem).value)\n        if (matches) {\n          matchedIndex = i\n          break\n        }\n        continue\n      }\n\n      if (!anythingDifferent(actual[i], expectedItem)) {\n        matchedIndex = i\n        break\n      }\n    }\n\n    if (matchedIndex >= 0) {\n      usedIndexes.add(matchedIndex)\n    } else {\n      differences[\"$\"] = [expected, actual]\n      break\n    }\n  }\n\n  return {\n    matches: Object.keys(differences).length === 0,\n    differences\n  }\n}\n\nexport {\n  arrayContaining,\n  isArrayContaining,\n  isObjectContaining,\n  matchArrayContaining,\n  matchObject,\n  objectContaining\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expect-utils.js","sourceRoot":"","sources":["../../../src/testing/expect-utils.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {anythingDifferent} from \"set-state-compare/build/diff-utils.js\"\n\n/**\n * Runs object containing.\n * @param {?} value - Value.\n * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.\n */\nfunction objectContaining(value) {\n  if (value === null || typeof value !== \"object\") {\n    throw new Error(`Expected object but got ${typeof value}`)\n  }\n\n  return {\n    __velociousMatcher: \"objectContaining\",\n    value\n  }\n}\n\n/**\n * Runs array containing.\n * @param {?} value - Value.\n * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.\n */\nfunction arrayContaining(value) {\n  if (!Array.isArray(value)) {\n    throw new Error(`Expected array but got ${typeof value}`)\n  }\n\n  return {\n    __velociousMatcher: \"arrayContaining\",\n    value\n  }\n}\n\n/**\n * Runs is object like.\n * @param {?} value - Value.\n * @returns {boolean} - Whether object-like.\n */\nfunction isObjectLike(value) {\n  return value !== null && typeof value === \"object\"\n}\n\n/**\n * Runs is array containing.\n * @param {?} value - Value.\n * @returns {boolean} - Whether arrayContaining matcher.\n */\nfunction isArrayContaining(value) {\n  return !!value && typeof value === \"object\" && (/**\n                                                   * Narrows the runtime value to the documented type.\n                                                    @type {?} */ (value)).__velociousMatcher === \"arrayContaining\"\n}\n\n/**\n * Runs is object containing.\n * @param {?} value - Value.\n * @returns {boolean} - Whether objectContaining matcher.\n */\nfunction isObjectContaining(value) {\n  return !!value && typeof value === \"object\" && (/**\n                                                   * Narrows the runtime value to the documented type.\n                                                    @type {?} */ (value)).__velociousMatcher === \"objectContaining\"\n}\n\n/**\n * Runs is plain object.\n * @param {?} value - Value.\n * @returns {boolean} - Whether plain object.\n */\nfunction isPlainObject(value) {\n  if (!value || typeof value !== \"object\") return false\n\n  const prototype = Object.getPrototypeOf(value)\n\n  return prototype === Object.prototype || prototype === null\n}\n\n/**\n * Runs values equal.\n * @param {?} actual - Actual value.\n * @param {?} expected - Expected value.\n * @returns {boolean} - Whether values are equal.\n */\nfunction valuesEqual(actual, expected) {\n  if (actual instanceof Date && expected instanceof Date) {\n    return actual.getTime() === expected.getTime()\n  }\n\n  if (actual instanceof RegExp && expected instanceof RegExp) {\n    return actual.source === expected.source && actual.flags === expected.flags\n  }\n\n  return Object.is(actual, expected)\n}\n\n/**\n * Runs collect match differences.\n * @param {?} actual - Actual value.\n * @param {?} expected - Expected value.\n * @param {string} path - Path.\n * @param {Record<string, Array<?>>} differences - Differences.\n * @returns {void} - No return value.\n */\nfunction collectMatchDifferences(actual, expected, path, differences) {\n  if (isObjectContaining(expected)) {\n    collectMatchDifferences(actual, /**\n                                     * Narrows the runtime value to the documented type.\n                                      @type {?} */ (expected).value, path, differences)\n    return\n  }\n\n  if (isArrayContaining(expected)) {\n    const {matches} = matchArrayContaining(actual, /**\n                                                    * Narrows the runtime value to the documented type.\n                                                     @type {Array<?>} */ (/**\n                                                                           * Narrows the runtime value to the documented type.\n                                                                            @type {?} */ (expected).value))\n\n    if (!matches) {\n      differences[path || \"$\"] = [expected, actual]\n    }\n\n    return\n  }\n\n  if (Array.isArray(expected)) {\n    if (!Array.isArray(actual)) {\n      differences[path || \"$\"] = [expected, actual]\n      return\n    }\n\n    for (let i = 0; i < expected.length; i++) {\n      const nextPath = `${path}[${i}]`\n      collectMatchDifferences(actual[i], expected[i], nextPath, differences)\n    }\n\n    return\n  }\n\n  if (isPlainObject(expected)) {\n    if (!isObjectLike(actual)) {\n      differences[path || \"$\"] = [expected, actual]\n      return\n    }\n\n    const expectedObject = /**\n                            * Narrows the runtime value to the documented type.\n                             @type {Record<string, ?>} */ (expected)\n    const actualObject = /**\n                          * Narrows the runtime value to the documented type.\n                           @type {Record<string, ?>} */ (actual)\n\n    for (const key of Object.keys(expectedObject)) {\n      const nextPath = path ? `${path}.${key}` : key\n\n      if (!Object.prototype.hasOwnProperty.call(actualObject, key)) {\n        differences[nextPath] = [expectedObject[key], undefined]\n        continue\n      }\n\n      collectMatchDifferences(actualObject[key], expectedObject[key], nextPath, differences)\n    }\n\n    return\n  }\n\n  if (!valuesEqual(actual, expected)) {\n    differences[path || \"$\"] = [expected, actual]\n  }\n}\n\n/**\n * Runs match object.\n * @param {?} actual - Actual value.\n * @param {Record<string, ?> | Array<?>} expected - Expected value.\n * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.\n */\nfunction matchObject(actual, expected) {\n  /**\n   * Differences.\n    @type {Record<string, Array<?>>} */\n  const differences = {}\n\n  collectMatchDifferences(actual, expected, \"\", differences)\n\n  return {\n    matches: Object.keys(differences).length === 0,\n    differences\n  }\n}\n\n/**\n * Runs match array containing.\n * @param {?} actual - Actual value.\n * @param {Array<?>} expected - Expected values.\n * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.\n */\nfunction matchArrayContaining(actual, expected) {\n  /**\n   * Differences.\n    @type {Record<string, Array<?>>} */\n  const differences = {}\n\n  if (!Array.isArray(actual)) {\n    differences[\"$\"] = [expected, actual]\n    return {matches: false, differences}\n  }\n\n  const usedIndexes = new Set()\n\n  for (const expectedItem of expected) {\n    let matchedIndex = -1\n\n    for (let i = 0; i < actual.length; i++) {\n      if (usedIndexes.has(i)) continue\n\n      if (isObjectContaining(expectedItem)) {\n        const {matches} = matchObject(actual[i], /**\n                                                  * Narrows the runtime value to the documented type.\n                                                   @type {?} */ (expectedItem).value)\n        if (matches) {\n          matchedIndex = i\n          break\n        }\n        continue\n      }\n\n      if (isArrayContaining(expectedItem)) {\n        const {matches} = matchArrayContaining(actual[i], /**\n                                                           * Narrows the runtime value to the documented type.\n                                                            @type {?} */ (expectedItem).value)\n        if (matches) {\n          matchedIndex = i\n          break\n        }\n        continue\n      }\n\n      if (!anythingDifferent(actual[i], expectedItem)) {\n        matchedIndex = i\n        break\n      }\n    }\n\n    if (matchedIndex >= 0) {\n      usedIndexes.add(matchedIndex)\n    } else {\n      differences[\"$\"] = [expected, actual]\n      break\n    }\n  }\n\n  return {\n    matches: Object.keys(differences).length === 0,\n    differences\n  }\n}\n\nexport {\n  arrayContaining,\n  isArrayContaining,\n  isObjectContaining,\n  matchArrayContaining,\n  matchObject,\n  objectContaining\n}\n"]}

package/build/src/testing/expect.d.ts

@@ -1,136 +1,165 @@
 export default class Expect extends BaseExpect {
     /**
-     * @param {any} object - Object.
+     * Runs constructor.
+     * @param {?} object - Object.
      */
-    constructor(object: any);
+    constructor(object: unknown);
     _object: any;
-    /** @type {Array<Expect | ExpectToChange>} */
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Array<Expect | ExpectToChange>} */
     expectations: Array<Expect | ExpectToChange>;
     /**
+     * Runs and change.
      * @param {function(): Promise<number>} changeCallback - Change callback.
      * @returns {ExpectToChange} - The and change.
      */
     andChange(changeCallback: () => Promise<number>): ExpectToChange;
     /**
+     * Returns not.
      * @returns {this} - A value.
      */
     get not(): this;
     _not: boolean | undefined;
     /**
-     * @param {any} result - Result.
+     * Runs to be.
+     * @param {?} result - Result.
      * @returns {void} - No return value.
      */
-    toBe(result: any): void;
+    toBe(result: unknown): void;
     /**
+     * Runs to be less than.
      * @param {number} result - Result.
      * @returns {void} - No return value.
      */
     toBeLessThan(result: number): void;
     /**
+     * Runs to be less than or equal.
      * @param {number} result - Result.
      * @returns {void} - No return value.
      */
     toBeLessThanOrEqual(result: number): void;
     /**
+     * Runs to be greater than.
      * @param {number} result - Result.
      * @returns {void} - No return value.
      */
     toBeGreaterThan(result: number): void;
     /**
+     * Runs to be greater than or equal.
      * @param {number} result - Result.
      * @returns {void} - No return value.
      */
     toBeGreaterThanOrEqual(result: number): void;
     /**
+     * Runs to be close to.
      * @param {number} result - Result.
      * @param {number} [precision] - Decimal precision.
      * @returns {void} - No return value.
      */
     toBeCloseTo(result: number, precision?: number): void;
     /**
+     * Runs to have length.
      * @param {number} result - Expected length.
      * @returns {void} - No return value.
      */
     toHaveLength(result: number): void;
     /**
+     * Runs to be defined.
      * @returns {void} - No return value.
      */
     toBeDefined(): void;
     /**
-     * @param {new (...args: any[]) => any} klass - Class constructor to check against (e.g. a built-in like Error).
+     * Runs to be instance of.
+     * @param {new (...args: Array<?>) => ?} klass - Class constructor to check against (e.g. a built-in like Error).
      * @returns {void} - No return value.
      */
-    toBeInstanceOf(klass: new (...args: any[]) => any): void;
+    toBeInstanceOf(klass: new (...args: Array<unknown>) => unknown): void;
     /**
+     * Runs to be false.
      * @returns {void} - No return value.
      */
     toBeFalse(): void;
     /**
+     * Runs to be null.
      * @returns {void} - No return value.
      */
     toBeNull(): void;
     /**
+     * Runs to be undefined.
      * @returns {void} - No return value.
      */
     toBeUndefined(): void;
     /**
+     * Runs to be true.
      * @returns {void} - No return value.
      */
     toBeTrue(): void;
     /**
+     * Runs to be truthy.
      * @returns {void} - No return value.
      */
     toBeTruthy(): void;
     /**
+     * Runs to change.
      * @param {function(): Promise<number>} changeCallback - Change callback.
      * @returns {ExpectToChange} - The change.
      */
     toChange(changeCallback: () => Promise<number>): ExpectToChange;
     /**
-     * @param {any} valueToContain - Value to contain.
+     * Runs to contain.
+     * @param {?} valueToContain - Value to contain.
      * @returns {void} - No return value.
      */
-    toContain(valueToContain: any): void;
+    toContain(valueToContain: unknown): void;
     /**
-     * @param {any} valueToContain - Value to contain.
+     * Runs to contain equal.
+     * @param {?} valueToContain - Value to contain.
      * @returns {void} - No return value.
      */
-    toContainEqual(valueToContain: any): void;
+    toContainEqual(valueToContain: unknown): void;
     /**
-     * @param {any} result - Result.
+     * Runs to equal.
+     * @param {?} result - Result.
      * @returns {void} - No return value.
      */
-    toEqual(result: any): void;
+    toEqual(result: unknown): void;
     /**
+     * Runs to match.
      * @param {RegExp} regex - Regex.
      * @returns {void} - No return value.
      */
     toMatch(regex: RegExp): void;
     /**
-     * @param {Record<string, any> | any[]} expected - Expected partial object.
+     * Runs to match object.
+     * @param {Record<string, ?> | Array<?>} expected - Expected partial object.
      * @returns {void} - No return value.
      */
-    toMatchObject(expected: Record<string, any> | any[]): void;
+    toMatchObject(expected: Record<string, unknown> | Array<unknown>): void;
     /**
+     * Runs to throw error.
      * @template T extends Error
      * @param {string|T} expectedError - Expected error.
      * @returns {Promise<void>} - Resolves when complete.
      */
     toThrowError<T>(expectedError: string | T): Promise<void>;
     /**
-     * @param {string|RegExp|Error|((new (...args: unknown[]) => Error))} [expected] - Expected error.
+     * Runs to throw.
+     * @param {string|RegExp|Error|((new (...args: Array<?>) => Error))} [expected] - Expected error.
      * @returns {Promise<void>} - Resolves when complete.
      */
-    toThrow(expected?: string | RegExp | Error | ((new (...args: unknown[]) => Error))): Promise<void>;
+    toThrow(expected?: string | RegExp | Error | ((new (...args: Array<unknown>) => Error))): Promise<void>;
     /**
-     * @returns {Promise<any>} - Resolves with the execute.
+     * Runs execute.
+     * @returns {Promise<?>} - Resolves with the execute.
      */
-    execute(): Promise<any>;
+    execute(): Promise<unknown>;
     /**
-     * @param {Record<string, any>} result - Result.
+     * Runs to have attributes.
+     * @param {Record<string, ?>} result - Result.
      * @returns {void} - No return value.
      */
-    toHaveAttributes(result: Record<string, any>): void;
+    toHaveAttributes(result: Record<string, unknown>): void;
 }
 import BaseExpect from "./base-expect.js";
 import ExpectToChange from "./expect-to-change.js";

package/build/src/testing/expect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../../src/testing/expect.js"],"names":[],"mappings":"AAaA;IACE;;OAEG;IACH,oBAFW,GAAG,EAQb;IAJC,aAAqB;IAErB,6CAA6C;IAC7C,cADW,KAAK,CAAC,MAAM,GAAG,cAAc,CAAC,CACnB;IAGxB;;;OAGG;IACH,0BAHW,MAAY,OAAO,CAAC,MAAM,CAAC,GACzB,cAAc,CAI1B;IAED;;OAEG;IACH,WAFa,IAAI,CAMhB;IAHC,0BAAgB;IAKlB;;;OAGG;IACH,aAHW,GAAG,GACD,IAAI,CAkBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;OAGG;IACH,4BAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;OAGG;IACH,+BAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;;OAIG;IACH,oBAJW,MAAM,cACN,MAAM,GACJ,IAAI,CA8BhB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;OAEG;IACH,eAFa,IAAI,CAgBhB;IAED;;;OAGG;IACH,sBAHW,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACzB,IAAI,CAQhB;IAED;;OAEG;IACH,aAFa,IAAI,CAIhB;IAED;;OAEG;IACH,YAFa,IAAI,CAIhB;IAED;;OAEG;IACH,iBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,YAFa,IAAI,CAIhB;IAED;;OAEG;IACH,cAFa,IAAI,CAchB;IAED;;;OAGG;IACH,yBAHW,MAAY,OAAO,CAAC,MAAM,CAAC,GACzB,cAAc,CAU1B;IAED;;;OAGG;IACH,0BAHW,GAAG,GACD,IAAI,CAsChB;IAED;;;OAGG;IACH,+BAHW,GAAG,GACD,IAAI,CAoBhB;IAED;;;OAGG;IACH,gBAHW,GAAG,GACD,IAAI,CA4HhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,IAAI,CAmBhB;IAED;;;OAGG;IACH,wBAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,GACzB,IAAI,CAoBhB;IAED;;;;OAIG;IACH,aAJa,CAAC,iBACH,MAAM,GAAC,CAAC,GACN,OAAO,CAAC,IAAI,CAAC,CAwCzB;IAED;;;OAGG;IACH,mBAHW,MAAM,GAAC,MAAM,GAAC,KAAK,GAAC,CAAC,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC,CA4DzB;IAED;;OAEG;IACH,WAFa,OAAO,CAAC,GAAG,CAAC,CAsBxB;IAED;;;OAGG;IACH,yBAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,IAAI,CAwBhB;CACF;uBA7sBsB,kBAAkB;2BACd,uBAAuB"}
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../../src/testing/expect.js"],"names":[],"mappings":"AAaA;IACE;;;OAGG;IACH,oBAFW,OAAC,EAUX;IANC,aAAqB;IAErB;;+CAE2C;IAC3C,cADS,KAAK,CAAC,MAAM,GAAG,cAAc,CAAC,CACjB;IAGxB;;;;OAIG;IACH,0BAHW,MAAY,OAAO,CAAC,MAAM,CAAC,GACzB,cAAc,CAI1B;IAED;;;OAGG;IACH,WAFa,IAAI,CAMhB;IAHC,0BAAgB;IAKlB;;;;OAIG;IACH,aAHW,OAAC,GACC,IAAI,CAkBhB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,cACN,MAAM,GACJ,IAAI,CA8BhB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,IAAI,CAsBhB;IAED;;;OAGG;IACH,eAFa,IAAI,CAgBhB;IAED;;;;OAIG;IACH,sBAHW,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,OAAC,GAC1B,IAAI,CAQhB;IAED;;;OAGG;IACH,aAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,YAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,iBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,YAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,cAFa,IAAI,CAchB;IAED;;;;OAIG;IACH,yBAHW,MAAY,OAAO,CAAC,MAAM,CAAC,GACzB,cAAc,CAU1B;IAED;;;;OAIG;IACH,0BAHW,OAAC,GACC,IAAI,CAsChB;IAED;;;;OAIG;IACH,+BAHW,OAAC,GACC,IAAI,CAoBhB;IAED;;;;OAIG;IACH,gBAHW,OAAC,GACC,IAAI,CAkIhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GAAG,KAAK,CAAC,OAAC,CAAC,GAC1B,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,aAJa,CAAC,iBACH,MAAM,GAAC,CAAC,GACN,OAAO,CAAC,IAAI,CAAC,CAwCzB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GAAC,MAAM,GAAC,KAAK,GAAC,CAAC,CAAC,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GACtD,OAAO,CAAC,IAAI,CAAC,CA4DzB;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,OAAC,CAAC,CAsBtB;IAED;;;;OAIG;IACH,yBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,IAAI,CA8BhB;CACF;uBAtvBsB,kBAAkB;2BACd,uBAAuB"}