vest 3.2.8-dev-6d7c74 → 3.2.8

package/vest.cjs.development.js

@@ -0,0 +1,2494 @@
+'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, {
+  suiteId,
+  name
+}) {
+  return {
+    carryOverTests: state.registerStateKey(() => []),
+    optionalFields: state.registerStateKey(() => ({})),
+    pending: state.registerStateKey(() => ({
+      pending: [],
+      lagging: []
+    })),
+    skippedTests: state.registerStateKey(() => []),
+    suiteId: state.registerStateKey(() => ({
+      id: suiteId,
+      name
+    })),
+    testCallbacks: state.registerStateKey(() => ({
+      fieldCallbacks: {},
+      doneCallbacks: []
+    })),
+    testObjects: state.registerStateKey(() => [])
+  };
+}
+
+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;
+
+const EXCLUSION_ITEM_TYPE_TESTS = 'tests';
+const EXCLUSION_ITEM_TYPE_GROUPS = 'groups';
+
+const context = createContext((ctxRef, parentContext) => parentContext ? null : assign({}, {
+  exclusion: {
+    [EXCLUSION_ITEM_TYPE_TESTS]: {},
+    [EXCLUSION_ITEM_TYPE_GROUPS]: {}
+  }
+}, ctxRef));
+
+/**
+ * @returns a unique numeric id.
+ */
+const id = (n => () => `${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;
+}
+const isNotNull = bindNot(isNull);
+
+function lengthEquals(value, arg1) {
+  return value.length === Number(arg1);
+}
+const lengthNotEquals = bindNot(lengthEquals);
+
+/**
+ * Creates a cache function
+ * @param {number} [maxSize] Max cache size
+ * @return {Function} cache function
+ */
+
+const createCache = (maxSize = 10) => {
+  const cacheStorage = [];
+  /**
+   * @param {Any[]} deps  dependency array.
+   * @param {Function}    cache action function.
+   */
+
+  const cache = (deps, cacheAction) => {
+    const cacheHit = cache.get(deps);
+
+    if (isNotNull(cacheHit)) {
+      return cacheHit[1];
+    }
+
+    const 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 = deps => cacheStorage[cacheStorage.findIndex(([cachedDeps]) => lengthEquals(deps, cachedDeps.length) && deps.every((dep, i) => dep === cachedDeps[i]))] || null;
+
+  return cache;
+};
+
+const SEVERITY_GROUP_WARN = 'warnings';
+const SEVERITY_COUNT_WARN = 'warnCount';
+const SEVERITY_GROUP_ERROR = 'errors';
+const SEVERITY_COUNT_ERROR = 'errorCount';
+const TEST_COUNT = 'testCount';
+
+const getStateRef = () => 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.
+ */
+
+const genTestsSummary = () => {
+  const [testObjects] = useTestObjects();
+  const [suiteIdState] = useSuiteId();
+  const [skippedTests] = useSkippedTests();
+  const summary = {
+    [SEVERITY_COUNT_ERROR]: 0,
+    [SEVERITY_COUNT_WARN]: 0,
+    [TEST_COUNT]: 0,
+    groups: {},
+    name: suiteIdState.name,
+    tests: {}
+  };
+  appendSummary(testObjects);
+  appendSummary(skippedTests, true);
+  return countFailures(summary);
+
+  function appendSummary(testObject, skipped) {
+    testObject.forEach(testObject => {
+      const {
+        fieldName,
+        groupName
+      } = testObject;
+      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)
+ */
+
+
+const countFailures = summary => {
+  for (const 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
+ */
+
+const genTestObject = (summaryKey, testObject, skipped) => {
+  const {
+    fieldName,
+    isWarning,
+    failed,
+    statement
+  } = testObject;
+  summaryKey[fieldName] = summaryKey[fieldName] || {
+    [SEVERITY_COUNT_ERROR]: 0,
+    [SEVERITY_COUNT_WARN]: 0,
+    [TEST_COUNT]: 0
+  };
+  const testKey = summaryKey[fieldName];
+
+  if (skipped) {
+    return testKey;
+  }
+
+  summaryKey[fieldName][TEST_COUNT]++; // Adds to severity group
+
+  const 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.
+ */
+
+const collectFailureMessages = (severity, options) => {
+  const [testObjects] = useTestObjects();
+  const {
+    group,
+    fieldName
+  } = options || {};
+  const res = testObjects.reduce((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
+  });
+}
+
+/**
+ * Throws a timed out error.
+ * @param {String} message  Error message to display.
+ * @param {Error} [type]    Alternative Error type.
+ */
+const throwError = (message, 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.
+ */
+
+const 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,
+    fieldName
+  });
+};
+
+/**
+ * Determines whether a certain test profile has failures.
+ * @param {VestTest} testObject
+ * @param {'warnings'|'errors'} severityKey lookup severity
+ * @param {string} [fieldName]
+ * @returns {Boolean}
+ */
+
+const 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.
+ */
+
+const has = (severityKey, fieldName) => {
+  const [testObjects] = useTestObjects();
+  return testObjects.some(testObject => 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}
+ */
+
+const hasByGroup = (severityKey, group, fieldName) => {
+  const [testObjects] = useTestObjects();
+  return testObjects.some(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) {
+  const result = !isNaN(parseFloat(value)) && !isNaN(Number(value)) && isFinite(value);
+  return Boolean(result);
+}
+const 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;
+}
+const isNotEmpty = bindNot(isEmpty);
+
+/**
+ * Checks if a given tests, or the suite as a whole still have remaining tests.
+ * @param {string} [fieldName]
+ * @returns {Boolean}
+ */
+
+const hasRemainingTests = fieldName => {
+  const [{
+    pending,
+    lagging
+  }] = usePending();
+  const allIncomplete = pending.concat(lagging);
+
+  if (isEmpty(allIncomplete)) {
+    return false;
+  }
+
+  if (fieldName) {
+    return allIncomplete.some(testObject => testObject.fieldName === fieldName);
+  }
+
+  return isNotEmpty(allIncomplete);
+};
+
+const HAS_WARNINGS = 'hasWarnings';
+const 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
+  }) : 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 () {
+    const args = Array.from(arguments);
+    const right = args.splice(cb.length - 1);
+    return cb.apply(null, args.concat([right]));
+  }, fnName || cb.name);
+}
+
+const cache = createCache(20);
+/**
+ * @param {boolean} [isDraft]
+ * @returns Vest output object.
+ */
+
+const produce = isDraft => {
+  const {
+    stateRef
+  } = context.use();
+  const [testObjects] = useTestObjects();
+  const ctxRef = {
+    stateRef
+  };
+  return cache([testObjects, isDraft], context.bind(ctxRef, () => [[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((properties, [name, fn, severityKey]) => {
+    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) {
+  const [callback, fieldName] = args.reverse();
+  const {
+    stateRef
+  } = context.use();
+  const output = produce(); // If we do not have any test runs for the current field
+
+  const shouldSkipRegistration = fieldName && (!output.tests[fieldName] || output.tests[fieldName].testCount === 0);
+
+  if (!isFunction(callback) || shouldSkipRegistration) {
+    return output;
+  }
+
+  const cb = context.bind({
+    stateRef
+  }, () => callback(produce(
+  /*isDraft:*/
+  true))); // is suite finished || field name exists, and test is finished
+
+  const shouldRunCallback = !hasRemainingTests() || fieldName && !hasRemainingTests(fieldName);
+
+  if (shouldRunCallback) {
+    cb();
+    return output;
+  }
+
+  const [, setTestCallbacks] = useTestCallbacks();
+  setTestCallbacks(current => {
+    if (fieldName) {
+      current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(cb);
+    } else {
+      current.doneCallbacks.push(cb);
+    }
+
+    return current;
+  });
+  return output;
+}
+
+function isValid() {
+  const result = produce();
+
+  if (result.hasErrors()) {
+    return false;
+  }
+
+  const [testObjects] = useTestObjects();
+
+  if (testObjects.length === 0) {
+    return false;
+  }
+
+  const [optionalFields] = useOptionalFields();
+  const [{
+    pending,
+    lagging
+  }] = usePending();
+
+  if (isNotEmpty(pending.concat(lagging).filter(testObject => !testObject.isWarning))) {
+    return false;
+  }
+
+  for (const 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.
+ */
+
+const createSuite = withArgs(args => {
+  const [tests, name] = args.reverse();
+
+  if (!isFunction(tests)) {
+    throwError('Suite initialization error. Expected `tests` to be a function.');
+  }
+
+  const handlers = [];
+  const state = createState(() => {
+    handlers.forEach(fn => fn({
+      suiteState: stateRef,
+      type: 'suiteStateUpdate'
+    }));
+  });
+  const stateRef = createStateRef(state, {
+    suiteId: id(),
+    name
+  });
+  /*
+    context.bind returns our `validate` function
+    We then wrap it with defineProperties to add
+    the `get`, and `reset` functions.
+   */
+
+  const suite = context.bind({
+    stateRef
+  }, function () {
+    const [previousTestObjects] = useTestObjects();
+    const [, setCarryOverTests] = useCarryOverTests();
+    const [{
+      pending
+    }, setPending] = usePending();
+    state.reset();
+    setCarryOverTests(() => 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
+  }, produce,
+  /*isDraft:*/
+  true);
+  suite.reset = state.reset;
+  suite.remove = context.bind({
+    stateRef
+  }, name => {
+    const [testObjects] = useTestObjects(); // We're mutating the array in `cancel`, so we have to first copy it.
+
+    asArray(testObjects).forEach(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;
+});
+
+/**
+ * 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
+  });
+};
+/**
+ * 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;
+}
+
+const isNotBoolean = bindNot(isBoolean);
+
+function isUndefined(value) {
+  return value === undefined;
+}
+const 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;
+  }
+
+  const 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;
+  }
+
+  const res = RuleResult.is(newRes) ? newRes : new RuleResult().setAttribute('warn', !!this.warn).setFailed(!newRes);
+  const failed = this.failed || res.failed;
+  const 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() {
+    return !this.failed;
+  }
+
+});
+/**
+ * Deeply merge the nested children of compound rules
+ *
+ * @param {?RuleResult} base
+ * @param {?RuleResult} add
+ * @return {RuleResult}
+ */
+
+function mergeChildren(base, add) {
+  const isRuleResultBase = RuleResult.is(base);
+  const 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 (const 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 (const 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);
+}
+
+const RUN_RULE = 'run';
+const TEST_RULE = 'test';
+const MODE_ALL = 'all';
+const MODE_ONE = 'one';
+const 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) {
+  const result = new RuleResult(true);
+
+  for (const chain of asArray(ruleGroups)) {
+    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) {
+  const result = new RuleResult(true);
+
+  if (isEmpty(rules)) {
+    result.setFailed(true);
+  }
+
+  const failedResults = [];
+  let count = 0;
+
+  for (const chain of rules) {
+    // Inner result for each iteration
+    const currentResult = runLazyRule(chain, value);
+
+    if (isNull(currentResult)) {
+      return null;
+    }
+
+    const 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(failedResult => 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));
+}
+const 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) {
+  const plainValue = EnforceContext.unwrap(value);
+  const result = new RuleResult(true).asArray(); // Fails if current value is not an array
+
+  if (isNotArray(plainValue)) {
+    return result.setFailed(true);
+  }
+
+  for (let 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) {
+  const {
+    obj,
+    key
+  } = inputObject; // 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
+  const obj = EnforceContext.unwrap(inputObject); // Create a new result object
+
+  const result = new RuleResult(true); // Iterate over the shape keys
+
+  for (const key in shapeObj) {
+    const current = shapeObj[key];
+    const value = obj[key];
+
+    if (shouldFailFast(value, result)) {
+      break;
+    } // Set each key in the result object
+
+
+    result.setChild(key, runLazyRule(current, new EnforceContext({
+      value,
+      obj,
+      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 (const key in obj) {
+      if (!hasOwnProperty(shapeObj, key)) {
+        return result.setFailed(true);
+      }
+    }
+  }
+
+  return result;
+}
+const loose = (obj, shapeObj) => shape(obj, shapeObj, {
+  loose: true
+});
+
+var compounds = {
+  allOf: allOf$1,
+  anyOf: anyOf$1,
+  isArrayOf: isArrayOf$1,
+  loose,
+  oneOf: oneOf$1,
+  optional: optional$2,
+  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 = true) {
+  return isWarn;
+}
+
+function when(value, condition, bail) {
+  const shouldBail = !optionalFunctionValue(condition, [EnforceContext.unwrap(value)].concat(EnforceContext.is(value) ? [value.key, value.obj] : []));
+  return bail(shouldBail);
+}
+
+var ruleMeta = {
+  warn: warn$1,
+  message,
+  when
+};
+
+function isStringValue (v) {
+  return String(v) === v;
+}
+
+function endsWith(value, arg1) {
+  return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
+}
+const doesNotEndWith = bindNot(endsWith);
+
+function equals(value, arg1) {
+  return value === arg1;
+}
+const 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;
+}
+const 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);
+}
+const isNotBetween = bindNot(isBetween);
+
+function isBlank(value) {
+  return typeof value === 'string' && value.trim() === '';
+}
+const isNotBlank = bindNot(isBlank);
+
+/**
+ * Validates that a given value is an even number
+ * @param {Number|String} value Value to be validated
+ * @return {Boolean}
+ */
+
+const isEven = value => {
+  if (isNumeric(value)) {
+    return value % 2 === 0;
+  }
+
+  return false;
+};
+
+function isNaN$1(value) {
+  return Number.isNaN(value);
+}
+const isNotNaN = bindNot(isNaN$1);
+
+function isNegative(value) {
+  if (isNumeric(value)) {
+    return Number(value) < 0;
+  }
+
+  return false;
+}
+const isPositive = bindNot(isNegative);
+
+function isNumber(value) {
+  return Boolean(typeof value === 'number');
+}
+const isNotNumber = bindNot(isNumber);
+
+/**
+ * Validates that a given value is an odd number
+ * @param {Number|String} value Value to be validated
+ * @return {Boolean}
+ */
+
+const isOdd = value => {
+  if (isNumeric(value)) {
+    return value % 2 !== 0;
+  }
+
+  return false;
+};
+
+const isNotString = bindNot(isStringValue);
+
+function isTruthy(value) {
+  return !!value;
+}
+const 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;
+  }
+}
+const notMatches = bindNot(matches);
+
+function numberEquals(value, arg1) {
+  return isNumeric(value) && isNumeric(arg1) && Number(value) === Number(arg1);
+}
+const 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);
+}
+const doesNotStartWith = bindNot(startsWith);
+
+function rules() {
+  return {
+    doesNotEndWith,
+    doesNotStartWith,
+    endsWith,
+    equals,
+    greaterThan,
+    greaterThanOrEquals,
+    gt: greaterThan,
+    gte: greaterThanOrEquals,
+    inside,
+    isArray,
+    isBetween,
+    isBoolean,
+    isBlank,
+    isEmpty,
+    isEven,
+    isFalsy,
+    isNaN: isNaN$1,
+    isNegative,
+    isNotArray,
+    isNotBetween,
+    isNotBlank,
+    isNotBoolean,
+    isNotEmpty,
+    isNotNaN,
+    isNotNull,
+    isNotNumber,
+    isNotNumeric,
+    isNotString,
+    isNotUndefined,
+    isNull,
+    isNumber,
+    isNumeric,
+    isOdd,
+    isPositive,
+    isString: isStringValue,
+    isTruthy,
+    isUndefined,
+    lengthEquals,
+    lengthNotEquals,
+    lessThan,
+    lessThanOrEquals,
+    longerThan,
+    longerThanOrEquals,
+    lt: lessThan,
+    lte: lessThanOrEquals,
+    matches,
+    notEquals,
+    notInside,
+    notMatches,
+    numberEquals,
+    numberNotEquals,
+    shorterThan,
+    shorterThanOrEquals,
+    startsWith
+  };
+}
+
+var runtimeRules = assign(rules(), compounds, ruleMeta);
+
+/**
+ * Determines whether a given string is a name of a rule
+ *
+ * @param {string} name
+ * @return {boolean}
+ */
+
+const isRule = name => hasOwnProperty(runtimeRules, name) && isFunction(runtimeRules[name]);
+
+const GLOBAL_OBJECT = Function('return this')();
+
+const proxySupported = () => isFunction(GLOBAL_OBJECT.Proxy);
+
+function genRuleProxy(target, output) {
+  if (proxySupported()) {
+    return new Proxy(target, {
+      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 {
+    /**
+     * 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 (const fnName in runtimeRules) {
+      if (!isFunction(target[fnName])) {
+        Object.defineProperties(target, {
+          [fnName]: {
+            get: () => output(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) {
+  const registeredRules = []; // Chained rules
+
+  const 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
+
+  const addFn = ruleName => {
+    return withArgs(args => {
+      const rule = runtimeRules[ruleName]; // Add a meta function
+
+      if (ruleMeta[rule.name] === rule) {
+        meta.push((value, ruleResult, bail) => {
+          ruleResult.setAttribute(rule.name, rule(value, args[0], bail));
+        });
+      } else {
+        // Register a rule
+        registeredRules.push(setFnName(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
+
+
+      const returnvalue = genRuleProxy({}, addFn);
+
+      returnvalue[RUN_RULE] = value => {
+        const result = new RuleResult(true);
+        let bailed = false; // Run meta chains
+
+        meta.forEach(fn => {
+          fn(value, result, shouldBail => bailed = shouldBail);
+        });
+
+        if (bailed) {
+          return null;
+        } // Iterate over all the registered rules
+        // This runs the function that's inside `addFn`
+
+
+        for (const fn of registeredRules) {
+          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] = value => 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 = 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 the rule please check that the return is valid` );
+} // 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, {
+  rule,
+  value
+}) {
+  const 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 = []) {
+  let result;
+  const isCompoundRule = isCompound(rule);
+  const ruleValue = isCompoundRule ? EnforceContext.wrap(value).setFailFast(true) : EnforceContext.unwrap(value);
+  result = rule.apply(null, [ruleValue].concat(args));
+
+  if (!isCompoundRule) {
+    result = transformResult(result, {
+      rule,
+      value
+    });
+  }
+
+  if (!result.pass) {
+    throw result.message;
+  }
+}
+
+/**
+ * Adds `template` property to enforce.
+ *
+ * @param {Function} enforce
+ */
+
+function bindTemplate(enforce) {
+  enforce.template = withArgs(rules => {
+    const template = value => {
+      runner(runLazyRules.bind(null, rules), value);
+      const proxy = genRuleProxy({}, ruleName => withArgs(args => {
+        runner(runtimeRules[ruleName], value, args);
+        return proxy;
+      }));
+      return proxy;
+    }; // `run` returns a deep ResultObject
+
+
+    template[RUN_RULE] = value => runLazyRules(rules, value); // `test` returns a boolean
+
+
+    template[TEST_RULE] = value => runLazyRules(rules, EnforceContext.wrap(value).setFailFast(true)).pass;
+
+    return template;
+  });
+}
+
+const Enforce = value => {
+  const proxy = genRuleProxy({}, ruleName => withArgs(args => {
+    runner(runtimeRules[ruleName], value, args);
+    return proxy;
+  }));
+  return proxy;
+};
+
+const enforce = genRuleProxy(Enforce, bindLazyRule);
+bindExtend(enforce, Enforce);
+bindTemplate(enforce);
+
+/**
+ *  @type {String}  Error message to display when a hook was called outside of context.
+ */
+const 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 = item => 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 = item => 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) {
+  const {
+    fieldName,
+    groupName
+  } = testObject;
+  const {
+    exclusion
+  } = context.use();
+  const keyTests = exclusion[EXCLUSION_ITEM_TYPE_TESTS];
+  const testValue = keyTests[fieldName]; // if test is skipped
+  // no need to proceed
+
+  if (testValue === false) {
+    return true;
+  }
+
+  const 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) {
+  const {
+    exclusion
+  } = context.use();
+  const keyGroups = exclusion[EXCLUSION_ITEM_TYPE_GROUPS];
+  const 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 (const group in keyGroups) {
+    // If any other group is only'ed
+    if (keyGroups[group] === true) {
+      return true;
+    }
+  }
+
+  return false;
+}
+/**
+ * @type {String} Exclusion group name: only.
+ */
+
+const EXCLUSION_GROUP_NAME_ONLY = 'only';
+/**
+ * @type {String} Exclusion group name: skip.
+ */
+
+const 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.
+ */
+
+const addTo = (exclusionGroup, itemType, item) => {
+  const ctx = context.use();
+
+  if (!item) {
+    return;
+  }
+
+  if (!ctx) {
+    throwError(`${exclusionGroup} ${ERROR_HOOK_CALLED_OUTSIDE}`);
+    return;
+  }
+
+  asArray(item).forEach(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}
+ */
+
+
+const hasIncludedTests = keyTests => {
+  for (const 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.
+ */
+
+const 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.
+ */
+
+const warn = () => {
+  const ctx = context.use();
+
+  if (!ctx) {
+    throwError('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
+    return;
+  }
+
+  if (!ctx.currentTest) {
+    throwError(ERROR_OUTSIDE_OF_TEST);
+    return;
+  }
+
+  ctx.currentTest.warn();
+};
+
+const throwGroupError = () => throwError("group initialization error. Incompatible argument passed to group.");
+/**
+ * Runs a group callback.
+ * @param {string} groupName
+ * @param {Function} tests
+ */
+
+
+const group = (groupName, tests) => {
+  if (!isStringValue(groupName)) {
+    throwGroupError();
+  }
+
+  if (!isFunction(tests)) {
+    throwGroupError();
+  } // Running with the context applied
+
+
+  context.bind({
+    groupName
+  }, tests)();
+};
+
+function optional(optionals) {
+  const [, setOptionalFields] = useOptionalFields();
+  setOptionalFields(state => {
+    asArray(optionals).forEach(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
+ */
+const removeElementFromArray = (array, element) => {
+  const index = array.indexOf(element);
+
+  if (index !== -1) {
+    array.splice(index, 1);
+  }
+
+  return array;
+};
+
+/**
+ * Sets a test as pending in the state.
+ * @param {VestTest} testObject
+ */
+
+const setPending = testObject => {
+  const [pendingState, setPending] = usePending();
+  const lagging = asArray(pendingState.lagging).reduce((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(state => ({
+    lagging,
+    pending: state.pending.concat(testObject)
+  }));
+};
+/**
+ * Removes a tests from the pending and lagging arrays.
+ * @param {VestTest} testObject
+ */
+
+const removePending = testObject => {
+  const [, setPending] = usePending();
+  setPending(state => ({
+    pending: removeElementFromArray(state.pending, testObject),
+    lagging: removeElementFromArray(state.lagging, testObject)
+  }));
+};
+
+/**
+ * Removes test object from suite state
+ * @param {VestTest} testObject
+ */
+
+var removeTestFromState = (testObject => {
+  const [, setTestObjects] = useTestObjects();
+  setTestObjects(testObjects => // 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({
+  fieldName,
+  statement,
+  testFn,
+  group
+}) {
+  const testObject = {
+    cancel,
+    fail,
+    failed: false,
+    fieldName,
+    id: id(),
+    isWarning: false,
+    statement,
+    testFn,
+    valueOf,
+    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((partitions, value, index) => {
+    partitions[predicate(value, index, array) ? 0 : 1].push(value);
+    return partitions;
+  }, [[], []]);
+}
+
+function mergeCarryOverTests(testObject) {
+  const [carryOverTests, setCarryOverTests] = useCarryOverTests();
+  const [, setTestObjects] = useTestObjects();
+  const [moveToTestObjects, keepInCarryOvers] = partition(carryOverTests, carryOverTest => isSameProfileTest(carryOverTest, testObject));
+  setCarryOverTests(() => keepInCarryOvers);
+  setTestObjects(testObjects => testObjects.concat(moveToTestObjects));
+}
+
+/**
+ * Stores test object inside suite state.
+ * @param {VestTest} testObject
+ */
+
+var addTestToState = (testObject => {
+  const [, setTestObjects] = useTestObjects();
+  setTestObjects(testObjects => testObjects.concat(testObject));
+});
+
+function isPromise(value) {
+  return value && isFunction(value.then);
+}
+
+function callEach(arr) {
+  return arr.forEach(fn => fn());
+}
+
+/**
+ * Runs async test.
+ * @param {VestTest} testObject A VestTest instance.
+ */
+
+const runAsyncTest = testObject => {
+  const {
+    asyncTest,
+    statement
+  } = testObject;
+  const {
+    stateRef
+  } = context.use();
+  const done = context.bind({
+    stateRef
+  }, () => {
+    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);
+  });
+  const fail = context.bind({
+    stateRef
+  }, rejectionMessage => {
+    testObject.statement = isStringValue(rejectionMessage) ? rejectionMessage : statement;
+    testObject.fail(); // Spreading the array to invalidate the cache
+
+    const [, setTestObjects] = useTestObjects();
+    setTestObjects(testObjects => 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.
+ */
+
+
+const runDoneCallbacks = fieldName => {
+  const [{
+    fieldCallbacks,
+    doneCallbacks
+  }] = useTestCallbacks();
+
+  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
+  }, () => {
+    let 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.
+
+  const 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) {
+    {
+      throwError(`Your test function ${testObject.fieldName} returned ${JSON.stringify(result)}. Only "false" or a Promise are supported. Return values may cause unexpected behavior.`);
+    }
+  }
+}
+
+/* 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((fieldName, args) => {
+      const [testFn, statement] = args.reverse();
+      return table.map(item => {
+        item = asArray(item);
+        return test(optionalFunctionValue(fieldName, item), optionalFunctionValue(statement, item), () => testFn.apply(null, item));
+      });
+    });
+  }
+
+  test.each = each;
+}
+
+/* eslint-disable jest/no-export */
+
+function bindTestMemo(test) {
+  const 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) {
+    const [suiteId] = useSuiteId();
+    const [deps, testFn, msg] = args.reverse(); // Implicit dependency for more specificity
+
+    const dependencies = [suiteId.id, fieldName].concat(deps);
+    const cached = cache.get(dependencies);
+
+    if (isNull(cached)) {
+      // Cache miss. Start fresh
+      return cache(dependencies, test.bind(null, fieldName, msg, testFn));
+    }
+
+    const [, testObject] = cached;
+
+    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
+ */
+
+const test = withArgs(function (fieldName, args) {
+  const [testFn, statement] = args.reverse();
+  const [, setSkippedTests] = useSkippedTests();
+  const {
+    groupName
+  } = context.use();
+  const testObject = VestTest({
+    fieldName,
+    group: groupName,
+    statement,
+    testFn
+  });
+
+  if (isExcluded(testObject)) {
+    setSkippedTests(skippedTests => skippedTests.concat(testObject));
+    mergeCarryOverTests(testObject);
+    return testObject;
+  }
+
+  if (!isFunction(testFn)) {
+    return testObject;
+  }
+
+  registerTest(testObject);
+  return testObject;
+});
+bindTestEach(test);
+bindTestMemo(test);
+
+const VERSION = "3.2.8";
+var vest = {
+  VERSION,
+  create: createSuite,
+  enforce,
+  group,
+  only,
+  optional,
+  skip,
+  skipWhen,
+  test,
+  warn
+};
+
+module.exports = vest;