velocious 1.0.431 → 1.0.433

package/build/src/testing/browser-test-app.js

@@ -1,32 +1,26 @@
 // @ts-check
-
-import SystemTestBrowserHelper from "system-testing/build/system-test-browser-helper.js"
-import BrowserEnvironmentHandler from "../environment-handlers/browser.js"
-import runFrontendModelEventHookScenario from "./browser-frontend-model-event-hook-scenarios.js"
-
+import SystemTestBrowserHelper from "system-testing/build/system-test-browser-helper.js";
+import BrowserEnvironmentHandler from "../environment-handlers/browser.js";
+import runFrontendModelEventHookScenario from "./browser-frontend-model-event-hook-scenarios.js";
 const root = document.getElementById("root") || (() => {
-  const element = document.createElement("div")
-  element.id = "root"
-  document.body.appendChild(element)
-  return element
-})()
-
-const systemTestingComponent = document.createElement("div")
-systemTestingComponent.setAttribute("data-testid", "systemTestingComponent")
-systemTestingComponent.setAttribute("data-focussed", "true")
-
-const blankText = document.createElement("div")
-blankText.setAttribute("data-testid", "blankText")
-blankText.textContent = "blank"
-
-systemTestingComponent.appendChild(blankText)
-root.appendChild(systemTestingComponent)
-
-const systemTestBrowserHelper = new SystemTestBrowserHelper()
-systemTestBrowserHelper.enableOnBrowser()
-
+    const element = document.createElement("div");
+    element.id = "root";
+    document.body.appendChild(element);
+    return element;
+})();
+const systemTestingComponent = document.createElement("div");
+systemTestingComponent.setAttribute("data-testid", "systemTestingComponent");
+systemTestingComponent.setAttribute("data-focussed", "true");
+const blankText = document.createElement("div");
+blankText.setAttribute("data-testid", "blankText");
+blankText.textContent = "blank";
+systemTestingComponent.appendChild(blankText);
+root.appendChild(systemTestingComponent);
+const systemTestBrowserHelper = new SystemTestBrowserHelper();
+systemTestBrowserHelper.enableOnBrowser();
 globalThis.velociousBrowserTest = {
-  BrowserEnvironmentHandler,
-  runFrontendModelEventHookScenario,
-  systemTestBrowserHelper
-}
+    BrowserEnvironmentHandler,
+    runFrontendModelEventHookScenario,
+    systemTestBrowserHelper
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/expect-to-change.js

@@ -1,55 +1,46 @@
 // @ts-check
