n4s 4.3.5-dev-d315d9 → 4.3.5

package/dist/cjs/compose.development.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var n4s = require('n4s');
 var vestUtils = require('vest-utils');
+var n4s = require('n4s');
 
 function ruleReturn(pass, message) {
-    const output = { pass };
+    var output = { pass: pass };
     if (message) {
         output.message = message;
     }
@@ -30,23 +30,27 @@ function runLazyRule(lazyRule, currentValue) {
 }
 
 /* eslint-disable max-lines-per-function */
-function compose(...composites) {
-    return vestUtils.assign((value) => {
-        const res = run(value);
+function compose() {
+    var composites = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        composites[_i] = arguments[_i];
+    }
+    return vestUtils.assign(function (value) {
+        var res = run(value);
         vestUtils.invariant(res.pass, vestUtils.StringObject(res.message));
     }, {
-        run,
-        test: (value) => run(value).pass,
+        run: run,
+        test: function (value) { return run(value).pass; }
     });
     function run(value) {
-        return n4s.ctx.run({ value }, () => {
-            return defaultToPassing(vestUtils.mapFirst(composites, (composite, breakout) => {
+        return n4s.ctx.run({ value: value }, function () {
+            return defaultToPassing(vestUtils.mapFirst(composites, function (composite, breakout) {
                 /* HACK: Just a small white lie. ~~HELP WANTED~~.
                    The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.
                    The problem is that lazy rules can't really be passed to this function due to some generic hell
                    so we're limiting it to a small set of functions.
                 */
-                const res = runLazyRule(composite, value);
+                var res = runLazyRule(composite, value);
                 breakout(!res.pass, res);
             }));
         });

package/dist/cjs/compose.production.js

@@ -1 +1 @@
-"use strict";var t=require("n4s"),n=require("vest-utils");function r(t,n){const r={pass:t};return n&&(r.message=n),r}function s(t){return n.defaultTo(t,r(!0))}function e(t,n){try{return t.run(n)}catch(t){return r(!1)}}module.exports=function(...r){return n.assign((t=>{const r=u(t);n.invariant(r.pass,n.StringObject(r.message))}),{run:u,test:t=>u(t).pass});function u(u){return t.ctx.run({value:u},(()=>s(n.mapFirst(r,((t,n)=>{const r=e(t,u);n(!r.pass,r)})))))}};
+"use strict";var n=require("vest-utils"),r=require("n4s");function t(n,r){var t={pass:n};return r&&(t.message=r),t}function u(r){return n.defaultTo(r,t(!0))}function e(n,r){try{return n.run(r)}catch(n){return t(!1)}}module.exports=function(){for(var t=[],s=0;s<arguments.length;s++)t[s]=arguments[s];return n.assign((function(r){var t=a(r);n.invariant(t.pass,n.StringObject(t.message))}),{run:a,test:function(n){return a(n).pass}});function a(s){return r.ctx.run({value:s},(function(){return u(n.mapFirst(t,(function(n,r){var t=e(n,s);r(!t.pass,t)})))}))}};

package/dist/cjs/compounds.development.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var n4s = require('n4s');
 var vestUtils = require('vest-utils');
+var n4s = require('n4s');
 
 function ruleReturn(pass, message) {
-    const output = { pass };
+    var output = { pass: pass };
     if (message) {
         output.message = message;
     }
@@ -32,23 +32,35 @@ function runLazyRule(lazyRule, currentValue) {
     }
 }
 
-function allOf(value, ...rules) {
-    return defaultToPassing(vestUtils.mapFirst(rules, (rule, breakout) => {
-        const res = runLazyRule(rule, value);
+function allOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    return defaultToPassing(vestUtils.mapFirst(rules, function (rule, breakout) {
+        var res = runLazyRule(rule, value);
         breakout(!res.pass, res);
     }));
 }
 
-function anyOf(value, ...rules) {
-    return defaultToFailing(vestUtils.mapFirst(rules, (rule, breakout) => {
-        const res = runLazyRule(rule, value);
+function anyOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    return defaultToFailing(vestUtils.mapFirst(rules, function (rule, breakout) {
+        var res = runLazyRule(rule, value);
         breakout(res.pass, res);
     }));
 }
 
-function noneOf(value, ...rules) {
-    return defaultToPassing(vestUtils.mapFirst(rules, (rule, breakout) => {
-        const res = runLazyRule(rule, value);
+function noneOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    return defaultToPassing(vestUtils.mapFirst(rules, function (rule, breakout) {
+        var res = runLazyRule(rule, value);
         breakout(res.pass, failing());
     }));
 }
@@ -58,11 +70,15 @@ function equals(value, arg1) {
 }
 vestUtils.bindNot(equals);
 
-const REQUIRED_COUNT = 1;
-function oneOf(value, ...rules) {
-    let passingCount = 0;
-    rules.some(rule => {
-        const res = runLazyRule(rule, value);
+var REQUIRED_COUNT = 1;
+function oneOf(value) {
+    var rules = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rules[_i - 1] = arguments[_i];
+    }
+    var passingCount = 0;
+    rules.some(function (rule) {
+        var res = runLazyRule(rule, value);
         if (res.pass) {
             passingCount++;
         }
@@ -73,4 +89,4 @@ function oneOf(value, ...rules) {
     return ruleReturn(equals(passingCount, REQUIRED_COUNT));
 }
 
-n4s.enforce.extend({ allOf, anyOf, noneOf, oneOf });
+n4s.enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });

package/dist/cjs/compounds.production.js

@@ -1 +1 @@
-"use strict";var n=require("n4s"),t=require("vest-utils");function r(n,t){const r={pass:n};return t&&(r.message=t),r}function e(){return r(!1)}function u(n){return t.defaultTo(n,r(!0))}function s(n,t){try{return n.run(t)}catch(n){return e()}}function o(n,t){return n===t}t.bindNot(o);n.enforce.extend({allOf:function(n,...r){return u(t.mapFirst(r,((t,r)=>{const e=s(t,n);r(!e.pass,e)})))},anyOf:function(n,...r){return u=t.mapFirst(r,((t,r)=>{const e=s(t,n);r(e.pass,e)})),t.defaultTo(u,e());var u},noneOf:function(n,...r){return u(t.mapFirst(r,((t,r)=>{r(s(t,n).pass,e())})))},oneOf:function(n,...e){let u=0;return e.some((r=>{if(s(r,n).pass&&u++,t.greaterThan(u,1))return!1})),r(o(u,1))}});
+"use strict";var n=require("vest-utils"),r=require("n4s");function t(n,r){var t={pass:n};return r&&(t.message=r),t}function e(){return t(!1)}function u(r){return n.defaultTo(r,e())}function f(r){return n.defaultTo(r,t(!0))}function a(n,r){try{return n.run(r)}catch(n){return e()}}function o(n,r){return n===r}n.bindNot(o);r.enforce.extend({allOf:function(r){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return f(n.mapFirst(t,(function(n,t){var e=a(n,r);t(!e.pass,e)})))},anyOf:function(r){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return u(n.mapFirst(t,(function(n,t){var e=a(n,r);t(e.pass,e)})))},noneOf:function(r){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return f(n.mapFirst(t,(function(n,t){t(a(n,r).pass,e())})))},oneOf:function(r){for(var e=[],u=1;u<arguments.length;u++)e[u-1]=arguments[u];var f=0;return e.some((function(t){if(a(t,r).pass&&f++,n.greaterThan(f,1))return!1})),t(o(f,1))}});

package/dist/cjs/n4s.development.js

@@ -8,12 +8,12 @@ var context = require('context');
 function endsWith(value, arg1) {
     return vestUtils.isStringValue(value) && vestUtils.isStringValue(arg1) && value.endsWith(arg1);
 }
-const doesNotEndWith = vestUtils.bindNot(endsWith);
+var doesNotEndWith = vestUtils.bindNot(endsWith);
 
 function equals(value, arg1) {
     return value === arg1;
 }
-const notEquals = vestUtils.bindNot(equals);
+var notEquals = vestUtils.bindNot(equals);
 
 function greaterThanOrEquals(value, gte) {
     return vestUtils.numberEquals(value, gte) || vestUtils.greaterThan(value, gte);
@@ -29,7 +29,7 @@ function inside(value, arg1) {
     }
     return false;
 }
-const notInside = vestUtils.bindNot(inside);
+var notInside = vestUtils.bindNot(inside);
 
 function lessThan(value, lt) {
     return vestUtils.isNumeric(value) && vestUtils.isNumeric(lt) && Number(value) < Number(lt);
@@ -42,19 +42,19 @@ function lessThanOrEquals(value, lte) {
 function isBetween(value, min, max) {
     return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
 }
-const isNotBetween = vestUtils.bindNot(isBetween);
+var isNotBetween = vestUtils.bindNot(isBetween);
 
 function isBlank(value) {
     return vestUtils.isNullish(value) || (vestUtils.isStringValue(value) && !value.trim());
 }
-const isNotBlank = vestUtils.bindNot(isBlank);
+var isNotBlank = vestUtils.bindNot(isBlank);
 
-const isNotBoolean = vestUtils.bindNot(vestUtils.isBoolean);
+var isNotBoolean = vestUtils.bindNot(vestUtils.isBoolean);
 
 /**
  * Validates that a given value is an even number
  */
-const isEven = (value) => {
+var isEven = function (value) {
     if (vestUtils.isNumeric(value)) {
         return value % 2 === 0;
     }
@@ -64,12 +64,12 @@ const isEven = (value) => {
 function isKeyOf(key, obj) {
     return key in obj;
 }
-const isNotKeyOf = vestUtils.bindNot(isKeyOf);
+var isNotKeyOf = vestUtils.bindNot(isKeyOf);
 
 function isNaN(value) {
     return Number.isNaN(value);
 }
-const isNotNaN = vestUtils.bindNot(isNaN);
+var isNotNaN = vestUtils.bindNot(isNaN);
 
 function isNegative(value) {
     return lessThan(value, 0);
@@ -78,37 +78,37 @@ function isNegative(value) {
 function isNumber(value) {
     return Boolean(typeof value === 'number');
 }
-const isNotNumber = vestUtils.bindNot(isNumber);
+var isNotNumber = vestUtils.bindNot(isNumber);
 
 /**
  * Validates that a given value is an odd number
  */
-const isOdd = (value) => {
+var isOdd = function (value) {
     if (vestUtils.isNumeric(value)) {
         return value % 2 !== 0;
     }
     return false;
 };
 
-const isNotString = vestUtils.bindNot(vestUtils.isStringValue);
+var isNotString = vestUtils.bindNot(vestUtils.isStringValue);
 
 function isTruthy(value) {
     return !!value;
 }
-const isFalsy = vestUtils.bindNot(isTruthy);
+var isFalsy = vestUtils.bindNot(isTruthy);
 
 function isValueOf(value, objectToCheck) {
     if (vestUtils.isNullish(objectToCheck)) {
         return false;
     }
-    for (const key in objectToCheck) {
+    for (var key in objectToCheck) {
         if (objectToCheck[key] === value) {
             return true;
         }
     }
     return false;
 }
-const isNotValueOf = vestUtils.bindNot(isValueOf);
+var isNotValueOf = vestUtils.bindNot(isValueOf);
 
 function longerThanOrEquals(value, arg1) {
     return greaterThanOrEquals(value.length, arg1);
@@ -123,7 +123,7 @@ function matches(value, regex) {
     }
     return false;
 }
-const notMatches = vestUtils.bindNot(matches);
+var notMatches = vestUtils.bindNot(matches);
 
 function condition(value, callback) {
     try {
@@ -145,102 +145,102 @@ function shorterThanOrEquals(value, arg1) {
 function startsWith(value, arg1) {
     return vestUtils.isStringValue(value) && vestUtils.isStringValue(arg1) && value.startsWith(arg1);
 }
-const doesNotStartWith = vestUtils.bindNot(startsWith);
+var doesNotStartWith = vestUtils.bindNot(startsWith);
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function
 function rules() {
     return {
-        condition,
-        doesNotEndWith,
-        doesNotStartWith,
-        endsWith,
-        equals,
+        condition: condition,
+        doesNotEndWith: doesNotEndWith,
+        doesNotStartWith: doesNotStartWith,
+        endsWith: endsWith,
+        equals: equals,
         greaterThan: vestUtils.greaterThan,
-        greaterThanOrEquals,
+        greaterThanOrEquals: greaterThanOrEquals,
         gt: vestUtils.greaterThan,
         gte: greaterThanOrEquals,
-        inside,
+        inside: inside,
         isArray: vestUtils.isArray,
-        isBetween,
-        isBlank,
+        isBetween: isBetween,
+        isBlank: isBlank,
         isBoolean: vestUtils.isBoolean,
         isEmpty: vestUtils.isEmpty,
-        isEven,
-        isFalsy,
-        isKeyOf,
-        isNaN,
-        isNegative,
+        isEven: isEven,
+        isFalsy: isFalsy,
+        isKeyOf: isKeyOf,
+        isNaN: isNaN,
+        isNegative: isNegative,
         isNotArray: vestUtils.isNotArray,
-        isNotBetween,
-        isNotBlank,
-        isNotBoolean,
+        isNotBetween: isNotBetween,
+        isNotBlank: isNotBlank,
+        isNotBoolean: isNotBoolean,
         isNotEmpty: vestUtils.isNotEmpty,
-        isNotKeyOf,
-        isNotNaN,
+        isNotKeyOf: isNotKeyOf,
+        isNotNaN: isNotNaN,
         isNotNull: vestUtils.isNotNull,
         isNotNullish: vestUtils.isNotNullish,
-        isNotNumber,
+        isNotNumber: isNotNumber,
         isNotNumeric: vestUtils.isNotNumeric,
-        isNotString,
+        isNotString: isNotString,
         isNotUndefined: vestUtils.isNotUndefined,
-        isNotValueOf,
+        isNotValueOf: isNotValueOf,
         isNull: vestUtils.isNull,
         isNullish: vestUtils.isNullish,
-        isNumber,
+        isNumber: isNumber,
         isNumeric: vestUtils.isNumeric,
-        isOdd,
+        isOdd: isOdd,
         isPositive: vestUtils.isPositive,
         isString: vestUtils.isStringValue,
-        isTruthy,
+        isTruthy: isTruthy,
         isUndefined: vestUtils.isUndefined,
-        isValueOf,
+        isValueOf: isValueOf,
         lengthEquals: vestUtils.lengthEquals,
         lengthNotEquals: vestUtils.lengthNotEquals,
-        lessThan,
-        lessThanOrEquals,
+        lessThan: lessThan,
+        lessThanOrEquals: lessThanOrEquals,
         longerThan: vestUtils.longerThan,
-        longerThanOrEquals,
+        longerThanOrEquals: longerThanOrEquals,
         lt: lessThan,
         lte: lessThanOrEquals,
-        matches,
-        notEquals,
-        notInside,
-        notMatches,
+        matches: matches,
+        notEquals: notEquals,
+        notInside: notInside,
+        notMatches: notMatches,
         numberEquals: vestUtils.numberEquals,
         numberNotEquals: vestUtils.numberNotEquals,
-        shorterThan,
-        shorterThanOrEquals,
-        startsWith,
+        shorterThan: shorterThan,
+        shorterThanOrEquals: shorterThanOrEquals,
+        startsWith: startsWith
     };
 }
 
-const baseRules = rules();
+var baseRules = rules();
 function getRule(ruleName) {
     return baseRules[ruleName];
 }
 
 function eachEnforceRule(action) {
-    for (const ruleName in baseRules) {
-        const ruleFn = getRule(ruleName);
+    for (var ruleName in baseRules) {
+        var ruleFn = getRule(ruleName);
         if (vestUtils.isFunction(ruleFn)) {
             action(ruleName, ruleFn);
         }
     }
 }
 
-const ctx = context.createCascade((ctxRef, parentContext) => {
-    const base = {
+var ctx = context.createCascade(function (ctxRef, parentContext) {
+    var base = {
         value: ctxRef.value,
-        meta: ctxRef.meta || {},
+        meta: ctxRef.meta || {}
     };
     if (!parentContext) {
         return vestUtils.assign(base, {
-            parent: emptyParent,
+            parent: emptyParent
         });
     }
     else if (ctxRef.set) {
         return vestUtils.assign(base, {
-            parent: () => stripContext(parentContext),
+            parent: function () { return stripContext(parentContext); }
         });
     }
     return parentContext;
@@ -252,13 +252,38 @@ function stripContext(ctx) {
     return {
         value: ctx.value,
         meta: ctx.meta,
-        parent: ctx.parent,
+        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 vestUtils.isFunction(Proxy);
@@ -269,7 +294,7 @@ function isProxySupported() {
 }
 
 function ruleReturn(pass, message) {
-    const output = { pass };
+    var output = { pass: pass };
     if (message) {
         output.message = message;
     }
@@ -285,13 +310,17 @@ function defaultToPassing(callback) {
 /**
  * Transform the result of a rule into a standard format
  */
-function transformResult(result, ruleName, value, ...args) {
+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 (vestUtils.isBoolean(result)) {
         return ruleReturn(result);
     }
-    return ruleReturn(result.pass, vestUtils.optionalFunctionValue(result.message, ruleName, value, ...args));
+    return ruleReturn(result.pass, vestUtils.optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
 }
 function validateResult(result) {
     // if result is boolean, or if result.pass is boolean
@@ -300,51 +329,55 @@ function validateResult(result) {
 
 // eslint-disable-next-line max-lines-per-function
 function enforceEager(value) {
-    const target = {
-        message,
+    var target = {
+        message: message
     };
-    let customMessage = undefined;
+    var customMessage = undefined;
     // 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((ruleName, ruleFn) => {
+        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).
-    const proxy = new Proxy(target, {
-        get: (_, key) => {
+    var proxy = new Proxy(target, {
+        get: function (_, key) {
             // On property access, we identify if it is a rule or not.
-            const rule = getRule(key);
+            var rule = getRule(key);
             // If it is a rule, we wrap it with `genRuleCall` that adds the base enforce behavior
             if (rule) {
                 return genRuleCall(proxy, rule, key);
             }
             return target[key];
-        },
+        }
     });
     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(...args) {
+        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
-            const transformedResult = ctx.run({ value }, () => {
-                return transformResult(rule(value, ...args), ruleName, value, ...args);
+            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));
             });
             function enforceMessage() {
                 if (!vestUtils.isNullish(customMessage))
                     return vestUtils.StringObject(customMessage);
                 if (vestUtils.isNullish(transformedResult.message)) {
-                    return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;
+                    return "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value));
                 }
                 return vestUtils.StringObject(transformedResult.message);
             }
@@ -362,33 +395,39 @@ function enforceEager(value) {
 
 // eslint-disable-next-line max-lines-per-function
 function genEnforceLazy(key) {
-    const registeredRules = [];
-    let lazyMessage;
+    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 (...args) => {
-            const rule = getRule(ruleName);
-            registeredRules.push((value) => transformResult(rule(value, ...args), ruleName, value, ...args));
-            let proxy = {
-                run: (value) => {
-                    return defaultToPassing(vestUtils.mapFirst(registeredRules, (rule, breakout) => {
+        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(vestUtils.mapFirst(registeredRules, function (rule, breakout) {
                         var _a;
-                        const res = ctx.run({ value }, () => rule(value));
+                        var res = ctx.run({ value: value }, function () { return rule(value); });
                         breakout(!res.pass, ruleReturn(!!res.pass, (_a = vestUtils.optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
                     }));
                 },
-                test: (value) => proxy.run(value).pass,
-                message: (message) => {
+                test: function (value) { return proxy.run(value).pass; },
+                message: function (message) {
                     if (message) {
                         lazyMessage = message;
                     }
                     return proxy;
-                },
+                }
             };
             if (!isProxySupported()) {
-                eachEnforceRule((ruleName) => {
+                eachEnforceRule(function (ruleName) {
                     proxy[ruleName] = addLazyRule(ruleName);
                 });
                 return proxy;
@@ -396,12 +435,12 @@ function genEnforceLazy(key) {
             // 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: (target, key) => {
+                get: function (target, key) {
                     if (getRule(key)) {
                         return addLazyRule(key);
                     }
                     return target[key]; // already has `run` and `test` on it
-                },
+                }
             });
             return proxy;
         };
@@ -435,16 +474,16 @@ function genEnforceLazy(key) {
  * while run will return an object with the validation result and an optional message created by the rule.
  */
 function genEnforce() {
-    const target = {
-        context: () => ctx.useX(),
-        extend: (customRules) => {
+    var target = {
+        context: function () { return ctx.useX(); },
+        extend: function (customRules) {
             vestUtils.assign(baseRules, customRules);
             handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
-        },
+        }
     };
     handleNoProxy();
     return new Proxy(vestUtils.assign(enforceEager, target), {
-        get: (target, key) => {
+        get: function (target, key) {
             if (key in target) {
                 return target[key];
             }
@@ -453,11 +492,11 @@ function genEnforce() {
             }
             // Only on the first rule access - start the chain of calls
             return genEnforceLazy(key);
-        },
+        }
     });
     function handleNoProxy() {
         if (!isProxySupported()) {
-            eachEnforceRule((ruleName) => {
+            eachEnforceRule(function (ruleName) {
                 // Only on the first rule access - start the chain of calls
                 target[ruleName] = genEnforceLazy(ruleName);
             });
@@ -465,7 +504,7 @@ function genEnforce() {
         }
     }
 }
-const enforce = genEnforce();
+var enforce = genEnforce();
 
 exports.ctx = ctx;
 exports.enforce = enforce;