n4s 5.0.1 → 5.0.2

package/dist/umd/n4s.development.js

@@ -1,213 +1,156 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('context')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'context'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.n4s = {}, global.context));
-}(this, (function (exports, context) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vest-utils'), require('context')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vest-utils', 'context'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.n4s = {}, global["vest-utils"], global.context));
+})(this, (function (exports, vestUtils, context) { 'use strict';
 
-  var assign = Object.assign;
-
-  function isFunction(value) {
-      return typeof value === 'function';
-  }
-
-  function bindNot(fn) {
-      return function () {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments[_i];
-          }
-          return !fn.apply(void 0, args);
+  const ctx = context.createCascade((ctxRef, parentContext) => {
+      const base = {
+          value: ctxRef.value,
+          meta: ctxRef.meta || {},
+      };
+      if (!parentContext) {
+          return vestUtils.assign(base, {
+              parent: emptyParent,
+          });
+      }
+      else if (ctxRef.set) {
+          return vestUtils.assign(base, {
+              parent: () => stripContext(parentContext),
+          });
+      }
+      return parentContext;
+  });
+  function stripContext(ctx) {
+      return {
+          value: ctx.value,
+          meta: ctx.meta,
+          parent: ctx.parent,
       };
   }
-
-  function isNull(value) {
-      return value === null;
-  }
-  var isNotNull = bindNot(isNull);
-
-  function isUndefined(value) {
-      return value === undefined;
-  }
-  var isNotUndefined = bindNot(isUndefined);
-
-  function isNullish(value) {
-      return isNull(value) || isUndefined(value);
-  }
-  var isNotNullish = bindNot(isNullish);
-
-  function isStringValue(v) {
-      return String(v) === v;
+  function emptyParent() {
+      return null;
   }
 
   function endsWith(value, arg1) {
-      return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
+      return vestUtils.isStringValue(value) && vestUtils.isStringValue(arg1) && value.endsWith(arg1);
   }
-  var doesNotEndWith = bindNot(endsWith);
+  const doesNotEndWith = vestUtils.bindNot(endsWith);
 
   function equals(value, arg1) {
       return value === arg1;
   }
-  var notEquals = bindNot(equals);
-
-  function isNumeric(value) {
-      var str = String(value);
-      var num = Number(value);
-      var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
-      return Boolean(result);
-  }
-  var isNotNumeric = bindNot(isNumeric);
-
-  function greaterThan(value, gt) {
-      return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
-  }
+  const notEquals = vestUtils.bindNot(equals);
 
   function greaterThanOrEquals(value, gte) {
-      return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
+      return vestUtils.numberEquals(value, gte) || vestUtils.greaterThan(value, gte);
   }
 
-  // The module is named "isArrayValue" since it
-  // is conflicting with a nested npm dependency.
-  // We may need to revisit this in the future.
-  function isArray(value) {
-      return Boolean(Array.isArray(value));
-  }
-  var isNotArray = bindNot(isArray);
-
   function inside(value, arg1) {
-      if (isArray(arg1)) {
+      if (vestUtils.isArray(arg1)) {
           return arg1.indexOf(value) !== -1;
       }
       // both value and arg1 are strings
-      if (isStringValue(arg1) && isStringValue(value)) {
+      if (vestUtils.isStringValue(arg1) && vestUtils.isStringValue(value)) {
           return arg1.indexOf(value) !== -1;
       }
       return false;
   }
-  var notInside = bindNot(inside);
+  const notInside = vestUtils.bindNot(inside);
+
+  function lessThan(value, lt) {
+      return vestUtils.isNumeric(value) && vestUtils.isNumeric(lt) && Number(value) < Number(lt);
+  }
 
   function lessThanOrEquals(value, lte) {
-      return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
+      return vestUtils.numberEquals(value, lte) || lessThan(value, lte);
   }
 
   function isBetween(value, min, max) {
       return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
   }
-  var isNotBetween = bindNot(isBetween);
+  const isNotBetween = vestUtils.bindNot(isBetween);
 
   function isBlank(value) {
-      return isNullish(value) || (isStringValue(value) && !value.trim());
+      return vestUtils.isNullish(value) || (vestUtils.isStringValue(value) && !value.trim());
   }
-  var isNotBlank = bindNot(isBlank);
+  const isNotBlank = vestUtils.bindNot(isBlank);
 
-  function isBoolean(value) {
-      return !!value === value;
-  }
-
-  var isNotBoolean = bindNot(isBoolean);
-
-  /**
-   * A safe hasOwnProperty access
-   */
-  function hasOwnProperty(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-  }
-
-  function isNumber(value) {
-      return Boolean(typeof value === 'number');
-  }
-  var isNotNumber = bindNot(isNumber);
-
-  function lengthEquals(value, arg1) {
-      return value.length === Number(arg1);
-  }
-  var lengthNotEquals = bindNot(lengthEquals);
-
-  function isEmpty(value) {
-      if (!value) {
-          return true;
-      }
-      else if (isNumber(value)) {
-          return value === 0;
-      }
-      else if (hasOwnProperty(value, 'length')) {
-          return lengthEquals(value, 0);
-      }
-      else if (typeof value === 'object') {
-          return lengthEquals(Object.keys(value), 0);
-      }
-      return true;
-  }
-  var isNotEmpty = bindNot(isEmpty);
+  const isNotBoolean = vestUtils.bindNot(vestUtils.isBoolean);
 
   /**
    * Validates that a given value is an even number
    */
-  var isEven = function (value) {
-      if (isNumeric(value)) {
+  const isEven = (value) => {
+      if (vestUtils.isNumeric(value)) {
           return value % 2 === 0;
       }
       return false;
   };
 
-  function isNaN$1(value) {
+  function isKeyOf(key, obj) {
+      return key in obj;
+  }
+  const isNotKeyOf = vestUtils.bindNot(isKeyOf);
+
+  function isNaN(value) {
       return Number.isNaN(value);
   }
-  var isNotNaN = bindNot(isNaN$1);
+  const isNotNaN = vestUtils.bindNot(isNaN);
 
   function isNegative(value) {
-      if (isNumeric(value)) {
-          return Number(value) < 0;
-      }
-      return false;
+      return lessThan(value, 0);
   }
-  var isPositive = bindNot(isNegative);
+
+  function isNumber(value) {
+      return Boolean(typeof value === 'number');
+  }
+  const isNotNumber = vestUtils.bindNot(isNumber);
 
   /**
    * Validates that a given value is an odd number
    */
-  var isOdd = function (value) {
-      if (isNumeric(value)) {
+  const isOdd = (value) => {
+      if (vestUtils.isNumeric(value)) {
           return value % 2 !== 0;
       }
       return false;
   };
 
-  var isNotString = bindNot(isStringValue);
+  const isNotString = vestUtils.bindNot(vestUtils.isStringValue);
 
   function isTruthy(value) {
       return !!value;
   }
-  var isFalsy = bindNot(isTruthy);
-
-  function lessThan(value, lt) {
-      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-  }
+  const isFalsy = vestUtils.bindNot(isTruthy);
 
-  function longerThan(value, arg1) {
-      return value.length > Number(arg1);
+  function isValueOf(value, objectToCheck) {
+      if (vestUtils.isNullish(objectToCheck)) {
+          return false;
+      }
+      for (const key in objectToCheck) {
+          if (objectToCheck[key] === value) {
+              return true;
+          }
+      }
+      return false;
   }
+  const isNotValueOf = vestUtils.bindNot(isValueOf);
 
   function longerThanOrEquals(value, arg1) {
-      return value.length >= Number(arg1);
+      return greaterThanOrEquals(value.length, arg1);
   }
 
   function matches(value, regex) {
       if (regex instanceof RegExp) {
           return regex.test(value);
       }
-      else if (isStringValue(regex)) {
+      else if (vestUtils.isStringValue(regex)) {
           return new RegExp(regex).test(value);
       }
-      else {
-          return false;
-      }
-  }
-  var notMatches = bindNot(matches);
-
-  function numberEquals(value, eq) {
-      return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+      return false;
   }
-  var numberNotEquals = bindNot(numberEquals);
+  const notMatches = vestUtils.bindNot(matches);
 
   function condition(value, callback) {
       try {
@@ -219,182 +162,92 @@
   }
 
   function shorterThan(value, arg1) {
-      return value.length < Number(arg1);
+      return lessThan(value.length, arg1);
   }
 
   function shorterThanOrEquals(value, arg1) {
-      return value.length <= Number(arg1);
+      return lessThanOrEquals(value.length, arg1);
   }
 
   function startsWith(value, arg1) {
-      return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
+      return vestUtils.isStringValue(value) && vestUtils.isStringValue(arg1) && value.startsWith(arg1);
   }
-  var doesNotStartWith = 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,
-          greaterThan: greaterThan,
-          greaterThanOrEquals: greaterThanOrEquals,
-          gt: greaterThan,
+          condition,
+          doesNotEndWith,
+          doesNotStartWith,
+          endsWith,
+          equals,
+          greaterThan: vestUtils.greaterThan,
+          greaterThanOrEquals,
+          gt: vestUtils.greaterThan,
           gte: greaterThanOrEquals,
-          inside: inside,
-          isArray: isArray,
-          isBetween: isBetween,
-          isBlank: isBlank,
-          isBoolean: isBoolean,
-          isEmpty: isEmpty,
-          isEven: isEven,
-          isFalsy: isFalsy,
-          isNaN: isNaN$1,
-          isNegative: isNegative,
-          isNotArray: isNotArray,
-          isNotBetween: isNotBetween,
-          isNotBlank: isNotBlank,
-          isNotBoolean: isNotBoolean,
-          isNotEmpty: isNotEmpty,
-          isNotNaN: isNotNaN,
-          isNotNull: isNotNull,
-          isNotNullish: isNotNullish,
-          isNotNumber: isNotNumber,
-          isNotNumeric: isNotNumeric,
-          isNotString: isNotString,
-          isNotUndefined: isNotUndefined,
-          isNull: isNull,
-          isNullish: isNullish,
-          isNumber: isNumber,
-          isNumeric: isNumeric,
-          isOdd: isOdd,
-          isPositive: isPositive,
-          isString: isStringValue,
-          isTruthy: isTruthy,
-          isUndefined: isUndefined,
-          lengthEquals: lengthEquals,
-          lengthNotEquals: lengthNotEquals,
-          lessThan: lessThan,
-          lessThanOrEquals: lessThanOrEquals,
-          longerThan: longerThan,
-          longerThanOrEquals: longerThanOrEquals,
+          inside,
+          isArray: vestUtils.isArray,
+          isBetween,
+          isBlank,
+          isBoolean: vestUtils.isBoolean,
+          isEmpty: vestUtils.isEmpty,
+          isEven,
+          isFalsy,
+          isKeyOf,
+          isNaN,
+          isNegative,
+          isNotArray: vestUtils.isNotArray,
+          isNotBetween,
+          isNotBlank,
+          isNotBoolean,
+          isNotEmpty: vestUtils.isNotEmpty,
+          isNotKeyOf,
+          isNotNaN,
+          isNotNull: vestUtils.isNotNull,
+          isNotNullish: vestUtils.isNotNullish,
+          isNotNumber,
+          isNotNumeric: vestUtils.isNotNumeric,
+          isNotString,
+          isNotUndefined: vestUtils.isNotUndefined,
+          isNotValueOf,
+          isNull: vestUtils.isNull,
+          isNullish: vestUtils.isNullish,
+          isNumber,
+          isNumeric: vestUtils.isNumeric,
+          isOdd,
+          isPositive: vestUtils.isPositive,
+          isString: vestUtils.isStringValue,
+          isTruthy,
+          isUndefined: vestUtils.isUndefined,
+          isValueOf,
+          lengthEquals: vestUtils.lengthEquals,
+          lengthNotEquals: vestUtils.lengthNotEquals,
+          lessThan,
+          lessThanOrEquals,
+          longerThan: vestUtils.longerThan,
+          longerThanOrEquals,
           lt: lessThan,
           lte: lessThanOrEquals,
-          matches: matches,
-          notEquals: notEquals,
-          notInside: notInside,
-          notMatches: notMatches,
-          numberEquals: numberEquals,
-          numberNotEquals: numberNotEquals,
-          shorterThan: shorterThan,
-          shorterThanOrEquals: shorterThanOrEquals,
-          startsWith: startsWith
+          matches,
+          notEquals,
+          notInside,
+          notMatches,
+          numberEquals: vestUtils.numberEquals,
+          numberNotEquals: vestUtils.numberNotEquals,
+          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);
-          if (isFunction(ruleFn)) {
-              action(ruleName, ruleFn);
-          }
-      }
-  }
-
-  var ctx = context.createContext(function (ctxRef, parentContext) {
-      var base = {
-          value: ctxRef.value,
-          meta: ctxRef.meta || {}
-      };
-      if (!parentContext) {
-          return assign(base, {
-              parent: emptyParent
-          });
-      }
-      else if (ctxRef.set) {
-          return assign(base, {
-              parent: function () { return stripContext(parentContext); }
-          });
-      }
-      return parentContext;
-  });
-  function stripContext(ctx) {
-      if (!ctx) {
-          return ctx;
-      }
-      return {
-          value: ctx.value,
-          meta: ctx.meta,
-          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 || from);
-  }
-
-  function optionalFunctionValue(value) {
-      var args = [];
-      for (var _i = 1; _i < arguments.length; _i++) {
-          args[_i - 1] = arguments[_i];
-      }
-      return isFunction(value) ? value.apply(void 0, args) : value;
-  }
-
-  function defaultTo(callback, defaultValue) {
-      var _a;
-      return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
-  }
-
-  /**
-   * Throws a timed out error.
-   */
-  function throwError(devMessage, productionMessage) {
-      throw new Error(devMessage );
-  }
-
-  function isProxySupported() {
-      try {
-          return isFunction(Proxy);
-      }
-      catch (_a) {
-          return false;
-      }
-  }
-
   function ruleReturn(pass, message) {
-      var output = { pass: pass };
+      const output = { pass };
       if (message) {
           output.message = message;
       }
@@ -404,139 +257,112 @@
       return ruleReturn(true);
   }
   function defaultToPassing(callback) {
-      return defaultTo(callback, passing());
+      return vestUtils.defaultTo(callback, passing());
   }
 
   /**
    * 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 (isBoolean(result)) {
+      if (vestUtils.isBoolean(result)) {
           return ruleReturn(result);
       }
-      else {
-          return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
-      }
+      return ruleReturn(result.pass, vestUtils.optionalFunctionValue(result.message, ruleName, value, ...args));
   }
   function validateResult(result) {
       // if result is boolean, or if result.pass is boolean
-      if (isBoolean(result) || (result && isBoolean(result.pass))) {
-          return;
-      }
-      throwError('Incorrect return value for rule: ' + JSON.stringify(result));
+      vestUtils.invariant(vestUtils.isBoolean(result) || (result && vestUtils.isBoolean(result.pass)), 'Incorrect return value for rule: ' + JSON.stringify(result));
   }
 
+  // eslint-disable-next-line max-lines-per-function
   function enforceEager(value) {
-      var target = {};
-      if (!isProxySupported()) {
-          eachEnforceRule(function (ruleName, ruleFn) {
-              target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-          });
-          return target;
-      }
-      var proxy = new Proxy(target, {
-          get: function (_, ruleName) {
-              var rule = getRule(ruleName);
+      const target = {
+          message,
+      };
+      let customMessage = undefined;
+      // We create a proxy intercepting access to the target object (which is empty).
+      const proxy = new Proxy(target, {
+          get: (_, key) => {
+              // On property access, we identify if it is a rule or not.
+              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, ruleName);
+                  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];
-              }
-              var transformedResult = transformResult.apply(void 0, __spreadArray([ctx.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
-                  ruleName,
-                  value], args));
-              if (!transformedResult.pass) {
-                  if (isEmpty(transformedResult.message)) {
-                      throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
-                  }
-                  else {
-                      // Explicitly throw a string so that vest.test can pick it up as the validation error message
-                      throw transformedResult.message;
+          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
+              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/${ruleName} failed with ${JSON.stringify(value)}`;
                   }
+                  return vestUtils.StringObject(transformedResult.message);
               }
+              // On rule failure (the result is false), we either throw an error
+              // or throw a string value if the rule has a message defined in it.
+              vestUtils.invariant(transformedResult.pass, enforceMessage());
               return target;
           };
       }
-  }
-
-  function mapFirst(array, callback) {
-      var broke = false;
-      var breakoutValue = null;
-      for (var i = 0; i < array.length; i++) {
-          callback(array[i], breakout, i);
-          if (broke) {
-              return breakoutValue;
-          }
-      }
-      function breakout(value) {
-          broke = true;
-          breakoutValue = value;
+      function message(input) {
+          customMessage = input;
+          return proxy;
       }
   }
 
   // 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)), ruleName, value], args));
-              });
-              var proxy = {
-                  run: function (value) {
-                      return defaultToPassing(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); });
-                          if (!res.pass) {
-                              breakout(ruleReturn(!!res.pass, (_a = optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
-                          }
+                          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) {
-                      proxy[ruleName] = addLazyRule(ruleName);
-                  });
-                  return proxy;
-              }
               // 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;
           };
@@ -570,21 +396,14 @@
    * 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) {
-              assign(baseRules, customRules);
-          }
+      const target = {
+          context: () => ctx.useX(),
+          extend: (customRules) => {
+              vestUtils.assign(baseRules, customRules);
+          },
       };
-      if (!isProxySupported()) {
-          eachEnforceRule(function (ruleName) {
-              // Only on the first rule access - start the chain of calls
-              target[ruleName] = genEnforceLazy(ruleName);
-          });
-          return target;
-      }
-      return new Proxy(assign(enforceEager, target), {
-          get: function (target, key) {
+      return new Proxy(vestUtils.assign(enforceEager, target), {
+          get: (target, key) => {
               if (key in target) {
                   return target[key];
               }
@@ -593,14 +412,12 @@
               }
               // Only on the first rule access - start the chain of calls
               return genEnforceLazy(key);
-          }
+          },
       });
   }
-  var enforce = genEnforce();
+  const enforce = genEnforce();
 
   exports.ctx = ctx;
   exports.enforce = enforce;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
+}));