n4s 3.0.0 → 4.0.0-dev-1aae50

package/n4s.umd.development.js

@@ -1,1109 +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';
-
-  /**
-   * Stores values and configuration passed down to compound rules.
-   *
-   * @param {Object} content
-   */
-  function EnforceContext(content) {
-    Object.assign(this, content);
-  }
-  /**
-   * Sets an EnforceContext config `failFast`
-   *
-   * @param {Boolean} failFast
-   * @return {EnforceContext}
-   */
-
-  EnforceContext.prototype.setFailFast = function (failFast) {
-    this.failFast = !!failFast;
-    return this;
-  };
-  /**
-   * Extracts the literal value from an EnforceContext object
-   * @param {*} value
-   * @return {*}
-   */
-
-
-  EnforceContext.unwrap = function unwrap(value) {
-    return EnforceContext.is(value) ? value.value : value;
-  };
-  /**
-   * Wraps a literal value within a context.
-   * @param {*} value
-   * @return {EnforceContext}
-   */
-
-
-  EnforceContext.wrap = function wrap(value) {
-    return EnforceContext.is(value) ? value : new EnforceContext({
-      value
-    });
-  };
-  /**
-   * Checks whether a given value is an EnforceContext instance
-   *
-   * @param {*} value
-   * @returns {boolean}
-   */
-
-
-  EnforceContext.is = function is(value) {
-    return value instanceof EnforceContext;
-  };
-
-  /**
-   * 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;
-  }
-
-  const isNotBoolean = bindNot(isBoolean);
-
-  function isNumeric(value) {
-    const result = !isNaN(parseFloat(value)) && !isNaN(Number(value)) && isFinite(value);
-    return Boolean(result);
-  }
-  const isNotNumeric = bindNot(isNumeric);
-
-  function lengthEquals(value, arg1) {
-    return value.length === Number(arg1);
-  }
-  const 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;
-  }
-  const isNotEmpty = bindNot(isEmpty);
-
-  function isUndefined(value) {
-    return value === undefined;
-  }
-  const isNotUndefined = bindNot(isUndefined);
-
-  const HAS_WARNINGS = 'hasWarnings';
-  const 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) {
-    const isWarning = this[HAS_WARNINGS] || child[HAS_WARNINGS] || child.warn || this.warn;
-    this.setAttribute(HAS_WARNINGS, isWarning && child.failed || false);
-    this.setAttribute(HAS_ERRORS, this[HAS_ERRORS] || child[HAS_ERRORS] || !isWarning && child.failed || false);
-    this.setFailed(this.failed || child.failed);
-    this.children = this.children || {};
-    this.children[key] = child;
-    return child;
-  };
-  /**
-   * Retrieves a child by its key
-   *
-   * @param {string} key
-   * @return {RuleResult|undefined}
-   */
-
-
-  RuleResult.prototype.getChild = function (key) {
-    return (this.children || {})[key];
-  };
-  /**
-   * Extends current instance with a new provided result
-   * @param {Boolean|RuleResult} newRes
-   */
-
-
-  RuleResult.prototype.extend = function (newRes) {
-    const res = RuleResult.is(newRes) ? newRes : new RuleResult().setAttribute('warn', !!this.warn).setFailed(!newRes);
-    const failed = this.failed || res.failed;
-    const children = mergeChildren(res, this).children;
-    Object.assign(this, res);
-
-    if (!isEmpty(children)) {
-      this.children = children;
-    }
-
-    this.setFailed(failed);
-    this.setAttribute(HAS_WARNINGS, !!(this[HAS_WARNINGS] || res[HAS_WARNINGS]));
-    this.setAttribute(HAS_ERRORS, !!(this[HAS_ERRORS] || res[HAS_ERRORS]));
-  };
-
-  Object.defineProperty(RuleResult.prototype, 'pass', {
-    get() {
-      return !this.failed;
-    }
-
-  });
-  /**
-   * Deeply merge the nested children of compound rules
-   *
-   * @param {?RuleResult} base
-   * @param {?RuleResult} add
-   * @return {RuleResult}
-   */
-
-  function mergeChildren(base, add) {
-    const isRuleResultBase = RuleResult.is(base);
-    const isRuleResultAdd = RuleResult.is(add); // If both base and add are result objects
-
-    if (isRuleResultBase && isRuleResultAdd) {
-      // Use failed if either is failing
-      base.setFailed(base.failed || add.failed); // If neither has a children object, or the children object is
-
-      if (isEmpty(base.children) && isEmpty(add.children)) {
-        return base;
-      } // If both have a children object
-
-
-      if (base.children && add.children) {
-        // Merge all the "right side" children back to base
-        for (const key in base.children) {
-          mergeChildren(base.children[key], add.children[key]);
-        } // If a child exists in "add" but not in "base", just copy the child as is
-
-
-        for (const key in add.children) {
-          if (!hasOwnProperty(base.children, key)) {
-            base.setChild(key, add.children[key]);
-          }
-        } // Return the modified base object
-
-
-        return base; // If base has no children (but add does)
-      } else if (!base.children) {
-        // Use add's children
-        base.children = add.children; // If add has no children
-      } else if (!add.children) {
-        // return base as is
-        return base;
-      } // If only base is `RuleResult`
-
-    } else if (isRuleResultBase) {
-      // Return base as is
-      return base; // If only add is RuleResult
-    } else if (isRuleResultAdd) {
-      // Return add as is
-      return add;
-    } // That's a weird case. Let's fail. Very unlikely.
-
-
-    return new RuleResult(false);
-  }
-
-  const RUN_RULE = 'run';
-  const TEST_RULE = 'test';
-  const MODE_ALL = 'all';
-  const MODE_ONE = 'one';
-  const MODE_ANY = 'any';
-
-  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) {
-    const result = new RuleResult(true);
-
-    for (const chain of asArray(ruleGroups)) {
-      if (shouldFailFast(value, result)) {
-        break;
-      }
-
-      result.extend(runLazyRule(chain, value));
-    }
-
-    return result;
-  }
-  /**
-   * Runs a single lazy rule
-   *
-   * @param {{run: Function}} ruleGroup
-   * @param {*} value
-   * @return {boolean|RuleResult}
-   */
-
-  function runLazyRule(ruleGroup, value) {
-    return ruleGroup[RUN_RULE](value);
-  }
-
-  /**
-   * Runs chains of rules
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} rules
-   * @param {RuleResult} options
-   */
-
-  function runCompoundChain(value, rules, options) {
-    const result = new RuleResult(true);
-
-    if (isEmpty(rules)) {
-      result.setFailed(true);
-    }
-
-    const failedResults = [];
-    let count = 0;
-
-    for (const chain of rules) {
-      // Inner result for each iteration
-      const currentResult = runLazyRule(chain, value);
-      const pass = currentResult.pass;
-
-      if (pass) {
-        count++;
-      } else {
-        failedResults.push(currentResult);
-      }
-
-      if (options) {
-        // "anyOf" is a special case.
-        // It shouldn't extend with failed results,
-        // that's why we continue
-        if (options.mode === MODE_ANY) {
-          if (pass) {
-            result.extend(currentResult);
-            break;
-          }
-
-          continue;
-        }
-
-        result.extend(currentResult); // MODE_ALL: All must pass.
-        // If one failed, exit.
-
-        if (options.mode === MODE_ALL) {
-          if (!pass) {
-            break;
-          }
-        } // MODE_ONE: only one must pass.
-        // If more than one passed, exit.
-
-
-        if (options.mode === MODE_ONE) {
-          result.setFailed(count !== 1);
-
-          if (count > 1) {
-            break;
-          }
-        }
-      } else {
-        result.extend(currentResult);
-
-        if (pass) {
-          break;
-        }
-      }
-    }
-
-    if (result.pass && count === 0) {
-      result.setFailed(true); // In some cases we do not want to extend failures, for example - in ANY
-      // when there is a valid response, so we do it before returning
-
-      failedResults.forEach(failedResult => result.extend(failedResult));
-    }
-
-    return result;
-  }
-
-  function setFnName(fn, value) {
-    return Object.defineProperty(fn, 'name', {
-      value
-    });
-  }
-
-  /**
-   * 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((...args) => {
-      const right = args.splice(cb.length - 1);
-      return cb.apply(null, args.concat([right]));
-    }, fnName || cb.name);
-  }
-
-  /**
-   * Runs a chaen of rules, making sure that all assertions pass
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function allOf(value, rules) {
-    return runCompoundChain(value, rules, {
-      mode: MODE_ALL
-    });
-  }
-
-  var allOf$1 = withArgs(allOf);
-
-  /**
-   * Runs chains of rules, making sure
-   * that at least one assertion passes
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function anyOf(value, ruleChains) {
-    return runCompoundChain(value, ruleChains, {
-      mode: MODE_ANY
-    });
-  }
-
-  var anyOf$1 = withArgs(anyOf);
-
-  function isArray(value) {
-    return Boolean(Array.isArray(value));
-  }
-  const isNotArray = bindNot(isArray);
-
-  /**
-   * Asserts that each element in an array passes
-   * at least one of the provided rule chain
-   *
-   * @param {EnforceContext} value
-   * @param {[{test: Function, run: Function}]} ruleChains
-   * @return {RuleResult}
-   */
-
-  function isArrayOf(value, ruleChains) {
-    const plainValue = EnforceContext.unwrap(value);
-    const result = new RuleResult(true).asArray(); // Fails if current value is not an array
-
-    if (isNotArray(plainValue)) {
-      return result.setFailed(true);
-    }
-
-    for (let i = 0; i < plainValue.length; i++) {
-      // Set result per each item in the array|
-      result.setChild(i, runCompoundChain(EnforceContext.wrap(plainValue[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);
-
-  function isNull(value) {
-    return value === null;
-  }
-  const isNotNull = bindNot(isNull);
-
-  /**
-   * @param {Array} ObjectEntry   Object and key leading to current value
-   * @param {Function[]} rules    Rules to validate the value with
-   */
-
-  function optional(inputObject, ruleGroups) {
-    const {
-      obj,
-      key
-    } = inputObject; // If current value is not defined, undefined or null
-    // Pass without further assertions
-
-    if (!hasOwnProperty(obj, key) || isUndefined(obj[key] || isNull(obj[key]))) {
-      return true;
-    } // Pass if exists but no assertions
-
-
-    if (isEmpty(ruleGroups)) {
-      return true;
-    } // Run chain with `all` mode
-
-
-    return runCompoundChain(obj[key], ruleGroups, {
-      mode: MODE_ALL
-    });
-  }
-
-  var optional$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
-    const obj = EnforceContext.unwrap(inputObject); // Create a new result object
-
-    const result = new RuleResult(true); // Iterate over the shape keys
-
-    for (const key in shapeObj) {
-      const current = shapeObj[key];
-      const value = obj[key];
-
-      if (shouldFailFast(value, result)) {
-        break;
-      } // Set each key in the result object
-
-
-      result.setChild(key, runLazyRule(current, new EnforceContext({
-        value,
-        obj,
-        key
-      }).setFailFast(inputObject.failFast)));
-    } // If mode is not loose
-
-
-    if (!(options || {}).loose) {
-      // Check that each key in the input object exists in the shape
-      for (const key in obj) {
-        if (!hasOwnProperty(shapeObj, key)) {
-          return result.setFailed(true);
-        }
-      }
-    }
-
-    return result;
-  }
-  const loose = (obj, shapeObj) => shape(obj, shapeObj, {
-    loose: true
-  });
-
-  var compounds = {
-    allOf: allOf$1,
-    anyOf: anyOf$1,
-    isArrayOf: isArrayOf$1,
-    loose,
-    oneOf: oneOf$1,
-    optional: optional$1,
-    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 = true) {
-    return isWarn;
-  }
-
-  var ruleMeta = {
-    warn,
-    message
-  };
-
-  function isString (v) {
-    return String(v) === v;
-  }
-
-  function endsWith(value, arg1) {
-    return isString(value) && isString(arg1) && value.endsWith(arg1);
-  }
-  const doesNotEndWith = bindNot(endsWith);
-
-  function equals(value, arg1) {
-    return value === arg1;
-  }
-  const notEquals = bindNot(equals);
-
-  function greaterThan(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) > Number(arg1);
-  }
-
-  function greaterThanOrEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) >= Number(arg1);
-  }
-
-  function inside(value, arg1) {
-    if (Array.isArray(arg1) && /^[s|n|b]/.test(typeof value)) {
-      return arg1.indexOf(value) !== -1;
-    } // both value and arg1 are strings
-
-
-    if (isString(arg1) && isString(value)) {
-      return arg1.indexOf(value) !== -1;
-    }
-
-    return false;
-  }
-  const notInside = bindNot(inside);
-
-  function lessThanOrEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) <= Number(arg1);
-  }
-
-  function isBetween(value, min, max) {
-    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
-  }
-  const isNotBetween = bindNot(isBetween);
-
-  /**
-   * Validates that a given value is an even number
-   * @param {Number|String} value Value to be validated
-   * @return {Boolean}
-   */
-
-  const isEven = value => {
-    if (isNumeric(value)) {
-      return value % 2 === 0;
-    }
-
-    return false;
-  };
-
-  function isNaN$1(value) {
-    return Number.isNaN(value);
-  }
-  const isNotNaN = bindNot(isNaN$1);
-
-  function isNegative(value) {
-    if (isNumeric(value)) {
-      return Number(value) < 0;
-    }
-
-    return false;
-  }
-  const isPositive = bindNot(isNegative);
-
-  function isNumber(value) {
-    return Boolean(typeof value === 'number');
-  }
-  const isNotNumber = bindNot(isNumber);
-
-  /**
-   * Validates that a given value is an odd number
-   * @param {Number|String} value Value to be validated
-   * @return {Boolean}
-   */
-
-  const isOdd = value => {
-    if (isNumeric(value)) {
-      return value % 2 !== 0;
-    }
-
-    return false;
-  };
-
-  const isNotString = bindNot(isString);
-
-  function isTruthy(value) {
-    return !!value;
-  }
-  const isFalsy = bindNot(isTruthy);
-
-  function lessThan(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) < Number(arg1);
-  }
-
-  function longerThan(value, arg1) {
-    return value.length > Number(arg1);
-  }
-
-  function longerThanOrEquals(value, arg1) {
-    return value.length >= Number(arg1);
-  }
-
-  function matches(value, regex) {
-    if (regex instanceof RegExp) {
-      return regex.test(value);
-    } else if (isString(regex)) {
-      return new RegExp(regex).test(value);
-    } else {
-      return false;
-    }
-  }
-  const notMatches = bindNot(matches);
-
-  function numberEquals(value, arg1) {
-    return isNumeric(value) && isNumeric(arg1) && Number(value) === Number(arg1);
-  }
-  const numberNotEquals = bindNot(numberEquals);
-
-  function shorterThan(value, arg1) {
-    return value.length < Number(arg1);
-  }
-
-  function shorterThanOrEquals(value, arg1) {
-    return value.length <= Number(arg1);
-  }
-
-  function startsWith(value, arg1) {
-    return isString(value) && isString(arg1) && value.startsWith(arg1);
-  }
-  const doesNotStartWith = bindNot(startsWith);
-
-  function rules() {
-    return {
-      doesNotEndWith,
-      doesNotStartWith,
-      endsWith,
-      equals,
-      greaterThan,
-      greaterThanOrEquals,
-      gt: greaterThan,
-      gte: greaterThanOrEquals,
-      inside,
-      isArray,
-      isBetween,
-      isBoolean,
-      isEmpty,
-      isEven,
-      isFalsy,
-      isNaN: isNaN$1,
-      isNegative,
-      isNotArray,
-      isNotBetween,
-      isNotBoolean,
-      isNotEmpty,
-      isNotNaN,
-      isNotNull,
-      isNotNumber,
-      isNotNumeric,
-      isNotString,
-      isNotUndefined,
-      isNull,
-      isNumber,
-      isNumeric,
-      isOdd,
-      isPositive,
-      isString,
-      isTruthy,
-      isUndefined,
-      lengthEquals,
-      lengthNotEquals,
-      lessThan,
-      lessThanOrEquals,
-      longerThan,
-      longerThanOrEquals,
-      lt: lessThan,
-      lte: lessThanOrEquals,
-      matches,
-      notEquals,
-      notInside,
-      notMatches,
-      numberEquals,
-      numberNotEquals,
-      shorterThan,
-      shorterThanOrEquals,
-      startsWith
-    };
-  }
-
-  var runtimeRules = Object.assign(rules(), compounds, ruleMeta);
-
-  /**
-   * Determines whether a given string is a name of a rule
-   *
-   * @param {string} name
-   * @return {boolean}
-   */
-
-  const isRule = name => hasOwnProperty(runtimeRules, name) && isFunction(runtimeRules[name]);
-
-  const GLOBAL_OBJECT = Function('return this')();
-
-  const proxySupported = () => isFunction(GLOBAL_OBJECT.Proxy);
-
-  function genRuleProxy(target, output) {
-    if (proxySupported()) {
-      return new Proxy(target, {
-        get: (target, fnName) => {
-          // A faster bailout when we access `run` and `test`
-          if (hasOwnProperty(target, fnName)) {
-            return target[fnName];
-          }
-
-          if (isRule(fnName)) {
-            return output(fnName);
-          }
-
-          return target[fnName];
-        }
-      });
-    } else {
-      /**
-       * This method is REALLY not recommended as it is slow and iterates over
-       * all the rules for each direct enforce reference. We only use it as a
-       * lightweight alternative for the much faster proxy interface
-       */
-      for (const fnName in runtimeRules) {
-        if (!isFunction(target[fnName])) {
-          Object.defineProperties(target, {
-            [fnName]: {
-              get: () => output(fnName)
-            }
-          });
-        }
-      }
-
-      return target;
-    }
-  }
-
-  /**
-   * Determines whether a given rule is a compound.
-   *
-   * @param {Function} rule
-   * @return {boolean}
-   */
-
-  function isCompound(rule) {
-    return hasOwnProperty(compounds, rule.name);
-  }
-
-  /**
-   * Creates a rule of lazily called rules.
-   * Each rule gets added a `.run()` property
-   * which runs all the accumulated rules in
-   * the chain against the supplied value
-   *
-   * @param {string} ruleName
-   * @return {{run: Function}}
-   */
-
-  function bindLazyRule(ruleName) {
-    const registeredRules = []; // Chained rules
-
-    const meta = []; // Meta properties to add onto the rule context
-    // Appends a function to the registeredRules array.
-    // It gets called every time the consumer usess chaining
-    // so, for example - enforce.isArray() <- this calles addFn
-
-    const addFn = ruleName => {
-      return withArgs(args => {
-        const rule = runtimeRules[ruleName]; // Add a meta function
-
-        if (ruleMeta[rule.name] === rule) {
-          meta.push((value, ruleResult) => {
-            ruleResult.setAttribute(rule.name, rule(value, args[0]));
-          });
-        } else {
-          // Register a rule
-          registeredRules.push(setFnName(value => {
-            return rule.apply(null, [// If the rule is compound - wraps the value with context
-            // Otherwise - unwraps it
-            isCompound(rule) ? EnforceContext.wrap(value) : EnforceContext.unwrap(value)].concat(args));
-          }, ruleName));
-        } // set addFn as the proxy handler
-
-
-        const returnvalue = genRuleProxy({}, addFn);
-
-        returnvalue[RUN_RULE] = value => {
-          const result = new RuleResult(true); // Run meta chains
-
-          meta.forEach(fn => {
-            fn(value, result);
-          }); // Iterate over all the registered rules
-          // This runs the function that's inside `addFn`
-
-          for (const fn of registeredRules) {
-            try {
-              result.extend(fn(value)); // If a chained rule fails, exit. We failed.
-
-              if (!result.pass) {
-                break;
-              }
-            } catch (e) {
-              result.setFailed(true);
-              break;
-            }
-          }
-
-          return result;
-        };
-
-        returnvalue[TEST_RULE] = value => returnvalue[RUN_RULE](EnforceContext.wrap(value).setFailFast(true)).pass;
-
-        return returnvalue;
-      }, ruleName);
-    }; // Returns the initial rule in the chain
-
-
-    return addFn(ruleName);
-  }
-
-  function bindExtend(enforce, Enforce) {
-    enforce.extend = customRules => {
-      Object.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.
-   */
-  const throwError = (message, 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 the rule please check that the return is valid` );
-  } // for easier testing and mocking
-
-  function getDefaultResult(value, rule) {
-    return {
-      message: formatResultMessage(rule, `invalid ${typeof value} value`)
-    };
-  }
-  function formatResultMessage(rule, msg) {
-    return `[${"n4s"}]:${rule.name} ${msg}`;
-  }
-  /**
-   * Transform the result of a rule into a standard format
-   * @param {string} interfaceName to be used in the messages
-   * @param {*} result of the rule
-   * @param {Object} options
-   * @param {function} options.rule
-   * @param {*} options.value
-   * @returns {Object} result
-   * @returns {string} result.message
-   * @returns {boolean} result.pass indicates if the test passes or not
-   */
-
-  function transformResult(result, {
-    rule,
-    value
-  }) {
-    const defaultResult = getDefaultResult(value, rule);
-    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 = formatResultMessage(rule, optionalFunctionValue(result.message));
-      }
-
-      return defaultResult;
-    }
-  }
-
-  /**
-   * Run a single rule against enforced value (e.g. `isNumber()`)
-   *
-   * @param {Function} rule - rule to run
-   * @param {Any} value
-   * @param {Array} args list of arguments sent from consumer
-   * @throws
-   */
-
-  function runner(rule, value, args = []) {
-    let result;
-    const isCompoundRule = isCompound(rule);
-    const ruleValue = isCompoundRule ? EnforceContext.wrap(value).setFailFast(true) : EnforceContext.unwrap(value);
-    result = rule.apply(null, [ruleValue].concat(args));
-
-    if (!isCompoundRule) {
-      result = transformResult(result, {
-        rule,
-        value
-      });
-    }
-
-    if (!result.pass) {
-      throw new Error(result.message);
-    }
-  }
-
-  /**
-   * Adds `template` property to enforce.
-   *
-   * @param {Function} enforce
-   */
-
-  function bindTemplate(enforce) {
-    enforce.template = withArgs(rules => {
-      const template = value => {
-        runner(runLazyRules.bind(null, rules), value);
-        const proxy = genRuleProxy({}, ruleName => withArgs(args => {
-          runner(runtimeRules[ruleName], value, args);
-          return proxy;
-        }));
-        return proxy;
-      }; // `run` returns a deep ResultObject
-
-
-      template[RUN_RULE] = value => runLazyRules(rules, value); // `test` returns a boolean
-
-
-      template[TEST_RULE] = value => runLazyRules(rules, EnforceContext.wrap(value).setFailFast(true)).pass;
-
-      return template;
-    });
-  }
-
-  const Enforce = value => {
-    const proxy = genRuleProxy({}, ruleName => withArgs(args => {
-      runner(runtimeRules[ruleName], value, args);
-      return proxy;
-    }));
-    return proxy;
-  };
-
-  const enforce = genRuleProxy(Enforce, bindLazyRule);
-  bindExtend(enforce, Enforce);
-  bindTemplate(enforce);
-
-  return enforce;
-
-})));