-
-import BaseExpect from "./base-expect.js"
-import restArgsError from "../utils/rest-args-error.js"
-
+import BaseExpect from "./base-expect.js";
+import restArgsError from "../utils/rest-args-error.js";
 export default class ExpectToChange extends BaseExpect {
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {function(): Promise<number>} args.changeCallback - Change callback.
-   * @param {import("./expect.js").default} args.expect - Expect.
-   */
-  constructor({changeCallback, expect, ...restArgs}) {
-    super()
-    restArgsError(restArgs)
-
-    this.expect = expect
-    this.changeCallback = changeCallback
-  }
-
-  /**
-   * Runs by.
-   * @param {number} count - Count value.
-   * @returns {import("./expect.js").default} - The by.
-   */
-  by(count) {
-    this.count = count
-
-    return this.expect
-  }
-
-  async runBefore() {
-    this.oldCount = await this.changeCallback()
-  }
-
-  async runAfter() {
-    this.newCount = await this.changeCallback()
-  }
-
-  /**
-   * Runs execute.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async execute() {
-    if (this.newCount === undefined || this.oldCount === undefined) {
-      throw new Error("ExpectToChange not executed properly")
+    /**
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {function(): Promise<number>} args.changeCallback - Change callback.
+     * @param {import("./expect.js").default} args.expect - Expect.
+     */
+    constructor({ changeCallback, expect, ...restArgs }) {
+        super();
+        restArgsError(restArgs);
+        this.expect = expect;
+        this.changeCallback = changeCallback;
     }
-
-    const difference = this.newCount - this.oldCount
-
-    if (difference != this.count) {
-      throw new Error(`Expected to change by ${this.count} but changed by ${difference}`)
+    /**
+     * Runs by.
+     * @param {number} count - Count value.
+     * @returns {import("./expect.js").default} - The by.
+     */
+    by(count) {
+        this.count = count;
+        return this.expect;
+    }
+    async runBefore() {
+        this.oldCount = await this.changeCallback();
+    }
+    async runAfter() {
+        this.newCount = await this.changeCallback();
+    }
+    /**
+     * Runs execute.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async execute() {
+        if (this.newCount === undefined || this.oldCount === undefined) {
+            throw new Error("ExpectToChange not executed properly");
+        }
+        const difference = this.newCount - this.oldCount;
+        if (difference != this.count) {
+            throw new Error(`Expected to change by ${this.count} but changed by ${difference}`);
+        }
     }
-  }
 }
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,83 +1,72 @@
 // @ts-check
-
-import {anythingDifferent} from "set-state-compare/build/diff-utils.js"
-
+import { anythingDifferent } from "set-state-compare/build/diff-utils.js";
 /**
  * Runs object containing.
  * @param {?} value - Value.
  * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
  */
 function objectContaining(value) {
-  if (value === null || typeof value !== "object") {
-    throw new Error(`Expected object but got ${typeof value}`)
-  }
-
-  return {
-    __velociousMatcher: "objectContaining",
-    value
-  }
+    if (value === null || typeof value !== "object") {
+        throw new Error(`Expected object but got ${typeof value}`);
+    }
+    return {
+        __velociousMatcher: "objectContaining",
+        value
+    };
 }
-
 /**
  * Runs array containing.
  * @param {?} value - Value.
  * @returns {{__velociousMatcher: string, value: ?}} - Matcher wrapper.
  */
 function arrayContaining(value) {
-  if (!Array.isArray(value)) {
-    throw new Error(`Expected array but got ${typeof value}`)
-  }
-
-  return {
-    __velociousMatcher: "arrayContaining",
-    value
-  }
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected array but got ${typeof value}`);
+    }
+    return {
+        __velociousMatcher: "arrayContaining",
+        value
+    };
 }
-
 /**
  * Runs is object like.
  * @param {?} value - Value.
  * @returns {boolean} - Whether object-like.
  */
 function isObjectLike(value) {
-  return value !== null && typeof value === "object"
+    return value !== null && typeof value === "object";
 }
-
 /**
  * Runs is array containing.
  * @param {?} value - Value.
  * @returns {boolean} - Whether arrayContaining matcher.
  */
 function isArrayContaining(value) {
-  return !!value && typeof value === "object" && (/**
-                                                   * Narrows the runtime value to the documented type.
-                                                    @type {?} */ (value)).__velociousMatcher === "arrayContaining"
+    return !!value && typeof value === "object" && ( /**
+                                                     * Narrows the runtime value to the documented type.
+                                                      @type {?} */(value)).__velociousMatcher === "arrayContaining";
 }
-
 /**
  * Runs is object containing.
  * @param {?} value - Value.
  * @returns {boolean} - Whether objectContaining matcher.
  */
 function isObjectContaining(value) {
-  return !!value && typeof value === "object" && (/**
-                                                   * Narrows the runtime value to the documented type.
-                                                    @type {?} */ (value)).__velociousMatcher === "objectContaining"
+    return !!value && typeof value === "object" && ( /**
+                                                     * Narrows the runtime value to the documented type.
+                                                      @type {?} */(value)).__velociousMatcher === "objectContaining";
 }
-
 /**
  * Runs is plain object.
  * @param {?} value - Value.
  * @returns {boolean} - Whether plain object.
  */
 function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false
-
-  const prototype = Object.getPrototypeOf(value)
-
-  return prototype === Object.prototype || prototype === null
+    if (!value || typeof value !== "object")
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
 }
-
 /**
  * Runs values equal.
  * @param {?} actual - Actual value.
@@ -85,17 +74,14 @@ function isPlainObject(value) {
  * @returns {boolean} - Whether values are equal.
  */
 function valuesEqual(actual, expected) {
-  if (actual instanceof Date && expected instanceof Date) {
-    return actual.getTime() === expected.getTime()
-  }
-
-  if (actual instanceof RegExp && expected instanceof RegExp) {
-    return actual.source === expected.source && actual.flags === expected.flags
-  }
-
-  return Object.is(actual, expected)
+    if (actual instanceof Date && expected instanceof Date) {
+        return actual.getTime() === expected.getTime();
+    }
+    if (actual instanceof RegExp && expected instanceof RegExp) {
+        return actual.source === expected.source && actual.flags === expected.flags;
+    }
+    return Object.is(actual, expected);
 }
-
 /**
  * Runs collect match differences.
  * @param {?} actual - Actual value.
@@ -105,73 +91,59 @@ function valuesEqual(actual, expected) {
  * @returns {void} - No return value.
  */
 function collectMatchDifferences(actual, expected, path, differences) {
-  if (isObjectContaining(expected)) {
-    collectMatchDifferences(actual, /**
-                                     * Narrows the runtime value to the documented type.
-                                      @type {?} */ (expected).value, path, differences)
-    return
-  }
-
-  if (isArrayContaining(expected)) {
-    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]
+    if (isObjectContaining(expected)) {
+        collectMatchDifferences(actual, /**
+                                         * Narrows the runtime value to the documented type.
+                                          @type {?} */ (expected).value, path, differences);
+        return;
     }
-
-    return
-  }
-
-  if (Array.isArray(expected)) {
-    if (!Array.isArray(actual)) {
-      differences[path || "$"] = [expected, actual]
-      return
+    if (isArrayContaining(expected)) {
+        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];
+        }
+        return;
     }
-
-    for (let i = 0; i < expected.length; i++) {
-      const nextPath = `${path}[${i}]`
-      collectMatchDifferences(actual[i], expected[i], nextPath, differences)
+    if (Array.isArray(expected)) {
+        if (!Array.isArray(actual)) {
+            differences[path || "$"] = [expected, actual];
+            return;
+        }
+        for (let i = 0; i < expected.length; i++) {
+            const nextPath = `${path}[${i}]`;
+            collectMatchDifferences(actual[i], expected[i], nextPath, differences);
+        }
+        return;
     }
-
-    return
-  }
-
-  if (isPlainObject(expected)) {
-    if (!isObjectLike(actual)) {
-      differences[path || "$"] = [expected, actual]
-      return
+    if (isPlainObject(expected)) {
+        if (!isObjectLike(actual)) {
+            differences[path || "$"] = [expected, actual];
+            return;
+        }
+        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)) {
+                differences[nextPath] = [expectedObject[key], undefined];
+                continue;
+            }
+            collectMatchDifferences(actualObject[key], expectedObject[key], nextPath, differences);
+        }
+        return;
     }
-
-    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)) {
-        differences[nextPath] = [expectedObject[key], undefined]
-        continue
-      }
-
-      collectMatchDifferences(actualObject[key], expectedObject[key], nextPath, differences)
+    if (!valuesEqual(actual, expected)) {
+        differences[path || "$"] = [expected, actual];
     }
-
-    return
-  }
-
-  if (!valuesEqual(actual, expected)) {
-    differences[path || "$"] = [expected, actual]
-  }
 }
-
 /**
  * Runs match object.
  * @param {?} actual - Actual value.
@@ -179,19 +151,16 @@ function collectMatchDifferences(actual, expected, path, differences) {
  * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
  */
 function matchObject(actual, expected) {
-  /**
-   * Differences.
-    @type {Record<string, Array<?>>} */
-  const differences = {}
-
-  collectMatchDifferences(actual, expected, "", differences)
-
-  return {
-    matches: Object.keys(differences).length === 0,
-    differences
-  }
+    /**
+     * Differences.
+      @type {Record<string, Array<?>>} */
+    const differences = {};
+    collectMatchDifferences(actual, expected, "", differences);
+    return {
+        matches: Object.keys(differences).length === 0,
+        differences
+    };
 }
-
 /**
  * Runs match array containing.
  * @param {?} actual - Actual value.
@@ -199,71 +168,57 @@ function matchObject(actual, expected) {
  * @returns {{matches: boolean, differences: Record<string, Array<?>>}} - Match result.
  */
 function matchArrayContaining(actual, expected) {
-  /**
-   * Differences.
-    @type {Record<string, Array<?>>} */
-  const differences = {}
-
-  if (!Array.isArray(actual)) {
-    differences["$"] = [expected, actual]
-    return {matches: false, differences}
-  }
-
-  const usedIndexes = new Set()
-
-  for (const expectedItem of expected) {
-    let matchedIndex = -1
-
-    for (let i = 0; i < actual.length; i++) {
-      if (usedIndexes.has(i)) continue
-
-      if (isObjectContaining(expectedItem)) {
-        const {matches} = matchObject(actual[i], /**
-                                                  * Narrows the runtime value to the documented type.
-                                                   @type {?} */ (expectedItem).value)
-        if (matches) {
-          matchedIndex = i
-          break
+    /**
+     * Differences.
+      @type {Record<string, Array<?>>} */
+    const differences = {};
+    if (!Array.isArray(actual)) {
+        differences["$"] = [expected, actual];
+        return { matches: false, differences };
+    }
+    const usedIndexes = new Set();
+    for (const expectedItem of expected) {
+        let matchedIndex = -1;
+        for (let i = 0; i < actual.length; i++) {
+            if (usedIndexes.has(i))
+                continue;
+            if (isObjectContaining(expectedItem)) {
+                const { matches } = matchObject(actual[i], /**
+                                                          * Narrows the runtime value to the documented type.
+                                                           @type {?} */ (expectedItem).value);
+                if (matches) {
+                    matchedIndex = i;
+                    break;
+                }
+                continue;
+            }
+            if (isArrayContaining(expectedItem)) {
+                const { matches } = matchArrayContaining(actual[i], /**
+                                                                   * Narrows the runtime value to the documented type.
+                                                                    @type {?} */ (expectedItem).value);
+                if (matches) {
+                    matchedIndex = i;
+                    break;
+                }
+                continue;
+            }
+            if (!anythingDifferent(actual[i], expectedItem)) {
+                matchedIndex = i;
+                break;
+            }
         }
-        continue
-      }
-
-      if (isArrayContaining(expectedItem)) {
-        const {matches} = matchArrayContaining(actual[i], /**
-                                                           * Narrows the runtime value to the documented type.
-                                                            @type {?} */ (expectedItem).value)
-        if (matches) {
-          matchedIndex = i
-          break
+        if (matchedIndex >= 0) {
+            usedIndexes.add(matchedIndex);
+        }
+        else {
+            differences["$"] = [expected, actual];
+            break;
         }
-        continue
-      }
-
-      if (!anythingDifferent(actual[i], expectedItem)) {
-        matchedIndex = i
-        break
-      }
-    }
-
-    if (matchedIndex >= 0) {
-      usedIndexes.add(matchedIndex)
-    } else {
-      differences["$"] = [expected, actual]
-      break
     }
-  }
-
-  return {
-    matches: Object.keys(differences).length === 0,
-    differences
-  }
-}
-
-export {
-  arrayContaining,
-  isArrayContaining,
-  isObjectContaining,
-  matchArrayContaining,
-  matchObject,
-  objectContaining
+    return {
+        matches: Object.keys(differences).length === 0,
+        differences
+    };
 }
+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":"AAAA,YAAY;AAEZ,OAAO,EAAC,iBAAiB,EAAC,MAAM,uCAAuC,CAAA;AAEvE;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,KAAK;IAC7B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,KAAK,EAAE,CAAC,CAAA;IAC5D,CAAC;IAED,OAAO;QACL,kBAAkB,EAAE,kBAAkB;QACtC,KAAK;KACN,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,KAAK;IAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,0BAA0B,OAAO,KAAK,EAAE,CAAC,CAAA;IAC3D,CAAC;IAED,OAAO;QACL,kBAAkB,EAAE,iBAAiB;QACrC,KAAK;KACN,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,KAAK;IACzB,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAA;AACpD,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,KAAK;IAC9B,OAAO,CAAC,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,EAAC;;kEAEe,CAAC,KAAK,CAAC,CAAC,CAAC,kBAAkB,KAAK,iBAAiB,CAAA;AAClH,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,KAAK;IAC/B,OAAO,CAAC,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,EAAC;;kEAEe,CAAC,KAAK,CAAC,CAAC,CAAC,kBAAkB,KAAK,kBAAkB,CAAA;AACnH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAErD,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;IAE9C,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAA;AAC7D,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,MAAM,EAAE,QAAQ;IACnC,IAAI,MAAM,YAAY,IAAI,IAAI,QAAQ,YAAY,IAAI,EAAE,CAAC;QACvD,OAAO,MAAM,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,OAAO,EAAE,CAAA;IAChD,CAAC;IAED,IAAI,MAAM,YAAY,MAAM,IAAI,QAAQ,YAAY,MAAM,EAAE,CAAC;QAC3D,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,IAAI,MAAM,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,CAAA;IAC7E,CAAC;IAED,OAAO,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW;IAClE,IAAI,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjC,uBAAuB,CAAC,MAAM,EAAE;;sDAEc,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,WAAW,CAAC,CAAA;QACnF,OAAM;IACR,CAAC;IAED,IAAI,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChC,MAAM,EAAC,OAAO,EAAC,GAAG,oBAAoB,CAAC,MAAM,EAAE;;4EAEqB,CAAC,EAAC;;2CAEe,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;QAEvG,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,WAAW,CAAC,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;QAC/C,CAAC;QAED,OAAM;IACR,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3B,WAAW,CAAC,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;YAC7C,OAAM;QACR,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzC,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAA;YAChC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAA;QACxE,CAAC;QAED,OAAM;IACR,CAAC;IAED,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,WAAW,CAAC,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;YAC7C,OAAM;QACR,CAAC;QAED,MAAM,cAAc,GAAG;;6DAE8B,CAAC,CAAC,QAAQ,CAAC,CAAA;QAChE,MAAM,YAAY,GAAG;;2DAE8B,CAAC,CAAC,MAAM,CAAC,CAAA;QAE5D,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;YAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA;YAE9C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC,EAAE,CAAC;gBAC7D,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,CAAA;gBACxD,SAAQ;YACV,CAAC;YAED,uBAAuB,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAA;QACxF,CAAC;QAED,OAAM;IACR,CAAC;IAED,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;QACnC,WAAW,CAAC,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;IAC/C,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,MAAM,EAAE,QAAQ;IACnC;;yCAEqC;IACrC,MAAM,WAAW,GAAG,EAAE,CAAA;IAEtB,uBAAuB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,WAAW,CAAC,CAAA;IAE1D,OAAO;QACL,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,KAAK,CAAC;QAC9C,WAAW;KACZ,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,MAAM,EAAE,QAAQ;IAC5C;;yCAEqC;IACrC,MAAM,WAAW,GAAG,EAAE,CAAA;IAEtB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3B,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;QACrC,OAAO,EAAC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAC,CAAA;IACtC,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,GAAG,EAAE,CAAA;IAE7B,KAAK,MAAM,YAAY,IAAI,QAAQ,EAAE,CAAC;QACpC,IAAI,YAAY,GAAG,CAAC,CAAC,CAAA;QAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;gBAAE,SAAQ;YAEhC,IAAI,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACrC,MAAM,EAAC,OAAO,EAAC,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;;uEAEc,CAAC,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAA;gBAC7E,IAAI,OAAO,EAAE,CAAC;oBACZ,YAAY,GAAG,CAAC,CAAA;oBAChB,MAAK;gBACP,CAAC;gBACD,SAAQ;YACV,CAAC;YAED,IAAI,iBAAiB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACpC,MAAM,EAAC,OAAO,EAAC,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;;gFAEc,CAAC,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAA;gBACtF,IAAI,OAAO,EAAE,CAAC;oBACZ,YAAY,GAAG,CAAC,CAAA;oBAChB,MAAK;gBACP,CAAC;gBACD,SAAQ;YACV,CAAC;YAED,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC;gBAChD,YAAY,GAAG,CAAC,CAAA;gBAChB,MAAK;YACP,CAAC;QACH,CAAC;QAED,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;YACtB,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;QAC/B,CAAC;aAAM,CAAC;YACN,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;YACrC,MAAK;QACP,CAAC;IACH,CAAC;IAED,OAAO;QACL,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,KAAK,CAAC;QAC9C,WAAW;KACZ,CAAA;AACH,CAAC;AAED,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,WAAW,EACX,gBAAgB,EACjB,CAAA","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"]}