vest 3.2.8-dev-6d7c74 → 3.2.8

package/vest.umd.production.js

@@ -0,0 +1,2708 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.vest = factory());
+}(this, (function () { 'use strict';
+
+  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() {
+      state.references = [];
+      registrations.forEach(function (_ref, index) {
+        var initialValue = _ref[0];
+        return initKey(index, initialValue);
+      });
+    }
+
+    function initKey(key, initialState) {
+      current().push();
+      set(key, optionalFunctionValue$1(initialState));
+      return function useStateKey() {
+        return [current()[key], function (nextState) {
+          return set(key, optionalFunctionValue$1(nextState, [current()[key]]));
+        }];
+      };
+    }
+
+    function current() {
+      return state.references;
+    }
+
+    function set(key, value) {
+      var prevValue = state.references[key];
+      state.references[key] = value;
+      var _registrations$key = registrations[key],
+          onUpdate = _registrations$key[1];
+
+      if (isFunction$1(onUpdate)) {
+        onUpdate(value, prevValue);
+      }
+
+      if (isFunction$1(onStateChange)) {
+        onStateChange();
+      }
+    }
+  }
+
+  function isFunction$1(f) {
+    return typeof f === 'function';
+  }
+
+  function optionalFunctionValue$1(value, args) {
+    return isFunction$1(value) ? value.apply(null, args) : value;
+  }
+
+  function asArray(possibleArg) {
+    return [].concat(possibleArg);
+  }
+
+  function createStateRef(state, _ref) {
+    var suiteId = _ref.suiteId,
+        name = _ref.name;
+    return {
+      carryOverTests: state.registerStateKey(function () {
+        return [];
+      }),
+      optionalFields: state.registerStateKey(function () {
+        return {};
+      }),
+      pending: state.registerStateKey(function () {
+        return {
+          pending: [],
+          lagging: []
+        };
+      }),
+      skippedTests: state.registerStateKey(function () {
+        return [];
+      }),
+      suiteId: state.registerStateKey(function () {
+        return {
+          id: suiteId,
+          name: name
+        };
+      }),
+      testCallbacks: state.registerStateKey(function () {
+        return {
+          fieldCallbacks: {},
+          doneCallbacks: []
+        };
+      }),
+      testObjects: state.registerStateKey(function () {
+        return [];
+      })
+    };
+  }
+
+  function _extends() {
+    _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+
+      return target;
+    };
+
+    return _extends.apply(this, arguments);
+  }
+
+  function createContext(init) {
+    var storage = {
+      ancestry: []
+    };
+    return {
+      run: run,
+      bind: bind,
+      use: use
+    };
+
+    function run(ctxRef, fn) {
+      var _init;
+
+      var parentContext = use();
+
+      var out = _extends({}, parentContext ? parentContext : {}, (_init = init === null || init === void 0 ? void 0 : init(ctxRef, parentContext)) !== null && _init !== void 0 ? _init : ctxRef);
+
+      var ctx = set(Object.freeze(out));
+      storage.ancestry.unshift(ctx);
+      var res = fn(ctx);
+      clear();
+      return res;
+    }
+
+    function bind(ctxRef, fn) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+
+      return function () {
+        for (var _len2 = arguments.length, runTimeArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          runTimeArgs[_key2] = arguments[_key2];
+        }
+
+        return run(ctxRef, function () {
+          return fn.apply(void 0, args.concat(runTimeArgs));
+        });
+      };
+    }
+
+    function use() {
+      return storage.ctx;
+    }
+
+    function set(value) {
+      return storage.ctx = value;
+    }
+
+    function clear() {
+      var _storage$ancestry$;
+
+      storage.ancestry.shift();
+      set((_storage$ancestry$ = storage.ancestry[0]) !== null && _storage$ancestry$ !== void 0 ? _storage$ancestry$ : null);
+    }
+  }
+
+  var assign = Object.assign;
+
+  var EXCLUSION_ITEM_TYPE_TESTS = 'tests';
+  var EXCLUSION_ITEM_TYPE_GROUPS = 'groups';
+
+  var context = createContext(function (ctxRef, parentContext) {
+    var _exclusion;
+
+    return parentContext ? null : assign({}, {
+      exclusion: (_exclusion = {}, _exclusion[EXCLUSION_ITEM_TYPE_TESTS] = {}, _exclusion[EXCLUSION_ITEM_TYPE_GROUPS] = {}, _exclusion)
+    }, ctxRef);
+  });
+
+  /**
+   * @returns a unique numeric id.
+   */
+  var id = function (n) {
+    return function () {
+      return "" + n++;
+    };
+  }(0);
+
+  function isFunction (v) {
+    return typeof v === 'function';
+  }
+
+  function bindNot(fn) {
+    return function () {
+      return !fn.apply(this, arguments);
+    };
+  }
+
+  function isNull(value) {
+    return value === null;
+  }
+  var isNotNull = bindNot(isNull);
+
+  function lengthEquals(value, arg1) {
+    return value.length === Number(arg1);
+  }
+  var lengthNotEquals = bindNot(lengthEquals);
+
+  /**
+   * Creates a cache function
+   * @param {number} [maxSize] Max cache size
+   * @return {Function} cache function
+   */
+
+  var createCache = function createCache(maxSize) {
+    if (maxSize === void 0) {
+      maxSize = 10;
+    }
+
+    var cacheStorage = [];
+    /**
+     * @param {Any[]} deps  dependency array.
+     * @param {Function}    cache action function.
+     */
+
+    var cache = function cache(deps, cacheAction) {
+      var cacheHit = cache.get(deps);
+
+      if (isNotNull(cacheHit)) {
+        return cacheHit[1];
+      }
+
+      var result = cacheAction();
+      cacheStorage.unshift([deps.concat(), result]);
+
+      if (cacheStorage.length > maxSize) {
+        cacheStorage.length = maxSize;
+      }
+
+      return result;
+    };
+    /**
+     * Retrieves an item from the cache.
+     * @param {deps} deps Dependency array
+     */
+
+
+    cache.get = function (deps) {
+      return cacheStorage[cacheStorage.findIndex(function (_ref) {
+        var cachedDeps = _ref[0];
+        return lengthEquals(deps, cachedDeps.length) && deps.every(function (dep, i) {
+          return dep === cachedDeps[i];
+        });
+      })] || null;
+    };
+
+    return cache;
+  };
+
+  var SEVERITY_GROUP_WARN = 'warnings';
+  var SEVERITY_COUNT_WARN = 'warnCount';
+  var SEVERITY_GROUP_ERROR = 'errors';
+  var SEVERITY_COUNT_ERROR = 'errorCount';
+  var TEST_COUNT = 'testCount';
+
+  var getStateRef = function getStateRef() {
+    return context.use().stateRef;
+  };
+
+  function useCarryOverTests() {
+    return getStateRef().carryOverTests();
+  }
+  function usePending() {
+    return getStateRef().pending();
+  }
+  function useSuiteId() {
+    return getStateRef().suiteId();
+  }
+  function useTestCallbacks() {
+    return getStateRef().testCallbacks();
+  }
+  function useTestObjects() {
+    return getStateRef().testObjects();
+  }
+  function useSkippedTests() {
+    return getStateRef().skippedTests();
+  }
+  function useOptionalFields() {
+    return getStateRef().optionalFields();
+  }
+
+  /**
+   * Reads the testObjects list and gets full validation result from it.
+   */
+
+  var genTestsSummary = function genTestsSummary() {
+    var _summary;
+
+    var _useTestObjects = useTestObjects(),
+        testObjects = _useTestObjects[0];
+
+    var _useSuiteId = useSuiteId(),
+        suiteIdState = _useSuiteId[0];
+
+    var _useSkippedTests = useSkippedTests(),
+        skippedTests = _useSkippedTests[0];
+
+    var summary = (_summary = {}, _summary[SEVERITY_COUNT_ERROR] = 0, _summary[SEVERITY_COUNT_WARN] = 0, _summary[TEST_COUNT] = 0, _summary.groups = {}, _summary.name = suiteIdState.name, _summary.tests = {}, _summary);
+    appendSummary(testObjects);
+    appendSummary(skippedTests, true);
+    return countFailures(summary);
+
+    function appendSummary(testObject, skipped) {
+      testObject.forEach(function (testObject) {
+        var fieldName = testObject.fieldName,
+            groupName = testObject.groupName;
+        summary.tests[fieldName] = genTestObject(summary.tests, testObject, skipped);
+
+        if (groupName) {
+          summary.groups[groupName] = summary.groups[groupName] || {};
+          summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject, skipped);
+        }
+      });
+    }
+  };
+  /**
+   * Counts the failed tests and adds global counters
+   * @param {Object} summary (generated by genTestsSummary)
+   */
+
+
+  var countFailures = function countFailures(summary) {
+    for (var test in summary.tests) {
+      summary[SEVERITY_COUNT_ERROR] += summary.tests[test][SEVERITY_COUNT_ERROR];
+      summary[SEVERITY_COUNT_WARN] += summary.tests[test][SEVERITY_COUNT_WARN];
+      summary[TEST_COUNT] += summary.tests[test][TEST_COUNT];
+    }
+
+    return summary;
+  };
+  /**
+   *
+   * @param {Object} summaryKey The container for the test result data
+   * @param {VestTest} testObject
+   * @returns {Object} Test result summary
+   */
+
+  var genTestObject = function genTestObject(summaryKey, testObject, skipped) {
+    var _ref;
+
+    var fieldName = testObject.fieldName,
+        isWarning = testObject.isWarning,
+        failed = testObject.failed,
+        statement = testObject.statement;
+    summaryKey[fieldName] = summaryKey[fieldName] || (_ref = {}, _ref[SEVERITY_COUNT_ERROR] = 0, _ref[SEVERITY_COUNT_WARN] = 0, _ref[TEST_COUNT] = 0, _ref);
+    var testKey = summaryKey[fieldName];
+
+    if (skipped) {
+      return testKey;
+    }
+
+    summaryKey[fieldName][TEST_COUNT]++; // Adds to severity group
+
+    var addTo = function addTo(count, group) {
+      testKey[count]++;
+
+      if (statement) {
+        testKey[group] = (testKey[group] || []).concat(statement);
+      }
+    };
+
+    if (failed) {
+      if (isWarning) {
+        addTo(SEVERITY_COUNT_WARN, SEVERITY_GROUP_WARN);
+      } else {
+        addTo(SEVERITY_COUNT_ERROR, SEVERITY_GROUP_ERROR);
+      }
+    }
+
+    return testKey;
+  };
+
+  /**
+   * Checks that a given test object matches the currently specified severity level
+   * @param {string} severity       Represents severity level
+   * @param {VestTest} testObject   VestTest instance
+   * @returns {boolean}
+   */
+
+  function isMatchingSeverityProfile(severity, testObject) {
+    return severity !== SEVERITY_GROUP_WARN && testObject.isWarning || severity === SEVERITY_GROUP_WARN && !testObject.isWarning;
+  }
+
+  /**
+   * @param {'warn'|'error'} severity   Filter by severity.
+   * @param {Object} options
+   * @param {String} [options.group]      Group name for error lookup.
+   * @param {String} [options.fieldName]  Field name for error lookup.
+   * @returns all messages for given criteria.
+   */
+
+  var collectFailureMessages = function collectFailureMessages(severity, options) {
+    var _useTestObjects = useTestObjects(),
+        testObjects = _useTestObjects[0];
+
+    var _ref = options || {},
+        group = _ref.group,
+        fieldName = _ref.fieldName;
+
+    var res = testObjects.reduce(function (collector, testObject) {
+      if (group && testObject.groupName !== group) {
+        return collector;
+      }
+
+      if (fieldName && testObject.fieldName !== fieldName) {
+        return collector;
+      }
+
+      if (!testObject.failed) {
+        return collector;
+      }
+
+      if (isMatchingSeverityProfile(severity, testObject)) {
+        return collector;
+      }
+
+      collector[testObject.fieldName] = (collector[testObject.fieldName] || []).concat(testObject.statement);
+      return collector;
+    }, {});
+
+    if (fieldName) {
+      return res[fieldName] || [];
+    } else {
+      return res;
+    }
+  };
+
+  /**
+   * @param {'errors'|'warnings'} severityKey lookup severity
+   * @param {string} [fieldName]
+   * @returns suite or field's errors or warnings.
+   */
+
+  function getFailures(severityKey, fieldName) {
+    return collectFailureMessages(severityKey, {
+      fieldName: fieldName
+    });
+  }
+
+  /**
+   * Throws a timed out error.
+   * @param {String} message  Error message to display.
+   * @param {Error} [type]    Alternative Error type.
+   */
+  var throwError = function throwError(message, type) {
+    if (type === void 0) {
+      type = Error;
+    }
+
+    throw new type("[" + "vest" + "]: " + message);
+  };
+
+  /**
+   * Gets failure messages by group.
+   * @param {'errors'|'warnings'} severityKey lookup severity
+   * @param {string} group                  Group name.
+   * @param {string} [fieldName]            Field name.
+   */
+
+  var getByGroup = function getByGroup(severityKey, group, fieldName) {
+    if (!group) {
+      throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
+    }
+
+    return collectFailureMessages(severityKey, {
+      group: group,
+      fieldName: fieldName
+    });
+  };
+
+  /**
+   * Determines whether a certain test profile has failures.
+   * @param {VestTest} testObject
+   * @param {'warnings'|'errors'} severityKey lookup severity
+   * @param {string} [fieldName]
+   * @returns {Boolean}
+   */
+
+  var hasLogic = function hasLogic(testObject, severityKey, fieldName) {
+    if (!testObject.failed) {
+      return false;
+    }
+
+    if (fieldName && fieldName !== testObject.fieldName) {
+      return false;
+    }
+
+    if (isMatchingSeverityProfile(severityKey, testObject)) {
+      return false;
+    }
+
+    return true;
+  };
+  /**
+   * @param {'warnings'|'errors'} severityKey lookup severity
+   * @param {string} [fieldName]
+   * @returns {Boolean} whether a suite or field have errors or warnings.
+   */
+
+  var has = function has(severityKey, fieldName) {
+    var _useTestObjects = useTestObjects(),
+        testObjects = _useTestObjects[0];
+
+    return testObjects.some(function (testObject) {
+      return hasLogic(testObject, severityKey, fieldName);
+    });
+  };
+
+  /**
+   * Checks whether there are failures in a given group.
+   * @param {'errors'|'warnings'} severityKey lookup severity
+   * @param {string} group                  Group name.
+   * @param {string} [fieldName]            Field name.
+   * @return {boolean}
+   */
+
+  var hasByGroup = function hasByGroup(severityKey, group, fieldName) {
+    var _useTestObjects = useTestObjects(),
+        testObjects = _useTestObjects[0];
+
+    return testObjects.some(function (testObject) {
+      if (group !== testObject.groupName) {
+        return false;
+      }
+
+      return hasLogic(testObject, severityKey, fieldName);
+    });
+  };
+
+  /**
+   * A safe hasOwnProperty access
+   */
+  function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  function isNumeric(value) {
+    var result = !isNaN(parseFloat(value)) && !isNaN(Number(value)) && isFinite(value);
+    return Boolean(result);
+  }
+  var isNotNumeric = bindNot(isNumeric);
+
+  function isEmpty(value) {
+    if (!value) {
+      return true;
+    } else if (isNumeric(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);
+
+  /**
+   * Checks if a given tests, or the suite as a whole still have remaining tests.
+   * @param {string} [fieldName]
+   * @returns {Boolean}
+   */
+
+  var hasRemainingTests = function hasRemainingTests(fieldName) {
+    var _usePending = usePending(),
+        _usePending$ = _usePending[0],
+        pending = _usePending$.pending,
+        lagging = _usePending$.lagging;
+
+    var allIncomplete = pending.concat(lagging);
+
+    if (isEmpty(allIncomplete)) {
+      return false;
+    }
+
+    if (fieldName) {
+      return allIncomplete.some(function (testObject) {
+        return testObject.fieldName === fieldName;
+      });
+    }
+
+    return isNotEmpty(allIncomplete);
+  };
+
+  var HAS_WARNINGS = 'hasWarnings';
+  var HAS_ERRORS = 'hasErrors';
+
+  function setFnName(fn, value) {
+    var _Object$getOwnPropert;
+
+    // Pre ES2015 non standard implementation, "Function.name" is non configurable field
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
+    return (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(fn, 'name')) !== null && _Object$getOwnPropert !== void 0 && _Object$getOwnPropert.configurable ? Object.defineProperty(fn, 'name', {
+      value: value
+    }) : fn;
+  }
+
+  /**
+   * ES5 Transpilation increases the size of spread arguments by a lot.
+   * Wraps a function and passes its spread params as an array.
+   *
+   * @param {Function} cb
+   * @param {String}   [fnName]
+   * @return {Function}
+   */
+
+  function withArgs(cb, fnName) {
+    return setFnName(function () {
+      var args = Array.from(arguments);
+      var right = args.splice(cb.length - 1);
+      return cb.apply(null, args.concat([right]));
+    }, fnName || cb.name);
+  }
+
+  var cache = createCache(20);
+  /**
+   * @param {boolean} [isDraft]
+   * @returns Vest output object.
+   */
+
+  var produce = function produce(isDraft) {
+    var _context$use = context.use(),
+        stateRef = _context$use.stateRef;
+
+    var _useTestObjects = useTestObjects(),
+        testObjects = _useTestObjects[0];
+
+    var ctxRef = {
+      stateRef: stateRef
+    };
+    return cache([testObjects, isDraft], context.bind(ctxRef, function () {
+      return [[HAS_ERRORS, has, SEVERITY_GROUP_ERROR], [HAS_WARNINGS, has, SEVERITY_GROUP_WARN], ['getErrors', getFailures, SEVERITY_GROUP_ERROR], ['getWarnings', getFailures, SEVERITY_GROUP_WARN], ['hasErrorsByGroup', hasByGroup, SEVERITY_GROUP_ERROR], ['hasWarningsByGroup', hasByGroup, SEVERITY_GROUP_WARN], ['getErrorsByGroup', getByGroup, SEVERITY_GROUP_ERROR], ['getWarningsByGroup', getByGroup, SEVERITY_GROUP_WARN]].concat([['isValid', isValid]], isDraft ? [] : [['done', withArgs(done)]]).reduce(function (properties, _ref) {
+        var name = _ref[0],
+            fn = _ref[1],
+            severityKey = _ref[2];
+        properties[name] = context.bind(ctxRef, fn, severityKey);
+        return properties;
+      }, genTestsSummary());
+    }));
+  };
+  /**
+   * Registers done callbacks.
+   * @param {string} [fieldName]
+   * @param {Function} doneCallback
+   * @register {Object} Vest output object.
+   */
+
+  function done(args) {
+    var _args$reverse = args.reverse(),
+        callback = _args$reverse[0],
+        fieldName = _args$reverse[1];
+
+    var _context$use2 = context.use(),
+        stateRef = _context$use2.stateRef;
+
+    var output = produce(); // If we do not have any test runs for the current field
+
+    var shouldSkipRegistration = fieldName && (!output.tests[fieldName] || output.tests[fieldName].testCount === 0);
+
+    if (!isFunction(callback) || shouldSkipRegistration) {
+      return output;
+    }
+
+    var cb = context.bind({
+      stateRef: stateRef
+    }, function () {
+      return callback(produce(
+      /*isDraft:*/
+      true));
+    }); // is suite finished || field name exists, and test is finished
+
+    var shouldRunCallback = !hasRemainingTests() || fieldName && !hasRemainingTests(fieldName);
+
+    if (shouldRunCallback) {
+      cb();
+      return output;
+    }
+
+    var _useTestCallbacks = useTestCallbacks(),
+        setTestCallbacks = _useTestCallbacks[1];
+
+    setTestCallbacks(function (current) {
+      if (fieldName) {
+        current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(cb);
+      } else {
+        current.doneCallbacks.push(cb);
+      }
+
+      return current;
+    });
+    return output;
+  }
+
+  function isValid() {
+    var result = produce();
+
+    if (result.hasErrors()) {
+      return false;
+    }
+
+    var _useTestObjects2 = useTestObjects(),
+        testObjects = _useTestObjects2[0];
+
+    if (testObjects.length === 0) {
+      return false;
+    }
+
+    var _useOptionalFields = useOptionalFields(),
+        optionalFields = _useOptionalFields[0];
+
+    var _usePending = usePending(),
+        _usePending$ = _usePending[0],
+        pending = _usePending$.pending,
+        lagging = _usePending$.lagging;
+
+    if (isNotEmpty(pending.concat(lagging).filter(function (testObject) {
+      return !testObject.isWarning;
+    }))) {
+      return false;
+    }
+
+    for (var test in result.tests) {
+      if (!optionalFields[test] && result.tests[test].testCount === 0) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Initializes a validation suite, creates a validation context.
+   * @param {String} [name]     Identifier for validation suite.
+   * @param {Function} tests  Validation suite body.
+   * @returns {Function} validator function.
+   */
+
+  var createSuite = withArgs(function (args) {
+    var _args$reverse = args.reverse(),
+        tests = _args$reverse[0],
+        name = _args$reverse[1];
+
+    if (!isFunction(tests)) {
+      throwError('Suite initialization error. Expected `tests` to be a function.');
+    }
+
+    var handlers = [];
+    var state = createState(function () {
+      handlers.forEach(function (fn) {
+        return fn({
+          suiteState: stateRef,
+          type: 'suiteStateUpdate'
+        });
+      });
+    });
+    var stateRef = createStateRef(state, {
+      suiteId: id(),
+      name: name
+    });
+    /*
+      context.bind returns our `validate` function
+      We then wrap it with defineProperties to add
+      the `get`, and `reset` functions.
+     */
+
+    var suite = context.bind({
+      stateRef: stateRef
+    }, function () {
+      var _useTestObjects = useTestObjects(),
+          previousTestObjects = _useTestObjects[0];
+
+      var _useCarryOverTests = useCarryOverTests(),
+          setCarryOverTests = _useCarryOverTests[1];
+
+      var _usePending = usePending(),
+          pending = _usePending[0].pending,
+          setPending = _usePending[1];
+
+      state.reset();
+      setCarryOverTests(function () {
+        return previousTestObjects;
+      }); // Move all the active pending tests to the lagging array
+
+      setPending({
+        lagging: pending,
+        pending: []
+      }); // Run the consumer's callback
+
+      tests.apply(null, arguments);
+      return produce();
+    });
+    suite.get = context.bind({
+      stateRef: stateRef
+    }, produce,
+    /*isDraft:*/
+    true);
+    suite.reset = state.reset;
+    suite.remove = context.bind({
+      stateRef: stateRef
+    }, function (name) {
+      var _useTestObjects2 = useTestObjects(),
+          testObjects = _useTestObjects2[0]; // We're mutating the array in `cancel`, so we have to first copy it.
+
+
+      asArray(testObjects).forEach(function (testObject) {
+        if (testObject.fieldName === name) {
+          testObject.cancel();
+        }
+      });
+    });
+
+    suite.subscribe = function (handler) {
+      if (!isFunction(handler)) return;
+      handlers.push(handler);
+      handler({
+        type: 'suiteSubscribeInit',
+        suiteState: stateRef
+      });
+    };
+
+    return suite;
+  });
+
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+    var it;
+
+    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+        var i = 0;
+        return function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        };
+      }
+
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
+    it = o[Symbol.iterator]();
+    return it.next.bind(it);
+  }
+
+  /**
+   * Stores values and configuration passed down to compound rules.
+   *
+   * @param {Object} content
+   */
+
+  function EnforceContext(content) {
+    assign(this, content);
+  }
+  /**
+   * Sets an EnforceContext config `failFast`
+   *
+   * @param {Boolean} failFast
+   * @return {EnforceContext}
+   */
+
+  EnforceContext.prototype.setFailFast = function (failFast) {
+    this.failFast = !!failFast;
+    return this;
+  };
+  /**
+   * Extracts the literal value from an EnforceContext object
+   * @param {*} value
+   * @return {*}
+   */
+
+
+  EnforceContext.unwrap = function unwrap(value) {
+    return EnforceContext.is(value) ? value.value : value;
+  };
+  /**
+   * Wraps a literal value within a context.
+   * @param {*} value
+   * @return {EnforceContext}
+   */
+
+
+  EnforceContext.wrap = function wrap(value) {
+    return EnforceContext.is(value) ? value : new EnforceContext({
+      value: value
+    });
+  };
+  /**
+   * Checks whether a given value is an EnforceContext instance
+   *
+   * @param {*} value
+   * @returns {boolean}
+   */
+
+
+  EnforceContext.is = function is(value) {
+    return value instanceof EnforceContext;
+  };
+
+  function isBoolean(value) {
+    return !!value === value;
+  }
+
+  var isNotBoolean = bindNot(isBoolean);
+
+  function isUndefined(value) {
+    return value === undefined;
+  }
+  var isNotUndefined = bindNot(isUndefined);
+
+  /**
+   * Stores a rule result in an easy to inspect and manipulate structure.
+   *
+   * @param {boolean|RuleResult} ruleRunResult
+   */
+
+  function RuleResult(ruleRunResult) {
+    if (isUndefined(ruleRunResult)) {
+      return;
+    }
+
+    if (isBoolean(ruleRunResult)) {
+      this.setFailed(!ruleRunResult);
+    } else {
+      this.extend(ruleRunResult);
+    }
+  }
+  /**
+   * Determines whether a given value is a RuleResult instance
+   * @param {*} res
+   * @return {boolean}
+   */
+
+  RuleResult.is = function (res) {
+    return res instanceof RuleResult;
+  };
+  /**
+   * Marks the current result object as an array
+   */
+
+
+  RuleResult.prototype.asArray = function () {
+    this.isArray = true;
+    return this;
+  };
+  /**
+   * @param {string} key
+   * @param {value} value
+   * @return {RuleResult} current instance
+   */
+
+
+  RuleResult.prototype.setAttribute = function (key, value) {
+    this[key] = value;
+    return this;
+  };
+  /**
+   * @param {boolean} failed
+   * @return {RuleResult} current instance
+   */
+
+
+  RuleResult.prototype.setFailed = function (failed) {
+    this.setAttribute(this.warn ? HAS_WARNINGS : HAS_ERRORS, failed);
+    return this.setAttribute('failed', failed);
+  };
+  /**
+   * Adds a nested result object
+   *
+   * @param {string} key
+   * @param {RuleResult} child
+   */
+
+
+  RuleResult.prototype.setChild = function (key, child) {
+    if (isNull(child)) {
+      return null;
+    }
+
+    var isWarning = this[HAS_WARNINGS] || child[HAS_WARNINGS] || child.warn || this.warn;
+    this.setAttribute(HAS_WARNINGS, isWarning && child.failed || false);
+    this.setAttribute(HAS_ERRORS, this[HAS_ERRORS] || child[HAS_ERRORS] || !isWarning && child.failed || false);
+    this.setFailed(this.failed || child.failed);
+    this.children = this.children || {};
+    this.children[key] = child;
+    return child;
+  };
+  /**
+   * Retrieves a child by its key
+   *
+   * @param {string} key
+   * @return {RuleResult|undefined}
+   */
+
+
+  RuleResult.prototype.getChild = function (key) {
+    return (this.children || {})[key];
+  };
+  /**
+   * Extends current instance with a new provided result
+   * @param {Boolean|RuleResult} newRes
+   */
+
+
+  RuleResult.prototype.extend = function (newRes) {
+    if (isNull(newRes)) {
+      return this;
+    }
+
+    var res = RuleResult.is(newRes) ? newRes : new RuleResult().setAttribute('warn', !!this.warn).setFailed(!newRes);
+    var failed = this.failed || res.failed;
+    var children = mergeChildren(res, this).children;
+    assign(this, res);
+
+    if (!isEmpty(children)) {
+      this.children = children;
+    }
+
+    this.setFailed(failed);
+    this.setAttribute(HAS_WARNINGS, !!(this[HAS_WARNINGS] || res[HAS_WARNINGS]));
+    this.setAttribute(HAS_ERRORS, !!(this[HAS_ERRORS] || res[HAS_ERRORS]));
+  };
+
+  Object.defineProperty(RuleResult.prototype, 'pass', {
+    get: function get() {
+      return !this.failed;
+    }
+  });
+  /**
+   * Deeply merge the nested children of compound rules
+   *
+   * @param {?RuleResult} base
+   * @param {?RuleResult} add
+   * @return {RuleResult}
+   */
+
+  function mergeChildren(base, add) {
+    var isRuleResultBase = RuleResult.is(base);
+    var isRuleResultAdd = RuleResult.is(add); // If both base and add are result objects
+
+    if (isRuleResultBase && isRuleResultAdd) {
+      // Use failed if either is failing
+      base.setFailed(base.failed || add.failed); // If neither has a children object, or the children object is
+
+      if (isEmpty(base.children) && isEmpty(add.children)) {
+        return base;
+      } // If both have a children object
+
+
+      if (base.children && add.children) {
+        // Merge all the "right side" children back to base
+        for (var key in base.children) {
+          mergeChildren(base.children[key], add.children[key]);
+        } // If a child exists in "add" but not in "base", just copy the child as is
+
+
+        for (var _key in add.children) {
+          if (!hasOwnProperty(base.children, _key)) {
+            base.setChild(_key, add.children[_key]);
+          }
+        } // Return the modified base object
+
+
+        return base; // If base has no children (but add does)
+      } else if (!base.children) {
+        // Use add's children
+        base.children = add.children; // If add has no children
+      } else if (!add.children) {
+        // return base as is
+        return base;
+      } // If only base is `RuleResult`
+
+    } else if (isRuleResultBase) {
+      // Return base as is
+      return base; // If only add is RuleResult
+    } else if (isRuleResultAdd) {
+      // Return add as is
+      return add;
+    } // That's a weird case. Let's fail. Very unlikely.
+
+
+    return new RuleResult(false);
+  }
+
+  var RUN_RULE = 'run';
+  var TEST_RULE = 'test';
+  var MODE_ALL = 'all';
+  var MODE_ONE = 'one';
+  var MODE_ANY = 'any';
+
+  /**
+   * Determines whether we should bail out of an enforcement.
+   *
+   * @param {EnforceContext} ctx
+   * @param {RuleResult} result
+   */
+
+  function shouldFailFast(ctx, result) {
+    if (result.pass || result.warn) {
+      return false;
+    }
+
+    return !!EnforceContext.is(ctx) && ctx.failFast;
+  }
+
+  /**
+   * Runs multiple enforce rules that are passed to compounds.
+   * Example: enforce.allOf(enforce.ruleOne(), enforce.ruleTwo().ruleThree())
+   *
+   * @param {{run: Function}[]} ruleGroups
+   * @param {*} value
+   * @return {RuleResult}
+   */
+
+  function runLazyRules(ruleGroups, value) {
+    var result = new RuleResult(true);
+
+    for (var _iterator = _createForOfIteratorHelperLoose(asArray(ruleGroups)), _step; !(_step = _iterator()).done;) {
+      var chain = _step.value;
+
+      if (shouldFailFast(value, result)) {
+        break;
+      }
+
+      result.extend(runLazyRule(chain, value));
+    }
+
+    return result;
+  }
+  /**
+   * Runs a single lazy rule
+   *
+   * @param {{run: Function}} ruleGroup
+   * @param {*} value
+   * @return {boolean|RuleResult}
+   */
+
+  function runLazyRule(ruleGroup, value) {
+    return ruleGroup[RUN_RULE](value);
+  }
+
+  /**
+   * Runs chains of rules
+   *
+   * @param {EnforceContext} value
+   * @param {[{test: Function, run: Function}]} rules
+   * @param {RuleResult} options
+   */
+
+  function runCompoundChain(value, rules, options) {
+    var result = new RuleResult(true);
+
+    if (isEmpty(rules)) {
+      result.setFailed(true);
+    }
+
+    var failedResults = [];
+    var count = 0;
+
+    for (var _iterator = _createForOfIteratorHelperLoose(rules), _step; !(_step = _iterator()).done;) {
+      var chain = _step.value;
+      // Inner result for each iteration
+      var currentResult = runLazyRule(chain, value);
+
+      if (isNull(currentResult)) {
+        return null;
+      }
+
+      var pass = currentResult.pass;
+
+      if (pass) {
+        count++;
+      } else {
+        failedResults.push(currentResult);
+      }
+
+      if (options) {
+        // "anyOf" is a special case.
+        // It shouldn't extend with failed results,
+        // that's why we continue
+        if (options.mode === MODE_ANY) {
+          if (pass) {
+            result.extend(currentResult);
+            break;
+          }
+
+          continue;
+        }
+
+        result.extend(currentResult); // MODE_ALL: All must pass.
+        // If one failed, exit.
+
+        if (options.mode === MODE_ALL) {
+          if (!pass) {
+            break;
+          }
+        } // MODE_ONE: only one must pass.
+        // If more than one passed, exit.
+
+
+        if (options.mode === MODE_ONE) {
+          result.setFailed(count !== 1);
+
+          if (count > 1) {
+            break;
+          }
+        }
+      } else {
+        result.extend(currentResult);
+
+        if (pass) {
+          break;
+        }
+      }
+    }
+
+    if (result.pass && count === 0) {
+      result.setFailed(true); // In some cases we do not want to extend failures, for example - in ANY
+      // when there is a valid response, so we do it before returning
+
+      failedResults.forEach(function (failedResult) {
+        return result.extend(failedResult);
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Runs a chain of rules, making sure that all assertions pass
+   *
+   * @param {EnforceContext} value
+   * @param {[{test: Function, run: Function}]} ruleChains
+   * @return {RuleResult}
+   */
+
+  function allOf(value, rules) {
+    return runCompoundChain(value, rules, {
+      mode: MODE_ALL
+    });
+  }
+
+  var allOf$1 = withArgs(allOf);
+
+  /**
+   * Runs chains of rules, making sure
+   * that at least one assertion passes
+   *
+   * @param {EnforceContext} value
+   * @param {[{test: Function, run: Function}]} ruleChains
+   * @return {RuleResult}
+   */
+
+  function anyOf(value, ruleChains) {
+    return runCompoundChain(value, ruleChains, {
+      mode: MODE_ANY
+    });
+  }
+
+  var anyOf$1 = withArgs(anyOf);
+
+  function isArray(value) {
+    return Boolean(Array.isArray(value));
+  }
+  var isNotArray = bindNot(isArray);
+
+  /**
+   * Asserts that each element in an array passes
+   * at least one of the provided rule chain
+   *
+   * @param {EnforceContext} value
+   * @param {[{test: Function, run: Function}]} ruleChains
+   * @return {RuleResult}
+   */
+
+  function isArrayOf(value, ruleChains) {
+    var plainValue = EnforceContext.unwrap(value);
+    var result = new RuleResult(true).asArray(); // Fails if current value is not an array
+
+    if (isNotArray(plainValue)) {
+      return result.setFailed(true);
+    }
+
+    for (var i = 0; i < plainValue.length; i++) {
+      // Set result per each item in the array
+      result.setChild(i, runCompoundChain(new EnforceContext({
+        value: plainValue[i],
+        obj: plainValue,
+        key: i
+      }).setFailFast(value.failFast), ruleChains, {
+        mode: MODE_ANY
+      }));
+    }
+
+    return result;
+  }
+
+  var isArrayOf$1 = withArgs(isArrayOf);
+
+  /**
+   * @param {EnforceContext} value
+   * @param {[{test: Function, run: Function}]} ruleChains
+   * @return {RuleResult}
+   */
+
+  function oneOf(value, rules) {
+    return runCompoundChain(value, rules, {
+      mode: MODE_ONE
+    });
+  }
+
+  var oneOf$1 = withArgs(oneOf);
+
+  /**
+   * @param {Array} ObjectEntry   Object and key leading to current value
+   * @param {Function[]} rules    Rules to validate the value with
+   */
+
+  function optional$1(inputObject, ruleGroups) {
+    var obj = inputObject.obj,
+        key = inputObject.key; // If current value is not defined, undefined or null
+    // Pass without further assertions
+
+    if (!hasOwnProperty(obj, key) || isUndefined(obj[key] || isNull(obj[key]))) {
+      return true;
+    } // Pass if exists but no assertions
+
+
+    if (isEmpty(ruleGroups)) {
+      return true;
+    } // Run chain with `all` mode
+
+
+    return runCompoundChain(obj[key], ruleGroups, {
+      mode: MODE_ALL
+    });
+  }
+
+  var optional$2 = withArgs(optional$1);
+
+  /**
+   * @param {EnforceContext} inputObject  Data object that gets validated
+   * @param {Object} shapeObj  Shape definition
+   * @param {Object} options
+   * @param {boolean} options.loose Ignore extra keys not defined in shapeObj
+   */
+
+  function shape(inputObject, shapeObj, options) {
+    // Extract the object from context
+    var obj = EnforceContext.unwrap(inputObject); // Create a new result object
+
+    var result = new RuleResult(true); // Iterate over the shape keys
+
+    for (var key in shapeObj) {
+      var current = shapeObj[key];
+      var value = obj[key];
+
+      if (shouldFailFast(value, result)) {
+        break;
+      } // Set each key in the result object
+
+
+      result.setChild(key, runLazyRule(current, new EnforceContext({
+        value: value,
+        obj: obj,
+        key: key
+      }).setFailFast(inputObject.failFast)));
+    } // If mode is not loose
+
+
+    if (!(options || {}).loose) {
+      // Check that each key in the input object exists in the shape
+      for (var _key in obj) {
+        if (!hasOwnProperty(shapeObj, _key)) {
+          return result.setFailed(true);
+        }
+      }
+    }
+
+    return result;
+  }
+  var loose = function loose(obj, shapeObj) {
+    return shape(obj, shapeObj, {
+      loose: true
+    });
+  };
+
+  var compounds = {
+    allOf: allOf$1,
+    anyOf: anyOf$1,
+    isArrayOf: isArrayOf$1,
+    loose: loose,
+    oneOf: oneOf$1,
+    optional: optional$2,
+    shape: shape
+  };
+
+  /**
+   * Takes a value. If it is a function, runs it and returns the result.
+   * Otherwise, returns the value as is.
+   *
+   * @param {Function|*} value    Value to return. Run it if a function.
+   * @param {Any[]} [args]        Arguments to pass if a function
+   * @return {Any}
+   */
+
+  function optionalFunctionValue(value, args) {
+    return isFunction(value) ? value.apply(null, args) : value;
+  }
+
+  function message(value, msg) {
+    return optionalFunctionValue(msg, [EnforceContext.unwrap(value)]);
+  }
+
+  function warn$1(_, isWarn) {
+    if (isWarn === void 0) {
+      isWarn = true;
+    }
+
+    return isWarn;
+  }
+
+  function when(value, condition, bail) {
+    var shouldBail = !optionalFunctionValue(condition, [EnforceContext.unwrap(value)].concat(EnforceContext.is(value) ? [value.key, value.obj] : []));
+    return bail(shouldBail);
+  }
+
+  var ruleMeta = {
+    warn: warn$1,
+    message: message,
+    when: when
+  };
+
+  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 greaterThan(value, arg1) {
+    return isNumeric(value) && isNumeric(arg1) && Number(value) > Number(arg1);
+  }
+
+  function greaterThanOrEquals(value, arg1) {
+    return isNumeric(value) && isNumeric(arg1) && Number(value) >= Number(arg1);
+  }
+
+  function inside(value, arg1) {
+    if (Array.isArray(arg1) && /^[s|n|b]/.test(typeof value)) {
+      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, arg1) {
+    return isNumeric(value) && isNumeric(arg1) && Number(value) <= Number(arg1);
+  }
+
+  function isBetween(value, min, max) {
+    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+  }
+  var isNotBetween = bindNot(isBetween);
+
+  function isBlank(value) {
+    return typeof value === 'string' && value.trim() === '';
+  }
+  var isNotBlank = bindNot(isBlank);
+
+  /**
+   * Validates that a given value is an even number
+   * @param {Number|String} value Value to be validated
+   * @return {Boolean}
+   */
+
+  var isEven = function isEven(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);
+
+  function isNumber(value) {
+    return Boolean(typeof value === 'number');
+  }
+  var isNotNumber = bindNot(isNumber);
+
+  /**
+   * Validates that a given value is an odd number
+   * @param {Number|String} value Value to be validated
+   * @return {Boolean}
+   */
+
+  var isOdd = function isOdd(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, arg1) {
+    return isNumeric(value) && isNumeric(arg1) && Number(value) < Number(arg1);
+  }
+
+  function longerThan(value, arg1) {
+    return value.length > Number(arg1);
+  }
+
+  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, arg1) {
+    return isNumeric(value) && isNumeric(arg1) && Number(value) === Number(arg1);
+  }
+  var numberNotEquals = bindNot(numberEquals);
+
+  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);
+
+  function rules() {
+    return {
+      doesNotEndWith: doesNotEndWith,
+      doesNotStartWith: doesNotStartWith,
+      endsWith: endsWith,
+      equals: equals,
+      greaterThan: greaterThan,
+      greaterThanOrEquals: greaterThanOrEquals,
+      gt: greaterThan,
+      gte: greaterThanOrEquals,
+      inside: inside,
+      isArray: isArray,
+      isBetween: isBetween,
+      isBoolean: isBoolean,
+      isBlank: isBlank,
+      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
+    };
+  }
+
+  var runtimeRules = assign(rules(), compounds, ruleMeta);
+
+  /**
+   * Determines whether a given string is a name of a rule
+   *
+   * @param {string} name
+   * @return {boolean}
+   */
+
+  var isRule = function isRule(name) {
+    return hasOwnProperty(runtimeRules, name) && isFunction(runtimeRules[name]);
+  };
+
+  var GLOBAL_OBJECT = Function('return this')();
+
+  var proxySupported = function proxySupported() {
+    return isFunction(GLOBAL_OBJECT.Proxy);
+  };
+
+  function genRuleProxy(target, output) {
+    if (proxySupported()) {
+      return new Proxy(target, {
+        get: function get(target, fnName) {
+          // A faster bailout when we access `run` and `test`
+          if (hasOwnProperty(target, fnName)) {
+            return target[fnName];
+          }
+
+          if (isRule(fnName)) {
+            return output(fnName);
+          }
+
+          return target[fnName];
+        }
+      });
+    } else {
+      var _loop = function _loop(fnName) {
+        if (!isFunction(target[fnName])) {
+          var _Object$definePropert;
+
+          Object.defineProperties(target, (_Object$definePropert = {}, _Object$definePropert[fnName] = {
+            get: function get() {
+              return output(fnName);
+            }
+          }, _Object$definePropert));
+        }
+      };
+
+      /**
+       * This method is REALLY not recommended as it is slow and iterates over
+       * all the rules for each direct enforce reference. We only use it as a
+       * lightweight alternative for the much faster proxy interface
+       */
+      for (var fnName in runtimeRules) {
+        _loop(fnName);
+      }
+
+      return target;
+    }
+  }
+
+  /**
+   * Determines whether a given rule is a compound.
+   *
+   * @param {Function} rule
+   * @return {boolean}
+   */
+
+  function isCompound(rule) {
+    return hasOwnProperty(compounds, rule.name);
+  }
+
+  /**
+   * Creates a rule of lazily called rules.
+   * Each rule gets added a `.run()` property
+   * which runs all the accumulated rules in
+   * the chain against the supplied value
+   *
+   * @param {string} ruleName
+   * @return {{run: Function}}
+   */
+
+  function bindLazyRule(ruleName) {
+    var registeredRules = []; // Chained rules
+
+    var meta = []; // Meta properties to add onto the rule context
+    // Appends a function to the registeredRules array.
+    // It gets called every time the consumer usess chaining
+    // so, for example - enforce.isArray() <- this calles addFn
+
+    var addFn = function addFn(ruleName) {
+      return withArgs(function (args) {
+        var rule = runtimeRules[ruleName]; // Add a meta function
+
+        if (ruleMeta[rule.name] === rule) {
+          meta.push(function (value, ruleResult, bail) {
+            ruleResult.setAttribute(rule.name, rule(value, args[0], bail));
+          });
+        } else {
+          // Register a rule
+          registeredRules.push(setFnName(function (value) {
+            return rule.apply(null, [// If the rule is compound - wraps the value with context
+            // Otherwise - unwraps it
+            isCompound(rule) ? EnforceContext.wrap(value) : EnforceContext.unwrap(value)].concat(args));
+          }, ruleName));
+        } // set addFn as the proxy handler
+
+
+        var returnvalue = genRuleProxy({}, addFn);
+
+        returnvalue[RUN_RULE] = function (value) {
+          var result = new RuleResult(true);
+          var bailed = false; // Run meta chains
+
+          meta.forEach(function (fn) {
+            fn(value, result, function (shouldBail) {
+              return bailed = shouldBail;
+            });
+          });
+
+          if (bailed) {
+            return null;
+          } // Iterate over all the registered rules
+          // This runs the function that's inside `addFn`
+
+
+          for (var _iterator = _createForOfIteratorHelperLoose(registeredRules), _step; !(_step = _iterator()).done;) {
+            var fn = _step.value;
+
+            try {
+              result.extend(fn(value)); // If a chained rule fails, exit. We failed.
+
+              if (!result.pass) {
+                break;
+              }
+            } catch (e) {
+              result.setFailed(true);
+              break;
+            }
+          }
+
+          return result;
+        };
+
+        returnvalue[TEST_RULE] = function (value) {
+          return returnvalue[RUN_RULE](EnforceContext.wrap(value).setFailFast(true)).pass;
+        };
+
+        return returnvalue;
+      }, ruleName);
+    }; // Returns the initial rule in the chain
+
+
+    return addFn(ruleName);
+  }
+
+  function bindExtend(enforce, Enforce) {
+    enforce.extend = function (customRules) {
+      assign(runtimeRules, customRules);
+
+      if (!proxySupported()) {
+        genRuleProxy(Enforce, bindLazyRule);
+      }
+
+      return enforce;
+    };
+  }
+
+  function validateResult(result, rule) {
+    // if result is boolean, or if result.pass is boolean
+    if (isBoolean(result) || result && isBoolean(result.pass)) {
+      return;
+    }
+
+    throwError(rule.name + 'wrong return value');
+  } // for easier testing and mocking
+
+  function getDefaultResult(value) {
+    return {
+      message: new Error("invalid " + typeof value + " value")
+    };
+  }
+  /**
+   * Transform the result of a rule into a standard format
+   * @param {string} interfaceName to be used in the messages
+   * @param {*} result of the rule
+   * @param {Object} options
+   * @param {function} options.rule
+   * @param {*} options.value
+   * @returns {Object} result
+   * @returns {string} result.message
+   * @returns {boolean} result.pass indicates if the test passes or not
+   */
+
+  function transformResult(result, _ref) {
+    var rule = _ref.rule,
+        value = _ref.value;
+    var defaultResult = getDefaultResult(value);
+    validateResult(result, rule); // if result is boolean
+
+    if (isBoolean(result)) {
+      return defaultResult.pass = result, defaultResult;
+    } else {
+      defaultResult.pass = result.pass;
+
+      if (result.message) {
+        defaultResult.message = optionalFunctionValue(result.message);
+      }
+
+      return defaultResult;
+    }
+  }
+
+  /**
+   * Run a single rule against enforced value (e.g. `isNumber()`)
+   *
+   * @param {Function} rule - rule to run
+   * @param {Any} value
+   * @param {Array} args list of arguments sent from consumer
+   * @throws
+   */
+
+  function runner(rule, value, args) {
+    if (args === void 0) {
+      args = [];
+    }
+
+    var result;
+    var isCompoundRule = isCompound(rule);
+    var ruleValue = isCompoundRule ? EnforceContext.wrap(value).setFailFast(true) : EnforceContext.unwrap(value);
+    result = rule.apply(null, [ruleValue].concat(args));
+
+    if (!isCompoundRule) {
+      result = transformResult(result, {
+        rule: rule,
+        value: value
+      });
+    }
+
+    if (!result.pass) {
+      throw result.message;
+    }
+  }
+
+  /**
+   * Adds `template` property to enforce.
+   *
+   * @param {Function} enforce
+   */
+
+  function bindTemplate(enforce) {
+    enforce.template = withArgs(function (rules) {
+      var template = function template(value) {
+        runner(runLazyRules.bind(null, rules), value);
+        var proxy = genRuleProxy({}, function (ruleName) {
+          return withArgs(function (args) {
+            runner(runtimeRules[ruleName], value, args);
+            return proxy;
+          });
+        });
+        return proxy;
+      }; // `run` returns a deep ResultObject
+
+
+      template[RUN_RULE] = function (value) {
+        return runLazyRules(rules, value);
+      }; // `test` returns a boolean
+
+
+      template[TEST_RULE] = function (value) {
+        return runLazyRules(rules, EnforceContext.wrap(value).setFailFast(true)).pass;
+      };
+
+      return template;
+    });
+  }
+
+  var Enforce = function Enforce(value) {
+    var proxy = genRuleProxy({}, function (ruleName) {
+      return withArgs(function (args) {
+        runner(runtimeRules[ruleName], value, args);
+        return proxy;
+      });
+    });
+    return proxy;
+  };
+
+  var enforce = genRuleProxy(Enforce, bindLazyRule);
+  bindExtend(enforce, Enforce);
+  bindTemplate(enforce);
+
+  /**
+   *  @type {String}  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.
+   * @param {String[]|String} item Item to be added to inclusion group.
+   */
+
+  function only(item) {
+    return addTo(EXCLUSION_GROUP_NAME_ONLY, EXCLUSION_ITEM_TYPE_TESTS, item);
+  }
+
+  only.group = function (item) {
+    return addTo(EXCLUSION_GROUP_NAME_ONLY, EXCLUSION_ITEM_TYPE_GROUPS, item);
+  };
+  /**
+   * Adds a field or multiple fields to exclusion group.
+   * @param {String[]|String} item Item to be added to exclusion group.
+   */
+
+
+  function skip(item) {
+    return addTo(EXCLUSION_GROUP_NAME_SKIP, EXCLUSION_ITEM_TYPE_TESTS, item);
+  }
+
+  skip.group = function (item) {
+    return addTo(EXCLUSION_GROUP_NAME_SKIP, EXCLUSION_ITEM_TYPE_GROUPS, item);
+  };
+  /**
+   * Checks whether a certain test profile excluded by any of the exclusion groups.
+   * @param {String} fieldName    Field name to test.
+   * @param {VestTest}            Test Object reference.
+   * @returns {Boolean}
+   */
+
+
+  function isExcluded(testObject) {
+    var fieldName = testObject.fieldName,
+        groupName = testObject.groupName;
+
+    var _context$use = context.use(),
+        exclusion = _context$use.exclusion;
+
+    var keyTests = exclusion[EXCLUSION_ITEM_TYPE_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[EXCLUSION_ITEM_TYPE_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.
+   * @param {String} groupName
+   * @return {Boolean}
+   */
+
+  function isGroupExcluded(groupName) {
+    var _context$use2 = context.use(),
+        exclusion = _context$use2.exclusion;
+
+    var keyGroups = exclusion[EXCLUSION_ITEM_TYPE_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;
+  }
+  /**
+   * @type {String} Exclusion group name: only.
+   */
+
+  var EXCLUSION_GROUP_NAME_ONLY = 'only';
+  /**
+   * @type {String} Exclusion group name: skip.
+   */
+
+  var EXCLUSION_GROUP_NAME_SKIP = 'skip';
+  /**
+   * Adds fields to a specified exclusion group.
+   * @param {String} exclusionGroup   To add the fields to.
+   * @param {String} itemType         Whether the item is a group or a test.
+   * @param {String[]|String} item    A field name or a list of field names.
+   */
+
+  var addTo = function addTo(exclusionGroup, itemType, item) {
+    var ctx = context.use();
+
+    if (!item) {
+      return;
+    }
+
+    if (!ctx) {
+      throwError(exclusionGroup + " " + ERROR_HOOK_CALLED_OUTSIDE);
+      return;
+    }
+
+    asArray(item).forEach(function (itemName) {
+      if (!isStringValue(itemName)) {
+        return null;
+      }
+
+      ctx.exclusion[itemType][itemName] = exclusionGroup === EXCLUSION_GROUP_NAME_ONLY;
+    });
+  };
+  /**
+   * Checks if context has included tests
+   * @param {Object} keyTests Object containing included and excluded tests
+   * @returns {boolean}
+   */
+
+
+  var hasIncludedTests = function hasIncludedTests(keyTests) {
+    for (var test in keyTests) {
+      if (keyTests[test] === true) {
+        return true; // excluded implicitly
+      }
+    }
+
+    return false;
+  };
+
+  // an if statement. The reason for it is to support version 4 api in version 3
+  // so that someone reading the latest docs can still run the code.
+
+  function skipWhen(conditional, callback) {
+    if (isFalsy(optionalFunctionValue(conditional))) {
+      if (isFunction(callback)) {
+        callback();
+      }
+    }
+  }
+
+  /**
+   * @type {String} Error message to display when `warn` gets called outside of a test.
+   */
+
+  var ERROR_OUTSIDE_OF_TEST = 'warn called outside of a test.';
+  /**
+   * Sets a running test to warn only mode.
+   */
+
+  var warn = function warn() {
+    var ctx = context.use();
+
+    if (!ctx) {
+      throwError('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
+      return;
+    }
+
+    if (!ctx.currentTest) {
+      throwError(ERROR_OUTSIDE_OF_TEST);
+      return;
+    }
+
+    ctx.currentTest.warn();
+  };
+
+  var throwGroupError = function throwGroupError() {
+    return throwError("group initialization error. Incompatible argument passed to group.");
+  };
+  /**
+   * Runs a group callback.
+   * @param {string} groupName
+   * @param {Function} tests
+   */
+
+
+  var group = function group(groupName, tests) {
+    if (!isStringValue(groupName)) {
+      throwGroupError();
+    }
+
+    if (!isFunction(tests)) {
+      throwGroupError();
+    } // Running with the context applied
+
+
+    context.bind({
+      groupName: groupName
+    }, tests)();
+  };
+
+  function optional(optionals) {
+    var _useOptionalFields = useOptionalFields(),
+        setOptionalFields = _useOptionalFields[1];
+
+    setOptionalFields(function (state) {
+      asArray(optionals).forEach(function (optionalField) {
+        state[optionalField] = true;
+      });
+      return state;
+    });
+  }
+
+  function isSameProfileTest(testObject1, testObject2) {
+    return testObject1.fieldName === testObject2.fieldName && testObject1.groupName === testObject2.groupName;
+  }
+
+  /**
+   * Removes first found element from array
+   * WARNING: Mutates array
+   *
+   * @param {any[]} array
+   * @param {any} element
+   */
+  var removeElementFromArray = function removeElementFromArray(array, element) {
+    var index = array.indexOf(element);
+
+    if (index !== -1) {
+      array.splice(index, 1);
+    }
+
+    return array;
+  };
+
+  /**
+   * Sets a test as pending in the state.
+   * @param {VestTest} testObject
+   */
+
+  var setPending = function setPending(testObject) {
+    var _usePending = usePending(),
+        pendingState = _usePending[0],
+        setPending = _usePending[1];
+
+    var lagging = asArray(pendingState.lagging).reduce(function (lagging, laggingTestObject) {
+      /**
+       * If the test is of the same profile
+       * (same name + same group) we cancel
+       * it. Otherwise, it is lagging.
+       */
+      if (isSameProfileTest(testObject, laggingTestObject) && // This last case handles memoized tests
+      // because that retain their od across runs
+      laggingTestObject.id !== testObject.id) {
+        laggingTestObject.cancel();
+      } else {
+        lagging.push(laggingTestObject);
+      }
+
+      return lagging;
+    }, []);
+    setPending(function (state) {
+      return {
+        lagging: lagging,
+        pending: state.pending.concat(testObject)
+      };
+    });
+  };
+  /**
+   * Removes a tests from the pending and lagging arrays.
+   * @param {VestTest} testObject
+   */
+
+  var removePending = function removePending(testObject) {
+    var _usePending2 = usePending(),
+        setPending = _usePending2[1];
+
+    setPending(function (state) {
+      return {
+        pending: removeElementFromArray(state.pending, testObject),
+        lagging: removeElementFromArray(state.lagging, testObject)
+      };
+    });
+  };
+
+  /**
+   * Removes test object from suite state
+   * @param {VestTest} testObject
+   */
+
+  var removeTestFromState = (function (testObject) {
+    var _useTestObjects = useTestObjects(),
+        setTestObjects = _useTestObjects[1];
+
+    setTestObjects(function (testObjects) {
+      return (// using asArray to clear the cache.
+        asArray(removeElementFromArray(testObjects, testObject))
+      );
+    });
+  });
+
+  /**
+   * Describes a test call inside a Vest suite.
+   * @param {String} fieldName            Name of the field being tested.
+   * @param {String} statement            The message returned when failing.
+   * @param {Promise|Function} testFn     The actual test callback or promise.
+   * @param {string} [group]              The group in which the test runs.
+   */
+
+  function VestTest(_ref) {
+    var fieldName = _ref.fieldName,
+        statement = _ref.statement,
+        testFn = _ref.testFn,
+        group = _ref.group;
+    var testObject = {
+      cancel: cancel,
+      fail: fail,
+      failed: false,
+      fieldName: fieldName,
+      id: id(),
+      isWarning: false,
+      statement: statement,
+      testFn: testFn,
+      valueOf: valueOf,
+      warn: warn
+    };
+
+    if (group) {
+      testObject.groupName = group;
+    }
+
+    return testObject;
+    /**
+     * @returns {Boolean} Current validity status of a test.
+     */
+
+    function valueOf() {
+      return testObject.failed !== true;
+    }
+    /**
+     * Sets a test to failed.
+     */
+
+
+    function fail() {
+      testObject.failed = true;
+    }
+    /**
+     * Sets a current test's `isWarning` to true.
+     */
+
+
+    function warn() {
+      testObject.isWarning = true;
+    }
+    /**
+     * Marks a test as canceled, removes it from the state.
+     * This function needs to be called within a stateRef context.
+     */
+
+
+    function cancel() {
+      testObject.canceled = true;
+      removePending(this);
+      removeTestFromState(this);
+    }
+  }
+
+  /**
+   *
+   * @param {any[]} array
+   * @param {() => boolean} predicate
+   * @returns {[any[], any[]]}
+   */
+  function partition(array, predicate) {
+    return array.reduce(function (partitions, value, index) {
+      partitions[predicate(value, index, array) ? 0 : 1].push(value);
+      return partitions;
+    }, [[], []]);
+  }
+
+  function mergeCarryOverTests(testObject) {
+    var _useCarryOverTests = useCarryOverTests(),
+        carryOverTests = _useCarryOverTests[0],
+        setCarryOverTests = _useCarryOverTests[1];
+
+    var _useTestObjects = useTestObjects(),
+        setTestObjects = _useTestObjects[1];
+
+    var _partition = partition(carryOverTests, function (carryOverTest) {
+      return isSameProfileTest(carryOverTest, testObject);
+    }),
+        moveToTestObjects = _partition[0],
+        keepInCarryOvers = _partition[1];
+
+    setCarryOverTests(function () {
+      return keepInCarryOvers;
+    });
+    setTestObjects(function (testObjects) {
+      return testObjects.concat(moveToTestObjects);
+    });
+  }
+
+  /**
+   * Stores test object inside suite state.
+   * @param {VestTest} testObject
+   */
+
+  var addTestToState = (function (testObject) {
+    var _useTestObjects = useTestObjects(),
+        setTestObjects = _useTestObjects[1];
+
+    setTestObjects(function (testObjects) {
+      return testObjects.concat(testObject);
+    });
+  });
+
+  function isPromise(value) {
+    return value && isFunction(value.then);
+  }
+
+  function callEach(arr) {
+    return arr.forEach(function (fn) {
+      return fn();
+    });
+  }
+
+  /**
+   * Runs async test.
+   * @param {VestTest} testObject A VestTest instance.
+   */
+
+  var runAsyncTest = function runAsyncTest(testObject) {
+    var asyncTest = testObject.asyncTest,
+        statement = testObject.statement;
+
+    var _context$use = context.use(),
+        stateRef = _context$use.stateRef;
+
+    var done = context.bind({
+      stateRef: stateRef
+    }, function () {
+      removePending(testObject); // This is for cases in which the suite state was already reset
+
+      if (testObject.canceled) {
+        return;
+      } // Perform required done callback calls and cleanups after the test is finished
+
+
+      runDoneCallbacks(testObject.fieldName);
+    });
+    var fail = context.bind({
+      stateRef: stateRef
+    }, function (rejectionMessage) {
+      testObject.statement = isStringValue(rejectionMessage) ? rejectionMessage : statement;
+      testObject.fail(); // Spreading the array to invalidate the cache
+
+      var _useTestObjects = useTestObjects(),
+          setTestObjects = _useTestObjects[1];
+
+      setTestObjects(function (testObjects) {
+        return testObjects.slice();
+      });
+      done();
+    });
+
+    try {
+      asyncTest.then(done, fail);
+    } catch (e) {
+      fail();
+    }
+  };
+  /**
+   * Runs done callback when async tests are finished running.
+   * @param {string} [fieldName] Field name with associated callbacks.
+   */
+
+
+  var runDoneCallbacks = function runDoneCallbacks(fieldName) {
+    var _useTestCallbacks = useTestCallbacks(),
+        _useTestCallbacks$ = _useTestCallbacks[0],
+        fieldCallbacks = _useTestCallbacks$.fieldCallbacks,
+        doneCallbacks = _useTestCallbacks$.doneCallbacks;
+
+    if (fieldName) {
+      if (!hasRemainingTests(fieldName) && Array.isArray(fieldCallbacks[fieldName])) {
+        callEach(fieldCallbacks[fieldName]);
+      }
+    }
+
+    if (!hasRemainingTests()) {
+      callEach(doneCallbacks);
+    }
+  };
+
+  /**
+   * Runs sync tests - or extracts promise.
+   * @param {VestTest} testObject VestTest instance.
+   * @returns {*} Result from test callback.
+   */
+
+  function runSyncTest(testObject) {
+    return context.run({
+      currentTest: testObject
+    }, function () {
+      var result;
+
+      try {
+        result = testObject.testFn();
+      } catch (e) {
+        if (isUndefined(testObject.statement) && isStringValue(e)) {
+          testObject.statement = e;
+        }
+
+        result = false;
+      }
+
+      if (result === false) {
+        testObject.fail();
+      }
+
+      return result;
+    });
+  }
+
+  /**
+   * Registers test, if async - adds to pending array
+   * @param {VestTest} testObject   A VestTest Instance.
+   */
+
+  function registerTest(testObject) {
+    addTestToState(testObject); // 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;
+        setPending(testObject);
+        runAsyncTest(testObject);
+      }
+    } catch (_unused) {
+    }
+  }
+
+  /* eslint-disable jest/no-export */
+
+  function bindTestEach(test) {
+    /**
+     * Run multiple tests using a parameter table
+     * @param {any[]} table         Array of arrays with params for each run (will accept 1d-array and treat every item as size one array)
+     * @param {String} fieldName    Name of the field to test.
+     * @param {String|function} [statement]  The message returned in case of a failure.  Follows printf syntax.
+     * @param {function} testFn     The actual test callback.
+     * @return {VestTest[]}           An array of VestTest instances.
+     */
+    function each(table) {
+      if (!Array.isArray(table)) {
+        throwError('test.each: Expected table to be an array.');
+      }
+
+      return withArgs(function (fieldName, args) {
+        var _args$reverse = args.reverse(),
+            testFn = _args$reverse[0],
+            statement = _args$reverse[1];
+
+        return table.map(function (item) {
+          item = asArray(item);
+          return test(optionalFunctionValue(fieldName, item), optionalFunctionValue(statement, item), function () {
+            return testFn.apply(null, item);
+          });
+        });
+      });
+    }
+
+    test.each = each;
+  }
+
+  /* eslint-disable jest/no-export */
+
+  function bindTestMemo(test) {
+    var cache = createCache(100); // arbitrary cache size
+
+    /**
+     * Caches, or returns an already cached test call
+     * @param {String} fieldName    Name of the field to test.
+     * @param {String} [statement]  The message returned in case of a failure.
+     * @param {function} testFn     The actual test callback.
+     * @param {any[]} deps          Dependency array.
+     * @return {VestTest}           A VestTest instance.
+     */
+
+    function memo(fieldName, args) {
+      var _useSuiteId = useSuiteId(),
+          suiteId = _useSuiteId[0];
+
+      var _args$reverse = args.reverse(),
+          deps = _args$reverse[0],
+          testFn = _args$reverse[1],
+          msg = _args$reverse[2]; // Implicit dependency for more specificity
+
+
+      var dependencies = [suiteId.id, fieldName].concat(deps);
+      var cached = cache.get(dependencies);
+
+      if (isNull(cached)) {
+        // Cache miss. Start fresh
+        return cache(dependencies, test.bind(null, fieldName, msg, testFn));
+      }
+
+      var testObject = cached[1];
+
+      if (isExcluded(testObject)) {
+        return testObject;
+      }
+
+      addTestToState(testObject);
+
+      if (testObject && isPromise(testObject.asyncTest)) {
+        setPending(testObject);
+        runAsyncTest(testObject);
+      }
+
+      return testObject;
+    }
+
+    test.memo = withArgs(memo);
+  }
+
+  /**
+   * Test function used by consumer to provide their own validations.
+   * @param {String} fieldName            Name of the field to test.
+   * @param {String} [statement]          The message returned in case of a failure.
+   * @param {function} testFn             The actual test callback.
+   * @return {VestTest}                 A VestTest instance.
+   *
+   * **IMPORTANT**
+   * Changes to this function need to reflect in test.memo as well
+   */
+
+  var test = withArgs(function (fieldName, args) {
+    var _args$reverse = args.reverse(),
+        testFn = _args$reverse[0],
+        statement = _args$reverse[1];
+
+    var _useSkippedTests = useSkippedTests(),
+        setSkippedTests = _useSkippedTests[1];
+
+    var _context$use = context.use(),
+        groupName = _context$use.groupName;
+
+    var testObject = VestTest({
+      fieldName: fieldName,
+      group: groupName,
+      statement: statement,
+      testFn: testFn
+    });
+
+    if (isExcluded(testObject)) {
+      setSkippedTests(function (skippedTests) {
+        return skippedTests.concat(testObject);
+      });
+      mergeCarryOverTests(testObject);
+      return testObject;
+    }
+
+    if (!isFunction(testFn)) {
+      return testObject;
+    }
+
+    registerTest(testObject);
+    return testObject;
+  });
+  bindTestEach(test);
+  bindTestMemo(test);
+
+  var VERSION = "3.2.8";
+  var vest = {
+    VERSION: VERSION,
+    create: createSuite,
+    enforce: enforce,
+    group: group,
+    only: only,
+    optional: optional,
+    skip: skip,
+    skipWhen: skipWhen,
+    test: test,
+    warn: warn
+  };
+
+  return vest;
+
+})));