vest 4.5.0 → 5.0.0-dev-781e21

package/dist/umd/enforce/compounds.development.js

@@ -1,153 +1,8 @@
-(function (factory) {
-  typeof define === 'function' && define.amd ? define(factory) :
-  factory();
-}((function () { '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);
-  }
-
-  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 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);
-
-  /**
-   * A safe hasOwnProperty access
-   */
-  function hasOwnProperty(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-  }
-
-  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 isBoolean(value) {
-      return !!value === value;
-  }
-
-  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 (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('n4s'), require('vest-utils')) :
+  typeof define === 'function' && define.amd ? define(['n4s', 'vest-utils'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.n4s, global['vest-utils']));
+}(this, (function (n4s, vestUtils) { 'use strict';
 
   function ruleReturn(pass, message) {
       var output = { pass: pass };
@@ -163,10 +18,10 @@
       return ruleReturn(true);
   }
   function defaultToFailing(callback) {
-      return defaultTo(callback, failing());
+      return vestUtils.defaultTo(callback, failing());
   }
   function defaultToPassing(callback) {
-      return defaultTo(callback, passing());
+      return vestUtils.defaultTo(callback, passing());
   }
 
   function runLazyRule(lazyRule, currentValue) {
@@ -183,7 +38,7 @@
       for (var _i = 1; _i < arguments.length; _i++) {
           rules[_i - 1] = arguments[_i];
       }
-      return defaultToPassing(mapFirst(rules, function (rule, breakout) {
+      return defaultToPassing(vestUtils.mapFirst(rules, function (rule, breakout) {
           var res = runLazyRule(rule, value);
           breakout(!res.pass, res);
       }));
@@ -194,550 +49,28 @@
       for (var _i = 1; _i < arguments.length; _i++) {
           rules[_i - 1] = arguments[_i];
       }
-      return defaultToFailing(mapFirst(rules, function (rule, breakout) {
+      return defaultToFailing(vestUtils.mapFirst(rules, function (rule, breakout) {
           var res = runLazyRule(rule, value);
           breakout(res.pass, res);
       }));
   }
 
-  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;
-      }
-  }
-
-  /**
-   * 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 = {};
-      // This condition is for when we don't have proxy support (ES5).
-      // In this case, we need to manually assign the rules to the target object on runtime.
-      // The follow up proxy block is used in case we do have proxy support, and we can assign each rule upon invocation.
-      if (!isProxySupported()) {
-          // We iterate over each of the rules, and add them to the target object being return by enforce
-          eachEnforceRule(function (ruleName, ruleFn) {
-              // We then wrap the rule with `genRuleCall` that adds the base enforce behavior
-              target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-          });
-          return target;
-      }
-      // We create a proxy intercepting access to the target object (which is empty).
-      var proxy = new Proxy(target, {
-          get: function (_, ruleName) {
-              // On property access, we identify if it is a rule or not.
-              var rule = getRule(ruleName);
-              // If it is a rule, we wrap it with `genRuleCall` that adds the base enforce behavior
-              if (rule) {
-                  return genRuleCall(proxy, rule, ruleName);
-              }
-          }
-      });
-      return proxy;
-      // This function is used to wrap a rule with the base enforce behavior
-      // It takes the target object, the rule function, and the rule name
-      // It then returns the rule, in a manner that can be used by enforce
-      function genRuleCall(target, rule, ruleName) {
-          return function ruleCall() {
-              var args = [];
-              for (var _i = 0; _i < arguments.length; _i++) {
-                  args[_i] = arguments[_i];
-              }
-              // Order of operation:
-              // 1. Create a context with the value being enforced
-              // 2. Call the rule within the context, and pass over the arguments passed to it
-              // 3. Transform the result to the correct output format
-              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));
-              });
-              // On rule failure (the result is false), we either throw an error
-              // or throw a string value if the rule has a message defined in it.
-              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();
-
   function noneOf(value) {
       var rules = [];
       for (var _i = 1; _i < arguments.length; _i++) {
           rules[_i - 1] = arguments[_i];
       }
-      return defaultToPassing(mapFirst(rules, function (rule, breakout) {
+      return defaultToPassing(vestUtils.mapFirst(rules, function (rule, breakout) {
           var res = runLazyRule(rule, value);
           breakout(res.pass, failing());
       }));
   }
 
+  function equals(value, arg1) {
+      return value === arg1;
+  }
+  vestUtils.bindNot(equals);
+
   var REQUIRED_COUNT = 1;
   function oneOf(value) {
       var rules = [];
@@ -750,13 +83,13 @@
           if (res.pass) {
               passingCount++;
           }
-          if (greaterThan(passingCount, REQUIRED_COUNT)) {
+          if (vestUtils.greaterThan(passingCount, REQUIRED_COUNT)) {
               return false;
           }
       });
       return ruleReturn(equals(passingCount, REQUIRED_COUNT));
   }
 
-  enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });
+  n4s.enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });
 
 })));