vest 4.4.3-dev-c786f7 → 4.6.0

package/dist/umd/vest.development.js

@@ -1,820 +1,12 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}));
-}(this, (function (exports) { 'use strict';
-
-  function bindNot(fn) {
-      return function () {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments[_i];
-          }
-          return !fn.apply(void 0, args);
-      };
-  }
-
-  function isNumeric(value) {
-      var str = String(value);
-      var num = Number(value);
-      var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
-      return Boolean(result);
-  }
-  var isNotNumeric = bindNot(isNumeric);
-
-  function numberEquals(value, eq) {
-      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
-  }
-  var numberNotEquals = bindNot(numberEquals);
-
-  function lengthEquals(value, arg1) {
-      return numberEquals(value.length, arg1);
-  }
-  var lengthNotEquals = bindNot(lengthEquals);
-
-  function greaterThan(value, gt) {
-      return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
-  }
-
-  function longerThan(value, arg1) {
-      return greaterThan(value.length, arg1);
-  }
-
-  /**
-   * Creates a cache function
-   */
-  function createCache(maxSize) {
-      if (maxSize === void 0) { maxSize = 1; }
-      var cacheStorage = [];
-      var cache = function (deps, cacheAction) {
-          var cacheHit = cache.get(deps);
-          // cache hit is not null
-          if (cacheHit)
-              return cacheHit[1];
-          var result = cacheAction();
-          cacheStorage.unshift([deps.concat(), result]);
-          if (longerThan(cacheStorage, maxSize))
-              cacheStorage.length = maxSize;
-          return result;
-      };
-      // invalidate an item in the cache by its dependencies
-      cache.invalidate = function (deps) {
-          var index = findIndex(deps);
-          if (index > -1)
-              cacheStorage.splice(index, 1);
-      };
-      // Retrieves an item from the cache.
-      cache.get = function (deps) {
-          return cacheStorage[findIndex(deps)] || null;
-      };
-      return cache;
-      function findIndex(deps) {
-          return cacheStorage.findIndex(function (_a) {
-              var cachedDeps = _a[0];
-              return lengthEquals(deps, cachedDeps.length) &&
-                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          });
-      }
-  }
-
-  function isNull(value) {
-      return value === null;
-  }
-  var isNotNull = bindNot(isNull);
-
-  function isUndefined(value) {
-      return value === undefined;
-  }
-  var isNotUndefined = bindNot(isUndefined);
-
-  function isNullish(value) {
-      return isNull(value) || isUndefined(value);
-  }
-  var isNotNullish = bindNot(isNullish);
-
-  function asArray(possibleArg) {
-      return [].concat(possibleArg);
-  }
-
-  function isFunction(value) {
-      return typeof value === 'function';
-  }
-
-  function optionalFunctionValue(value) {
-      var args = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-          args[_i - 1] = arguments[_i];
-      }
-      return isFunction(value) ? value.apply(void 0, args) : value;
-  }
-
-  function defaultTo(value, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(value)) !== null && _a !== void 0 ? _a : optionalFunctionValue(defaultValue);
-  }
-
-  // The module is named "isArrayValue" since it
-  // is conflicting with a nested npm dependency.
-  // We may need to revisit this in the future.
-  function isArray(value) {
-      return Boolean(Array.isArray(value));
-  }
-  var isNotArray = bindNot(isArray);
-
-  function last(values) {
-      var valuesArray = asArray(values);
-      return valuesArray[valuesArray.length - 1];
-  }
-
-  // This is kind of a map/filter in one function.
-  // Normally, behaves like a nested-array map,
-  // but returning `null` will drop the element from the array
-  function transform(array, cb) {
-      var res = [];
-      for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-          var v = array_1[_i];
-          if (isArray(v)) {
-              res.push(transform(v, cb));
-          }
-          else {
-              var output = cb(v);
-              if (isNotNull(output)) {
-                  res.push(output);
-              }
-          }
-      }
-      return res;
-  }
-  function valueAtPath(array, path) {
-      return getCurrent(array, path)[last(path)];
-  }
-  function setValueAtPath(array, path, value) {
-      var current = getCurrent(array, path);
-      current[last(path)] = value;
-      return array;
-  }
-  function flatten(values) {
-      return asArray(values).reduce(function (acc, value) {
-          if (isArray(value)) {
-              return acc.concat(flatten(value));
-          }
-          return asArray(acc).concat(value);
-      }, []);
-  }
-  function getCurrent(array, path) {
-      var current = array;
-      for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
-          var p = _a[_i];
-          current[p] = defaultTo(current[p], []);
-          current = current[p];
-      }
-      return current;
-  }
-
-  function callEach(arr) {
-      return arr.forEach(function (fn) { return fn(); });
-  }
-
-  /**
-   * A safe hasOwnProperty access
-   */
-  function hasOwnProperty(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-  }
-
-  function isPromise(value) {
-      return value && isFunction(value.then);
-  }
-
-  var assign = Object.assign;
-
-  function invariant(condition, 
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  message) {
-      if (condition) {
-          return;
-      }
-      // If message is a string object (rather than string literal)
-      // Throw the value directly as a string
-      // Alternatively, throw an error with the message
-      throw message instanceof String
-          ? message.valueOf()
-          : new Error(message ? optionalFunctionValue(message) : message);
-  }
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  function StringObject(value) {
-      return new String(optionalFunctionValue(value));
-  }
-
-  function isStringValue(v) {
-      return String(v) === v;
-  }
-
-  function either(a, b) {
-      return !!a !== !!b;
-  }
-
-  function isBoolean(value) {
-      return !!value === value;
-  }
-
-  function deferThrow(message) {
-      setTimeout(function () {
-          throw new Error(message);
-      }, 0);
-  }
-
-  function createBus() {
-      var listeners = {};
-      return {
-          emit: function (event, data) {
-              listener(event).forEach(function (handler) {
-                  handler(data);
-              });
-          },
-          on: function (event, handler) {
-              listeners[event] = listener(event).concat(handler);
-              return {
-                  off: function () {
-                      listeners[event] = listener(event).filter(function (h) { return h !== handler; });
-                  }
-              };
-          }
-      };
-      function listener(event) {
-          return listeners[event] || [];
-      }
-  }
-
-  /**
-   * @returns a unique numeric id.
-   */
-  var genId = (function (n) { return function () {
-      return "".concat(n++);
-  }; })(0);
-
-  function mapFirst(array, callback) {
-      var broke = false;
-      var breakoutValue = null;
-      for (var i = 0; i < array.length; i++) {
-          callback(array[i], breakout, i);
-          if (broke) {
-              return breakoutValue;
-          }
-      }
-      function breakout(conditional, value) {
-          if (conditional) {
-              broke = true;
-              breakoutValue = value;
-          }
-      }
-  }
-
-  function isEmpty(value) {
-      if (!value) {
-          return true;
-      }
-      else if (hasOwnProperty(value, 'length')) {
-          return lengthEquals(value, 0);
-      }
-      else if (typeof value === 'object') {
-          return lengthEquals(Object.keys(value), 0);
-      }
-      return false;
-  }
-  var isNotEmpty = bindNot(isEmpty);
-
-  function isPositive(value) {
-      return greaterThan(value, 0);
-  }
-
-  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 greaterThanOrEquals(value, gte) {
-      return numberEquals(value, gte) || greaterThan(value, gte);
-  }
-
-  function inside(value, arg1) {
-      if (isArray(arg1)) {
-          return arg1.indexOf(value) !== -1;
-      }
-      // both value and arg1 are strings
-      if (isStringValue(arg1) && isStringValue(value)) {
-          return arg1.indexOf(value) !== -1;
-      }
-      return false;
-  }
-  var notInside = bindNot(inside);
-
-  function lessThan(value, lt) {
-      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-  }
-
-  function lessThanOrEquals(value, lte) {
-      return numberEquals(value, lte) || lessThan(value, lte);
-  }
-
-  function isBetween(value, min, max) {
-      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-  }
-  var isNotBetween = bindNot(isBetween);
-
-  function isBlank(value) {
-      return isNullish(value) || (isStringValue(value) && !value.trim());
-  }
-  var isNotBlank = bindNot(isBlank);
-
-  var isNotBoolean = bindNot(isBoolean);
-
-  /**
-   * Validates that a given value is an even number
-   */
-  var isEven = function (value) {
-      if (isNumeric(value)) {
-          return value % 2 === 0;
-      }
-      return false;
-  };
-
-  function isKeyOf(key, obj) {
-      return key in obj;
-  }
-  var isNotKeyOf = bindNot(isKeyOf);
-
-  function isNaN$1(value) {
-      return Number.isNaN(value);
-  }
-  var isNotNaN = bindNot(isNaN$1);
-
-  function isNegative(value) {
-      return lessThan(value, 0);
-  }
-
-  function isNumber(value) {
-      return Boolean(typeof value === 'number');
-  }
-  var isNotNumber = bindNot(isNumber);
-
-  /**
-   * Validates that a given value is an odd number
-   */
-  var isOdd = function (value) {
-      if (isNumeric(value)) {
-          return value % 2 !== 0;
-      }
-      return false;
-  };
-
-  var isNotString = bindNot(isStringValue);
-
-  function isTruthy(value) {
-      return !!value;
-  }
-  var isFalsy = bindNot(isTruthy);
-
-  function isValueOf(value, objectToCheck) {
-      if (isNullish(objectToCheck)) {
-          return false;
-      }
-      for (var key in objectToCheck) {
-          if (objectToCheck[key] === value) {
-              return true;
-          }
-      }
-      return false;
-  }
-  var isNotValueOf = bindNot(isValueOf);
-
-  function longerThanOrEquals(value, arg1) {
-      return greaterThanOrEquals(value.length, 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 condition(value, callback) {
-      try {
-          return callback(value);
-      }
-      catch (_a) {
-          return false;
-      }
-  }
-
-  function shorterThan(value, arg1) {
-      return lessThan(value.length, arg1);
-  }
-
-  function shorterThanOrEquals(value, arg1) {
-      return lessThanOrEquals(value.length, arg1);
-  }
-
-  function startsWith(value, arg1) {
-      return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
-  }
-  var doesNotStartWith = bindNot(startsWith);
-
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function
-  function rules() {
-      return {
-          condition: condition,
-          doesNotEndWith: doesNotEndWith,
-          doesNotStartWith: doesNotStartWith,
-          endsWith: endsWith,
-          equals: equals,
-          greaterThan: greaterThan,
-          greaterThanOrEquals: greaterThanOrEquals,
-          gt: greaterThan,
-          gte: greaterThanOrEquals,
-          inside: inside,
-          isArray: isArray,
-          isBetween: isBetween,
-          isBlank: isBlank,
-          isBoolean: isBoolean,
-          isEmpty: isEmpty,
-          isEven: isEven,
-          isFalsy: isFalsy,
-          isKeyOf: isKeyOf,
-          isNaN: isNaN$1,
-          isNegative: isNegative,
-          isNotArray: isNotArray,
-          isNotBetween: isNotBetween,
-          isNotBlank: isNotBlank,
-          isNotBoolean: isNotBoolean,
-          isNotEmpty: isNotEmpty,
-          isNotKeyOf: isNotKeyOf,
-          isNotNaN: isNotNaN,
-          isNotNull: isNotNull,
-          isNotNullish: isNotNullish,
-          isNotNumber: isNotNumber,
-          isNotNumeric: isNotNumeric,
-          isNotString: isNotString,
-          isNotUndefined: isNotUndefined,
-          isNotValueOf: isNotValueOf,
-          isNull: isNull,
-          isNullish: isNullish,
-          isNumber: isNumber,
-          isNumeric: isNumeric,
-          isOdd: isOdd,
-          isPositive: isPositive,
-          isString: isStringValue,
-          isTruthy: isTruthy,
-          isUndefined: isUndefined,
-          isValueOf: isValueOf,
-          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 baseRules = rules();
-  function getRule(ruleName) {
-      return baseRules[ruleName];
-  }
-
-  function eachEnforceRule(action) {
-      for (var ruleName in baseRules) {
-          var ruleFn = getRule(ruleName);
-          if (isFunction(ruleFn)) {
-              action(ruleName, ruleFn);
-          }
-      }
-  }
-
-  // eslint-disable-next-line max-lines-per-function
-  function createContext(init) {
-      var storage = { ancestry: [] };
-      return {
-          bind: bind,
-          run: run,
-          use: use,
-          useX: useX
-      };
-      function useX(errorMessage) {
-          var ctx = use();
-          invariant(ctx, defaultTo(errorMessage, 'Context was used after it was closed'));
-          return ctx;
-      }
-      function run(ctxRef, fn) {
-          var _a;
-          var parentContext = use();
-          var out = assign({}, parentContext ? parentContext : {}, (_a = optionalFunctionValue(init, ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
-          var ctx = set(Object.freeze(out));
-          storage.ancestry.unshift(ctx);
-          var res = fn(ctx);
-          clear();
-          return res;
-      }
-      function bind(ctxRef, fn) {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore - this one's pretty hard to get right
-          var returnedFn = function () {
-              var runTimeArgs = [];
-              for (var _i = 0; _i < arguments.length; _i++) {
-                  runTimeArgs[_i] = arguments[_i];
-              }
-              return run(ctxRef, function () {
-                  return fn.apply(void 0, runTimeArgs);
-              });
-          };
-          return returnedFn;
-      }
-      function use() {
-          return storage.ctx;
-      }
-      function set(value) {
-          return (storage.ctx = value);
-      }
-      function clear() {
-          var _a;
-          storage.ancestry.shift();
-          set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
-      }
-  }
-
-  var ctx = createContext(function (ctxRef, parentContext) {
-      var base = {
-          value: ctxRef.value,
-          meta: ctxRef.meta || {}
-      };
-      if (!parentContext) {
-          return assign(base, {
-              parent: emptyParent
-          });
-      }
-      else if (ctxRef.set) {
-          return assign(base, {
-              parent: function () { return stripContext(parentContext); }
-          });
-      }
-      return parentContext;
-  });
-  function stripContext(ctx) {
-      if (!ctx) {
-          return ctx;
-      }
-      return {
-          value: ctx.value,
-          meta: ctx.meta,
-          parent: ctx.parent
-      };
-  }
-  function emptyParent() {
-      return null;
-  }
-
-  /******************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-
-  function __spreadArray(to, from, pack) {
-      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-          if (ar || !(i in from)) {
-              if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-              ar[i] = from[i];
-          }
-      }
-      return to.concat(ar || Array.prototype.slice.call(from));
-  }
-
-  function isProxySupported() {
-      try {
-          return isFunction(Proxy);
-      }
-      catch (_a) {
-          return false;
-      }
-  }
-
-  function ruleReturn(pass, message) {
-      var output = { pass: pass };
-      if (message) {
-          output.message = message;
-      }
-      return output;
-  }
-  function passing() {
-      return ruleReturn(true);
-  }
-  function defaultToPassing(callback) {
-      return defaultTo(callback, passing());
-  }
-
-  /**
-   * Transform the result of a rule into a standard format
-   */
-  function transformResult(result, ruleName, value) {
-      var args = [];
-      for (var _i = 3; _i < arguments.length; _i++) {
-          args[_i - 3] = arguments[_i];
-      }
-      validateResult(result);
-      // if result is boolean
-      if (isBoolean(result)) {
-          return ruleReturn(result);
-      }
-      else {
-          return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
-      }
-  }
-  function validateResult(result) {
-      // if result is boolean, or if result.pass is boolean
-      invariant(isBoolean(result) || (result && isBoolean(result.pass)), 'Incorrect return value for rule: ' + JSON.stringify(result));
-  }
-
-  function enforceEager(value) {
-      var target = {};
-      if (!isProxySupported()) {
-          eachEnforceRule(function (ruleName, ruleFn) {
-              target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-          });
-          return target;
-      }
-      var proxy = new Proxy(target, {
-          get: function (_, ruleName) {
-              var rule = getRule(ruleName);
-              if (rule) {
-                  return genRuleCall(proxy, rule, ruleName);
-              }
-          }
-      });
-      return proxy;
-      function genRuleCall(target, rule, ruleName) {
-          return function ruleCall() {
-              var args = [];
-              for (var _i = 0; _i < arguments.length; _i++) {
-                  args[_i] = arguments[_i];
-              }
-              var transformedResult = ctx.run({ value: value }, function () {
-                  return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
-              });
-              invariant(transformedResult.pass, isNullish(transformedResult.message)
-                  ? "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value))
-                  : StringObject(transformedResult.message));
-              return target;
-          };
-      }
-  }
-
-  // eslint-disable-next-line max-lines-per-function
-  function genEnforceLazy(key) {
-      var registeredRules = [];
-      var lazyMessage;
-      return addLazyRule(key);
-      // eslint-disable-next-line max-lines-per-function
-      function addLazyRule(ruleName) {
-          // eslint-disable-next-line max-lines-per-function
-          return function () {
-              var args = [];
-              for (var _i = 0; _i < arguments.length; _i++) {
-                  args[_i] = arguments[_i];
-              }
-              var rule = getRule(ruleName);
-              registeredRules.push(function (value) {
-                  return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
-              });
-              var proxy = {
-                  run: function (value) {
-                      return defaultToPassing(mapFirst(registeredRules, function (rule, breakout) {
-                          var _a;
-                          var res = ctx.run({ value: value }, function () { return rule(value); });
-                          breakout(!res.pass, ruleReturn(!!res.pass, (_a = optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
-                      }));
-                  },
-                  test: function (value) { return proxy.run(value).pass; },
-                  message: function (message) {
-                      if (message) {
-                          lazyMessage = message;
-                      }
-                      return proxy;
-                  }
-              };
-              if (!isProxySupported()) {
-                  eachEnforceRule(function (ruleName) {
-                      proxy[ruleName] = addLazyRule(ruleName);
-                  });
-                  return proxy;
-              }
-              // reassigning the proxy here is not pretty
-              // but it's a cleaner way of getting `run` and `test` for free
-              proxy = new Proxy(proxy, {
-                  get: function (target, key) {
-                      if (getRule(key)) {
-                          return addLazyRule(key);
-                      }
-                      return target[key]; // already has `run` and `test` on it
-                  }
-              });
-              return proxy;
-          };
-      }
-  }
-
-  /**
-   * Enforce is quite complicated, I want to explain it in detail.
-   * It is dynamic in nature, so a lot of proxy objects are involved.
-   *
-   * Enforce has two main interfaces
-   * 1. eager
-   * 2. lazy
-   *
-   * The eager interface is the most commonly used, and the easier to understand.
-   * It throws an error when a rule is not satisfied.
-   * The eager interface is declared in enforceEager.ts and it is quite simple to understand.
-   * enforce is called with a value, and the return value is a proxy object that points back to all the rules.
-   * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same
-   * proxy object is returned. Otherwise, an error is thrown.
-   *
-   * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.
-   * Rather than calling enforce directly, the lazy interface has all the rules as "methods" (only by proxy).
-   * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls
-   * and the parameters passed to them. None of the rules are called yet.
-   * The rules are only invoked in sequence once either of these chained functions are called:
-   * 1. test(value)
-   * 2. run(value)
-   *
-   * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,
-   * while run will return an object with the validation result and an optional message created by the rule.
-   */
-  function genEnforce() {
-      var target = {
-          context: function () { return ctx.useX(); },
-          extend: function (customRules) {
-              assign(baseRules, customRules);
-              handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
-          }
-      };
-      handleNoProxy();
-      return new Proxy(assign(enforceEager, target), {
-          get: function (target, key) {
-              if (key in target) {
-                  return target[key];
-              }
-              if (!getRule(key)) {
-                  return;
-              }
-              // Only on the first rule access - start the chain of calls
-              return genEnforceLazy(key);
-          }
-      });
-      function handleNoProxy() {
-          if (!isProxySupported()) {
-              eachEnforceRule(function (ruleName) {
-                  // Only on the first rule access - start the chain of calls
-                  target[ruleName] = genEnforceLazy(ruleName);
-              });
-              return assign(enforceEager, target);
-          }
-      }
-  }
-  var enforce = genEnforce();
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('n4s'), require('vest-utils'), require('context')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'n4s', 'vest-utils', 'context'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}, global.n4s, global['vest-utils'], global.context));
+}(this, (function (exports, n4s, vestUtils, context$1) { 'use strict';
 
   function shouldUseErrorAsMessage(message, error) {
       // kind of cheating with this safe guard, but it does the job
-      return isUndefined(message) && isStringValue(error);
+      return vestUtils.isUndefined(message) && vestUtils.isStringValue(error);
   }
 
   var IsolateTypes;
@@ -868,10 +60,10 @@
       };
   }
 
-  var context = createContext(function (ctxRef, parentContext) {
+  var context = context$1.createContext(function (ctxRef, parentContext) {
       return parentContext
           ? null
-          : assign({}, {
+          : vestUtils.assign({
               exclusion: {
                   tests: {},
                   groups: {}
@@ -898,29 +90,22 @@
       return useStateRef().testCallbacks();
   }
   // OPTIONAL FIELDS
-  function useOptionalField(fieldName) {
-      var optionalFields = useOptionalFields()[0];
-      return optionalFields[fieldName];
-  }
   function useOptionalFields() {
       return useStateRef().optionalFields();
   }
   function useSetOptionalField(fieldName, setter) {
       var _a = useOptionalFields(), setOptionalFields = _a[1];
-      setOptionalFields(function (optionalFields) {
+      setOptionalFields(function (prev) {
           var _a;
-          return assign(optionalFields, (_a = {},
-              _a[fieldName] = optionalFunctionValue(setter, optionalFields[fieldName]),
+          return vestUtils.assign(prev, (_a = {},
+              _a[fieldName] = vestUtils.assign({}, prev[fieldName], setter(prev[fieldName])),
               _a));
       });
   }
-  function useOptionalFieldApplied(fieldName) {
-      var _a;
-      return (_a = useOptionalField(fieldName)) === null || _a === void 0 ? void 0 : _a[1];
-  }
-  function useOptionalFieldConfig(fieldName) {
+  function useOptionalField(fieldName) {
       var _a;
-      return (_a = useOptionalField(fieldName)) === null || _a === void 0 ? void 0 : _a[0];
+      var optionalFields = useOptionalFields()[0];
+      return (_a = optionalFields[fieldName]) !== null && _a !== void 0 ? _a : {};
   }
   function useTestObjects() {
       return useStateRef().testObjects();
@@ -935,7 +120,7 @@
           var current = _a.current, prev = _a.prev;
           return ({
               prev: prev,
-              current: asArray(handler(current))
+              current: vestUtils.asArray(handler(current))
           });
       });
   }
@@ -943,10 +128,10 @@
   function useAllIncomplete() {
       return useTestsFlat().filter(function (test) { return test.isPending(); });
   }
-  var flatCache = createCache();
+  var flatCache = vestUtils.cache();
   function useTestsFlat() {
       var current = useTestObjects()[0].current;
-      return flatCache([current], function () { return flatten(current); });
+      return flatCache([current], function () { return vestUtils.nestedArray.flatten(current); });
   }
   function useEachTestObject(handler) {
       var testObjects = useTestsFlat();
@@ -962,7 +147,7 @@
       function VestTest(fieldName, testFn, _a) {
           var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
           this.key = null;
-          this.id = genId();
+          this.id = vestUtils.seq();
           this.severity = TestSeverity.Error;
           this.status = STATUS_UNTESTED;
           this.fieldName = fieldName;
@@ -1050,18 +235,9 @@
       VestTest.prototype.valueOf = function () {
           return !this.isFailing();
       };
-      VestTest.prototype.hasFailures = function () {
-          return this.isFailing() || this.isWarning();
-      };
-      VestTest.prototype.isNonActionable = function () {
-          return this.isSkipped() || this.isOmitted() || this.isCanceled();
-      };
       VestTest.prototype.isPending = function () {
           return this.statusEquals(STATUS_PENDING);
       };
-      VestTest.prototype.isTested = function () {
-          return this.hasFailures() || this.isPassing();
-      };
       VestTest.prototype.isOmitted = function () {
           return this.statusEquals(STATUS_OMITTED);
       };
@@ -1083,6 +259,20 @@
       VestTest.prototype.isWarning = function () {
           return this.statusEquals(STATUS_WARNING);
       };
+      VestTest.prototype.hasFailures = function () {
+          return this.isFailing() || this.isWarning();
+      };
+      VestTest.prototype.isNonActionable = function () {
+          return this.isSkipped() || this.isOmitted() || this.isCanceled();
+      };
+      VestTest.prototype.isTested = function () {
+          return this.hasFailures() || this.isPassing();
+      };
+      VestTest.prototype.awaitsResolution = function () {
+          // Is the test in a state where it can still be run, or complete running
+          // and its final status is indeterminate?
+          return this.isSkipped() || this.isUntested() || this.isPending();
+      };
       VestTest.prototype.statusEquals = function (status) {
           return this.status === status;
       };
@@ -1135,12 +325,12 @@
       }
       function initKey(key, initialState, prevState) {
           current().push();
-          set(key, optionalFunctionValue(initialState, prevState));
+          set(key, vestUtils.optionalFunctionValue(initialState, prevState));
           return function useStateKey() {
               return [
                   current()[key],
                   function (nextState) {
-                      return set(key, optionalFunctionValue(nextState, current()[key]));
+                      return set(key, vestUtils.optionalFunctionValue(nextState, current()[key]));
                   },
               ];
           };
@@ -1152,10 +342,10 @@
           var prevValue = state.references[index];
           state.references[index] = value;
           var _a = registrations[index], onUpdate = _a[1];
-          if (isFunction(onUpdate)) {
+          if (vestUtils.isFunction(onUpdate)) {
               onUpdate(value, prevValue);
           }
-          if (isFunction(onStateChange)) {
+          if (vestUtils.isFunction(onStateChange)) {
               onStateChange();
           }
       }
@@ -1202,11 +392,11 @@
 
   function usePrevKeys() {
       var prev = useTestObjects()[0].prev;
-      return asArray(getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
+      return vestUtils.asArray(vestUtils.nestedArray.getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
           if (!(testObject instanceof VestTest)) {
               return prevKeys;
           }
-          if (isNullish(testObject.key)) {
+          if (vestUtils.isNullish(testObject.key)) {
               return prevKeys;
           }
           prevKeys[testObject.key] = testObject;
@@ -1219,22 +409,22 @@
   }
   function useRetainTestKey(key, testObject) {
       var current = useIsolate().keys.current;
-      if (isNullish(current[key])) {
+      if (vestUtils.isNullish(current[key])) {
           current[key] = testObject;
       }
       else {
-          deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+          vestUtils.deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
       }
   }
 
   function isolate(_a, callback) {
       var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-      invariant(isFunction(callback));
+      vestUtils.invariant(vestUtils.isFunction(callback));
       // Generate a new Isolate layer, with its own cursor
       var isolate = generateIsolate(type, useCurrentPath());
       var output = context.run({ isolate: isolate }, function () {
           isolate.keys.prev = usePrevKeys();
-          useSetTests(function (tests) { return setValueAtPath(tests, isolate.path, []); });
+          useSetTests(function (tests) { return vestUtils.nestedArray.setValueAtPath(tests, isolate.path, []); });
           var res = callback();
           return res;
       });
@@ -1272,7 +462,7 @@
       return !!(fieldName && testObject.fieldName === fieldName);
   }
 
-  var nonMatchingGroupName = bindNot(matchingGroupName);
+  var nonMatchingGroupName = vestUtils.bindNot(matchingGroupName);
   function matchingGroupName(testObject, groupName) {
       return testObject.groupName === groupName;
   }
@@ -1281,7 +471,7 @@
    * Checks that a given test object matches the currently specified severity level
    */
   function nonMatchingSeverityProfile(severity, testObject) {
-      return either(severity === Severity.WARNINGS, testObject.warns());
+      return vestUtils.either(severity === Severity.WARNINGS, testObject.warns());
   }
 
   /**
@@ -1322,26 +512,85 @@
       return true;
   }
 
+  /**
+   * Marks a field as optional, either just by name, or by a given condition.
+   *
+   * @example
+   *
+   * optional('field_name');
+   *
+   * optional({
+   *  username: () => allowUsernameEmpty,
+   * });
+   */
+  function optional(optionals) {
+      // There are two types of optional field declarations:
+      // 1. Delayed: A string, which is the name of the field to be optional.
+      // We will only determine whether to omit the test after the suite is done running
+      //
+      // 2. Immediate: Either a boolean or a function, which is used to determine
+      // if the field should be optional.
+      // Delayed case (field name)
+      if (vestUtils.isArray(optionals) || vestUtils.isStringValue(optionals)) {
+          vestUtils.asArray(optionals).forEach(function (optionalField) {
+              useSetOptionalField(optionalField, function () { return ({
+                  type: OptionalFieldTypes.Delayed,
+                  applied: false,
+                  rule: null
+              }); });
+          });
+      }
+      else {
+          var _loop_1 = function (field) {
+              var value = optionals[field];
+              useSetOptionalField(field, function () { return ({
+                  type: OptionalFieldTypes.Immediate,
+                  rule: value,
+                  applied: vestUtils.optionalFunctionValue(value)
+              }); });
+          };
+          // Immediately case (function or boolean)
+          for (var field in optionals) {
+              _loop_1(field);
+          }
+      }
+  }
+  function optionalFiedIsApplied(fieldName) {
+      if (!fieldName) {
+          return false;
+      }
+      return useOptionalField(fieldName).applied;
+  }
+  var OptionalFieldTypes;
+  (function (OptionalFieldTypes) {
+      OptionalFieldTypes[OptionalFieldTypes["Immediate"] = 0] = "Immediate";
+      OptionalFieldTypes[OptionalFieldTypes["Delayed"] = 1] = "Delayed";
+  })(OptionalFieldTypes || (OptionalFieldTypes = {}));
+
   // eslint-disable-next-line max-statements, complexity
   function shouldAddValidProperty(fieldName) {
-      if (fieldIsOmitted(fieldName)) {
+      // Is the field optional, and the optional condition is applied
+      if (optionalFiedIsApplied(fieldName)) {
           return true;
       }
-      if (hasErrorsByTestObjects(fieldName)) {
+      var testObjects = useTestsFlat();
+      // Are there no tests?
+      if (vestUtils.isEmpty(testObjects)) {
           return false;
       }
-      var testObjects = useTestsFlat();
-      if (isEmpty(testObjects)) {
+      // Does the field have any tests with errors?
+      if (hasErrorsByTestObjects(fieldName)) {
           return false;
       }
       // Does the given field have any pending tests that are not optional?
       if (hasNonOptionalIncomplete(fieldName)) {
           return false;
       }
+      // Does the field have no missing tests?
       return noMissingTests(fieldName);
   }
   function shouldAddValidPropertyInGroup(groupName, fieldName) {
-      if (fieldIsOmitted(fieldName)) {
+      if (optionalFiedIsApplied(fieldName)) {
           return true;
       }
       if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
@@ -1353,71 +602,76 @@
       }
       return noMissingTestsByGroup(groupName, fieldName);
   }
-  function fieldIsOmitted(fieldName) {
-      if (!fieldName) {
-          return false;
-      }
-      return useOptionalFieldApplied(fieldName) === true;
-  }
   // Does the given field have any pending tests that are not optional?
   function hasNonOptionalIncomplete(fieldName) {
-      return isNotEmpty(useAllIncomplete().filter(function (testObject) {
-          return isOptionalFieldIncomplete(testObject, fieldName);
+      return vestUtils.isNotEmpty(useAllIncomplete().filter(function (testObject) {
+          return isTestObjectOptional(testObject, fieldName);
       }));
   }
   // Do the given group/field have any pending tests that are not optional?
   function hasNonOptionalIncompleteByGroup(groupName, fieldName) {
-      return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+      return vestUtils.isNotEmpty(useAllIncomplete().filter(function (testObject) {
           if (nonMatchingGroupName(testObject, groupName)) {
               return false;
           }
-          return isOptionalFieldIncomplete(testObject, fieldName);
+          return isTestObjectOptional(testObject, fieldName);
       }));
   }
-  function isOptionalFieldIncomplete(testObject, fieldName) {
+  function isTestObjectOptional(testObject, fieldName) {
       if (nonMatchingFieldName(testObject, fieldName)) {
           return false;
       }
-      return useOptionalFieldConfig(testObject.fieldName) !== true;
+      return optionalFiedIsApplied(fieldName);
   }
+  // Did all of the tests for the provided field run/omit?
+  // This makes sure that the fields are not skipped or pending.
   function noMissingTests(fieldName) {
       var testObjects = useTestsFlat();
       return testObjects.every(function (testObject) {
-          if (nonMatchingFieldName(testObject, fieldName)) {
-              return true;
-          }
-          return missingTestsLogic(testObject, fieldName);
+          return noMissingTestsLogic(testObject, fieldName);
       });
   }
+  // Does the group have no missing tests?
   function noMissingTestsByGroup(groupName, fieldName) {
       var testObjects = useTestsFlat();
       return testObjects.every(function (testObject) {
           if (nonMatchingGroupName(testObject, groupName)) {
               return true;
           }
-          return missingTestsLogic(testObject, fieldName);
+          return noMissingTestsLogic(testObject, fieldName);
       });
   }
-  function missingTestsLogic(testObject, fieldName) {
+  // Does the object qualify as either tested or omitted (but not skipped!)
+  function noMissingTestsLogic(testObject, fieldName) {
       if (nonMatchingFieldName(testObject, fieldName)) {
           return true;
       }
-      return (useOptionalFieldConfig(testObject.fieldName) === true ||
+      /**
+       * The reason we're checking for the optional field here and not in "omitOptionalFields"
+       * is because that unlike the bool/function check we do there, here it only depends on
+       * whether the field was tested alredy or not.
+       *
+       * We qualify the test as not missing only if it was already run, if it is omitted,
+       * or if it is marked as optional, even if the optional check did not apply yet -
+       * but the test did not reach its final state.
+       */
+      return (optionalTestAwaitsResolution(testObject) ||
           testObject.isTested() ||
           testObject.isOmitted());
   }
-
-  function useSummary() {
-      var summary = context.useX().summary;
-      invariant(summary);
-      return summary;
+  function optionalTestAwaitsResolution(testObject) {
+      // Does the test belong to an optional field,
+      // and the test itself is still in an indeterminate state?
+      return (useOptionalField(testObject.fieldName).type ===
+          OptionalFieldTypes.Delayed && testObject.awaitsResolution());
   }
+
   /**
    * Reads the testObjects list and gets full validation result from it.
    */
   function genTestsSummary() {
       var testObjects = useTestsFlat();
-      var summary = assign(baseStats(), {
+      var summary = vestUtils.assign(baseStats(), {
           groups: {},
           tests: {},
           valid: false
@@ -1494,7 +748,7 @@
       };
   }
   function baseTestStats() {
-      return assign(baseStats(), {
+      return vestUtils.assign(baseStats(), {
           errors: [],
           warnings: []
       });
@@ -1514,7 +768,7 @@
       var output = {};
       var countKey = countKeyBySeverity(severityKey);
       for (var field in testGroup) {
-          if (isPositive(testGroup[field][countKey])) {
+          if (vestUtils.isPositive(testGroup[field][countKey])) {
               // We will probably never get to the fallback array
               // leaving it just in case the implementation changes
               output[field] = testGroup[field][severityKey] || [];
@@ -1523,118 +777,117 @@
       return output;
   }
 
-  function getErrors(fieldName) {
-      return getFailures(Severity.ERRORS, fieldName);
-  }
-  function getWarnings(fieldName) {
-      return getFailures(Severity.WARNINGS, fieldName);
+  // eslint-disable-next-line max-lines-per-function, max-statements
+  function suiteSelectors(summary) {
+      var selectors = {
+          getErrors: getErrors,
+          getErrorsByGroup: getErrorsByGroup,
+          getWarnings: getWarnings,
+          getWarningsByGroup: getWarningsByGroup,
+          hasErrors: hasErrors,
+          hasErrorsByGroup: hasErrorsByGroup,
+          hasWarnings: hasWarnings,
+          hasWarningsByGroup: hasWarningsByGroup,
+          isValid: isValid,
+          isValidByGroup: isValidByGroup
+      };
+      return selectors;
+      // Booleans
+      function isValid(fieldName) {
+          var _a;
+          return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
+      }
+      function isValidByGroup(groupName, fieldName) {
+          var group = summary.groups[groupName];
+          if (!group) {
+              return false;
+          }
+          if (fieldName) {
+              return isFieldValid(group, fieldName);
+          }
+          for (var fieldName_1 in group) {
+              if (!isFieldValid(group, fieldName_1)) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      function hasWarnings(fieldName) {
+          return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
+      }
+      function hasErrors(fieldName) {
+          return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
+      }
+      function hasWarningsByGroup(groupName, fieldName) {
+          return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
+      }
+      function hasErrorsByGroup(groupName, fieldName) {
+          return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
+      }
+      function getWarnings(fieldName) {
+          return getFailures(summary, Severity.WARNINGS, fieldName);
+      }
+      function getErrors(fieldName) {
+          return getFailures(summary, Severity.ERRORS, fieldName);
+      }
+      function getErrorsByGroup(groupName, fieldName) {
+          return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
+      }
+      function getWarningsByGroup(groupName, fieldName) {
+          return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
+      }
   }
-  /**
-   * @returns suite or field's errors or warnings.
-   */
-  function getFailures(severityKey, fieldName) {
-      var summary = useSummary();
+  // Gathers all failures of a given severity
+  // With a fieldName, it will only gather failures for that field
+  function getFailures(summary, severityKey, fieldName) {
       return gatherFailures(summary.tests, severityKey, fieldName);
   }
-
-  function getErrorsByGroup(groupName, fieldName) {
-      return getFailuresByGroup(groupName, Severity.ERRORS, fieldName);
-  }
-  function getWarningsByGroup(groupName, fieldName) {
-      return getFailuresByGroup(groupName, Severity.WARNINGS, fieldName);
-  }
-  function getFailuresByGroup(groupName, severityKey, fieldName) {
-      var summary = useSummary();
+  // Gathers all failures of a given severity within a group
+  // With a fieldName, it will only gather failures for that field
+  function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
       return gatherFailures(summary.groups[groupName], severityKey, fieldName);
   }
-
-  function hasErrors(fieldName) {
-      return hasFailures(SeverityCount.ERROR_COUNT, fieldName);
-  }
-  function hasWarnings(fieldName) {
-      return hasFailures(SeverityCount.WARN_COUNT, fieldName);
-  }
-  function hasFailures(severityCount, fieldName) {
+  // Checks if a field is valid within a container object - can be within a group or top level
+  function isFieldValid(testContainer, fieldName) {
       var _a;
-      var summary = useSummary();
-      if (fieldName) {
-          return isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
-      }
-      return isPositive(summary[severityCount]);
-  }
-
-  function hasErrorsByGroup(groupName, fieldName) {
-      return hasFailuresByGroup(Severity.ERRORS, groupName, fieldName);
-  }
-  function hasWarningsByGroup(groupName, fieldName) {
-      return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
+      return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
   }
-  // eslint-disable-next-line max-statements
-  function hasFailuresByGroup(severityKey, groupName, fieldName) {
+  // Checks if a there are any failures of a given severity within a group
+  // If a fieldName is provided, it will only check for failures within that field
+  function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
       var _a, _b;
-      var summary = useSummary();
-      var severityCount = countKeyBySeverity(severityKey);
       var group = summary.groups[groupName];
       if (!group) {
           return false;
       }
       if (fieldName) {
-          return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
+          return vestUtils.isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
       }
       for (var field in group) {
-          if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
+          if (vestUtils.isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
               return true;
           }
       }
       return false;
   }
-
-  function isValid(fieldName) {
-      var summary = useSummary();
-      return fieldName
-          ? Boolean(isFieldValid(summary.tests, fieldName))
-          : summary.valid;
-  }
-  function isValidByGroup(groupName, fieldName) {
-      var summary = useSummary();
-      var group = summary.groups[groupName];
-      if (!group) {
-          return false;
-      }
-      if (fieldName) {
-          return isFieldValid(group, fieldName);
-      }
-      for (var fieldName_1 in group) {
-          if (!isFieldValid(group, fieldName_1)) {
-              return false;
-          }
-      }
-      return true;
-  }
-  function isFieldValid(testContainer, fieldName) {
+  // Checks if there are any failures of a given severity
+  // If a fieldName is provided, it will only check for failures within that field
+  function hasFailures(summary, countKey, fieldName) {
       var _a;
-      return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
+      var failureCount = fieldName
+          ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
+          : summary[countKey] || 0;
+      return vestUtils.isPositive(failureCount);
   }
 
-  var cache$1 = createCache(1);
+  var cache$1 = vestUtils.cache(1);
   function produceSuiteResult() {
       var testObjects = useTestsFlat();
       var ctxRef = { stateRef: useStateRef() };
       return cache$1([testObjects], context.bind(ctxRef, function () {
           var summary = genTestsSummary();
           var suiteName = useSuiteName();
-          var ref = { summary: summary };
-          return assign(summary, {
-              getErrors: context.bind(ref, getErrors),
-              getErrorsByGroup: context.bind(ref, getErrorsByGroup),
-              getWarnings: context.bind(ref, getWarnings),
-              getWarningsByGroup: context.bind(ref, getWarningsByGroup),
-              hasErrors: context.bind(ref, hasErrors),
-              hasErrorsByGroup: context.bind(ref, hasErrorsByGroup),
-              hasWarnings: context.bind(ref, hasWarnings),
-              hasWarningsByGroup: context.bind(ref, hasWarningsByGroup),
-              isValid: context.bind(ref, isValid),
-              isValidByGroup: context.bind(ref, isValidByGroup),
+          return vestUtils.assign(summary, suiteSelectors(summary), {
               suiteName: suiteName
           });
       }));
@@ -1645,7 +898,7 @@
    */
   function hasRemainingTests(fieldName) {
       var allIncomplete = useAllIncomplete();
-      if (isEmpty(allIncomplete)) {
+      if (vestUtils.isEmpty(allIncomplete)) {
           return false;
       }
       if (fieldName) {
@@ -1653,15 +906,15 @@
               return matchingFieldName(testObject, fieldName);
           });
       }
-      return isNotEmpty(allIncomplete);
+      return true;
   }
 
-  var cache = createCache(20);
+  var cache = vestUtils.cache(20);
   function produceFullResult() {
       var testObjects = useTestsFlat();
       var ctxRef = { stateRef: useStateRef() };
       return cache([testObjects], context.bind(ctxRef, function () {
-          return assign({}, produceSuiteResult(), {
+          return vestUtils.assign({}, produceSuiteResult(), {
               done: context.bind(ctxRef, done)
           });
       }));
@@ -1670,10 +923,10 @@
    * DONE is here and not in its own module to prevent circular dependency issues.
    */
   function shouldSkipDoneRegistration(callback, fieldName, output) {
+      var _a;
       // If we do not have any test runs for the current field
-      return !!(!isFunction(callback) ||
-          (fieldName &&
-              (!output.tests[fieldName] || isEmpty(output.tests[fieldName].testCount))));
+      return !!(!vestUtils.isFunction(callback) ||
+          (fieldName && vestUtils.numberEquals((_a = output.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount, 0)));
   }
   function shouldRunDoneCallback(fieldName) {
       // is suite finished || field name exists, and test is finished;
@@ -1715,34 +968,48 @@
       });
   }
 
+  /**
+   * This module gets triggered once the suite is done running its sync tests.
+   *
+   * It goes over all the tests in the state, and checks if they need to be omitted.
+   */
   function omitOptionalFields() {
       var optionalFields = useOptionalFields()[0];
-      if (isEmpty(optionalFields)) {
+      // If there are no optional fields, we don't need to do anything
+      if (vestUtils.isEmpty(optionalFields)) {
           return;
       }
+      // Create an object to store the fields that need to be omitted
       var shouldOmit = {};
-      useSetTests(function (tests) {
-          return transform(tests, function (testObject) {
-              var fieldName = testObject.fieldName;
-              if (hasOwnProperty(shouldOmit, fieldName)) {
-                  verifyAndOmit(testObject);
-              }
-              else {
-                  runOptionalConfig(testObject);
-              }
-              return testObject;
-          });
+      // iterate over each of the tests in the state
+      useTestsFlat().forEach(function (testObject) {
+          // If we already added the current field (not this test specifically)
+          // no need for further checks, go and omit the test
+          if (vestUtils.hasOwnProperty(shouldOmit, testObject.fieldName)) {
+              verifyAndOmit(testObject);
+          }
+          else {
+              // check if the field has an optional function
+              // if so, run it and verify/omit the test
+              runOptionalConfig(testObject);
+          }
       });
+      // refresh the tests in the state so that the omitted fields are applied
+      useRefreshTestObjects();
       function verifyAndOmit(testObject) {
           if (shouldOmit[testObject.fieldName]) {
               testObject.omit();
-              useSetOptionalField(testObject.fieldName, function (current) { return [current[0], true]; });
+              useSetOptionalField(testObject.fieldName, function () { return ({
+                  applied: true
+              }); });
           }
       }
       function runOptionalConfig(testObject) {
-          var optionalConfig = useOptionalFieldConfig(testObject.fieldName);
-          if (isFunction(optionalConfig)) {
-              shouldOmit[testObject.fieldName] = optionalConfig();
+          // Ge the optional configuration for the given field
+          var optionalConfig = useOptionalField(testObject.fieldName);
+          // If the optional was set to a function or a boolean, run it and verify/omit the test
+          if (optionalConfig.type === OptionalFieldTypes.Immediate) {
+              shouldOmit[testObject.fieldName] = vestUtils.optionalFunctionValue(optionalConfig.rule);
               verifyAndOmit(testObject);
           }
       }
@@ -1753,7 +1020,7 @@
    */
   function removeTestFromState (testObject) {
       useSetTests(function (tests) {
-          return transform(tests, function (test) { return (testObject !== test ? test : null); });
+          return vestUtils.nestedArray.transform(tests, function (test) { return (testObject !== test ? test : null); });
       });
   }
 
@@ -1764,8 +1031,8 @@
       var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
       if (fieldName &&
           !hasRemainingTests(fieldName) &&
-          isArray(fieldCallbacks[fieldName])) {
-          callEach(fieldCallbacks[fieldName]);
+          vestUtils.isArray(fieldCallbacks[fieldName])) {
+          vestUtils.callEach(fieldCallbacks[fieldName]);
       }
   }
   /**
@@ -1773,12 +1040,12 @@
    */
   function runDoneCallbacks() {
       var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-      callEach(doneCallbacks);
+      vestUtils.callEach(doneCallbacks);
   }
 
   // eslint-disable-next-line max-lines-per-function
   function initBus() {
-      var vestBus = createBus();
+      var vestBus = vestUtils.bus.createBus();
       // Report a the completion of a test. There may be other tests with the same
       // name that are still running, or not yet started.
       vestBus.on(Events.TEST_COMPLETED, function (testObject) {
@@ -1823,7 +1090,7 @@
   }
   function useBus() {
       var context$1 = context.useX();
-      invariant(context$1.bus);
+      vestUtils.invariant(context$1.bus);
       return context$1.bus;
   }
   var Events;
@@ -1842,16 +1109,16 @@
           args[_i] = arguments[_i];
       }
       var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
-      invariant(isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
+      vestUtils.invariant(vestUtils.isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
       // Event bus initialization
       var bus = initBus();
       // State initialization
       var state = createState();
       // State reference - this holds the actual state values
-      var stateRef = createStateRef(state, { suiteId: genId(), suiteName: suiteName });
+      var stateRef = createStateRef(state, { suiteId: vestUtils.seq(), suiteName: suiteName });
       // Create base context reference. All hooks will derive their data from this
       var ctxRef = { stateRef: stateRef, bus: bus };
-      var suite = assign(
+      var suite = vestUtils.assign(
       // Bind the suite body to the context
       context.bind(ctxRef, function () {
           var args = [];
@@ -1897,7 +1164,7 @@
    * })
    */
   function each(list, callback) {
-      invariant(isFunction(callback), 'each callback must be a function');
+      vestUtils.invariant(vestUtils.isFunction(callback), 'each callback must be a function');
       isolate({ type: IsolateTypes.EACH }, function () {
           list.forEach(function (arg, index) {
               callback(arg, index);
@@ -1927,7 +1194,7 @@
               // we should skip the test if the parent conditional is true.
               isExcludedIndividually() ||
                   // Otherwise, we should skip the test if the conditional is true.
-                  optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
+                  vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(produceSuiteResult))
           }, function () { return callback(); });
       });
   }
@@ -1962,7 +1229,7 @@
       return addTo(1 /* ExclusionGroup.SKIP */, 'groups', item);
   };
   //Checks whether a certain test profile excluded by any of the exclusion groups.
-  // eslint-disable-next-line complexity, max-statements, max-lines-per-function
+  // eslint-disable-next-line complexity, max-statements
   function isExcluded(testObject) {
       var fieldName = testObject.fieldName, groupName = testObject.groupName;
       if (isExcludedIndividually())
@@ -2003,7 +1270,7 @@
           // Check if inclusion rules for this field (`include` hook)
           // TODO: Check if this may need to be moved outside of the condition.
           // What if there are no included tests? This shouldn't run then?
-          return !optionalFunctionValue(inclusion[fieldName]);
+          return !vestUtils.optionalFunctionValue(inclusion[fieldName]);
       }
       // We're done here. This field is not excluded
       return false;
@@ -2015,7 +1282,7 @@
       var context$1 = context.useX();
       var exclusion = context$1.exclusion;
       var keyGroups = exclusion.groups;
-      var groupPresent = hasOwnProperty(keyGroups, groupName);
+      var groupPresent = vestUtils.hasOwnProperty(keyGroups, groupName);
       // When group is either only'ed or skipped
       if (groupPresent) {
           // Return true if group is skipped and false if only'ed
@@ -2033,8 +1300,8 @@
       if (!item) {
           return;
       }
-      asArray(item).forEach(function (itemName) {
-          if (!isStringValue(itemName)) {
+      vestUtils.asArray(item).forEach(function (itemName) {
+          if (!vestUtils.isStringValue(itemName)) {
               return;
           }
           context$1.exclusion[itemType][itemName] =
@@ -2081,8 +1348,8 @@
    * });
    */
   function group(groupName, tests) {
-      invariant(isStringValue(groupName), groupErrorMsg('name must be a string'));
-      invariant(isFunction(tests), groupErrorMsg('callback must be a function'));
+      vestUtils.invariant(vestUtils.isStringValue(groupName), groupErrorMsg('name must be a string'));
+      vestUtils.invariant(vestUtils.isFunction(tests), groupErrorMsg('callback must be a function'));
       // Running with the context applied
       isolate({ type: IsolateTypes.GROUP }, function () {
           context.run({ groupName: groupName }, tests);
@@ -2095,24 +1362,24 @@
   function include(fieldName) {
       var context$1 = context.useX();
       var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
-      invariant(isStringValue(fieldName));
-      inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
+      vestUtils.invariant(vestUtils.isStringValue(fieldName));
+      inclusion[fieldName] = vestUtils.defaultTo(exclusion.tests[fieldName], true);
       return { when: when };
       function when(condition) {
           var context$1 = context.useX();
           var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
           // This callback will run as part of the "isExcluded" series of checks
           inclusion[fieldName] = function () {
-              if (hasOwnProperty(exclusion.tests, fieldName)) {
+              if (vestUtils.hasOwnProperty(exclusion.tests, fieldName)) {
                   // I suspect this code is technically unreachable because
                   // if there are any skip/only rules applied to the current
                   // field, the "isExcluded" function will have already bailed
-                  return defaultTo(exclusion.tests[fieldName], true);
+                  return vestUtils.defaultTo(exclusion.tests[fieldName], true);
               }
-              if (isStringValue(condition)) {
+              if (vestUtils.isStringValue(condition)) {
                   return Boolean(exclusion.tests[condition]);
               }
-              return optionalFunctionValue(condition, optionalFunctionValue(produceSuiteResult));
+              return vestUtils.optionalFunctionValue(condition, vestUtils.optionalFunctionValue(produceSuiteResult));
           };
       }
   }
@@ -2166,42 +1433,39 @@
   function omitWhen(conditional, callback) {
       isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
           context.run({
-              omitted: isOmitted() ||
-                  optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
+              omitted: inActiveOmitWhen() ||
+                  vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(produceSuiteResult))
           }, function () { return callback(); });
       });
   }
-  function isOmitted() {
+  // Checks that we're currently in an active omitWhen block
+  function inActiveOmitWhen() {
       return !!context.useX().omitted;
   }
 
-  /**
-   * Marks a field as optional, either just by name, or by a given condition.
-   *
-   * @example
-   *
-   * optional('field_name');
-   *
-   * optional({
-   *  username: () => allowUsernameEmpty,
-   * });
-   */
-  function optional(optionals) {
-      // When the optional is given as a string or a list of strings
-      // we just add them to the list of optional fields.
-      if (isArray(optionals) || isStringValue(optionals)) {
-          asArray(optionals).forEach(function (optionalField) {
-              useSetOptionalField(optionalField, [true, false]);
-          });
-      }
-      else {
-          // if it's an object, we iterate over the keys and add them to the list
-          var optionalFunctions = optionals;
-          for (var field in optionalFunctions) {
-              var predicate = optionalFunctions[field];
-              useSetOptionalField(field, [predicate, false]);
-          }
-      }
+  /******************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+
+  function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+              if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+              ar[i] = from[i];
+          }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
   }
 
   function isSameProfileTest(testObject1, testObject2) {
@@ -2222,7 +1486,7 @@
    */
   function runAsyncTest(testObject) {
       var asyncTest = testObject.asyncTest, message = testObject.message;
-      if (!isPromise(asyncTest))
+      if (!vestUtils.isPromise(asyncTest))
           return;
       var emit = useBus().emit;
       var stateRef = useStateRef();
@@ -2235,7 +1499,7 @@
           if (testObject.isCanceled()) {
               return;
           }
-          testObject.message = isStringValue(rejectionMessage)
+          testObject.message = vestUtils.isStringValue(rejectionMessage)
               ? rejectionMessage
               : message;
           testObject.fail();
@@ -2270,7 +1534,7 @@
       try {
           // try catch for safe property access
           // in case object is an enforce chain
-          if (isPromise(result)) {
+          if (vestUtils.isPromise(result)) {
               testObject.asyncTest = result;
               testObject.setPending();
               runAsyncTest(testObject);
@@ -2297,12 +1561,12 @@
   function useTestAtCursor(newTestObject) {
       var testObjects = useTestObjects()[0];
       var prevTests = testObjects.prev;
-      if (isEmpty(prevTests)) {
+      if (vestUtils.isEmpty(prevTests)) {
           useSetTestAtCursor(newTestObject);
           return newTestObject;
       }
       var prevTest = useGetTestAtCursor(prevTests);
-      if (!isNullish(newTestObject.key)) {
+      if (!vestUtils.isNullish(newTestObject.key)) {
           var nextTest_1 = handleKeyTest(newTestObject.key, newTestObject);
           useSetTestAtCursor(nextTest_1);
           return nextTest_1;
@@ -2313,7 +1577,7 @@
           // Need to see if this has any effect at all.
           prevTest = null;
       }
-      var nextTest = defaultTo(prevTest, newTestObject);
+      var nextTest = vestUtils.defaultTo(prevTest, newTestObject);
       useSetTestAtCursor(nextTest);
       return nextTest;
   }
@@ -2330,21 +1594,21 @@
   function useSetTestAtCursor(testObject) {
       var cursorPath = useCurrentPath();
       useSetTests(function (tests) {
-          return setValueAtPath(tests, cursorPath, testObject);
+          return vestUtils.nestedArray.setValueAtPath(tests, cursorPath, testObject);
       });
   }
   function useGetTestAtCursor(tests) {
       var cursorPath = useCurrentPath();
-      return valueAtPath(tests, cursorPath);
+      return vestUtils.nestedArray.valueAtPath(tests, cursorPath);
   }
   function testReorderDetected(prevTest, newTest) {
-      return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
+      return vestUtils.isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
   }
   function throwTestOrderError(prevTest, newTestObject) {
       if (shouldAllowReorder()) {
           return;
       }
-      deferThrow("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
+      vestUtils.deferThrow("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
   }
   function handleKeyTest(key, newTestObject) {
       var prevTestByKey = usePrevTestByKey(key);
@@ -2366,7 +1630,7 @@
           return testObject;
       }
       var prevRunTest = useTestAtCursor(testObject);
-      if (isOmitted()) {
+      if (inActiveOmitWhen() || optionalFiedIsApplied(testObject.fieldName)) {
           prevRunTest.omit();
           cursor.next();
           return prevRunTest;
@@ -2390,16 +1654,15 @@
       if (testObject.isUntested()) {
           registerTest(testObject);
       }
-      else if (isPromise(testObject.asyncTest)) {
+      else if (vestUtils.isPromise(testObject.asyncTest)) {
           testObject.setPending();
           runAsyncTest(testObject);
       }
   }
 
   /* eslint-disable jest/valid-title */
-  // eslint-disable-next-line max-lines-per-function
   function bindTestMemo(test) {
-      var cache = createCache(10); // arbitrary cache size
+      var cache = vestUtils.cache(10); // arbitrary cache size
       // eslint-disable-next-line max-statements
       function memo(fieldName) {
           var args = [];
@@ -2411,7 +1674,7 @@
           // Implicit dependency for more specificity
           var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
           var cached = cache.get(dependencies);
-          if (isNull(cached)) {
+          if (vestUtils.isNull(cached)) {
               // cache miss
               return cache(dependencies, function () { return test(fieldName, msg, testFn); });
           }
@@ -2430,9 +1693,9 @@
       for (var _i = 1; _i < arguments.length; _i++) {
           args[_i - 1] = arguments[_i];
       }
-      var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
-      invariant(isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
-      invariant(isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
+      var _a = (vestUtils.isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
+      vestUtils.invariant(vestUtils.isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
+      vestUtils.invariant(vestUtils.isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
       var context$1 = context.useX();
       var testObject = new VestTest(fieldName, testFn, {
           message: message,
@@ -2450,7 +1713,7 @@
    *  enforce(data.username).isNotBlank();
    * });
    */
-  var test = assign(testBase, {
+  var test = vestUtils.assign(testBase, {
       memo: bindTestMemo(testBase)
   });
   function incompatibleParamsError(name, expected) {
@@ -2464,18 +1727,23 @@
    */
   function warn() {
       var ctx = context.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-      invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
+      vestUtils.invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.4.3-dev-c786f7";
+  var VERSION = "4.6.0";
 
+  Object.defineProperty(exports, 'enforce', {
+    enumerable: true,
+    get: function () {
+      return n4s.enforce;
+    }
+  });
   exports.VERSION = VERSION;
   exports.context = context;
   exports.create = create;
   exports.each = each;
   exports.eager = eager;
-  exports.enforce = enforce;
   exports.group = group;
   exports.include = include;
   exports.omitWhen = omitWhen;
@@ -2483,6 +1751,7 @@
   exports.optional = optional;
   exports.skip = skip;
   exports.skipWhen = skipWhen;
+  exports.suiteSelectors = suiteSelectors;
   exports.test = test;
   exports.warn = warn;