n4s 3.1.0 → 4.0.0-dev-e266d9

package/n4s.umd.production.js

@@ -1,1231 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.n4s = factory());
-}(this, (function () { 'use strict';
-
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-  }
-
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-    return arr2;
-  }
-
-  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-    var it;
-
-    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-        var i = 0;
-        return function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        };
-      }
-
-      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-
-    it = o[Symbol.iterator]();
-    return it.next.bind(it);
-  }
-
-  var assign = Object.assign;
-
-  /**
-   * Stores values and configuration passed down to compound rules.
-   *
-   * @param {Object} content
-   */
-
-  function EnforceContext(content) {
-    assign(this, content);
-  }
-  /**
-   * Sets an EnforceContext config `failFast`
-   *
-   * @param {Boolean} failFast
-   * @return {EnforceContext}
-   */
-
-  EnforceContext.prototype.setFailFast = function (failFast) {
-    this.failFast = !!failFast;
-    return this;
-  };
-  /**
-   * Extracts the literal value from an EnforceContext object
-   * @param {*} value
-   * @return {*}
-   */
-
-
-  EnforceContext.unwrap = function unwrap(value) {
-    return EnforceContext.is(value) ? value.value : value;
-  };
-  /**
-   * Wraps a literal value within a context.
-   * @param {*} value
-   * @return {EnforceContext}
-   */
-
-
-  EnforceContext.wrap = function wrap(value) {
-    return EnforceContext.is(value) ? value : new EnforceContext({
-      value: value
-    });
-  };
-  /**
-   * Checks whether a given value is an EnforceContext instance
-   *
-   * @param {*} value
-   * @returns {boolean}
-   */
-
-
-  EnforceContext.is = function is(value) {
-    return value instanceof EnforceContext;
-  };
-
-  /**
-   * A safe hasOwnProperty access
-   */
-  function hasOwnProperty(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-  }
-
-  function bindNot(fn) {
-    return function () {
-      return !fn.apply(this, arguments);
-    };
-  }
-
-  function isBoolean(value) {
-    return !!value === value;
-  }
-
-  var isNotBoolean = bindNot(isBoolean);
-
-  function isNumeric(value) {
-    var result = !isNaN(parseFloat(value)) && !isNaN(Number(value)) && isFinite(value);
-    return Boolean(result);
-  }
-  var isNotNumeric = bindNot(isNumeric);
-
-  function lengthEquals(value, arg1) {
-    return value.length === Number(arg1);
-  }
-  var lengthNotEquals = bindNot(lengthEquals);
-
-  function isEmpty(value) {
-    if (!value) {
-      return true;
-    } else if (isNumeric(value)) {
-      return value === 0;
-    } else if (hasOwnProperty(value, 'length')) {
-      return lengthEquals(value, 0);
-    } else if (typeof value === 'object') {
-      return lengthEquals(Object.keys(value), 0);
-    }
-
-    return true;
-  }
-  var isNotEmpty = bindNot(isEmpty);
-
-  function isNull(value) {
-    return value === null;
-  }
-  var isNotNull = bindNot(isNull);
-
-  function isUndefined(value) {
-    return value === undefined;
-  }
-  var isNotUndefined = bindNot(isUndefined);
-
-  var HAS_WARNINGS = 'hasWarnings';
-  var HAS_ERRORS = 'hasErrors';
-
-  /**
-   * Stores a rule result in an easy to inspect and manipulate structure.
-   *
-   * @param {boolean|RuleResult} ruleRunResult
-   */
-
-  function RuleResult(ruleRunResult) {
-    if (isUndefined(ruleRunResult)) {
-      return;
-    }
-
-    if (isBoolean(ruleRunResult)) {
-      this.setFailed(!ruleRunResult);
-    } else {
-      this.extend(ruleRunResult);
-    }
-  }
-  /**
-   * Determines whether a given value is a RuleResult instance
-   * @param {*} res
-   * @return {boolean}
-   */
-
-  RuleResult.is = function (res) {
-    return res instanceof RuleResult;
-  };
-  /**
-   * Marks the current result object as an array
-   */
-
-
-  RuleResult.prototype.asArray = function () {
-    this.isArray = true;
-    return this;
-  };
-  /**
-   * @param {string} key
-   * @param {value} value
-   * @return {RuleResult} current instance
-   */
-
-
-  RuleResult.prototype.setAttribute = function (key, value) {
-    this[key] = value;
-    return this;
-  };
-  /**
-   * @param {boolean} failed
-   * @return {RuleResult} current instance
-   */
-
-
-  RuleResult.prototype.setFailed = function (failed) {
-    this.setAttribute(this.warn ? HAS_WARNINGS : HAS_ERRORS, failed);
-    return this.setAttribute('failed', failed);
-  };
-  /**
-   * Adds a nested result object
-   *
-   * @param {string} key
-   * @param {RuleResult} child
-   */
-
-
-  RuleResult.prototype.setChild = function (key, child) {
-    if (isNull(child)) {
-      return null;
-    }
-
-    var isWarning = this[HAS_WARNINGS] || child[HAS_WARNINGS] || child.warn || this.warn;
-    this.setAttribute(HAS_WARNINGS, isWarning && child.failed || false);
-    this.setAttribute(HAS_ERRORS, this[HAS_ERRORS] || child[HAS_ERRORS] || !isWarning && child.failed || false);
-    this.setFailed(this.failed || child.failed);
-    this.children = this.children || {};
-    this.children[key] = child;
-    return child;
-  };
-  /**
-   * Retrieves a child by its key
-   *
-   * @param {string} key
-   * @return {RuleResult|undefined}
-   */
-
-
-  RuleResult.prototype.getChild = function (key) {
-    return (this.children || {})[key];
-  };
-  /**
-   * Extends current instance with a new provided result
-   * @param {Boolean|RuleResult} newRes
-   */
-
-
-  RuleResult.prototype.extend = function (newRes) {
-    if (isNull(newRes)) {
-      return this;
-    }
-
-    var res = RuleResult.is(newRes) ? newRes : new RuleResult().setAttribute('warn', !!this.warn).setFailed(!newRes);
-    var failed = this.failed || res.failed;
-    var children = mergeChildren(res, this).children;
-    assign(this, res);
-
-    if (!isEmpty(children)) {
-      this.children = children;
-    }
-
-    this.setFailed(failed);
-    this.setAttribute(HAS_WARNINGS, !!(this[HAS_WARNINGS] || res[HAS_WARNINGS]));
-    this.setAttribute(HAS_ERRORS, !!(this[HAS_ERRORS] || res[HAS_ERRORS]));
-  };
-
-  Object.defineProperty(RuleResult.prototype, 'pass', {
-    get: function get() {
-      return !this.failed;
-    }
-  });
-  /**
-   * Deeply merge the nested children of compound rules
-   *
-   * @param {?RuleResult} base
-   * @param {?RuleResult} add
-   * @return {RuleResult}
-   */
-
-  function mergeChildren(base, add) {
-    var isRuleResultBase = RuleResult.is(base);
-    var isRuleResultAdd = RuleResult.is(add); // If both base and add are result objects
-
-    if (isRuleResultBase && isRuleResultAdd) {
-      // Use failed if either is failing
-      base.setFailed(base.failed || add.failed); // If neither has a children object, or the children object is
-
-      if (isEmpty(base.children) && isEmpty(add.children)) {
-        return base;
-      } // If both have a children object
-
-
-      if (base.children && add.children) {
-        // Merge all the "right side" children back to base
-        for (var key in base.children) {
-          mergeChildren(base.children[key], add.children[key]);
-        } // If a child exists in "add" but not in "base", just copy the child as is
-
-
-        for (var _key in add.children) {
-          if (!hasOwnProperty(base.children, _key)) {
-            base.setChild(_key, add.children[_key]);
-          }
-        } // Return the modified base object
-
-
-        return base; // If base has no children (but add does)
-      } else if (!base.children) {
-        // Use add's children
-        base.children = add.children; // If add has no children
-      } else if (!add.children) {
-        // return base as is
-        return base;
-      } // If only base is `RuleResult`
-
-    } else if (isRuleResultBase) {
-      // Return base as is
-      return base; // If only add is RuleResult
-    } else if (isRuleResultAdd) {
-      // Return add as is
-      return add;
-    } // That's a weird case. Let's fail. Very unlikely.
-
-
-    return new RuleResult(false);
-  }
-
-  var RUN_RULE = 'run';
-  var TEST_RULE = 'test';
-  var MODE_ALL = 'all';
-  var MODE_ONE = 'one';
-  var MODE_ANY = 'any';
-
-  function isFunction (v) {
-    return typeof v === 'function';
-  }
-
-  function asArray(possibleArg) {
-    return [].concat(possibleArg);
-  }
-
-  /**
-   * Determines whether we should bail out of an enforcement.
-   *
-   * @param {EnforceContext} ctx
-   * @param {RuleResult} result
-   */
-
-  function shouldFailFast(ctx, result) {
-    if (result.pass || result.warn) {
-      return false;
-    }
-
-    return !!EnforceContext.is(ctx) && ctx.failFast;
-  }
-
-  /**
-   * Runs multiple enforce rules that are passed to compounds.
-   * Example: enforce.allOf(enforce.ruleOne(), enforce.ruleTwo().ruleThree())
-   *
-   * @param {{run: Function}[]} ruleGroups
-   * @param {*} value
-   * @return {RuleResult}
-   */
-
-  function runLazyRules(ruleGroups, value) {
-    var result = new RuleResult(true);
-
-    for (var _iterator = _createForOfIteratorHelperLoose(asArray(ruleGroups)), _step; !(_step = _iterator()).done;) {
-      var chain = _step.value;
-
-      if (shouldFailFast(value, result)) {
-        break;
-      }
-
-      result.extend(runLazyRule(chain, value));
-    }
-
-    return result;
-  }
-  /**
-   * Runs a single lazy rule
-   *
-   * @param {{run: Function}} ruleGroup
-   * @param {*} value
-   * @return {boolean|RuleResult}
-   */
-
-  function runLazyRule(ruleGroup, value) {
-    return ruleGroup[RUN_RULE](value);
-  }
-
-  /**
-   * Runs chains of rules
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} rules
-   * @param {RuleResult} options
-   */
-
-  function runCompoundChain(value, rules, options) {
-    var result = new RuleResult(true);
-
-    if (isEmpty(rules)) {
-      result.setFailed(true);
-    }
-
-    var failedResults = [];
-    var count = 0;
-
-    for (var _iterator = _createForOfIteratorHelperLoose(rules), _step; !(_step = _iterator()).done;) {
-      var chain = _step.value;
-      // Inner result for each iteration
-      var currentResult = runLazyRule(chain, value);
-
-      if (isNull(currentResult)) {
-        return null;
-      }
-
-      var pass = currentResult.pass;
-
-      if (pass) {
-        count++;
-      } else {
-        failedResults.push(currentResult);
-      }
-
-      if (options) {
-        // "anyOf" is a special case.
-        // It shouldn't extend with failed results,
-        // that's why we continue
-        if (options.mode === MODE_ANY) {
-          if (pass) {
-            result.extend(currentResult);
-            break;
-          }
-
-          continue;
-        }
-
-        result.extend(currentResult); // MODE_ALL: All must pass.
-        // If one failed, exit.
-
-        if (options.mode === MODE_ALL) {
-          if (!pass) {
-            break;
-          }
-        } // MODE_ONE: only one must pass.
-        // If more than one passed, exit.
-
-
-        if (options.mode === MODE_ONE) {
-          result.setFailed(count !== 1);
-
-          if (count > 1) {
-            break;
-          }
-        }
-      } else {
-        result.extend(currentResult);
-
-        if (pass) {
-          break;
-        }
-      }
-    }
-
-    if (result.pass && count === 0) {
-      result.setFailed(true); // In some cases we do not want to extend failures, for example - in ANY
-      // when there is a valid response, so we do it before returning
-
-      failedResults.forEach(function (failedResult) {
-        return result.extend(failedResult);
-      });
-    }
-
-    return result;
-  }
-
-  function setFnName(fn, value) {
-    var _Object$getOwnPropert;
-
-    // Pre ES2015 non standard implementation, "Function.name" is non configurable field
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
-    return (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(fn, 'name')) !== null && _Object$getOwnPropert !== void 0 && _Object$getOwnPropert.configurable ? Object.defineProperty(fn, 'name', {
-      value: value
-    }) : fn;
-  }
-
-  /**
-   * ES5 Transpilation increases the size of spread arguments by a lot.
-   * Wraps a function and passes its spread params as an array.
-   *
-   * @param {Function} cb
-   * @param {String}   [fnName]
-   * @return {Function}
-   */
-
-  function withArgs(cb, fnName) {
-    return setFnName(function () {
-      var args = Array.from(arguments);
-      var right = args.splice(cb.length - 1);
-      return cb.apply(null, args.concat([right]));
-    }, fnName || cb.name);
-  }
-
-  /**
-   * Runs a chain of rules, making sure that all assertions pass
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function allOf(value, rules) {
-    return runCompoundChain(value, rules, {
-      mode: MODE_ALL
-    });
-  }
-
-  var allOf$1 = withArgs(allOf);
-
-  /**
-   * Runs chains of rules, making sure
-   * that at least one assertion passes
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function anyOf(value, ruleChains) {
-    return runCompoundChain(value, ruleChains, {
-      mode: MODE_ANY
-    });
-  }
-
-  var anyOf$1 = withArgs(anyOf);
-
-  function isArray(value) {
-    return Boolean(Array.isArray(value));
-  }
-  var isNotArray = bindNot(isArray);
-
-  /**
-   * Asserts that each element in an array passes
-   * at least one of the provided rule chain
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function isArrayOf(value, ruleChains) {
-    var plainValue = EnforceContext.unwrap(value);
-    var result = new RuleResult(true).asArray(); // Fails if current value is not an array
-
-    if (isNotArray(plainValue)) {
-      return result.setFailed(true);
-    }
-
-    for (var i = 0; i < plainValue.length; i++) {
-      // Set result per each item in the array
-      result.setChild(i, runCompoundChain(new EnforceContext({
-        value: plainValue[i],
-        obj: plainValue,
-        key: i
-      }).setFailFast(value.failFast), ruleChains, {
-        mode: MODE_ANY
-      }));
-    }
-
-    return result;
-  }
-
-  var isArrayOf$1 = withArgs(isArrayOf);
-
-  /**
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function oneOf(value, rules) {
-    return runCompoundChain(value, rules, {
-      mode: MODE_ONE
-    });
-  }
-
-  var oneOf$1 = withArgs(oneOf);
-
-  /**
-   * @param {Array} ObjectEntry   Object and key leading to current value
-   * @param {Function[]} rules    Rules to validate the value with
-   */
-
-  function optional(inputObject, ruleGroups) {
-    var obj = inputObject.obj,
-        key = inputObject.key; // If current value is not defined, undefined or null
-    // Pass without further assertions
-
-    if (!hasOwnProperty(obj, key) || isUndefined(obj[key] || isNull(obj[key]))) {
-      return true;
-    } // Pass if exists but no assertions
-
-
-    if (isEmpty(ruleGroups)) {
-      return true;
-    } // Run chain with `all` mode
-
-
-    return runCompoundChain(obj[key], ruleGroups, {
-      mode: MODE_ALL
-    });
-  }
-
-  var optional$1 = withArgs(optional);
-
-  /**
-   * @param {EnforceContext} inputObject  Data object that gets validated
-   * @param {Object} shapeObj  Shape definition
-   * @param {Object} options
-   * @param {boolean} options.loose Ignore extra keys not defined in shapeObj
-   */
-
-  function shape(inputObject, shapeObj, options) {
-    // Extract the object from context
-    var obj = EnforceContext.unwrap(inputObject); // Create a new result object
-
-    var result = new RuleResult(true); // Iterate over the shape keys
-
-    for (var key in shapeObj) {
-      var current = shapeObj[key];
-      var value = obj[key];
-
-      if (shouldFailFast(value, result)) {
-        break;
-      } // Set each key in the result object
-
-
-      result.setChild(key, runLazyRule(current, new EnforceContext({
-        value: value,
-        obj: obj,
-        key: key
-      }).setFailFast(inputObject.failFast)));
-    } // If mode is not loose
-
-
-    if (!(options || {}).loose) {
-      // Check that each key in the input object exists in the shape
-      for (var _key in obj) {
-        if (!hasOwnProperty(shapeObj, _key)) {
-          return result.setFailed(true);
-        }
-      }
-    }
-
-    return result;
-  }
-  var loose = function loose(obj, shapeObj) {
-    return shape(obj, shapeObj, {
-      loose: true
-    });
-  };
-
-  var compounds = {
-    allOf: allOf$1,
-    anyOf: anyOf$1,
-    isArrayOf: isArrayOf$1,
-    loose: loose,
-    oneOf: oneOf$1,
-    optional: optional$1,
-    shape: shape
-  };
-
-  /**
-   * Takes a value. If it is a function, runs it and returns the result.
-   * Otherwise, returns the value as is.
-   *
-   * @param {Function|*} value    Value to return. Run it if a function.
-   * @param {Any[]} [args]        Arguments to pass if a function
-   * @return {Any}
-   */
-
-  function optionalFunctionValue(value, args) {
-    return isFunction(value) ? value.apply(null, args) : value;
-  }
-
-  function message(value, msg) {
-    return optionalFunctionValue(msg, [EnforceContext.unwrap(value)]);
-  }
-
-  function warn(_, isWarn) {
-    if (isWarn === void 0) {
-      isWarn = true;
-    }
-
-    return isWarn;
-  }
-
-  function when(value, condition, bail) {
-    var shouldBail = !optionalFunctionValue(condition, [EnforceContext.unwrap(value)].concat(EnforceContext.is(value) ? [value.key, value.obj] : []));
-    return bail(shouldBail);
-  }
-
-  var ruleMeta = {
-    warn: warn,
-    message: message,
-    when: when
-  };
-
-  function isString (v) {
-    return String(v) === v;
-  }
-
-  function endsWith(value, arg1) {
-    return isString(value) && isString(arg1) && value.endsWith(arg1);
-  }
-  var doesNotEndWith = bindNot(endsWith);
-
-  function equals(value, arg1) {
-    return value === arg1;
-  }
-  var notEquals = bindNot(equals);
-
-  function greaterThan(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) > Number(arg1);
-  }
-
-  function greaterThanOrEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) >= Number(arg1);
-  }
-
-  function inside(value, arg1) {
-    if (Array.isArray(arg1) && /^[s|n|b]/.test(typeof value)) {
-      return arg1.indexOf(value) !== -1;
-    } // both value and arg1 are strings
-
-
-    if (isString(arg1) && isString(value)) {
-      return arg1.indexOf(value) !== -1;
-    }
-
-    return false;
-  }
-  var notInside = bindNot(inside);
-
-  function lessThanOrEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) <= Number(arg1);
-  }
-
-  function isBetween(value, min, max) {
-    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-  }
-  var isNotBetween = bindNot(isBetween);
-
-  function isBlank(value) {
-    return typeof value === 'string' && value.trim() === '';
-  }
-  var isNotBlank = bindNot(isBlank);
-
-  /**
-   * Validates that a given value is an even number
-   * @param {Number|String} value Value to be validated
-   * @return {Boolean}
-   */
-
-  var isEven = function isEven(value) {
-    if (isNumeric(value)) {
-      return value % 2 === 0;
-    }
-
-    return false;
-  };
-
-  function isNaN$1(value) {
-    return Number.isNaN(value);
-  }
-  var isNotNaN = bindNot(isNaN$1);
-
-  function isNegative(value) {
-    if (isNumeric(value)) {
-      return Number(value) < 0;
-    }
-
-    return false;
-  }
-  var isPositive = bindNot(isNegative);
-
-  function isNumber(value) {
-    return Boolean(typeof value === 'number');
-  }
-  var isNotNumber = bindNot(isNumber);
-
-  /**
-   * Validates that a given value is an odd number
-   * @param {Number|String} value Value to be validated
-   * @return {Boolean}
-   */
-
-  var isOdd = function isOdd(value) {
-    if (isNumeric(value)) {
-      return value % 2 !== 0;
-    }
-
-    return false;
-  };
-
-  var isNotString = bindNot(isString);
-
-  function isTruthy(value) {
-    return !!value;
-  }
-  var isFalsy = bindNot(isTruthy);
-
-  function lessThan(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) < Number(arg1);
-  }
-
-  function longerThan(value, arg1) {
-    return value.length > Number(arg1);
-  }
-
-  function longerThanOrEquals(value, arg1) {
-    return value.length >= Number(arg1);
-  }
-
-  function matches(value, regex) {
-    if (regex instanceof RegExp) {
-      return regex.test(value);
-    } else if (isString(regex)) {
-      return new RegExp(regex).test(value);
-    } else {
-      return false;
-    }
-  }
-  var notMatches = bindNot(matches);
-
-  function numberEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) === Number(arg1);
-  }
-  var numberNotEquals = bindNot(numberEquals);
-
-  function shorterThan(value, arg1) {
-    return value.length < Number(arg1);
-  }
-
-  function shorterThanOrEquals(value, arg1) {
-    return value.length <= Number(arg1);
-  }
-
-  function startsWith(value, arg1) {
-    return isString(value) && isString(arg1) && value.startsWith(arg1);
-  }
-  var doesNotStartWith = bindNot(startsWith);
-
-  function rules() {
-    return {
-      doesNotEndWith: doesNotEndWith,
-      doesNotStartWith: doesNotStartWith,
-      endsWith: endsWith,
-      equals: equals,
-      greaterThan: greaterThan,
-      greaterThanOrEquals: greaterThanOrEquals,
-      gt: greaterThan,
-      gte: greaterThanOrEquals,
-      inside: inside,
-      isArray: isArray,
-      isBetween: isBetween,
-      isBoolean: isBoolean,
-      isBlank: isBlank,
-      isEmpty: isEmpty,
-      isEven: isEven,
-      isFalsy: isFalsy,
-      isNaN: isNaN$1,
-      isNegative: isNegative,
-      isNotArray: isNotArray,
-      isNotBetween: isNotBetween,
-      isNotBlank: isNotBlank,
-      isNotBoolean: isNotBoolean,
-      isNotEmpty: isNotEmpty,
-      isNotNaN: isNotNaN,
-      isNotNull: isNotNull,
-      isNotNumber: isNotNumber,
-      isNotNumeric: isNotNumeric,
-      isNotString: isNotString,
-      isNotUndefined: isNotUndefined,
-      isNull: isNull,
-      isNumber: isNumber,
-      isNumeric: isNumeric,
-      isOdd: isOdd,
-      isPositive: isPositive,
-      isString: isString,
-      isTruthy: isTruthy,
-      isUndefined: isUndefined,
-      lengthEquals: lengthEquals,
-      lengthNotEquals: lengthNotEquals,
-      lessThan: lessThan,
-      lessThanOrEquals: lessThanOrEquals,
-      longerThan: longerThan,
-      longerThanOrEquals: longerThanOrEquals,
-      lt: lessThan,
-      lte: lessThanOrEquals,
-      matches: matches,
-      notEquals: notEquals,
-      notInside: notInside,
-      notMatches: notMatches,
-      numberEquals: numberEquals,
-      numberNotEquals: numberNotEquals,
-      shorterThan: shorterThan,
-      shorterThanOrEquals: shorterThanOrEquals,
-      startsWith: startsWith
-    };
-  }
-
-  var runtimeRules = assign(rules(), compounds, ruleMeta);
-
-  /**
-   * Determines whether a given string is a name of a rule
-   *
-   * @param {string} name
-   * @return {boolean}
-   */
-
-  var isRule = function isRule(name) {
-    return hasOwnProperty(runtimeRules, name) && isFunction(runtimeRules[name]);
-  };
-
-  var GLOBAL_OBJECT = Function('return this')();
-
-  var proxySupported = function proxySupported() {
-    return isFunction(GLOBAL_OBJECT.Proxy);
-  };
-
-  function genRuleProxy(target, output) {
-    if (proxySupported()) {
-      return new Proxy(target, {
-        get: function get(target, fnName) {
-          // A faster bailout when we access `run` and `test`
-          if (hasOwnProperty(target, fnName)) {
-            return target[fnName];
-          }
-
-          if (isRule(fnName)) {
-            return output(fnName);
-          }
-
-          return target[fnName];
-        }
-      });
-    } else {
-      var _loop = function _loop(fnName) {
-        if (!isFunction(target[fnName])) {
-          var _Object$definePropert;
-
-          Object.defineProperties(target, (_Object$definePropert = {}, _Object$definePropert[fnName] = {
-            get: function get() {
-              return output(fnName);
-            }
-          }, _Object$definePropert));
-        }
-      };
-
-      /**
-       * This method is REALLY not recommended as it is slow and iterates over
-       * all the rules for each direct enforce reference. We only use it as a
-       * lightweight alternative for the much faster proxy interface
-       */
-      for (var fnName in runtimeRules) {
-        _loop(fnName);
-      }
-
-      return target;
-    }
-  }
-
-  /**
-   * Determines whether a given rule is a compound.
-   *
-   * @param {Function} rule
-   * @return {boolean}
-   */
-
-  function isCompound(rule) {
-    return hasOwnProperty(compounds, rule.name);
-  }
-
-  /**
-   * Creates a rule of lazily called rules.
-   * Each rule gets added a `.run()` property
-   * which runs all the accumulated rules in
-   * the chain against the supplied value
-   *
-   * @param {string} ruleName
-   * @return {{run: Function}}
-   */
-
-  function bindLazyRule(ruleName) {
-    var registeredRules = []; // Chained rules
-
-    var meta = []; // Meta properties to add onto the rule context
-    // Appends a function to the registeredRules array.
-    // It gets called every time the consumer usess chaining
-    // so, for example - enforce.isArray() <- this calles addFn
-
-    var addFn = function addFn(ruleName) {
-      return withArgs(function (args) {
-        var rule = runtimeRules[ruleName]; // Add a meta function
-
-        if (ruleMeta[rule.name] === rule) {
-          meta.push(function (value, ruleResult, bail) {
-            ruleResult.setAttribute(rule.name, rule(value, args[0], bail));
-          });
-        } else {
-          // Register a rule
-          registeredRules.push(setFnName(function (value) {
-            return rule.apply(null, [// If the rule is compound - wraps the value with context
-            // Otherwise - unwraps it
-            isCompound(rule) ? EnforceContext.wrap(value) : EnforceContext.unwrap(value)].concat(args));
-          }, ruleName));
-        } // set addFn as the proxy handler
-
-
-        var returnvalue = genRuleProxy({}, addFn);
-
-        returnvalue[RUN_RULE] = function (value) {
-          var result = new RuleResult(true);
-          var bailed = false; // Run meta chains
-
-          meta.forEach(function (fn) {
-            fn(value, result, function (shouldBail) {
-              return bailed = shouldBail;
-            });
-          });
-
-          if (bailed) {
-            return null;
-          } // Iterate over all the registered rules
-          // This runs the function that's inside `addFn`
-
-
-          for (var _iterator = _createForOfIteratorHelperLoose(registeredRules), _step; !(_step = _iterator()).done;) {
-            var fn = _step.value;
-
-            try {
-              result.extend(fn(value)); // If a chained rule fails, exit. We failed.
-
-              if (!result.pass) {
-                break;
-              }
-            } catch (e) {
-              result.setFailed(true);
-              break;
-            }
-          }
-
-          return result;
-        };
-
-        returnvalue[TEST_RULE] = function (value) {
-          return returnvalue[RUN_RULE](EnforceContext.wrap(value).setFailFast(true)).pass;
-        };
-
-        return returnvalue;
-      }, ruleName);
-    }; // Returns the initial rule in the chain
-
-
-    return addFn(ruleName);
-  }
-
-  function bindExtend(enforce, Enforce) {
-    enforce.extend = function (customRules) {
-      assign(runtimeRules, customRules);
-
-      if (!proxySupported()) {
-        genRuleProxy(Enforce, bindLazyRule);
-      }
-
-      return enforce;
-    };
-  }
-
-  /**
-   * Throws a timed out error.
-   * @param {String} message  Error message to display.
-   * @param {Error} [type]    Alternative Error type.
-   */
-  var throwError = function throwError(message, type) {
-    if (type === void 0) {
-      type = Error;
-    }
-
-    throw new type("[" + "n4s" + "]: " + message);
-  };
-
-  function validateResult(result, rule) {
-    // if result is boolean, or if result.pass is boolean
-    if (isBoolean(result) || result && isBoolean(result.pass)) {
-      return;
-    }
-
-    throwError(rule.name + 'wrong return value');
-  } // for easier testing and mocking
-
-  function getDefaultResult(value) {
-    return {
-      message: new Error("invalid " + typeof value + " value")
-    };
-  }
-  /**
-   * Transform the result of a rule into a standard format
-   * @param {string} interfaceName to be used in the messages
-   * @param {*} result of the rule
-   * @param {Object} options
-   * @param {function} options.rule
-   * @param {*} options.value
-   * @returns {Object} result
-   * @returns {string} result.message
-   * @returns {boolean} result.pass indicates if the test passes or not
-   */
-
-  function transformResult(result, _ref) {
-    var rule = _ref.rule,
-        value = _ref.value;
-    var defaultResult = getDefaultResult(value);
-    validateResult(result, rule); // if result is boolean
-
-    if (isBoolean(result)) {
-      return defaultResult.pass = result, defaultResult;
-    } else {
-      defaultResult.pass = result.pass;
-
-      if (result.message) {
-        defaultResult.message = optionalFunctionValue(result.message);
-      }
-
-      return defaultResult;
-    }
-  }
-
-  /**
-   * Run a single rule against enforced value (e.g. `isNumber()`)
-   *
-   * @param {Function} rule - rule to run
-   * @param {Any} value
-   * @param {Array} args list of arguments sent from consumer
-   * @throws
-   */
-
-  function runner(rule, value, args) {
-    if (args === void 0) {
-      args = [];
-    }
-
-    var result;
-    var isCompoundRule = isCompound(rule);
-    var ruleValue = isCompoundRule ? EnforceContext.wrap(value).setFailFast(true) : EnforceContext.unwrap(value);
-    result = rule.apply(null, [ruleValue].concat(args));
-
-    if (!isCompoundRule) {
-      result = transformResult(result, {
-        rule: rule,
-        value: value
-      });
-    }
-
-    if (!result.pass) {
-      throw result.message;
-    }
-  }
-
-  /**
-   * Adds `template` property to enforce.
-   *
-   * @param {Function} enforce
-   */
-
-  function bindTemplate(enforce) {
-    enforce.template = withArgs(function (rules) {
-      var template = function template(value) {
-        runner(runLazyRules.bind(null, rules), value);
-        var proxy = genRuleProxy({}, function (ruleName) {
-          return withArgs(function (args) {
-            runner(runtimeRules[ruleName], value, args);
-            return proxy;
-          });
-        });
-        return proxy;
-      }; // `run` returns a deep ResultObject
-
-
-      template[RUN_RULE] = function (value) {
-        return runLazyRules(rules, value);
-      }; // `test` returns a boolean
-
-
-      template[TEST_RULE] = function (value) {
-        return runLazyRules(rules, EnforceContext.wrap(value).setFailFast(true)).pass;
-      };
-
-      return template;
-    });
-  }
-
-  var Enforce = function Enforce(value) {
-    var proxy = genRuleProxy({}, function (ruleName) {
-      return withArgs(function (args) {
-        runner(runtimeRules[ruleName], value, args);
-        return proxy;
-      });
-    });
-    return proxy;
-  };
-
-  var enforce = genRuleProxy(Enforce, bindLazyRule);
-  bindExtend(enforce, Enforce);
-  bindTemplate(enforce);
-
-  return enforce;
-
-})));