n4s 3.0.0 → 4.0.0-dev-1aae50

package/n4s.cjs.development.js

@@ -1,1103 +0,0 @@
-'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);
-
-module.exports = enforce;