vest 4.0.0-dev-7acb76 → 4.0.0-dev-1aae50

package/dist/umd/vest.development.js

@@ -1,2204 +1,1700 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}));
-}(this, (function (exports) { 'use strict';
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('n4s'), require('context')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'n4s', 'context'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}, global.n4s, global.context));
+}(this, (function (exports, n4s, context$1) { 'use strict';
+
+  var assign = Object.assign;
+
+  /**
+   * @returns a unique numeric id.
+   */
+  var genId = (function (n) { return function () {
+      return "" + n++;
+  }; })(0);
+
+  function isFunction(value) {
+      return typeof value === 'function';
+  }
+
+  function optionalFunctionValue(value) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+          args[_i - 1] = arguments[_i];
+      }
+      return isFunction(value) ? value.apply(void 0, args) : value;
+  }
+
+  function defaultTo(callback, defaultValue) {
+      var _a;
+      return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+  }
+
+  /**
+   * Throws a timed out error.
+   */
+  function throwError(devMessage, productionMessage) {
+      throw new Error(devMessage );
+  }
+  function throwErrorDeferred(devMessage, productionMessage) {
+      setTimeout(function () {
+          throwError(devMessage);
+      }, 0);
+  }
+
+  // eslint-disable-next-line max-lines-per-function
+  function createState(onStateChange) {
+      var state = {
+          references: []
+      };
+      var registrations = [];
+      return {
+          registerStateKey: registerStateKey,
+          reset: reset
+      };
+      /**
+       * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
+       *
+       * @example
+       *
+       * const useColor = state.registerStateKey("blue");
+       *
+       * let [color, setColor] = useColor(); // -> ["blue", Function]
+       *
+       * setColor("green");
+       *
+       * useColor()[0]; -> "green"
+       */
+      function registerStateKey(initialState, onUpdate) {
+          var key = registrations.length;
+          registrations.push([initialState, onUpdate]);
+          return initKey(key, initialState);
+      }
+      function reset() {
+          var prev = current();
+          state.references = [];
+          registrations.forEach(function (_a, index) {
+              var initialValue = _a[0];
+              return initKey(index, initialValue, prev[index]);
+          });
+      }
+      function initKey(key, initialState, prevState) {
+          current().push();
+          set(key, optionalFunctionValue(initialState, prevState));
+          return function useStateKey() {
+              return [
+                  current()[key],
+                  function (nextState) {
+                      return set(key, optionalFunctionValue(nextState, current()[key]));
+                  },
+              ];
+          };
+      }
+      function current() {
+          return state.references;
+      }
+      function set(index, value) {
+          var prevValue = state.references[index];
+          state.references[index] = value;
+          var _a = registrations[index], onUpdate = _a[1];
+          if (isFunction(onUpdate)) {
+              onUpdate(value, prevValue);
+          }
+          if (isFunction(onStateChange)) {
+              onStateChange();
+          }
+      }
+  }
+
+  var IsolateTypes;
+  (function (IsolateTypes) {
+      IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
+      IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
+      IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
+      IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
+      IsolateTypes[IsolateTypes["GROUP"] = 4] = "GROUP";
+  })(IsolateTypes || (IsolateTypes = {}));
+
+  function createStateRef(state, _a) {
+      var suiteId = _a.suiteId, suiteName = _a.suiteName;
+      return {
+          optionalFields: state.registerStateKey(function () { return ({}); }),
+          suiteId: state.registerStateKey(suiteId),
+          suiteName: state.registerStateKey(suiteName),
+          testCallbacks: state.registerStateKey(function () { return ({
+              fieldCallbacks: {},
+              doneCallbacks: []
+          }); }),
+          testObjects: state.registerStateKey(function (prev) {
+              return {
+                  prev: prev ? prev.current : [],
+                  current: []
+              };
+          })
+      };
+  }
+
+  function asArray(possibleArg) {
+      return [].concat(possibleArg);
+  }
+
+  function last(values) {
+      var valuesArray = asArray(values);
+      return valuesArray[valuesArray.length - 1];
+  }
+
+  function createCursor() {
+      var storage = {
+          cursor: []
+      };
+      function addLevel() {
+          storage.cursor.push(0);
+      }
+      function removeLevel() {
+          storage.cursor.pop();
+      }
+      function cursorAt() {
+          return last(storage.cursor);
+      }
+      function getCursor() {
+          return asArray(storage.cursor);
+      }
+      function next() {
+          storage.cursor[storage.cursor.length - 1]++;
+          return last(storage.cursor);
+      }
+      function reset() {
+          storage.cursor = [0];
+      }
+      reset();
+      return {
+          addLevel: addLevel,
+          cursorAt: cursorAt,
+          getCursor: getCursor,
+          next: next,
+          removeLevel: removeLevel,
+          reset: reset
+      };
+  }
+
+  var context = context$1.createContext(function (ctxRef, parentContext) {
+      return parentContext
+          ? null
+          : assign({}, {
+              exclusion: {
+                  tests: {},
+                  groups: {}
+              },
+              isolate: {
+                  type: IsolateTypes.DEFAULT,
+                  keys: {
+                      current: {},
+                      prev: {}
+                  }
+              },
+              testCursor: createCursor()
+          }, ctxRef);
+  });
+
+  function bindNot(fn) {
+      return function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+          }
+          return !fn.apply(void 0, args);
+      };
+  }
+
+  // The module is named "isArrayValue" since it
+  // is conflicting with a nested npm dependency.
+  // We may need to revisit this in the future.
+  function isArray(value) {
+      return Boolean(Array.isArray(value));
+  }
+
+  function isNull(value) {
+      return value === null;
+  }
+  var isNotNull = bindNot(isNull);
+
+  // This is sort of a map/filter in one function.
+  // Normally, behaves like a nested-array map
+  // Returning `null` will drop the element from the array
+  function transform(array, cb) {
+      var res = [];
+      for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+          var v = array_1[_i];
+          if (isArray(v)) {
+              res.push(transform(v, cb));
+          }
+          else {
+              var output = cb(v);
+              if (isNotNull(output)) {
+                  res.push(output);
+              }
+          }
+      }
+      return res;
+  }
+  function valueAtPath(array, path) {
+      return getCurrent(array, path)[last(path)];
+  }
+  function setValueAtPath(array, path, value) {
+      var current = getCurrent(array, path);
+      current[last(path)] = value;
+      return array;
+  }
+  function flatten(values) {
+      return asArray(values).reduce(function (acc, value) {
+          if (isArray(value)) {
+              return acc.concat(flatten(value));
+          }
+          return asArray(acc).concat(value);
+      }, []);
+  }
+  function getCurrent(array, path) {
+      var current = array;
+      for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
+          var p = _a[_i];
+          current[p] = defaultTo(current[p], []);
+          current = current[p];
+      }
+      return current;
+  }
+
+  function isUndefined(value) {
+      return value === undefined;
+  }
+
+  function isNullish(value) {
+      return isNull(value) || isUndefined(value);
+  }
+
+  function isStringValue(v) {
+      return String(v) === v;
+  }
+
+  function shouldUseErrorAsMessage(message, error) {
+      // kind of cheating with this safe guard, but it does the job
+      return isUndefined(message) && isStringValue(error);
+  }
+
+  function lengthEquals(value, arg1) {
+      return value.length === Number(arg1);
+  }
+
+  function longerThan(value, arg1) {
+      return value.length > Number(arg1);
+  }
+
+  /**
+   * Creates a cache function
+   */
+  function createCache(maxSize) {
+      if (maxSize === void 0) { maxSize = 1; }
+      var cacheStorage = [];
+      var cache = function (deps, cacheAction) {
+          var cacheHit = cache.get(deps);
+          // cache hit is not null
+          if (cacheHit)
+              return cacheHit[1];
+          var result = cacheAction();
+          cacheStorage.unshift([deps.concat(), result]);
+          if (longerThan(cacheStorage, maxSize))
+              cacheStorage.length = maxSize;
+          return result;
+      };
+      // invalidate an item in the cache by its dependencies
+      cache.invalidate = function (deps) {
+          var index = cacheStorage.findIndex(function (_a) {
+              var cachedDeps = _a[0];
+              return lengthEquals(deps, cachedDeps.length) &&
+                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
+          });
+          if (index > -1)
+              cacheStorage.splice(index, 1);
+      };
+      // Retrieves an item from the cache.
+      cache.get = function (deps) {
+          return cacheStorage[cacheStorage.findIndex(function (_a) {
+              var cachedDeps = _a[0];
+              return lengthEquals(deps, cachedDeps.length) &&
+                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
+          })] || null;
+      };
+      return cache;
+  }
+
+  // STATE REF
+  function useStateRef() {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return context.useX().stateRef; // I should revisit this
+  }
+  // STATE KEYS
+  function useSuiteId() {
+      return useStateRef().suiteId()[0];
+  }
+  function useSuiteName() {
+      return useStateRef().suiteName()[0];
+  }
+  function useTestCallbacks() {
+      return useStateRef().testCallbacks();
+  }
+  function useOptionalFields() {
+      return useStateRef().optionalFields();
+  }
+  function useTestObjects() {
+      return useStateRef().testObjects();
+  }
+  // STATE ACTIONS
+  function useRefreshTestObjects() {
+      var _a = useTestObjects(), setTestObjects = _a[1];
+      setTestObjects(function (_a) {
+          var current = _a.current, prev = _a.prev;
+          return ({
+              prev: prev,
+              current: asArray(current)
+          });
+      });
+  }
+  function useSetTests(handler) {
+      var _a = useTestObjects(), testObjects = _a[1];
+      testObjects(function (_a) {
+          var current = _a.current, prev = _a.prev;
+          return ({
+              prev: prev,
+              current: asArray(handler(current))
+          });
+      });
+  }
+  // Derived state
+  function useAllIncomplete() {
+      var current = useTestObjects()[0].current;
+      return flatten(transform(current, function (testObject) {
+          return testObject.isPending() ? testObject : null;
+      }));
+  }
+  function useOmittedFields() {
+      var testObjects = useTestsFlat();
+      return testObjects.reduce(function (omittedFields, testObject) {
+          if (omittedFields[testObject.fieldName]) {
+              return omittedFields;
+          }
+          if (testObject.isOmitted()) {
+              omittedFields[testObject.fieldName] = true;
+          }
+          return omittedFields;
+      }, {});
+  }
+  var flatCache = createCache();
+  function useTestsFlat() {
+      var current = useTestObjects()[0].current;
+      return flatCache([current], function () { return flatten(current); });
+  }
+
+  var TestSeverity;
+  (function (TestSeverity) {
+      TestSeverity["Error"] = "error";
+      TestSeverity["Warning"] = "warning";
+  })(TestSeverity || (TestSeverity = {}));
+  var VestTest = /** @class */ (function () {
+      function VestTest(fieldName, testFn, _a) {
+          var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
+          this.key = null;
+          this.id = genId();
+          this.severity = TestSeverity.Error;
+          this.status = STATUS_UNTESTED;
+          this.fieldName = fieldName;
+          this.testFn = testFn;
+          if (groupName) {
+              this.groupName = groupName;
+          }
+          if (message) {
+              this.message = message;
+          }
+          if (key) {
+              this.key = key;
+          }
+      }
+      VestTest.prototype.run = function () {
+          var result;
+          try {
+              result = this.testFn();
+          }
+          catch (error) {
+              if (shouldUseErrorAsMessage(this.message, error)) {
+                  this.message = error;
+              }
+              result = false;
+          }
+          if (result === false) {
+              this.fail();
+          }
+          return result;
+      };
+      VestTest.prototype.setStatus = function (status) {
+          if (this.isFinalStatus() && status !== STATUS_OMITTED) {
+              return;
+          }
+          this.status = status;
+      };
+      VestTest.prototype.warns = function () {
+          return this.severity === TestSeverity.Warning;
+      };
+      VestTest.prototype.setPending = function () {
+          this.setStatus(STATUS_PENDING);
+      };
+      VestTest.prototype.fail = function () {
+          this.setStatus(this.warns() ? STATUS_WARNING : STATUS_FAILED);
+      };
+      VestTest.prototype.done = function () {
+          if (this.isFinalStatus()) {
+              return;
+          }
+          this.setStatus(STATUS_PASSING);
+      };
+      VestTest.prototype.warn = function () {
+          this.severity = TestSeverity.Warning;
+      };
+      VestTest.prototype.isFinalStatus = function () {
+          return this.hasFailures() || this.isCanceled() || this.isPassing();
+      };
+      VestTest.prototype.skip = function (force) {
+          if (this.isPending() && !force) {
+              // Without this condition, the test will be marked as skipped even if it is pending.
+              // This means that it will not be counted in "allIncomplete" and its done callbacks
+              // will not be called, or will be called prematurely.
+              // What this mostly say is that when we have a pending test for one field, and we then
+              // start typing in a different field - the pending test will be canceled, which
+              // is usually an unwanted behavior.
+              // The only scenario in which we DO want to cancel the async test regardless
+              // is when we specifically skip a test with `skipWhen`, which is handled by the
+              // "force" boolean flag.
+              // I am not a fan of this flag, but it gets the job done.
+              return;
+          }
+          this.setStatus(STATUS_SKIPPED);
+      };
+      VestTest.prototype.cancel = function () {
+          this.setStatus(STATUS_CANCELED);
+          useRefreshTestObjects();
+      };
+      VestTest.prototype.omit = function () {
+          this.setStatus(STATUS_OMITTED);
+      };
+      VestTest.prototype.valueOf = function () {
+          return !this.isFailing();
+      };
+      VestTest.prototype.hasFailures = function () {
+          return this.isFailing() || this.isWarning();
+      };
+      VestTest.prototype.isPending = function () {
+          return this.status === STATUS_PENDING;
+      };
+      VestTest.prototype.isTested = function () {
+          return this.hasFailures() || this.isPassing();
+      };
+      VestTest.prototype.isOmitted = function () {
+          return this.status === STATUS_OMITTED;
+      };
+      VestTest.prototype.isUntested = function () {
+          return this.status === STATUS_UNTESTED;
+      };
+      VestTest.prototype.isFailing = function () {
+          return this.status === STATUS_FAILED;
+      };
+      VestTest.prototype.isCanceled = function () {
+          return this.status === STATUS_CANCELED;
+      };
+      VestTest.prototype.isSkipped = function () {
+          return this.status === STATUS_SKIPPED;
+      };
+      VestTest.prototype.isPassing = function () {
+          return this.status === STATUS_PASSING;
+      };
+      VestTest.prototype.isWarning = function () {
+          return this.status === STATUS_WARNING;
+      };
+      return VestTest;
+  }());
+  var STATUS_UNTESTED = 'UNTESTED';
+  var STATUS_SKIPPED = 'SKIPPED';
+  var STATUS_FAILED = 'FAILED';
+  var STATUS_WARNING = 'WARNING';
+  var STATUS_PASSING = 'PASSING';
+  var STATUS_PENDING = 'PENDING';
+  var STATUS_CANCELED = 'CANCELED';
+  var STATUS_OMITTED = 'OMITTED';
+
+  function usePath() {
+      var context$1 = context.useX();
+      return context$1.testCursor.getCursor();
+  }
+  function useCursorAt() {
+      var context$1 = context.useX();
+      return context$1.testCursor.cursorAt();
+  }
+  function moveForward() {
+      var context$1 = context.useX();
+      return context$1.testCursor.next();
+  }
+  function addLevel() {
+      var context$1 = context.useX();
+      context$1.testCursor.addLevel();
+  }
+  function removeLevel() {
+      var context$1 = context.useX();
+      context$1.testCursor.removeLevel();
+  }
+
+  function usePrevKeys() {
+      var prev = useTestObjects()[0].prev;
+      return asArray(getCurrent(prev, usePath())).reduce(function (prevKeys, testObject) {
+          if (!(testObject instanceof VestTest)) {
+              return prevKeys;
+          }
+          if (isNullish(testObject.key)) {
+              return prevKeys;
+          }
+          prevKeys[testObject.key] = testObject;
+          return prevKeys;
+      }, {});
+  }
+  function usePrevTestByKey(key) {
+      var prev = context.useX().isolate.keys.prev;
+      return prev[key];
+  }
+  function useRetainTestKey(key, testObject) {
+      var context$1 = context.useX();
+      var current = context$1.isolate.keys.current;
+      if (isNullish(current[key])) {
+          current[key] = testObject;
+      }
+      else {
+          throwErrorDeferred("Encountered the same test key \"" + key + "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.");
+      }
+  }
+
+  function isolate(_a, callback) {
+      var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
+      if (!isFunction(callback)) {
+          return;
+      }
+      var keys = {
+          current: {},
+          prev: {}
+      };
+      var path = usePath();
+      return context.run({ isolate: { type: type, keys: keys } }, function () {
+          addLevel();
+          keys.prev = usePrevKeys();
+          useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
+          var res = callback();
+          removeLevel();
+          moveForward();
+          return res;
+      });
+  }
+  function shouldAllowReorder() {
+      return context.useX().isolate.type === IsolateTypes.EACH;
+  }
+
+  /**
+   * A safe hasOwnProperty access
+   */
+  function hasOwnProperty(obj, key) {
+      return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  function isNumber(value) {
+      return Boolean(typeof value === 'number');
+  }
+
+  function isEmpty(value) {
+      if (!value) {
+          return true;
+      }
+      else if (isNumber(value)) {
+          return value === 0;
+      }
+      else if (hasOwnProperty(value, 'length')) {
+          return lengthEquals(value, 0);
+      }
+      else if (typeof value === 'object') {
+          return lengthEquals(Object.keys(value), 0);
+      }
+      return true;
+  }
+  var isNotEmpty = bindNot(isEmpty);
+
+  function nonMatchingFieldName(testObject, fieldName) {
+      return !!fieldName && !matchingFieldName(testObject, fieldName);
+  }
+  function matchingFieldName(testObject, fieldName) {
+      return !!(fieldName && testObject.fieldName === fieldName);
+  }
+
+  /**
+   * Checks if a given field, or the suite as a whole still have remaining tests.
+   */
+  function hasRemainingTests(fieldName) {
+      var allIncomplete = useAllIncomplete();
+      if (isEmpty(allIncomplete)) {
+          return false;
+      }
+      if (fieldName) {
+          return allIncomplete.some(function (testObject) {
+              return matchingFieldName(testObject, fieldName);
+          });
+      }
+      return isNotEmpty(allIncomplete);
+  }
+
+  /**
+   * Reads the testObjects list and gets full validation result from it.
+   */
+  function genTestsSummary() {
+      var testObjects = useTestsFlat();
+      var summary = {
+          errorCount: 0,
+          groups: {},
+          testCount: 0,
+          tests: {},
+          warnCount: 0
+      };
+      appendSummary(testObjects);
+      return countFailures(summary);
+      function appendSummary(testObjects) {
+          testObjects.forEach(function (testObject) {
+              var fieldName = testObject.fieldName, groupName = testObject.groupName;
+              summary.tests[fieldName] = genTestObject(summary.tests, testObject);
+              if (groupName) {
+                  summary.groups[groupName] = summary.groups[groupName] || {};
+                  summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject);
+              }
+          });
+      }
+  }
+  /**
+   * Counts the failed tests and adds global counters
+   */
+  function countFailures(summary) {
+      for (var test in summary.tests) {
+          summary.errorCount += summary.tests[test].errorCount;
+          summary.warnCount += summary.tests[test].warnCount;
+          summary.testCount += summary.tests[test].testCount;
+      }
+      return summary;
+  }
+  // eslint-disable-next-line max-statements
+  function genTestObject(summaryKey, testObject) {
+      var fieldName = testObject.fieldName, message = testObject.message;
+      summaryKey[fieldName] = summaryKey[fieldName] || {
+          errorCount: 0,
+          warnCount: 0,
+          testCount: 0
+      };
+      var testKey = summaryKey[fieldName];
+      if (testObject.isSkipped())
+          return testKey;
+      summaryKey[fieldName].testCount++;
+      // Adds to severity group
+      function addTo(countKey, group) {
+          testKey[countKey]++;
+          if (message) {
+              testKey[group] = (testKey[group] || []).concat(message);
+          }
+      }
+      if (testObject.isFailing()) {
+          addTo('errorCount', 'errors');
+      }
+      else if (testObject.isWarning()) {
+          addTo('warnCount', 'warnings');
+      }
+      return testKey;
+  }
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
 
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
 
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
 
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
+  var __assign = function() {
+      __assign = Object.assign || function __assign(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments[i];
+              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+          }
+          return t;
+      };
+      return __assign.apply(this, arguments);
+  };
 
