n4s 4.3.6 → 4.3.8-dev-9c596e

package/dist/cjs/compose.development.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var vestUtils = require('vest-utils');
 var n4s = require('n4s');
+var vestUtils = require('vest-utils');
 
 function ruleReturn(pass, message) {
-    var output = { pass: pass };
+    const output = { pass };
     if (message) {
         output.message = message;
     }
@@ -30,27 +30,23 @@ function runLazyRule(lazyRule, currentValue) {
 }
 
 /* eslint-disable max-lines-per-function */
-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);
+function compose(...composites) {
+    return vestUtils.assign((value) => {
+        const res = run(value);
         vestUtils.invariant(res.pass, vestUtils.StringObject(res.message));
     }, {
-        run: run,
-        test: function (value) { return run(value).pass; }
+        run,
+        test: (value) => run(value).pass,
     });
     function run(value) {
-        return n4s.ctx.run({ value: value }, function () {
-            return defaultToPassing(vestUtils.mapFirst(composites, function (composite, breakout) {
+        return n4s.ctx.run({ value }, () => {
+            return defaultToPassing(vestUtils.mapFirst(composites, (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.
                 */
-                var res = runLazyRule(composite, value);
+                const res = runLazyRule(composite, value);
                 breakout(!res.pass, res);
             }));
         });

package/dist/cjs/compose.production.js

@@ -1 +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 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)})))}))}};
+"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)})))))}};

package/dist/cjs/compounds.development.js

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

package/dist/cjs/compounds.production.js

@@ -1 +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))}});
+"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))}});

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