-    function __spreadArray(to, from, pack) {
-        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-        return to.concat(ar || from);
-    }
-
-    var assign = Object.assign;
-
-    function isFunction(value) {
-        return typeof value === 'function';
-    }
-
-    function mapFirst(array, callback) {
-        var broke = false;
-        var breakoutValue = null;
-        for (var i = 0; i < array.length; i++) {
-            callback(array[i], breakout, i);
-            if (broke) {
-                return breakoutValue;
-            }
-        }
-        function breakout(value) {
-            broke = true;
-            breakoutValue = value;
-        }
-    }
-
-    function optionalFunctionValue(value) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        return isFunction(value) ? value.apply(void 0, args) : value;
-    }
-
-    function defaultTo(callback, defaultValue) {
-        var _a;
-        return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
-    }
-
-    function ruleReturn(pass, message) {
-        var output = { pass: pass };
-        if (message) {
-            output.message = message;
-        }
-        return output;
-    }
-    function failing() {
-        return ruleReturn(false);
-    }
-    function passing() {
-        return ruleReturn(true);
-    }
-    function defaultToFailing(callback) {
-        return defaultTo(callback, failing());
-    }
-    function defaultToPassing(callback) {
-        return defaultTo(callback, passing());
-    }
-
-    function runLazyRule(lazyRule, currentValue) {
-        try {
-            return lazyRule.run(currentValue);
-        }
-        catch (_a) {
-            return failing();
-        }
-    }
-
-    function allOf(value) {
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        return defaultToPassing(mapFirst(rules, function (rule, breakout) {
-            var res = runLazyRule(rule, value);
-            if (!res.pass) {
-                breakout(res);
-            }
-        }));
-    }
-
-    function anyOf(value) {
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        return defaultToFailing(mapFirst(rules, function (rule, breakout) {
-            var res = runLazyRule(rule, value);
-            if (res.pass) {
-                breakout(res);
-            }
-        }));
-    }
-
-    function noneOf(value) {
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        return defaultToPassing(mapFirst(rules, function (rule, breakout) {
-            var res = runLazyRule(rule, value);
-            if (res.pass) {
-                breakout(failing());
-            }
-        }));
-    }
-
-    function bindNot(fn) {
-        return function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return !fn.apply(void 0, args);
-        };
-    }
-
-    function lengthEquals(value, arg1) {
-        return value.length === Number(arg1);
-    }
-    var lengthNotEquals = bindNot(lengthEquals);
-
-    function longerThan(value, arg1) {
-        return value.length > Number(arg1);
-    }
-
-    function oneOf(value) {
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        var passing = [];
-        rules.some(function (rule) {
-            if (longerThan(passing, 1)) {
-                return false;
-            }
-            var res = runLazyRule(rule, value);
-            if (res.pass) {
-                passing.push(res);
-            }
-        });
-        return ruleReturn(lengthEquals(passing, 1));
-    }
-
-    function isNull(value) {
-        return value === null;
-    }
-    var isNotNull = bindNot(isNull);
-
-    function isUndefined(value) {
-        return value === undefined;
-    }
-    var isNotUndefined = bindNot(isUndefined);
-
-    function optional$1(value, ruleChain) {
-        if (isUndefined(value) || isNull(value)) {
-            return passing();
-        }
-        return runLazyRule(ruleChain, value);
-    }
-
-    function compounds() {
-        return { allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf, optional: optional$1 };
-    }
-
-    function isStringValue(v) {
-        return String(v) === v;
-    }
-
-    function endsWith(value, arg1) {
-        return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
-    }
-    var doesNotEndWith = bindNot(endsWith);
-
-    function equals(value, arg1) {
-        return value === arg1;
-    }
-    var notEquals = bindNot(equals);
-
-    function isNumeric(value) {
-        var str = String(value);
-        var num = Number(value);
-        var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
-        return Boolean(result);
-    }
-    var isNotNumeric = bindNot(isNumeric);
-
-    function greaterThan(value, gt) {
-        return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
-    }
-
-    function greaterThanOrEquals(value, gte) {
-        return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
-    }
-
-    // The module is named "isArrayValue" since it
-    // is conflicting with a nested npm dependency.
-    // We may need to revisit this in the future.
-    function isArray(value) {
-        return Boolean(Array.isArray(value));
-    }
-    var isNotArray = bindNot(isArray);
-
-    function inside(value, arg1) {
-        if (isArray(arg1)) {
-            return arg1.indexOf(value) !== -1;
-        }
-        // both value and arg1 are strings
-        if (isStringValue(arg1) && isStringValue(value)) {
-            return arg1.indexOf(value) !== -1;
-        }
-        return false;
-    }
-    var notInside = bindNot(inside);
-
-    function lessThanOrEquals(value, lte) {
-        return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
-    }
-
-    function isBetween(value, min, max) {
-        return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-    }
-    var isNotBetween = bindNot(isBetween);
-
-    function isBlank(value) {
-        return isStringValue(value) && !value.trim();
-    }
-    var isNotBlank = bindNot(isBlank);
-
-    function isBoolean(value) {
-        return !!value === value;
-    }
-
-    var isNotBoolean = bindNot(isBoolean);
-
-    /**
-     * A safe hasOwnProperty access
-     */
-    function hasOwnProperty(obj, key) {
-        return Object.prototype.hasOwnProperty.call(obj, key);
-    }
-
-    function isNumber(value) {
-        return Boolean(typeof value === 'number');
-    }
-    var isNotNumber = bindNot(isNumber);
-
-    function isEmpty(value) {
-        if (!value) {
-            return true;
-        }
-        else if (isNumber(value)) {
-            return value === 0;
-        }
-        else if (hasOwnProperty(value, 'length')) {
-            return lengthEquals(value, 0);
-        }
-        else if (typeof value === 'object') {
-            return lengthEquals(Object.keys(value), 0);
-        }
-        return true;
-    }
-    var isNotEmpty = bindNot(isEmpty);
-
-    /**
-     * Validates that a given value is an even number
-     */
-    var isEven = function (value) {
-        if (isNumeric(value)) {
-            return value % 2 === 0;
-        }
-        return false;
-    };
-
-    function isNaN$1(value) {
-        return Number.isNaN(value);
-    }
-    var isNotNaN = bindNot(isNaN$1);
-
-    function isNegative(value) {
-        if (isNumeric(value)) {
-            return Number(value) < 0;
-        }
-        return false;
-    }
-    var isPositive = bindNot(isNegative);
-
-    /**
-     * Validates that a given value is an odd number
-     */
-    var isOdd = function (value) {
-        if (isNumeric(value)) {
-            return value % 2 !== 0;
-        }
-        return false;
-    };
-
-    var isNotString = bindNot(isStringValue);
-
-    function isTruthy(value) {
-        return !!value;
-    }
-    var isFalsy = bindNot(isTruthy);
-
-    function lessThan(value, lt) {
-        return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-    }
-
-    function longerThanOrEquals(value, arg1) {
-        return value.length >= Number(arg1);
-    }
-
-    function matches(value, regex) {
-        if (regex instanceof RegExp) {
-            return regex.test(value);
-        }
-        else if (isStringValue(regex)) {
-            return new RegExp(regex).test(value);
-        }
-        else {
-            return false;
-        }
-    }
-    var notMatches = bindNot(matches);
-
-    function numberEquals(value, eq) {
-        return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
-    }
-    var numberNotEquals = bindNot(numberEquals);
-
-    function condition(value, callback) {
-        try {
-            return callback(value);
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-
-    function shorterThan(value, arg1) {
-        return value.length < Number(arg1);
-    }
-
-    function shorterThanOrEquals(value, arg1) {
-        return value.length <= Number(arg1);
-    }
-
-    function startsWith(value, arg1) {
-        return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
-    }
-    var doesNotStartWith = bindNot(startsWith);
-
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function
-    function rules() {
-        return {
-            condition: condition,
-            doesNotEndWith: doesNotEndWith,
-            doesNotStartWith: doesNotStartWith,
-            endsWith: endsWith,
-            equals: equals,
-            greaterThan: greaterThan,
-            greaterThanOrEquals: greaterThanOrEquals,
-            gt: greaterThan,
-            gte: greaterThanOrEquals,
-            inside: inside,
-            isArray: isArray,
-            isBetween: isBetween,
-            isBlank: isBlank,
-            isBoolean: isBoolean,
-            isEmpty: isEmpty,
-            isEven: isEven,
-            isFalsy: isFalsy,
-            isNaN: isNaN$1,
-            isNegative: isNegative,
-            isNotArray: isNotArray,
-            isNotBetween: isNotBetween,
-            isNotBlank: isNotBlank,
-            isNotBoolean: isNotBoolean,
-            isNotEmpty: isNotEmpty,
-            isNotNaN: isNotNaN,
-            isNotNull: isNotNull,
-            isNotNumber: isNotNumber,
-            isNotNumeric: isNotNumeric,
-            isNotString: isNotString,
-            isNotUndefined: isNotUndefined,
-            isNull: isNull,
-            isNumber: isNumber,
-            isNumeric: isNumeric,
-            isOdd: isOdd,
-            isPositive: isPositive,
-            isString: isStringValue,
-            isTruthy: isTruthy,
-            isUndefined: isUndefined,
-            lengthEquals: lengthEquals,
-            lengthNotEquals: lengthNotEquals,
-            lessThan: lessThan,
-            lessThanOrEquals: lessThanOrEquals,
-            longerThan: longerThan,
-            longerThanOrEquals: longerThanOrEquals,
-            lt: lessThan,
-            lte: lessThanOrEquals,
-            matches: matches,
-            notEquals: notEquals,
-            notInside: notInside,
-            notMatches: notMatches,
-            numberEquals: numberEquals,
-            numberNotEquals: numberNotEquals,
-            shorterThan: shorterThan,
-            shorterThanOrEquals: shorterThanOrEquals,
-            startsWith: startsWith
-        };
-    }
-
-    /**
-     * Throws a timed out error.
-     */
-    function throwError(devMessage, productionMessage) {
-        throw new Error(devMessage );
-    }
-    function throwErrorDeferred(devMessage, productionMessage) {
-        setTimeout(function () {
-            throwError(devMessage);
-        }, 0);
-    }
-
-    // eslint-disable-next-line max-lines-per-function
-    function createContext(init) {
-        var storage = { ancestry: [] };
-        return {
-            bind: bind,
-            run: run,
-            use: use,
-            useX: useX
-        };
-        function useX(errorMessage) {
-            var _a;
-            return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
-        }
-        function run(ctxRef, fn) {
-            var _a;
-            var parentContext = use();
-            var out = assign({}, parentContext ? parentContext : {}, (_a = init === null || init === void 0 ? void 0 : init(ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
-            var ctx = set(Object.freeze(out));
-            storage.ancestry.unshift(ctx);
-            var res = fn(ctx);
-            clear();
-            return res;
-        }
-        function bind(ctxRef, fn) {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore - this one's pretty hard to get right
-            var returnedFn = function () {
-                var runTimeArgs = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    runTimeArgs[_i] = arguments[_i];
-                }
-                return run(ctxRef, function () {
-                    return fn.apply(void 0, runTimeArgs);
-                });
-            };
-            return returnedFn;
-        }
-        function use() {
-            return storage.ctx;
-        }
-        function set(value) {
-            return (storage.ctx = value);
-        }
-        function clear() {
-            var _a;
-            storage.ancestry.shift();
-            set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
-        }
-    }
-
-    var ctx$1 = createContext(function (ctxRef, parentContext) {
-        var base = {
-            value: ctxRef.value,
-            meta: ctxRef.meta || {}
-        };
-        if (!parentContext) {
-            return assign(base, {
-                parent: emptyParent
-            });
-        }
-        else if (ctxRef.set) {
-            return assign(base, {
-                parent: function () { return stripContext(parentContext); }
-            });
-        }
-        return parentContext;
-    });
-    function stripContext(ctx) {
-        if (!ctx) {
-            return ctx;
-        }
-        return {
-            value: ctx.value,
-            meta: ctx.meta,
-            parent: ctx.parent
-        };
-    }
-    function emptyParent() {
-        return null;
-    }
-
-    function isArrayOf(inputArray, currentRule) {
-        return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
-            var res = ctx$1.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
-            if (!res.pass) {
-                breakout(res);
-            }
-        }));
-    }
-
-    function loose(inputObject, shapeObject) {
-        var _loop_1 = function (key) {
-            var currentValue = inputObject[key];
-            var currentRule = shapeObject[key];
-            var res = ctx$1.run({ value: currentValue, set: true, meta: { key: key } }, function () {
-                return runLazyRule(currentRule, currentValue);
-            });
-            if (!res.pass) {
-                return { value: res };
-            }
-        };
-        for (var key in shapeObject) {
-            var state_1 = _loop_1(key);
-            if (typeof state_1 === "object")
-                return state_1.value;
-        }
-        return passing();
-    }
-
-    function shape(inputObject, shapeObject) {
-        var baseRes = loose(inputObject, shapeObject);
-        if (!baseRes.pass) {
-            return baseRes;
-        }
-        for (var key in inputObject) {
-            if (!hasOwnProperty(shapeObject, key)) {
-                return failing();
-            }
-        }
-        return passing();
-    }
-
-    function schema() {
-        return { shape: shape, loose: loose, isArrayOf: isArrayOf };
-    }
-
-    var baseRules = assign(rules(), compounds(), schema());
-    function getRule(ruleName) {
-        return baseRules[ruleName];
-    }
-
-    function eachEnforceRule(action) {
-        for (var ruleName in baseRules) {
-            var ruleFn = getRule(ruleName);
-            if (isFunction(ruleFn)) {
-                action(ruleName, ruleFn);
-            }
-        }
-    }
-
-    function isProxySupported() {
-        try {
-            return typeof Proxy === 'function';
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-
-    /**
-     * Transform the result of a rule into a standard format
-     */
-    function transformResult(result, ruleName, value) {
-        var args = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-            args[_i - 3] = arguments[_i];
-        }
-        validateResult(result);
-        // if result is boolean
-        if (isBoolean(result)) {
-            return ruleReturn(result);
-        }
-        else {
-            return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
-        }
-    }
-    function validateResult(result) {
-        // if result is boolean, or if result.pass is boolean
-        if (isBoolean(result) || (result && isBoolean(result.pass))) {
-            return;
-        }
-        throwError('Incorrect return value for rule: ' + JSON.stringify(result));
-    }
-
-    function enforceEager(value) {
-        var target = {};
-        if (!isProxySupported()) {
-            eachEnforceRule(function (ruleName, ruleFn) {
-                target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-            });
-            return target;
-        }
-        var proxy = new Proxy(target, {
-            get: function (_, ruleName) {
-                var rule = getRule(ruleName);
-                if (rule) {
-                    return genRuleCall(proxy, rule, ruleName);
-                }
-            }
-        });
-        return proxy;
-        function genRuleCall(target, rule, ruleName) {
-            return function ruleCall() {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
-                    ruleName,
-                    value], args));
-                if (!transformedResult.pass) {
-                    if (isEmpty(transformedResult.message)) {
-                        throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
-                    }
-                    else {
-                        // Explicitly throw a string so that vest.test can pick it up as the validation error message
-                        throw transformedResult.message;
-                    }
-                }
-                return target;
-            };
-        }
-    }
-
-    // eslint-disable-next-line max-lines-per-function
-    function genEnforceLazy(key) {
-        var registeredRules = [];
-        var lazyMessage;
-        return addLazyRule(key);
-        // eslint-disable-next-line max-lines-per-function
-        function addLazyRule(ruleName) {
-            // eslint-disable-next-line max-lines-per-function
-            return function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var rule = getRule(ruleName);
-                registeredRules.push(function (value) {
-                    return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
-                });
-                var proxy = {
-                    run: function (value) {
-                        return defaultToPassing(mapFirst(registeredRules, function (rule, breakout) {
-                            var _a;
-                            var res = ctx$1.run({ value: value }, function () { return rule(value); });
-                            if (!res.pass) {
-                                breakout(ruleReturn(!!res.pass, (_a = optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
-                            }
-                        }));
-                    },
-                    test: function (value) { return proxy.run(value).pass; },
-                    message: function (message) {
-                        if (message) {
-                            lazyMessage = message;
-                        }
-                        return proxy;
-                    }
-                };
-                if (!isProxySupported()) {
-                    eachEnforceRule(function (ruleName) {
-                        proxy[ruleName] = addLazyRule(ruleName);
-                    });
-                    return proxy;
-                }
-                // reassigning the proxy here is not pretty
-                // but it's a cleaner way of getting `run` and `test` for free
-                proxy = new Proxy(proxy, {
-                    get: function (target, key) {
-                        if (getRule(key)) {
-                            return addLazyRule(key);
-                        }
-                        return target[key]; // already has `run` and `test` on it
-                    }
-                });
-                return proxy;
-            };
-        }
-    }
-
-    // Help needed improving the typings of this file.
-    // Ideally, we'd be able to extend TShapeObject, but that's not possible.
-    function partial(shapeObject) {
-        var output = {};
-        for (var key in shapeObject) {
-            output[key] = enforce.optional(shapeObject[key]);
-        }
-        return output;
-    }
-
-    function modifiers() {
-        return { partial: partial };
-    }
-
-    /**
-     * Enforce is quite complicated, I want to explain it in detail.
-     * It is dynamic in nature, so a lot of proxy objects are involved.
-     *
-     * Enforce has two main interfaces
-     * 1. eager
-     * 2. lazy
-     *
-     * The eager interface is the most commonly used, and the easier to understand.
-     * It throws an error when a rule is not satisfied.
-     * The eager interface is declared in enforceEager.ts and it is quite simple to understand.
-     * enforce is called with a value, and the return value is a proxy object that points back to all the rules.
-     * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same
-     * proxy object is returned. Otherwise, an error is thrown.
-     *
-     * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.
-     * Rather than calling enforce directly, the lazy interface has all the rules as "methods" (only by proxy).
-     * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls
-     * and the parameters passed to them. None of the rules are called yet.
-     * The rules are only invoked in sequence once either of these chained functions are called:
-     * 1. test(value)
-     * 2. run(value)
-     *
-     * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,
-     * while run will return an object with the validation result and an optional message created by the rule.
-     */
-    function genEnforce() {
-        var target = __assign({ context: function () { return ctx$1.useX(); }, extend: function (customRules) {
-                assign(baseRules, customRules);
-            } }, modifiers());
-        if (!isProxySupported()) {
-            eachEnforceRule(function (ruleName) {
-                // Only on the first rule access - start the chain of calls
-                target[ruleName] = genEnforceLazy(ruleName);
-            });
-            return target;
-        }
-        return new Proxy(assign(enforceEager, target), {
-            get: function (target, key) {
-                if (key in target) {
-                    return target[key];
-                }
-                if (!getRule(key)) {
-                    return;
-                }
-                // Only on the first rule access - start the chain of calls
-                return genEnforceLazy(key);
-            }
-        });
-    }
-    var enforce = genEnforce();
-
-    /**
-     * @returns a unique numeric id.
-     */
-    var genId = (function (n) { return function () {
-        return "" + n++;
-    }; })(0);
-
-    // eslint-disable-next-line max-lines-per-function
-    function createState(onStateChange) {
-        var state = {
-            references: []
-        };
-        var registrations = [];
-        return {
-            registerStateKey: registerStateKey,
-            reset: reset
-        };
-        /**
-         * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-         *
-         * @example
-         *
-         * const useColor = state.registerStateKey("blue");
-         *
-         * let [color, setColor] = useColor(); // -> ["blue", Function]
-         *
-         * setColor("green");
-         *
-         * useColor()[0]; -> "green"
-         */
-        function registerStateKey(initialState, onUpdate) {
-            var key = registrations.length;
-            registrations.push([initialState, onUpdate]);
-            return initKey(key, initialState);
-        }
-        function reset() {
-            var prev = current();
-            state.references = [];
-            registrations.forEach(function (_a, index) {
-                var initialValue = _a[0];
-                return initKey(index, initialValue, prev[index]);
-            });
-        }
-        function initKey(key, initialState, prevState) {
-            current().push();
-            set(key, optionalFunctionValue(initialState, prevState));
-            return function useStateKey() {
-                return [
-                    current()[key],
-                    function (nextState) {
-                        return set(key, optionalFunctionValue(nextState, current()[key]));
-                    },
-                ];
-            };
-        }
-        function current() {
-            return state.references;
-        }
-        function set(index, value) {
-            var prevValue = state.references[index];
-            state.references[index] = value;
-            var _a = registrations[index], onUpdate = _a[1];
-            if (isFunction(onUpdate)) {
-                onUpdate(value, prevValue);
-            }
-            if (isFunction(onStateChange)) {
-                onStateChange();
-            }
-        }
-    }
-
-    var IsolateTypes;
-    (function (IsolateTypes) {
-        IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
-        IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
-        IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
-        IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
-        IsolateTypes[IsolateTypes["GROUP"] = 4] = "GROUP";
-    })(IsolateTypes || (IsolateTypes = {}));
-
-    function createStateRef(state, _a) {
-        var suiteId = _a.suiteId;
-        return {
-            optionalFields: state.registerStateKey(function () { return ({}); }),
-            suiteId: state.registerStateKey(suiteId),
-            testCallbacks: state.registerStateKey(function () { return ({
-                fieldCallbacks: {},
-                doneCallbacks: []
-            }); }),
-            testObjects: state.registerStateKey(function (prev) {
-                return {
-                    prev: (prev ? prev.current : []),
-                    current: []
-                };
-            })
-        };
-    }
-
-    function asArray(possibleArg) {
-        return [].concat(possibleArg);
-    }
-
-    function last(values) {
-        var valuesArray = asArray(values);
-        var _a = valuesArray, l = _a.length, _b = l - 1, lastValue = _a[_b];
-        return lastValue;
-    }
-
-    function createCursor() {
-        var storage = {
-            cursor: []
-        };
-        function addLevel() {
-            storage.cursor.push(0);
-        }
-        function removeLevel() {
-            storage.cursor.pop();
-        }
-        function cursorAt() {
-            return last(storage.cursor);
-        }
-        function getCursor() {
-            return asArray(storage.cursor);
-        }
-        function next() {
-            storage.cursor[storage.cursor.length - 1]++;
-            return last(storage.cursor);
-        }
-        function reset() {
-            storage.cursor = [0];
-        }
-        reset();
-        return {
-            addLevel: addLevel,
-            cursorAt: cursorAt,
-            getCursor: getCursor,
-            next: next,
-            removeLevel: removeLevel,
-            reset: reset
-        };
-    }
-
-    var ctx = createContext(function (ctxRef, parentContext) {
-        return parentContext
-            ? null
-            : assign({}, {
-                isolate: { type: IsolateTypes.DEFAULT },
-                testCursor: createCursor(),
-                exclusion: {
-                    tests: {},
-                    groups: {}
-                }
-            }, ctxRef);
-    });
-
-    // This is sort of a map/filter in one function.
-    // Normally, behaves like a nested-array map
-    // Returning `null` will drop the element from the array
-    function transform(array, cb) {
-        var res = [];
-        for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-            var v = array_1[_i];
-            if (isArray(v)) {
-                res.push(transform(v, cb));
-            }
-            else {
-                var output = cb(v);
-                if (isNotNull(output)) {
-                    res.push(output);
-                }
-            }
-        }
-        return res;
-    }
-    function valueAtPath(array, path) {
-        return getCurrent(array, path)[last(path)];
-    }
-    function setValueAtPath(array, path, value) {
-        var current = getCurrent(array, path);
-        current[last(path)] = value;
-        return array;
-    }
-    function flatten(values) {
-        return asArray(values).reduce(function (acc, value) {
-            if (isArray(value)) {
-                return acc.concat(flatten(value));
-            }
-            return asArray(acc).concat(value);
-        }, []);
-    }
-    function getCurrent(array, path) {
-        var current = array;
-        for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
-            var p = _a[_i];
-            current[p] = defaultTo(current[p], []);
-            current = current[p];
-        }
-        return current;
-    }
-
-    /**
-     * Creates a cache function
-     */
-    function createCache(maxSize) {
-        if (maxSize === void 0) { maxSize = 1; }
-        var cacheStorage = [];
-        var cache = function (deps, cacheAction) {
-            var cacheHit = cache.get(deps);
-            // cache hit is not null
-            if (cacheHit)
-                return cacheHit[1];
-            var result = cacheAction();
-            cacheStorage.unshift([deps.concat(), result]);
-            if (longerThan(cacheStorage, maxSize))
-                cacheStorage.length = maxSize;
-            return result;
-        };
-        // invalidate an item in the cache by its dependencies
-        cache.invalidate = function (deps) {
-            var index = cacheStorage.findIndex(function (_a) {
-                var cachedDeps = _a[0];
-                return lengthEquals(deps, cachedDeps.length) &&
-                    deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-            });
-            if (index > -1)
-                cacheStorage.splice(index, 1);
-        };
-        // Retrieves an item from the cache.
-        cache.get = function (deps) {
-            return cacheStorage[cacheStorage.findIndex(function (_a) {
-                var cachedDeps = _a[0];
-                return lengthEquals(deps, cachedDeps.length) &&
-                    deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-            })] || null;
-        };
-        return cache;
-    }
-
-    // STATE REF
-    function useStateRef() {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return ctx.useX().stateRef; // I should revisit this
-    }
-    // STATE KEYS
-    function useSuiteId() {
-        return useStateRef().suiteId();
-    }
-    function useTestCallbacks() {
-        return useStateRef().testCallbacks();
-    }
-    function useOptionalFields() {
-        return useStateRef().optionalFields();
-    }
-    function useTestObjects() {
-        return useStateRef().testObjects();
-    }
-    // STATE ACTIONS
-    function useRefreshTestObjects() {
-        var _a = useTestObjects(), setTestObjects = _a[1];
-        setTestObjects(function (_a) {
-            var current = _a.current, prev = _a.prev;
-            return ({
-                prev: prev,
-                current: asArray(current)
-            });
-        });
-    }
-    function useSetTests(handler) {
-        var _a = useTestObjects(), testObjects = _a[1];
-        testObjects(function (_a) {
-            var current = _a.current, prev = _a.prev;
-            return ({
-                prev: prev,
-                current: asArray(handler(current))
-            });
-        });
-    }
-    // Derived state
-    function useAllIncomplete() {
-        var current = useTestObjects()[0].current;
-        return flatten(transform(current, function (testObject) {
-            return testObject.isPending() ? testObject : null;
-        }));
-    }
-    function useOmittedFields() {
-        var testObjects = useTestsFlat();
-        return testObjects.reduce(function (omittedFields, testObject) {
-            if (omittedFields[testObject.fieldName]) {
-                return omittedFields;
-            }
-            if (testObject.isOmitted()) {
-                omittedFields[testObject.fieldName] = true;
-            }
-            return omittedFields;
-        }, {});
-    }
-    var flatCache = createCache();
-    function useTestsFlat() {
-        var current = useTestObjects()[0].current;
-        return flatCache([current], function () { return flatten(current); });
-    }
-
-    function usePath() {
-        var context = ctx.useX();
-        return context.testCursor.getCursor();
-    }
-    function useCursorAt() {
-        var context = ctx.useX();
-        return context.testCursor.cursorAt();
-    }
-    function moveForward() {
-        var context = ctx.useX();
-        return context.testCursor.next();
-    }
-    function addLevel() {
-        var context = ctx.useX();
-        context.testCursor.addLevel();
-    }
-    function removeLevel() {
-        var context = ctx.useX();
-        context.testCursor.removeLevel();
-    }
-
-    function isolate(_a, callback) {
-        var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-        if (!isFunction(callback)) {
-            return;
-        }
-        var path = usePath();
-        return ctx.run({ isolate: { type: type } }, function () {
-            addLevel();
-            useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
-            var res = callback();
-            removeLevel();
-            moveForward();
-            return res;
-        });
-    }
-    function shouldAllowReorder() {
-        return ctx.useX().isolate.type === IsolateTypes.EACH;
-    }
-
-    function nonMatchingFieldName(testObject, fieldName) {
-        return !!fieldName && !matchingFieldName(testObject, fieldName);
-    }
-    function matchingFieldName(testObject, fieldName) {
-        return !!(fieldName && testObject.fieldName === fieldName);
-    }
-
-    function omitOptionalTests() {
-        var optionalFields = useOptionalFields()[0];
-        if (isEmpty(optionalFields)) {
-            return;
-        }
-        var shouldOmit = {};
-        useSetTests(function (tests) {
-            return transform(tests, function (testObject) {
-                var fieldName = testObject.fieldName;
-                if (shouldOmit.hasOwnProperty(fieldName)) {
-                    omit(testObject);
-                }
-                else {
-                    var optionalConfig = optionalFields[fieldName];
-                    if (isFunction(optionalConfig)) {
-                        shouldOmit[fieldName] = optionalConfig();
-                        omit(testObject);
-                    }
-                }
-                return testObject;
-            });
-        });
-        function omit(testObject) {
-            if (shouldOmit[testObject.fieldName]) {
-                testObject.omit();
-            }
-        }
-    }
-
-    /**
-     * Checks if a given field, or the suite as a whole still have remaining tests.
-     */
-    function hasRemainingTests(fieldName) {
-        var allIncomplete = useAllIncomplete();
-        if (isEmpty(allIncomplete)) {
-            return false;
-        }
-        if (fieldName) {
-            return allIncomplete.some(function (testObject) {
-                return matchingFieldName(testObject, fieldName);
-            });
-        }
-        return isNotEmpty(allIncomplete);
-    }
-
-    /**
-     * Reads the testObjects list and gets full validation result from it.
-     */
-    function genTestsSummary() {
-        var testObjects = useTestsFlat();
-        var summary = {
-            errorCount: 0,
-            groups: {},
-            testCount: 0,
-            tests: {},
-            warnCount: 0
-        };
-        appendSummary(testObjects);
-        return countFailures(summary);
-        function appendSummary(testObjects) {
-            testObjects.forEach(function (testObject) {
-                var fieldName = testObject.fieldName, groupName = testObject.groupName;
-                summary.tests[fieldName] = genTestObject(summary.tests, testObject);
-                if (groupName) {
-                    summary.groups[groupName] = summary.groups[groupName] || {};
-                    summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject);
-                }
-            });
-        }
-    }
-    /**
-     * Counts the failed tests and adds global counters
-     */
-    function countFailures(summary) {
-        for (var test in summary.tests) {
-            summary.errorCount += summary.tests[test].errorCount;
-            summary.warnCount += summary.tests[test].warnCount;
-            summary.testCount += summary.tests[test].testCount;
-        }
-        return summary;
-    }
-    // eslint-disable-next-line max-statements
-    function genTestObject(summaryKey, testObject) {
-        var fieldName = testObject.fieldName, message = testObject.message;
-        summaryKey[fieldName] = summaryKey[fieldName] || {
-            errorCount: 0,
-            warnCount: 0,
-            testCount: 0
-        };
-        var testKey = summaryKey[fieldName];
-        if (testObject.isSkipped())
-            return testKey;
-        summaryKey[fieldName].testCount++;
-        // Adds to severity group
-        function addTo(countKey, group) {
-            testKey[countKey]++;
-            if (message) {
-                testKey[group] = (testKey[group] || []).concat(message);
-            }
-        }
-        if (testObject.isFailing()) {
-            addTo('errorCount', 'errors');
-        }
-        else if (testObject.isWarning()) {
-            addTo('warnCount', 'warnings');
-        }
-        return testKey;
-    }
-
-    function either(a, b) {
-        return !!a !== !!b;
-    }
-
-    /**
-     * Checks that a given test object matches the currently specified severity level
-     */
-    function nonMatchingSeverityProfile(severity, testObject) {
-        return either(severity === 'warnings', testObject.warns);
-    }
-
-    function collectFailureMessages(severity, testObjects, options) {
-        var _a;
-        if (options === void 0) { options = {}; }
-        var _b = options || {}, group = _b.group, fieldName = _b.fieldName;
-        var res = testObjects.reduce(function (collector, testObject) {
-            if (noMatch(testObject, severity, group, fieldName)) {
-                return collector;
-            }
-            if (!testObject.hasFailures()) {
-                return collector;
-            }
-            collector[testObject.fieldName] = (collector[testObject.fieldName] || []).concat(testObject.message || []);
-            return collector;
-        }, __assign({}, (fieldName && (_a = {}, _a[fieldName] = [], _a))));
-        return res;
-    }
-    function noGroupMatch(testObject, groupName) {
-        return !!(groupName && testObject.groupName !== groupName);
-    }
-    function noMatch(testObject, severity, group, fieldName) {
-        if (noGroupMatch(testObject, group)) {
-            return true;
-        }
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return true;
-        }
-        if (nonMatchingSeverityProfile(severity, testObject)) {
-            return true;
-        }
-        return false;
-    }
-
-    function getFailuresArrayOrObject(group, fieldName) {
-        if (fieldName) {
-            return group[fieldName];
-        }
-        return group;
-    }
-
-    function getErrors(fieldName) {
-        return getFailures('errors', fieldName);
-    }
-    function getWarnings(fieldName) {
-        return getFailures('warnings', fieldName);
-    }
-    /**
-     * @returns suite or field's errors or warnings.
-     */
-    function getFailures(severityKey, fieldName) {
-        var testObjects = useTestsFlat();
-        var failureMessages = collectFailureMessages(severityKey, testObjects, {
-            fieldName: fieldName
-        });
-        return getFailuresArrayOrObject(failureMessages, fieldName);
-    }
-
-    function getErrorsByGroup(groupName, fieldName) {
-        var errors = getByGroup('errors', groupName, fieldName);
-        return getFailuresArrayOrObject(errors, fieldName);
-    }
-    function getWarningsByGroup(groupName, fieldName) {
-        var warnings = getByGroup('warnings', groupName, fieldName);
-        return getFailuresArrayOrObject(warnings, fieldName);
-    }
-    /**
-     * Gets failure messages by group.
-     */
-    function getByGroup(severityKey, group, fieldName) {
-        if (!group) {
-            throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
-        }
-        var testObjects = useTestsFlat();
-        var failureMessages = collectFailureMessages(severityKey, testObjects, {
-            group: group,
-            fieldName: fieldName
-        });
-        return failureMessages;
-    }
-
-    /**
-     * Determines whether a certain test profile has failures.
-     */
-    function hasFailuresLogic(testObject, severityKey, fieldName) {
-        if (!testObject.hasFailures()) {
-            return false;
-        }
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return false;
-        }
-        if (nonMatchingSeverityProfile(severityKey, testObject)) {
-            return false;
-        }
-        return true;
-    }
-
-    function hasErrors(fieldName) {
-        return has('errors', fieldName);
-    }
-    function hasWarnings(fieldName) {
-        return has('warnings', fieldName);
-    }
-    function has(severityKey, fieldName) {
-        var testObjects = useTestsFlat();
-        return testObjects.some(function (testObject) {
-            return hasFailuresLogic(testObject, severityKey, fieldName);
-        });
-    }
-
-    function hasErrorsByGroup(groupName, fieldName) {
-        return hasByGroup('errors', groupName, fieldName);
-    }
-    function hasWarningsByGroup(groupName, fieldName) {
-        return hasByGroup('warnings', groupName, fieldName);
-    }
-    /**
-     * Checks whether there are failures in a given group.
-     */
-    function hasByGroup(severityKey, group, fieldName) {
-        var testObjects = useTestsFlat();
-        return testObjects.some(function (testObject) {
-            return group === testObject.groupName
-                ? hasFailuresLogic(testObject, severityKey, fieldName)
-                : false;
-        });
-    }
-
-    // eslint-disable-next-line max-statements, complexity
-    function isValid(result, fieldName) {
-        if (fieldIsOmitted(fieldName)) {
-            return true;
-        }
-        if (result.hasErrors(fieldName)) {
-            return false;
-        }
-        var testObjects = useTestsFlat();
-        if (isEmpty(testObjects)) {
-            return false;
-        }
-        if (fieldDoesNotExist(result, fieldName)) {
-            return false;
-        }
-        if (hasNonOptionalIncomplete(fieldName)) {
-            return false;
-        }
-        return noMissingTests(fieldName);
-    }
-    function fieldIsOmitted(fieldName) {
-        var omittedFields = useOmittedFields();
-        if (!fieldName) {
-            return false;
-        }
-        return !!omittedFields[fieldName];
-    }
-    function hasNonOptionalIncomplete(fieldName) {
-        var optionalFields = useOptionalFields()[0];
-        return isNotEmpty(useAllIncomplete().filter(function (testObject) {
-            if (nonMatchingFieldName(testObject, fieldName)) {
-                return false;
-            }
-            return optionalFields[testObject.fieldName] !== true;
-        }));
-    }
-    function fieldDoesNotExist(result, fieldName) {
-        return !!fieldName && isEmpty(result.tests[fieldName]);
-    }
-    function noMissingTests(fieldName) {
-        var testObjects = useTestsFlat();
-        var optionalFields = useOptionalFields()[0];
-        return testObjects.every(function (testObject) {
-            if (nonMatchingFieldName(testObject, fieldName)) {
-                return true;
-            }
-            return (optionalFields[testObject.fieldName] === true ||
-                testObject.isTested() ||
-                testObject.isOmitted());
-        });
-    }
-
-    var cache$1 = createCache(20);
-    function produceDraft() {
-        var testObjects = useTestsFlat();
-        var ctxRef = { stateRef: useStateRef() };
-        return cache$1([testObjects], ctx.bind(ctxRef, function () {
-            return assign(genTestsSummary(), {
-                getErrors: ctx.bind(ctxRef, getErrors),
-                getErrorsByGroup: ctx.bind(ctxRef, getErrorsByGroup),
-                getWarnings: ctx.bind(ctxRef, getWarnings),
-                getWarningsByGroup: ctx.bind(ctxRef, getWarningsByGroup),
-                hasErrors: ctx.bind(ctxRef, hasErrors),
-                hasErrorsByGroup: ctx.bind(ctxRef, hasErrorsByGroup),
-                hasWarnings: ctx.bind(ctxRef, hasWarnings),
-                hasWarningsByGroup: ctx.bind(ctxRef, hasWarningsByGroup),
-                isValid: ctx.bind(ctxRef, function (fieldName) {
-                    return isValid(produceDraft(), fieldName);
-                })
-            });
-        }));
-    }
-
-    var cache = createCache(20);
-    function produceFullResult() {
-        var testObjects = useTestsFlat();
-        var ctxRef = { stateRef: useStateRef() };
-        return cache([testObjects], ctx.bind(ctxRef, function () {
-            return assign({}, produceDraft(), {
-                done: ctx.bind(ctxRef, done)
-            });
-        }));
-    }
-    /**
-     * DONE is here and not in its own module to prevent circular dependency issues.
-     */
-    function shouldSkipDoneRegistration(callback, fieldName, output) {
-        // If we do not have any test runs for the current field
-        return !!(!isFunction(callback) ||
-            (fieldName &&
-                (!output.tests[fieldName] || output.tests[fieldName].testCount === 0)));
-    }
-    function shouldRunDoneCallback(fieldName) {
-        // is suite finished || field name exists, and test is finished;
-        return !!(!hasRemainingTests() ||
-            (fieldName && !hasRemainingTests(fieldName)));
-    }
-    /**
-     * Registers done callbacks.
-     * @register {Object} Vest output object.
-     */
-    var done = function done() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var _a = args.reverse(), callback = _a[0], fieldName = _a[1];
-        var output = produceFullResult();
-        if (shouldSkipDoneRegistration(callback, fieldName, output)) {
-            return output;
-        }
-        var doneCallback = function () { return callback(produceDraft()); };
-        if (shouldRunDoneCallback(fieldName)) {
-            doneCallback();
-            return output;
-        }
-        deferDoneCallback(doneCallback, fieldName);
-        return output;
-    };
-    function deferDoneCallback(doneCallback, fieldName) {
-        var deferredCallback = ctx.bind({}, doneCallback);
-        var _a = useTestCallbacks(), setTestCallbacks = _a[1];
-        setTestCallbacks(function (current) {
-            if (fieldName) {
-                current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
-            }
-            else {
-                current.doneCallbacks.push(deferredCallback);
-            }
-            return current;
-        });
-    }
-
-    /**
-     * Removes test object from suite state
-     */
-    function removeTestFromState (testObject) {
-        useSetTests(function (tests) {
-            return transform(tests, function (test) { return (testObject !== test ? test : null); });
-        });
-    }
-
-    function createBus() {
-        var listeners = {};
-        return {
-            emit: function (event, data) {
-                if (!listeners[event]) {
-                    return;
-                }
-                listeners[event].forEach(function (listener) {
-                    listener(data);
-                });
-            },
-            on: function (event, handler) {
-                if (!listeners[event]) {
-                    listeners[event] = [];
-                }
-                listeners[event].push(handler);
-                return {
-                    off: function () {
-                        listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
-                    }
-                };
-            }
-        };
-    }
-
-    function callEach(arr) {
-        return arr.forEach(function (fn) { return fn(); });
-    }
-
-    /**
-     * Runs done callback per field when async tests are finished running.
-     */
-    function runFieldCallbacks(fieldName) {
-        var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
-        if (fieldName) {
-            if (!hasRemainingTests(fieldName) && isArray(fieldCallbacks[fieldName])) {
-                callEach(fieldCallbacks[fieldName]);
-            }
-        }
-    }
-    /**
-     * Runs unlabelled done callback when async tests are finished running.
-     */
-    function runDoneCallbacks() {
-        var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-        if (!hasRemainingTests()) {
-            callEach(doneCallbacks);
-        }
-    }
-
-    function initBus() {
-        var bus = createBus();
-        bus.on(Events.TEST_COMPLETED, function (testObject) {
-            if (testObject.isCanceled()) {
-                return;
-            }
-            testObject.done();
-            runFieldCallbacks(testObject.fieldName);
-            runDoneCallbacks();
-        });
-        return bus;
-    }
-    function useBus() {
-        var context = ctx.useX();
-        if (!context.bus) {
-            throwError();
-        }
-        return context.bus;
-    }
-    var Events;
-    (function (Events) {
-        Events["TEST_COMPLETED"] = "test_completed";
-    })(Events || (Events = {}));
-
-    // eslint-disable-next-line max-lines-per-function
-    function create(suiteCallback) {
-        if (!isFunction(suiteCallback)) {
-            throwError('Suite initialization error. Expected `tests` to be a function.');
-        }
-        var bus = initBus();
-        var state = createState();
-        var stateRef = createStateRef(state, { suiteId: genId() });
-        var suite = assign(ctx.bind({ stateRef: stateRef, bus: bus }, function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            state.reset();
-            // Run the consumer's callback
-            isolate({ type: IsolateTypes.SUITE }, function () {
-                suiteCallback.apply(void 0, args);
-            });
-            omitOptionalTests();
-            var res = produceFullResult();
-            return res;
-        }), {
-            get: ctx.bind({ stateRef: stateRef }, produceDraft),
-            remove: ctx.bind({ stateRef: stateRef }, function (name) {
-                var testObjects = useTestsFlat();
-                // We're mutating the array in `cancel`, so we have to first copy it.
-                testObjects.forEach(function (testObject) {
-                    if (matchingFieldName(testObject, name)) {
-                        testObject.cancel();
-                        removeTestFromState(testObject);
-                    }
-                });
-            }),
-            reset: state.reset
-        });
-        return suite;
-    }
-
-    /**
-     * Error message to display when a hook was called outside of context.
-     */
-    var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
-
-    /**
-     * Adds a field or multiple fields to inclusion group.
-     */
-    function only(item) {
-        return addTo('only', 'tests', item);
-    }
-    only.group = function (item) { return addTo('only', 'groups', item); };
-    /**
-     * Adds a field or multiple fields to exclusion group.
-     */
-    function skip(item) {
-        return addTo('skip', 'tests', item);
-    }
-    skip.group = function (item) { return addTo('skip', 'groups', item); };
-    //Checks whether a certain test profile excluded by any of the exclusion groups.
-    // eslint-disable-next-line complexity, max-statements
-    function isExcluded(testObject) {
-        var fieldName = testObject.fieldName, groupName = testObject.groupName;
-        var context = ctx.useX();
-        if (context.skipped)
-            return true;
-        var exclusion = context.exclusion;
-        var keyTests = exclusion.tests;
-        var testValue = keyTests[fieldName];
-        // if test is skipped
-        // no need to proceed
-        if (testValue === false)
-            return true;
-        var isTestIncluded = testValue === true;
-        // If inside a group
-        if (groupName) {
-            if (isGroupExcluded(groupName)) {
-                return true; // field excluded by group
-                // if group is `only`ed
-            }
-            else if (exclusion.groups[groupName] === true) {
-                if (isTestIncluded)
-                    return false;
-                // If there is _ANY_ `only`ed test (and we already know this one isn't)
-                if (hasIncludedTests(keyTests))
-                    return true; // Excluded implicitly
-                return keyTests[fieldName] === false;
-            }
-        }
-        // if field is only'ed
-        if (isTestIncluded)
-            return false;
-        // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
-        // Otherwise return false
-        return hasIncludedTests(keyTests);
-    }
-    /**
-     * Checks whether a given group is excluded from running.
-     */
-    function isGroupExcluded(groupName) {
-        var context = ctx.useX();
-        var exclusion = context.exclusion;
-        var keyGroups = exclusion.groups;
-        var groupPresent = hasOwnProperty(keyGroups, groupName);
-        // When group is either only'ed or skipped
-        if (groupPresent) {
-            // Return true if group is skipped and false if only'ed
-            return keyGroups[groupName] === false;
-        }
-        // Group is not present
-        for (var group in keyGroups) {
-            // If any other group is only'ed
-            if (keyGroups[group] === true) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Adds fields to a specified exclusion group.
-     */
-    function addTo(exclusionGroup, itemType, item) {
-        var context = ctx.useX(ERROR_HOOK_CALLED_OUTSIDE);
-        if (!item) {
-            return;
-        }
-        asArray(item).forEach(function (itemName) {
-            if (!isStringValue(itemName)) {
-                return;
-            }
-            context.exclusion[itemType][itemName] = exclusionGroup === 'only';
-        });
-    }
-    /**
-     * Checks if context has included tests
-     */
-    function hasIncludedTests(keyTests) {
-        for (var test in keyTests) {
-            if (keyTests[test] === true) {
-                return true; // excluded implicitly
-            }
-        }
-        return false;
-    }
-
-    function skipWhen(conditional, callback) {
-        isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
-            ctx.run({ skipped: optionalFunctionValue(conditional) }, function () { return callback(); });
-        });
-    }
-
-    var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
-        ;
-    /**
-     * Sets a running test to warn only mode.
-     */
-    function warn() {
-        var ctx$1 = ctx.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-        if (!ctx$1.currentTest) {
-            throwError(ERROR_OUTSIDE_OF_TEST);
-        }
-        ctx$1.currentTest.warn();
-    }
-
-    /**
-     * Runs a group callback.
-     */
-    function group(groupName, tests) {
-        if (!isStringValue(groupName)) {
-            throwGroupError('name must be a string');
-        }
-        if (!isFunction(tests)) {
-            throwGroupError('callback must be a function');
-        }
-        // Running with the context applied
-        isolate({ type: IsolateTypes.GROUP }, function () {
-            ctx.run({ groupName: groupName }, tests);
-        });
-    }
-    function throwGroupError(error) {
-        throwError("Wrong arguments passed to group. Group " + error + ".");
-    }
-
-    function optional(optionals) {
-        var _a = useOptionalFields(), setOptionalFields = _a[1];
-        setOptionalFields(function (state) {
-            if (!isArray(optionals) && !isStringValue(optionals)) {
-                var optionalFunctions = optionals;
-                for (var field in optionalFunctions) {
-                    var predicate = optionalFunctions[field];
-                    state[field] = predicate;
-                }
-            }
-            else {
-                asArray(optionals).forEach(function (optionalField) {
-                    state[optionalField] = true;
-                });
-            }
-            return state;
-        });
-    }
-
-    function shouldUseErrorAsMessage(message, error) {
-        // kind of cheating with this safe guard, but it does the job
-        return isUndefined(message) && isStringValue(error);
-    }
-
-    var VestTest = /** @class */ (function () {
-        function VestTest(fieldName, testFn, _a) {
-            var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName;
-            this.id = genId();
-            this.warns = false;
-            this.status = STATUS_UNTESTED;
-            this.fieldName = fieldName;
-            this.testFn = testFn;
-            if (groupName) {
-                this.groupName = groupName;
-            }
-            if (message) {
-                this.message = message;
-            }
-        }
-        VestTest.prototype.run = function () {
-            var result;
-            try {
-                result = this.testFn();
-            }
-            catch (error) {
-                if (shouldUseErrorAsMessage(this.message, error)) {
-                    this.message = error;
-                }
-                result = false;
-            }
-            if (result === false) {
-                this.fail();
-            }
-            return result;
-        };
-        VestTest.prototype.setStatus = function (status) {
-            if (this.isFinalStatus() && status !== STATUS_OMITTED) {
-                return;
-            }
-            this.status = status;
-        };
-        VestTest.prototype.setPending = function () {
-            this.setStatus(STATUS_PENDING);
-        };
-        VestTest.prototype.fail = function () {
-            this.setStatus(this.warns ? STATUS_WARNING : STATUS_FAILED);
-        };
-        VestTest.prototype.done = function () {
-            if (this.isFinalStatus()) {
-                return;
-            }
-            this.setStatus(STATUS_PASSING);
-        };
-        VestTest.prototype.warn = function () {
-            this.warns = true;
-        };
-        VestTest.prototype.isFinalStatus = function () {
-            return this.hasFailures() || this.isCanceled() || this.isPassing();
-        };
-        VestTest.prototype.skip = function () {
-            if (this.isPending()) {
-                // Without this condition, the test will be marked as skipped even if it is pending.
-                // This means that it will not be counted in "allIncomplete" and its done callbacks
-                // will not be called, or will be called prematurely.
-                return;
-            }
-            this.setStatus(STATUS_SKIPPED);
-        };
-        VestTest.prototype.cancel = function () {
-            this.setStatus(STATUS_CANCELED);
-            useRefreshTestObjects();
-        };
-        VestTest.prototype.omit = function () {
-            this.setStatus(STATUS_OMITTED);
-        };
-        VestTest.prototype.valueOf = function () {
-            return !this.isFailing();
-        };
-        VestTest.prototype.hasFailures = function () {
-            return this.isFailing() || this.isWarning();
-        };
-        VestTest.prototype.isPending = function () {
-            return this.status === STATUS_PENDING;
-        };
-        VestTest.prototype.isTested = function () {
-            return this.hasFailures() || this.isPassing();
-        };
-        VestTest.prototype.isOmitted = function () {
-            return this.status === STATUS_OMITTED;
-        };
-        VestTest.prototype.isUntested = function () {
-            return this.status === STATUS_UNTESTED;
-        };
-        VestTest.prototype.isFailing = function () {
-            return this.status === STATUS_FAILED;
-        };
-        VestTest.prototype.isCanceled = function () {
-            return this.status === STATUS_CANCELED;
-        };
-        VestTest.prototype.isSkipped = function () {
-            return this.status === STATUS_SKIPPED;
-        };
-        VestTest.prototype.isPassing = function () {
-            return this.status === STATUS_PASSING;
-        };
-        VestTest.prototype.isWarning = function () {
-            return this.status === STATUS_WARNING;
-        };
-        return VestTest;
-    }());
-    var STATUS_UNTESTED = 'UNTESTED';
-    var STATUS_SKIPPED = 'SKIPPED';
-    var STATUS_FAILED = 'FAILED';
-    var STATUS_WARNING = 'WARNING';
-    var STATUS_PASSING = 'PASSING';
-    var STATUS_PENDING = 'PENDING';
-    var STATUS_CANCELED = 'CANCELED';
-    var STATUS_OMITTED = 'OMITTED';
-
-    function isPromise(value) {
-        return value && isFunction(value.then);
-    }
-
-    function isSameProfileTest(testObject1, testObject2) {
-        return (testObject1.fieldName === testObject2.fieldName &&
-            testObject1.groupName === testObject2.groupName);
-    }
-
-    function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
-        if (currentRunTestObject !== prevRunTestObject &&
-            isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
-            prevRunTestObject.isPending()) {
-            prevRunTestObject.cancel();
-        }
-    }
-
-    /**
-     * Runs async test.
-     */
-    function runAsyncTest(testObject) {
-        var asyncTest = testObject.asyncTest, message = testObject.message;
-        if (!isPromise(asyncTest))
-            return;
-        var emit = useBus().emit;
-        var stateRef = useStateRef();
-        var done = ctx.bind({ stateRef: stateRef }, function () {
-            // invalidating the "produce" cache
-            useRefreshTestObjects();
-            emit(Events.TEST_COMPLETED, testObject);
-        });
-        var fail = ctx.bind({ stateRef: stateRef }, function (rejectionMessage) {
-            if (testObject.isCanceled()) {
-                return;
-            }
-            testObject.message = isStringValue(rejectionMessage)
-                ? rejectionMessage
-                : message;
-            testObject.fail();
-            done();
-        });
-        try {
-            asyncTest.then(done, fail);
-        }
-        catch (e) {
-            fail();
-        }
-    }
-
-    /**
-     * Runs sync tests - or extracts promise.
-     */
-    function runSyncTest(testObject) {
-        return ctx.run({ currentTest: testObject }, function () {
-            var result;
-            try {
-                result = testObject.testFn();
-            }
-            catch (e) {
-                if (shouldUseErrorAsMessage(testObject.message, e)) {
-                    testObject.message = e;
-                }
-                result = false;
-            }
-            if (result === false) {
-                testObject.fail();
-            }
-            return result;
-        });
-    }
-
-    /**
-     * Registers test, if async - adds to pending array
-     */
-    function registerTest(testObject) {
-        var emit = useBus().emit;
-        // Run test callback.
-        // If a promise is returned, set as async and
-        // Move to pending list.
-        var result = runSyncTest(testObject);
-        try {
-            // try catch for safe property access
-            // in case object is an enforce chain
-            if (isPromise(result)) {
-                testObject.asyncTest = result;
-                testObject.setPending();
-                runAsyncTest(testObject);
-            }
-            else {
-                emit(Events.TEST_COMPLETED, testObject);
-            }
-        }
-        catch (e) {
-            throwError("Your test function " + testObject.fieldName + " returned " + JSON.stringify(result) + ". Only \"false\" or a Promise are supported. Return values may cause unexpected behavior.");
-        }
-    }
-
-    /**
-     * This module serves as the "collision detection" mechanism for Vest.
-     * It is used to ensure that tests are not called in a different order than
-     * they were called in the previous run.
-     * If they are, it will throw a deferred error unless explicitly allowed.
-     *
-     * For now it seems pretty safe, and it covers most common use cases, but it can
-     * be improved in the future both in terms of performance and scenarios it covers.
-     */
-    // eslint-disable-next-line max-statements, max-lines-per-function
-    function useTestAtCursor(newTestObject) {
-        var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
-        var prevTests = testObjects.prev;
-        if (isEmpty(prevTests)) {
-            useSetTestAtCursor(newTestObject);
-            return newTestObject;
-        }
-        var prevTest = useGetTestAtCursor(prevTests);
-        if (shouldPurgePrevTest(prevTest, newTestObject)) {
-            throwTestOrderError(prevTest, newTestObject);
-            // Here we handle just the omission of tests in the middle of the test suite.
-            // We need to also handle a case in which tests are added in between other tests.
-            // At the moment all we can do is just splice the tests out of the array when this happens.
-            // A viable solution would be to use something like React's key prop to identify tests regardless
-            // of their position in the suite. https://reactjs.org/docs/lists-and-keys.html#keys
-            var current = getCurrent(prevTests, usePath());
-            var cursorAt = useCursorAt();
-            current.splice(cursorAt);
-            // We actually don't mind mutating the state directly (as can be seen above). There is no harm in it
-            // since we're only touching the "prev" state. The reason we still use the setter function is
-            // to prevent future headaches if we ever do need to rely on prev-state immutability.
-            setTestObjects(function (_a) {
-                var current = _a.current;
-                return ({
-                    prev: prevTests,
-                    current: current
-                });
-            });
-            // Need to see if this has any effect at all.
-            prevTest = null;
-        }
-        var nextTest = defaultTo(prevTest, newTestObject);
-        useSetTestAtCursor(nextTest);
-        return nextTest;
-    }
-    function useSetTestAtCursor(testObject) {
-        var cursorPath = usePath();
-        useSetTests(function (tests) {
-            return setValueAtPath(tests, cursorPath, testObject);
-        });
-    }
-    function useGetTestAtCursor(tests) {
-        var cursorPath = usePath();
-        return valueAtPath(tests, cursorPath);
-    }
-    function shouldPurgePrevTest(prevTest, newTest) {
-        return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
-    }
-    function throwTestOrderError(prevTest, newTestObject) {
-        if (shouldAllowReorder()) {
-            return;
-        }
-        throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    expected: " + prevTest.fieldName + "\n    received: " + newTestObject.fieldName + "\n    This happens when you conditionally call your tests using if/else.\n    This might lead to incorrect validation results.\n    Replacing if/else with skipWhen solves these issues.");
-    }
-
-    function registerPrevRunTest(testObject) {
-        var prevRunTest = useTestAtCursor(testObject);
-        if (isExcluded(testObject)) {
-            testObject.skip();
-            moveForward();
-            return prevRunTest;
-        }
-        cancelOverriddenPendingTest(prevRunTest, testObject);
-        useSetTestAtCursor(testObject);
-        moveForward();
-        registerTestObjectByTier(testObject);
-        return testObject;
-    }
-    function registerTestObjectByTier(testObject) {
-        if (testObject.isUntested()) {
-            registerTest(testObject);
-        }
-        else if (isPromise(testObject.asyncTest)) {
-            testObject.setPending();
-            runAsyncTest(testObject);
-        }
-    }
-
-    function bindTestEach(test) {
-        /**
-         * Run multiple tests using a parameter table
-         */
-        function each(table) {
-            if (!isArray(table)) {
-                throwError('test.each: Expected table to be an array.');
-            }
-            function eachReturn(fieldName) {
-                var args = [];
-                for (var _i = 1; _i < arguments.length; _i++) {
-                    args[_i - 1] = arguments[_i];
-                }
-                var _a = args.reverse(), testFn = _a[0], message = _a[1];
-                return isolate({ type: IsolateTypes.EACH }, function () {
-                    return table.map(function (item) {
-                        item = asArray(item);
-                        return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item)), optionalFunctionValue.apply(void 0, __spreadArray([message], item)), function () { return testFn.apply(void 0, item); } // eslint-disable-line max-nested-callbacks
-                        );
-                    });
-                });
-            }
-            return eachReturn;
-        }
-        return each;
-    }
-
-    // eslint-disable-next-line max-lines-per-function
-    function bindTestMemo(test) {
-        var cache = createCache(100); // arbitrary cache size
-        // eslint-disable-next-line max-statements
-        function memo(fieldName) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            var suiteId = useSuiteId()[0];
-            var cursorAt = useCursorAt();
-            var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
-            // Implicit dependency for more specificity
-            var dependencies = [suiteId, fieldName, cursorAt].concat(deps);
-            var cached = cache.get(dependencies);
-            if (isNull(cached)) {
-                // cache miss
-                return cache(dependencies, function () { return test(fieldName, msg, testFn); });
-            }
-            if (cached[1].isCanceled()) {
-                // cache hit, but test is canceled
-                cache.invalidate(dependencies);
-                return cache(dependencies, function () { return test(fieldName, msg, testFn); });
-            }
-            return registerPrevRunTest(cached[1]);
-        }
-        return memo;
-    }
-
-    function testBase(fieldName) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var _a = args.reverse(), testFn = _a[0], message = _a[1];
-        var context = ctx.useX();
-        var testObject = new VestTest(fieldName, testFn, {
-            message: message,
-            groupName: context === null || context === void 0 ? void 0 : context.groupName
-        });
-        return registerPrevRunTest(testObject);
-    }
-    var test = assign(testBase, {
-        each: bindTestEach(testBase),
-        memo: bindTestMemo(testBase)
-    });
-
-    var VERSION = "4.0.0-dev-7acb76";
-
-    exports.VERSION = VERSION;
-    exports.create = create;
-    exports.enforce = enforce;
-    exports.group = group;
-    exports.only = only;
-    exports.optional = optional;
-    exports.skip = skip;
-    exports.skipWhen = skipWhen;
-    exports.test = test;
-    exports.warn = warn;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
+  function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+              if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+              ar[i] = from[i];
+          }
+      }
+      return to.concat(ar || from);
+  }
+
+  function either(a, b) {
+      return !!a !== !!b;
+  }
+
+  /**
+   * Checks that a given test object matches the currently specified severity level
+   */
+  function nonMatchingSeverityProfile(severity, testObject) {
+      return either(severity === 'warnings', testObject.warns());
+  }
+
+  function collectFailureMessages(severity, testObjects, options) {
+      var _a;
+      if (options === void 0) { options = {}; }
+      var _b = options || {}, group = _b.group, fieldName = _b.fieldName;
+      var res = testObjects.reduce(function (collector, testObject) {
+          if (noMatch(testObject, severity, group, fieldName)) {
+              return collector;
+          }
+          if (!testObject.hasFailures()) {
+              return collector;
+          }
+          collector[testObject.fieldName] = (collector[testObject.fieldName] || []).concat(testObject.message || []);
+          return collector;
+      }, __assign({}, (fieldName && (_a = {}, _a[fieldName] = [], _a))));
+      return res;
+  }
+  function noGroupMatch(testObject, groupName) {
+      return !!(groupName && testObject.groupName !== groupName);
+  }
+  function noMatch(testObject, severity, group, fieldName) {
+      if (noGroupMatch(testObject, group)) {
+          return true;
+      }
+      if (nonMatchingFieldName(testObject, fieldName)) {
+          return true;
+      }
+      if (nonMatchingSeverityProfile(severity, testObject)) {
+          return true;
+      }
+      return false;
+  }
+
+  function getFailuresArrayOrObject(group, fieldName) {
+      if (fieldName) {
+          return group[fieldName];
+      }
+      return group;
+  }
+
+  function getErrors(fieldName) {
+      return getFailures('errors', fieldName);
+  }
+  function getWarnings(fieldName) {
+      return getFailures('warnings', fieldName);
+  }
+  /**
+   * @returns suite or field's errors or warnings.
+   */
+  function getFailures(severityKey, fieldName) {
+      var testObjects = useTestsFlat();
+      var failureMessages = collectFailureMessages(severityKey, testObjects, {
+          fieldName: fieldName
+      });
+      return getFailuresArrayOrObject(failureMessages, fieldName);
+  }
+
+  function getErrorsByGroup(groupName, fieldName) {
+      var errors = getByGroup('errors', groupName, fieldName);
+      return getFailuresArrayOrObject(errors, fieldName);
+  }
+  function getWarningsByGroup(groupName, fieldName) {
+      var warnings = getByGroup('warnings', groupName, fieldName);
+      return getFailuresArrayOrObject(warnings, fieldName);
+  }
+  /**
+   * Gets failure messages by group.
+   */
+  function getByGroup(severityKey, group, fieldName) {
+      if (!group) {
+          throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
+      }
+      var testObjects = useTestsFlat();
+      var failureMessages = collectFailureMessages(severityKey, testObjects, {
+          group: group,
+          fieldName: fieldName
+      });
+      return failureMessages;
+  }
+
+  /**
+   * Determines whether a certain test profile has failures.
+   */
+  function hasFailuresLogic(testObject, severityKey, fieldName) {
+      if (!testObject.hasFailures()) {
+          return false;
+      }
+      if (nonMatchingFieldName(testObject, fieldName)) {
+          return false;
+      }
+      if (nonMatchingSeverityProfile(severityKey, testObject)) {
+          return false;
+      }
+      return true;
+  }
+
+  function hasErrors(fieldName) {
+      return has('errors', fieldName);
+  }
+  function hasWarnings(fieldName) {
+      return has('warnings', fieldName);
+  }
+  function has(severityKey, fieldName) {
+      var testObjects = useTestsFlat();
+      return testObjects.some(function (testObject) {
+          return hasFailuresLogic(testObject, severityKey, fieldName);
+      });
+  }
+
+  function hasErrorsByGroup(groupName, fieldName) {
+      return hasByGroup('errors', groupName, fieldName);
+  }
+  function hasWarningsByGroup(groupName, fieldName) {
+      return hasByGroup('warnings', groupName, fieldName);
+  }
+  /**
+   * Checks whether there are failures in a given group.
+   */
+  function hasByGroup(severityKey, group, fieldName) {
+      var testObjects = useTestsFlat();
+      return testObjects.some(function (testObject) {
+          return group === testObject.groupName
+              ? hasFailuresLogic(testObject, severityKey, fieldName)
+              : false;
+      });
+  }
+
+  // eslint-disable-next-line max-statements, complexity
+  function isValid(result, fieldName) {
+      if (fieldIsOmitted(fieldName)) {
+          return true;
+      }
+      if (result.hasErrors(fieldName)) {
+          return false;
+      }
+      var testObjects = useTestsFlat();
+      if (isEmpty(testObjects)) {
+          return false;
+      }
+      if (fieldDoesNotExist(result, fieldName)) {
+          return false;
+      }
+      if (hasNonOptionalIncomplete(fieldName)) {
+          return false;
+      }
+      return noMissingTests(fieldName);
+  }
+  function fieldIsOmitted(fieldName) {
+      var omittedFields = useOmittedFields();
+      if (!fieldName) {
+          return false;
+      }
+      return !!omittedFields[fieldName];
+  }
+  function hasNonOptionalIncomplete(fieldName) {
+      var optionalFields = useOptionalFields()[0];
+      return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+          if (nonMatchingFieldName(testObject, fieldName)) {
+              return false;
+          }
+          return optionalFields[testObject.fieldName] !== true;
+      }));
+  }
+  function fieldDoesNotExist(result, fieldName) {
+      return !!fieldName && isEmpty(result.tests[fieldName]);
+  }
+  function noMissingTests(fieldName) {
+      var testObjects = useTestsFlat();
+      var optionalFields = useOptionalFields()[0];
+      return testObjects.every(function (testObject) {
+          if (nonMatchingFieldName(testObject, fieldName)) {
+              return true;
+          }
+          return (optionalFields[testObject.fieldName] === true ||
+              testObject.isTested() ||
+              testObject.isOmitted());
+      });
+  }
+
+  var cache$1 = createCache(20);
+  function produceDraft() {
+      var testObjects = useTestsFlat();
+      var ctxRef = { stateRef: useStateRef() };
+      return cache$1([testObjects], context.bind(ctxRef, function () {
+          var suiteName = useSuiteName();
+          return assign(genTestsSummary(), {
+              getErrors: context.bind(ctxRef, getErrors),
+              getErrorsByGroup: context.bind(ctxRef, getErrorsByGroup),
+              getWarnings: context.bind(ctxRef, getWarnings),
+              getWarningsByGroup: context.bind(ctxRef, getWarningsByGroup),
+              hasErrors: context.bind(ctxRef, hasErrors),
+              hasErrorsByGroup: context.bind(ctxRef, hasErrorsByGroup),
+              hasWarnings: context.bind(ctxRef, hasWarnings),
+              hasWarningsByGroup: context.bind(ctxRef, hasWarningsByGroup),
+              isValid: context.bind(ctxRef, function (fieldName) {
+                  return isValid(produceDraft(), fieldName);
+              }),
+              suiteName: suiteName
+          });
+      }));
+  }
+
+  var cache = createCache(20);
+  function produceFullResult() {
+      var testObjects = useTestsFlat();
+      var ctxRef = { stateRef: useStateRef() };
+      return cache([testObjects], context.bind(ctxRef, function () {
+          return assign({}, produceDraft(), {
+              done: context.bind(ctxRef, done)
+          });
+      }));
+  }
+  /**
+   * DONE is here and not in its own module to prevent circular dependency issues.
+   */
+  function shouldSkipDoneRegistration(callback, fieldName, output) {
+      // If we do not have any test runs for the current field
+      return !!(!isFunction(callback) ||
+          (fieldName &&
+              (!output.tests[fieldName] || isEmpty(output.tests[fieldName].testCount))));
+  }
+  function shouldRunDoneCallback(fieldName) {
+      // is suite finished || field name exists, and test is finished;
+      return !!(!hasRemainingTests() ||
+          (fieldName && !hasRemainingTests(fieldName)));
+  }
+  /**
+   * Registers done callbacks.
+   * @register {Object} Vest output object.
+   */
+  var done = function done() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+      }
+      var _a = args.reverse(), callback = _a[0], fieldName = _a[1];
+      var output = produceFullResult();
+      if (shouldSkipDoneRegistration(callback, fieldName, output)) {
+          return output;
+      }
+      var doneCallback = function () { return callback(produceDraft()); };
+      if (shouldRunDoneCallback(fieldName)) {
+          doneCallback();
+          return output;
+      }
+      deferDoneCallback(doneCallback, fieldName);
+      return output;
+  };
+  function deferDoneCallback(doneCallback, fieldName) {
+      var deferredCallback = context.bind({}, doneCallback);
+      var _a = useTestCallbacks(), setTestCallbacks = _a[1];
+      setTestCallbacks(function (current) {
+          if (fieldName) {
+              current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
+          }
+          else {
+              current.doneCallbacks.push(deferredCallback);
+          }
+          return current;
+      });
+  }
+
+  function createBus() {
+      var listeners = {};
+      return {
+          emit: function (event, data) {
+              if (!listeners[event]) {
+                  return;
+              }
+              listeners[event].forEach(function (listener) {
+                  listener(data);
+              });
+          },
+          on: function (event, handler) {
+              if (!listeners[event]) {
+                  listeners[event] = [];
+              }
+              listeners[event].push(handler);
+              return {
+                  off: function () {
+                      listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
+                  }
+              };
+          }
+      };
+  }
+
+  function omitOptionalTests() {
+      var optionalFields = useOptionalFields()[0];
+      if (isEmpty(optionalFields)) {
+          return;
+      }
+      var shouldOmit = {};
+      useSetTests(function (tests) {
+          return transform(tests, function (testObject) {
+              var fieldName = testObject.fieldName;
+              if (shouldOmit.hasOwnProperty(fieldName)) {
+                  omit(testObject);
+              }
+              else {
+                  var optionalConfig = optionalFields[fieldName];
+                  if (isFunction(optionalConfig)) {
+                      shouldOmit[fieldName] = optionalConfig();
+                      omit(testObject);
+                  }
+              }
+              return testObject;
+          });
+      });
+      function omit(testObject) {
+          if (shouldOmit[testObject.fieldName]) {
+              testObject.omit();
+          }
+      }
+  }
+
+  /**
+   * Removes test object from suite state
+   */
+  function removeTestFromState (testObject) {
+      useSetTests(function (tests) {
+          return transform(tests, function (test) { return (testObject !== test ? test : null); });
+      });
+  }
+
+  function callEach(arr) {
+      return arr.forEach(function (fn) { return fn(); });
+  }
+
+  /**
+   * Runs done callback per field when async tests are finished running.
+   */
+  function runFieldCallbacks(fieldName) {
+      var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
+      if (fieldName) {
+          if (!hasRemainingTests(fieldName) && isArray(fieldCallbacks[fieldName])) {
+              callEach(fieldCallbacks[fieldName]);
+          }
+      }
+  }
+  /**
+   * Runs unlabelled done callback when async tests are finished running.
+   */
+  function runDoneCallbacks() {
+      var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
+      if (!hasRemainingTests()) {
+          callEach(doneCallbacks);
+      }
+  }
+
+  function initBus() {
+      var bus = createBus();
+      // Report a the completion of a test. There may be other tests with the same
+      // name that are still running, or not yet started.
+      bus.on(Events.TEST_COMPLETED, function (testObject) {
+          if (testObject.isCanceled()) {
+              return;
+          }
+          testObject.done();
+          runFieldCallbacks(testObject.fieldName);
+          runDoneCallbacks();
+      });
+      // Report that the suite completed its synchronous test run.
+      // Async operations may still be running.
+      bus.on(Events.SUITE_COMPLETED, function () {
+          // Remove tests that are optional and need to be omitted
+          omitOptionalTests();
+      });
+      // Removes a certain field from the state.
+      bus.on(Events.REMOVE_FIELD, function (fieldName) {
+          var testObjects = useTestsFlat();
+          testObjects.forEach(function (testObject) {
+              if (matchingFieldName(testObject, fieldName)) {
+                  testObject.cancel();
+                  removeTestFromState(testObject);
+              }
+          });
+      });
+      return bus;
+  }
+  function useBus() {
+      var context$1 = context.useX();
+      if (!context$1.bus) {
+          throwError();
+      }
+      return context$1.bus;
+  }
+  var Events;
+  (function (Events) {
+      Events["TEST_COMPLETED"] = "test_completed";
+      Events["REMOVE_FIELD"] = "remove_field";
+      Events["SUITE_COMPLETED"] = "suite_completed";
+  })(Events || (Events = {}));
+
+  // eslint-disable-next-line max-lines-per-function
+  function create() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+      }
+      var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
+      if (!isFunction(suiteCallback)) {
+          throwError('vest.create: Expected callback to be a function.');
+      }
+      // Event bus initialization
+      var bus = initBus();
+      // State initialization
+      var state = createState();
+      // State reference - this holds the actual state values
+      var stateRef = createStateRef(state, { suiteId: genId(), suiteName: suiteName });
+      // Create base context reference. All hooks will derive their data from this
+      var ctxRef = { stateRef: stateRef, bus: bus };
+      var suite = assign(
+      // Bind the suite body to the context
+      context.bind(ctxRef, function () {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+          }
+          // Reset the state. Migrates current test objects to `prev` array.
+          state.reset();
+          // Create a top level isolate
+          isolate({ type: IsolateTypes.SUITE }, function () {
+              // Run the consumer's callback
+              suiteCallback.apply(void 0, args);
+          });
+          // Report the suite is done registering tests
+          // Async tests may still be running
+          bus.emit(Events.SUITE_COMPLETED);
+          // Return the result
+          return produceFullResult();
+      }), {
+          get: context.bind(ctxRef, produceDraft),
+          reset: state.reset,
+          remove: context.bind(ctxRef, function (fieldName) {
+              bus.emit(Events.REMOVE_FIELD, fieldName);
+          })
+      });
+      return suite;
+  }
+
+  function each(list, callback) {
+      if (!isFunction(callback)) {
+          throwError('callback must be a function');
+      }
+      isolate({ type: IsolateTypes.EACH }, function () {
+          list.forEach(function (arg, index) {
+              callback(arg, index);
+          });
+      });
+  }
+
+  /**
+   * Error message to display when a hook was called outside of context.
+   */
+  var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
+
+  /**
+   * Adds a field or multiple fields to inclusion group.
+   */
+  function only(item) {
+      return addTo(0 /* ONLY */, 'tests', item);
+  }
+  only.group = function (item) {
+      return addTo(0 /* ONLY */, 'groups', item);
+  };
+  /**
+   * Adds a field or multiple fields to exclusion group.
+   */
+  function skip(item) {
+      return addTo(1 /* SKIP */, 'tests', item);
+  }
+  skip.group = function (item) {
+      return addTo(1 /* SKIP */, 'groups', item);
+  };
+  function isExcludedIndividually() {
+      return !!context.useX().skipped;
+  }
+  //Checks whether a certain test profile excluded by any of the exclusion groups.
+  // eslint-disable-next-line complexity, max-statements
+  function isExcluded(testObject) {
+      var fieldName = testObject.fieldName, groupName = testObject.groupName;
+      if (isExcludedIndividually())
+          return true;
+      var context$1 = context.useX();
+      var exclusion = context$1.exclusion;
+      var keyTests = exclusion.tests;
+      var testValue = keyTests[fieldName];
+      // if test is skipped
+      // no need to proceed
+      if (testValue === false)
+          return true;
+      var isTestIncluded = testValue === true;
+      // If inside a group
+      if (groupName) {
+          if (isGroupExcluded(groupName)) {
+              return true; // field excluded by group
+              // if group is `only`ed
+          }
+          else if (exclusion.groups[groupName] === true) {
+              if (isTestIncluded)
+                  return false;
+              // If there is _ANY_ `only`ed test (and we already know this one isn't)
+              if (hasIncludedTests(keyTests))
+                  return true; // Excluded implicitly
+              return keyTests[fieldName] === false;
+          }
+      }
+      if (isMissingFromIncludedGroup(groupName)) {
+          return true;
+      }
+      // if field is only'ed
+      if (isTestIncluded)
+          return false;
+      // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
+      // Otherwise return false
+      return hasIncludedTests(keyTests);
+  }
+  // eslint-disable-next-line max-statements
+  function isMissingFromIncludedGroup(groupName) {
+      var context$1 = context.useX();
+      var exclusion = context$1.exclusion;
+      if (!hasIncludedGroups()) {
+          return false;
+      }
+      if (!groupName) {
+          return true;
+      }
+      if (groupName in exclusion.groups) {
+          if (exclusion.groups[groupName]) {
+              return false;
+          }
+          return true;
+      }
+      return true;
+  }
+  function hasIncludedGroups() {
+      var context$1 = context.useX();
+      var exclusion = context$1.exclusion;
+      for (var group in exclusion.groups) {
+          if (exclusion.groups[group]) {
+              return true;
+          }
+      }
+      return false;
+  }
+  /**
+   * Checks whether a given group is excluded from running.
+   */
+  function isGroupExcluded(groupName) {
+      var context$1 = context.useX();
+      var exclusion = context$1.exclusion;
+      var keyGroups = exclusion.groups;
+      var groupPresent = hasOwnProperty(keyGroups, groupName);
+      // When group is either only'ed or skipped
+      if (groupPresent) {
+          // Return true if group is skipped and false if only'ed
+          return keyGroups[groupName] === false;
+      }
+      // Group is not present
+      for (var group in keyGroups) {
+          // If any other group is only'ed
+          if (keyGroups[group] === true) {
+              return true;
+          }
+      }
+      return false;
+  }
+  /**
+   * Adds fields to a specified exclusion group.
+   */
+  function addTo(exclusionGroup, itemType, item) {
+      var context$1 = context.useX(ERROR_HOOK_CALLED_OUTSIDE);
+      if (!item) {
+          return;
+      }
+      asArray(item).forEach(function (itemName) {
+          if (!isStringValue(itemName)) {
+              return;
+          }
+          context$1.exclusion[itemType][itemName] =
+              exclusionGroup === 0 /* ONLY */;
+      });
+  }
+  /**
+   * Checks if context has included tests
+   */
+  function hasIncludedTests(keyTests) {
+      for (var test in keyTests) {
+          if (keyTests[test] === true) {
+              return true; // excluded implicitly
+          }
+      }
+      return false;
+  }
+
+  /**
+   * Runs a group callback.
+   */
+  function group(groupName, tests) {
+      if (!isStringValue(groupName)) {
+          throwGroupError('name must be a string');
+      }
+      if (!isFunction(tests)) {
+          throwGroupError('callback must be a function');
+      }
+      // Running with the context applied
+      isolate({ type: IsolateTypes.GROUP }, function () {
+          context.run({ groupName: groupName }, tests);
+      });
+  }
+  function throwGroupError(error) {
+      throwError("Wrong arguments passed to group. Group " + error + ".");
+  }
+
+  function optional(optionals) {
+      var _a = useOptionalFields(), setOptionalFields = _a[1];
+      setOptionalFields(function (state) {
+          if (!isArray(optionals) && !isStringValue(optionals)) {
+              var optionalFunctions = optionals;
+              for (var field in optionalFunctions) {
+                  var predicate = optionalFunctions[field];
+                  state[field] = predicate;
+              }
+          }
+          else {
+              asArray(optionals).forEach(function (optionalField) {
+                  state[optionalField] = true;
+              });
+          }
+          return state;
+      });
+  }
+
+  function skipWhen(conditional, callback) {
+      isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
+          context.run({
+              skipped: optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+          }, function () { return callback(); });
+      });
+  }
+
+  var isNotString = bindNot(isStringValue);
+
+  function isPromise(value) {
+      return value && isFunction(value.then);
+  }
+
+  function isSameProfileTest(testObject1, testObject2) {
+      return (testObject1.fieldName === testObject2.fieldName &&
+          testObject1.groupName === testObject2.groupName);
+  }
+
+  function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
+      if (currentRunTestObject !== prevRunTestObject &&
+          isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+          prevRunTestObject.isPending()) {
+          prevRunTestObject.cancel();
+      }
+  }
+
+  /**
+   * Runs async test.
+   */
+  function runAsyncTest(testObject) {
+      var asyncTest = testObject.asyncTest, message = testObject.message;
+      if (!isPromise(asyncTest))
+          return;
+      var emit = useBus().emit;
+      var stateRef = useStateRef();
+      var done = context.bind({ stateRef: stateRef }, function () {
+          // invalidating the "produce" cache
+          useRefreshTestObjects();
+          emit(Events.TEST_COMPLETED, testObject);
+      });
+      var fail = context.bind({ stateRef: stateRef }, function (rejectionMessage) {
+          if (testObject.isCanceled()) {
+              return;
+          }
+          testObject.message = isStringValue(rejectionMessage)
+              ? rejectionMessage
+              : message;
+          testObject.fail();
+          done();
+      });
+      try {
+          asyncTest.then(done, fail);
+      }
+      catch (e) {
+          fail();
+      }
+  }
+
+  /**
+   * Runs sync tests - or extracts promise.
+   */
+  function runSyncTest(testObject) {
+      return context.run({ currentTest: testObject }, function () {
+          var result;
+          try {
+              result = testObject.testFn();
+          }
+          catch (e) {
+              if (shouldUseErrorAsMessage(testObject.message, e)) {
+                  testObject.message = e;
+              }
+              result = false;
+          }
+          if (result === false) {
+              testObject.fail();
+          }
+          return result;
+      });
+  }
+
+  /**
+   * Registers test, if async - adds to pending array
+   */
+  function registerTest(testObject) {
+      var bus = useBus();
+      // Run test callback.
+      // If a promise is returned, set as async and
+      // Move to pending list.
+      var result = runSyncTest(testObject);
+      try {
+          // try catch for safe property access
+          // in case object is an enforce chain
+          if (isPromise(result)) {
+              testObject.asyncTest = result;
+              testObject.setPending();
+              runAsyncTest(testObject);
+          }
+          else {
+              bus.emit(Events.TEST_COMPLETED, testObject);
+          }
+      }
+      catch (e) {
+          throwError("Your test function " + testObject.fieldName + " returned a value. Only \"false\" or Promise returns are supported.");
+      }
+  }
+
+  /**
+   * This module serves as the "collision detection" mechanism for Vest.
+   * It is used to ensure that tests are not called in a different order than
+   * they were called in the previous run.
+   * If they are, it will throw a deferred error unless explicitly allowed.
+   *
+   * For now it seems pretty safe, and it covers most common use cases, but it can
+   * be improved in the future both in terms of performance and scenarios it covers.
+   */
+  // eslint-disable-next-line max-statements, max-lines-per-function
+  function useTestAtCursor(newTestObject) {
+      var testObjects = useTestObjects()[0];
+      var prevTests = testObjects.prev;
+      if (isEmpty(prevTests)) {
+          useSetTestAtCursor(newTestObject);
+          return newTestObject;
+      }
+      var prevTest = useGetTestAtCursor(prevTests);
+      if (!isNullish(newTestObject.key)) {
+          var nextTest_1 = handleKeyTest(newTestObject.key, newTestObject);
+          useSetTestAtCursor(nextTest_1);
+          return nextTest_1;
+      }
+      if (shouldPurgePrevTest(prevTest, newTestObject)) {
+          throwTestOrderError(prevTest, newTestObject);
+          removeAllNextTestsInIsolate();
+          // Need to see if this has any effect at all.
+          prevTest = null;
+      }
+      var nextTest = defaultTo(prevTest, newTestObject);
+      useSetTestAtCursor(nextTest);
+      return nextTest;
+  }
+  function removeAllNextTestsInIsolate() {
+      var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
+      var prevTests = testObjects.prev;
+      var current = getCurrent(prevTests, usePath());
+      var cursorAt = useCursorAt();
+      current.splice(cursorAt);
+      // We actually don't mind mutating the state directly (as can be seen above). There is no harm in it
+      // since we're only touching the "prev" state. The reason we still use the setter function is
+      // to prevent future headaches if we ever do need to rely on prev-state immutability.
+      setTestObjects(function (_a) {
+          var current = _a.current;
+          return ({
+              prev: prevTests,
+              current: current
+          });
+      });
+  }
+  function useSetTestAtCursor(testObject) {
+      var cursorPath = usePath();
+      useSetTests(function (tests) {
+          return setValueAtPath(tests, cursorPath, testObject);
+      });
+  }
+  function useGetTestAtCursor(tests) {
+      var cursorPath = usePath();
+      return valueAtPath(tests, cursorPath);
+  }
+  function shouldPurgePrevTest(prevTest, newTest) {
+      return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
+  }
+  function throwTestOrderError(prevTest, newTestObject) {
+      if (shouldAllowReorder()) {
+          return;
+      }
+      throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    expected: " + prevTest.fieldName + "\n    received: " + newTestObject.fieldName + "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.");
+  }
+  function handleKeyTest(key, newTestObject) {
+      var prevTestByKey = usePrevTestByKey(key);
+      var nextTest = newTestObject;
+      if (prevTestByKey) {
+          nextTest = prevTestByKey;
+      }
+      useRetainTestKey(key, nextTest);
+      return nextTest;
+  }
+
+  function registerPrevRunTest(testObject) {
+      var prevRunTest = useTestAtCursor(testObject);
+      if (isExcluded(testObject)) {
+          // We're forcing skipping the pending test
+          // if we're directly within a skipWhen block
+          // This mostly means that we're probably giving
+          // up on this async test intentionally.
+          prevRunTest.skip(isExcludedIndividually());
+          moveForward();
+          return prevRunTest;
+      }
+      cancelOverriddenPendingTest(prevRunTest, testObject);
+      useSetTestAtCursor(testObject);
+      moveForward();
+      registerTestObjectByTier(testObject);
+      return testObject;
+  }
+  function registerTestObjectByTier(testObject) {
+      if (testObject.isUntested()) {
+          registerTest(testObject);
+      }
+      else if (isPromise(testObject.asyncTest)) {
+          testObject.setPending();
+          runAsyncTest(testObject);
+      }
+  }
+
+  // eslint-disable-next-line max-lines-per-function
+  function bindTestMemo(test) {
+      var cache = createCache(100); // arbitrary cache size
+      // eslint-disable-next-line max-statements
+      function memo(fieldName) {
+          var args = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+              args[_i - 1] = arguments[_i];
+          }
+          var cursorAt = useCursorAt();
+          var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
+          // Implicit dependency for more specificity
+          var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
+          var cached = cache.get(dependencies);
+          if (isNull(cached)) {
+              // cache miss
+              return cache(dependencies, function () { return test(fieldName, msg, testFn); });
+          }
+          if (cached[1].isCanceled()) {
+              // cache hit, but test is canceled
+              cache.invalidate(dependencies);
+              return cache(dependencies, function () { return test(fieldName, msg, testFn); });
+          }
+          return registerPrevRunTest(cached[1]);
+      }
+      return memo;
+  }
+
+  function testBase(fieldName) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+          args[_i - 1] = arguments[_i];
+      }
+      var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args)), message = _a[0], testFn = _a[1], key = _a[2];
+      if (isNotString(fieldName)) {
+          throwIncompatibleParamsError('fieldName', 'string');
+      }
+      if (!isFunction(testFn)) {
+          throwIncompatibleParamsError('Test callback', 'function');
+      }
+      var context$1 = context.useX();
+      var testObject = new VestTest(fieldName, testFn, {
+          message: message,
+          groupName: context$1.groupName,
+          key: key
+      });
+      return registerPrevRunTest(testObject);
+  }
+  var test = assign(testBase, {
+      memo: bindTestMemo(testBase)
+  });
+  function throwIncompatibleParamsError(name, expected) {
+      throwError("Incompatible params passed to test function. " + name + " must be a " + expected);
+  }
+
+  var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
+      ;
+  /**
+   * Sets a running test to warn only mode.
+   */
+  function warn() {
+      var ctx = context.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
+      if (!ctx.currentTest) {
+          throwError(ERROR_OUTSIDE_OF_TEST);
+      }
+      ctx.currentTest.warn();
+  }
+
+  var VERSION = "4.0.0-dev-1aae50";
+
+  Object.defineProperty(exports, 'enforce', {
+    enumerable: true,
+    get: function () {
+      return n4s.enforce;
+    }
+  });
+  exports.VERSION = VERSION;
+  exports.create = create;
+  exports.each = each;
+  exports.group = group;
+  exports.only = only;
+  exports.optional = optional;
+  exports.skip = skip;
+  exports.skipWhen = skipWhen;
+  exports.test = test;
+  exports.warn = warn;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
 
 })));