vest 4.0.1 → 4.0.2

package/dist/umd/enforce/compose.development.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('n4s')) :
-  typeof define === 'function' && define.amd ? define(['n4s'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.compose = factory(global.n4s));
-}(this, (function (n4s) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.compose = factory());
+}(this, (function () { 'use strict';
 
   function mapFirst(array, callback) {
       var broke = false;
@@ -43,6 +43,16 @@
       throw new Error(devMessage );
   }
 
+  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);
+      };
+  }
+
   /**
    * A safe hasOwnProperty access
    */
@@ -53,10 +63,12 @@
   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) {
@@ -73,6 +85,400 @@
       }
       return true;
   }
+  var isNotEmpty = bindNot(isEmpty);
+
+  var assign = Object.assign;
+
+  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 endsWith(value, arg1) {
+      return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
+  }
+  var doesNotEndWith = 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);
+  }
+
+  function greaterThanOrEquals(value, gte) {
+      return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(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)) {
+          return arg1.indexOf(value) !== -1;
+      }
+      // both value and arg1 are strings
+      if (isStringValue(arg1) && isStringValue(value)) {
+          return arg1.indexOf(value) !== -1;
+      }
+      return false;
+  }
+  var notInside = bindNot(inside);
+
+  function lessThanOrEquals(value, lte) {
+      return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
+  }
+
+  function isBetween(value, min, max) {
+      return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+  }
+  var isNotBetween = bindNot(isBetween);
+
+  function isBlank(value) {
+      return isNullish(value) || (isStringValue(value) && !value.trim());
+  }
+  var isNotBlank = bindNot(isBlank);
+
+  function isBoolean(value) {
+      return !!value === value;
+  }
+
+  var isNotBoolean = bindNot(isBoolean);
+
+  /**
+   * Validates that a given value is an even number
+   */
+  var isEven = function (value) {
+      if (isNumeric(value)) {
+          return value % 2 === 0;
+      }
+      return false;
+  };
+
+  function isKeyOf(key, obj) {
+      return key in obj;
+  }
+  var isNotKeyOf = bindNot(isKeyOf);
+
+  function isNaN$1(value) {
+      return Number.isNaN(value);
+  }
+  var isNotNaN = bindNot(isNaN$1);
+
+  function isNegative(value) {
+      if (isNumeric(value)) {
+          return Number(value) < 0;
+      }
+      return false;
+  }
+  var isPositive = bindNot(isNegative);
+
+  /**
+   * Validates that a given value is an odd number
+   */
+  var isOdd = function (value) {
+      if (isNumeric(value)) {
+          return value % 2 !== 0;
+      }
+      return false;
+  };
+
+  var isNotString = bindNot(isStringValue);
+
+  function isTruthy(value) {
+      return !!value;
+  }
+  var isFalsy = bindNot(isTruthy);
+
+  function isValueOf(value, objectToCheck) {
+      if (isNullish(objectToCheck)) {
+          return false;
+      }
+      for (var key in objectToCheck) {
+          if (objectToCheck[key] === value) {
+              return true;
+          }
+      }
+      return false;
+  }
+  var isNotValueOf = bindNot(isValueOf);
+
+  function lessThan(value, lt) {
+      return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+  }
+
+  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 (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);
+  }
+  var numberNotEquals = bindNot(numberEquals);
+
+  function condition(value, callback) {
+      try {
+          return callback(value);
+      }
+      catch (_a) {
+          return false;
+      }
+  }
+
+  function shorterThan(value, arg1) {
+      return value.length < Number(arg1);
+  }
+
+  function shorterThanOrEquals(value, arg1) {
+      return value.length <= Number(arg1);
+  }
+
+  function startsWith(value, arg1) {
+      return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
+  }
+  var doesNotStartWith = 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,
+          gte: greaterThanOrEquals,
+          inside: inside,
+          isArray: isArray,
+          isBetween: isBetween,
+          isBlank: isBlank,
+          isBoolean: isBoolean,
+          isEmpty: isEmpty,
+          isEven: isEven,
+          isFalsy: isFalsy,
+          isKeyOf: isKeyOf,
+          isNaN: isNaN$1,
+          isNegative: isNegative,
+          isNotArray: isNotArray,
+          isNotBetween: isNotBetween,
+          isNotBlank: isNotBlank,
+          isNotBoolean: isNotBoolean,
+          isNotEmpty: isNotEmpty,
+          isNotKeyOf: isNotKeyOf,
+          isNotNaN: isNotNaN,
+          isNotNull: isNotNull,
+          isNotNullish: isNotNullish,
+          isNotNumber: isNotNumber,
+          isNotNumeric: isNotNumeric,
+          isNotString: isNotString,
+          isNotUndefined: isNotUndefined,
+          isNotValueOf: isNotValueOf,
+          isNull: isNull,
+          isNullish: isNullish,
+          isNumber: isNumber,
+          isNumeric: isNumeric,
+          isOdd: isOdd,
+          isPositive: isPositive,
+          isString: isStringValue,
+          isTruthy: isTruthy,
+          isUndefined: isUndefined,
+          isValueOf: isValueOf,
+          lengthEquals: lengthEquals,
+          lengthNotEquals: lengthNotEquals,
+          lessThan: lessThan,
+          lessThanOrEquals: lessThanOrEquals,
+          longerThan: longerThan,
+          longerThanOrEquals: longerThanOrEquals,
+          lt: lessThan,
+          lte: lessThanOrEquals,
+          matches: matches,
+          notEquals: notEquals,
+          notInside: notInside,
+          notMatches: notMatches,
+          numberEquals: numberEquals,
+          numberNotEquals: numberNotEquals,
+          shorterThan: shorterThan,
+          shorterThanOrEquals: shorterThanOrEquals,
+          startsWith: startsWith
+      };
+  }
+
+  var 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);
+          }
+      }
+  }
+
+  // eslint-disable-next-line max-lines-per-function
+  function createContext(init) {
+      var storage = { ancestry: [] };
+      return {
+          bind: bind,
+          run: run,
+          use: use,
+          useX: useX
+      };
+      function useX(errorMessage) {
+          var _a;
+          return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
+      }
+      function run(ctxRef, fn) {
+          var _a;
+          var parentContext = use();
+          var out = assign({}, parentContext ? parentContext : {}, (_a = optionalFunctionValue(init, ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
+          var ctx = set(Object.freeze(out));
+          storage.ancestry.unshift(ctx);
+          var res = fn(ctx);
+          clear();
+          return res;
+      }
+      function bind(ctxRef, fn) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore - this one's pretty hard to get right
+          var returnedFn = function () {
+              var runTimeArgs = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                  runTimeArgs[_i] = arguments[_i];
+              }
+              return run(ctxRef, function () {
+                  return fn.apply(void 0, runTimeArgs);
+              });
+          };
+          return returnedFn;
+      }
+      function use() {
+          return storage.ctx;
+      }
+      function set(value) {
+          return (storage.ctx = value);
+      }
+      function clear() {
+          var _a;
+          storage.ancestry.shift();
+          set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
+      }
+  }
+
+  var ctx = 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 || Array.prototype.slice.call(from));
+  }
+
+  function isProxySupported() {
+      try {
+          return isFunction(Proxy);
+      }
+      catch (_a) {
+          return false;
+      }
+  }
 
   function ruleReturn(pass, message) {
       var output = { pass: pass };
@@ -91,6 +497,182 @@
       return 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];
+      }
+      validateResult(result);
+      // if result is boolean
+      if (isBoolean(result)) {
+          return ruleReturn(result);
+      }
+      else {
+          return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([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));
+  }
+
+  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);
+              if (rule) {
+                  return genRuleCall(proxy, rule, ruleName);
+              }
+          }
+      });
+      return proxy;
+      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 target;
+          };
+      }
+  }
+
+  // eslint-disable-next-line max-lines-per-function
+  function genEnforceLazy(key) {
+      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 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) {
+                          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));
+                          }
+                      }));
+                  },
+                  test: function (value) { return proxy.run(value).pass; },
+                  message: function (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) {
+                      if (getRule(key)) {
+                          return addLazyRule(key);
+                      }
+                      return target[key]; // already has `run` and `test` on it
+                  }
+              });
+              return proxy;
+          };
+      }
+  }
+
+  /**
+   * Enforce is quite complicated, I want to explain it in detail.
+   * It is dynamic in nature, so a lot of proxy objects are involved.
+   *
+   * Enforce has two main interfaces
+   * 1. eager
+   * 2. lazy
+   *
+   * The eager interface is the most commonly used, and the easier to understand.
+   * It throws an error when a rule is not satisfied.
+   * The eager interface is declared in enforceEager.ts and it is quite simple to understand.
+   * enforce is called with a value, and the return value is a proxy object that points back to all the rules.
+   * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same
+   * proxy object is returned. Otherwise, an error is thrown.
+   *
+   * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.
+   * Rather than calling enforce directly, the lazy interface has all the rules as "methods" (only by proxy).
+   * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls
+   * and the parameters passed to them. None of the rules are called yet.
+   * The rules are only invoked in sequence once either of these chained functions are called:
+   * 1. test(value)
+   * 2. run(value)
+   *
+   * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,
+   * 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);
+          }
+      };
+      if (!isProxySupported()) {
+          eachEnforceRule(function (ruleName) {
+              // Only on the first rule access - start the chain of calls
+              target[ruleName] = genEnforceLazy(ruleName);
+          });
+          return assign(enforceEager, target);
+      }
+      return new Proxy(assign(enforceEager, target), {
+          get: function (target, key) {
+              if (key in target) {
+                  return target[key];
+              }
+              if (!getRule(key)) {
+                  return;
+              }
+              // Only on the first rule access - start the chain of calls
+              return genEnforceLazy(key);
+          }
+      });
+  }
+  genEnforce();
+
   function runLazyRule(lazyRule, currentValue) {
       try {
           return lazyRule.run(currentValue);
@@ -122,7 +704,7 @@
           test: function (value) { return run(value).pass; }
       });
       function run(value) {
-          return n4s.ctx.run({ value: value }, function () {
+          return ctx.run({ value: value }, function () {
               return defaultToPassing(mapFirst(composites, function (composite, breakout) {
                   /* HACK: Just a small white lie. ~~HELP WANTED~~.
                      The ideal is that instead of `TLazyRuleRunners` We would simply use `TLazy` to begin with.

package/dist/umd/enforce/compose.production.js

@@ -1 +1 @@
-"use strict";!function(n,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("n4s")):"function"==typeof define&&define.amd?define(["n4s"],e):(n="undefined"!=typeof globalThis?globalThis:n||self).compose=e(n.n4s)}(this,(function(n){function e(n,e){function t(n){r=!0,o=n}for(var r=!1,o=null,u=0;u<n.length;u++)if(e(n[u],t,u),r)return o}function t(n,e){var t;return null!==(t=function(n){for(var e=[],t=1;t<arguments.length;t++)e[t-1]=arguments[t];return"function"==typeof n?n.apply(void 0,e):n}(n))&&void 0!==t?t:e}function r(n){if(n){if("number"==typeof n)return 0===n;if(Object.prototype.hasOwnProperty.call(n,"length"))return n.length===Number(0);if("object"==typeof n)return Object.keys(n).length===Number(0)}return!0}function o(n,e){return n={pass:n},e&&(n.message=e),n}return function(){function u(r){return n.ctx.run({value:r},(function(){return t(e(f,(function(n,e){try{var t=n.run(r)}catch(n){t=o(!1)}t.pass||e(t)})),o(!0))}))}for(var f=[],i=0;i<arguments.length;i++)f[i]=arguments[i];return Object.assign((function(n){if(!(n=u(n)).pass){if(r(n.message))throw Error(t(void 0,void 0));throw n.message}}),{run:u,test:function(n){return u(n).pass}})}}));
+"use strict";!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(n="undefined"!=typeof globalThis?globalThis:n||self).compose=t()}(this,(function(){function n(n,t){function r(n){e=!0,u=n}for(var e=!1,u=null,i=0;i<n.length;i++)if(t(n[i],r,i),e)return u}function t(n){return"function"==typeof n}function r(n){for(var r=[],e=1;e<arguments.length;e++)r[e-1]=arguments[e];return t(n)?n.apply(void 0,r):n}function e(n,t){var e;return null!==(e=r(n))&&void 0!==e?e:t}function u(n,t){throw Error(e(t,n))}function i(n){return function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return!n.apply(void 0,t)}}function o(n){return"number"==typeof n}function s(n,t){return n.length===Number(t)}function f(n){if(n){if(o(n))return 0===n;if(Object.prototype.hasOwnProperty.call(n,"length"))return s(n,0);if("object"==typeof n)return s(Object.keys(n),0)}return!0}function a(n){return null===n}function c(n){return void 0===n}function l(n){return null===n||c(n)}function N(n){return String(n)===n}function h(n,t){return N(n)&&N(t)&&n.endsWith(t)}function p(n,t){return n===t}function v(n){var t=Number(n);return!(isNaN(parseFloat(String(n)))||isNaN(Number(n))||!isFinite(t))}function g(n,t){return v(n)&&v(t)&&Number(n)>Number(t)}function m(n,t){return v(n)&&v(t)&&Number(n)>=Number(t)}function d(n){return!!Array.isArray(n)}function y(n,t){return!!(d(t)||N(t)&&N(n))&&-1!==t.indexOf(n)}function b(n,t){return v(n)&&v(t)&&Number(n)<=Number(t)}function O(n,t,r){return m(n,t)&&b(n,r)}function x(n){return l(n)||N(n)&&!n.trim()}function E(n){return!!n===n}function w(n,t){return n in t}function T(n){return Number.isNaN(n)}function q(n){return!!v(n)&&0>Number(n)}function j(n){return!!n}function S(n,t){if(l(t))return!1;for(var r in t)if(t[r]===n)return!0;return!1}function A(n,t){return v(n)&&v(t)&&Number(n)<Number(t)}function B(n,t){return t instanceof RegExp?t.test(n):!!N(t)&&new RegExp(t).test(n)}function P(n,t){return v(n)&&v(t)&&Number(n)===Number(t)}function W(n,t){return N(n)&&N(t)&&n.startsWith(t)}function k(n){for(var r in Nn){var e=Nn[r];t(e)&&n(r,e)}}function F(){return null}function I(n,t,r){if(r||2===arguments.length)for(var e,u=0,i=t.length;u<i;u++)!e&&u in t||(e||(e=Array.prototype.slice.call(t,0,u)),e[u]=t[u]);return n.concat(e||Array.prototype.slice.call(t))}function J(){try{return t(Proxy)}catch(n){return!1}}function K(n,t){return n={pass:n},t&&(n.message=t),n}function R(n,t,e){for(var i=[],o=3;o<arguments.length;o++)i[o-3]=arguments[o];return E(n)||n&&E(n.pass)||u("Incorrect return value for rule: "+JSON.stringify(n)),E(n)?K(n):K(n.pass,r.apply(void 0,I([n.message,t,e],i)))}function U(n){function t(t,r,e){return function(){for(var i=[],o=0;o<arguments.length;o++)i[o]=arguments[o];if(!(o=R.apply(void 0,I([hn.run({value:n},(function(){return r.apply(void 0,I([n],i))})),e,n],i))).pass){if(!f(o.message))throw o.message;u("enforce/"+e+" failed with "+JSON.stringify(n))}return t}}var r={};if(!J())return k((function(n,e){r[n]=t(r,e,n)})),r;var e=new Proxy(r,{get:function(n,r){if(n=Nn[r])return t(e,n,r)}});return e}function V(t){var u,i=[];return function t(o){return function(){for(var s=[],f=0;f<arguments.length;f++)s[f]=arguments[f];var a=Nn[o];i.push((function(n){return R.apply(void 0,I([a.apply(void 0,I([n],s)),o,n],s))}));var c={run:function(t){return e(n(i,(function(n,e){var i,o=hn.run({value:t},(function(){return n(t)}));o.pass||e(K(!!o.pass,null!==(i=r(u,t,o.message))&&void 0!==i?i:o.message))})),K(!0))},test:function(n){return c.run(n).pass},message:function(n){return n&&(u=n),c}};return J()?c=new Proxy(c,{get:function(n,r){return Nn[r]?t(r):n[r]}}):(k((function(n){c[n]=t(n)})),c)}}(t)}var X,z=i(o),C=i(s),M=i(f),D=Object.assign,G=i(a),H=i(c),L=i(l),Q=i(h),Y=i(p),Z=i(v),$=i(d),_=i(y),nn=i(O),tn=i(x),rn=i(E),en=i(w),un=i(T),on=i(q),sn=i(N),fn=i(j),an=i(S),cn=i(B),ln=i(P),Nn={condition:function(n,t){try{return t(n)}catch(n){return!1}},doesNotEndWith:Q,doesNotStartWith:i(W),endsWith:h,equals:p,greaterThan:g,greaterThanOrEquals:m,gt:g,gte:m,inside:y,isArray:d,isBetween:O,isBlank:x,isBoolean:E,isEmpty:f,isEven:function(n){return!!v(n)&&0==n%2},isFalsy:fn,isKeyOf:w,isNaN:T,isNegative:q,isNotArray:$,isNotBetween:nn,isNotBlank:tn,isNotBoolean:rn,isNotEmpty:M,isNotKeyOf:en,isNotNaN:un,isNotNull:G,isNotNullish:L,isNotNumber:z,isNotNumeric:Z,isNotString:sn,isNotUndefined:H,isNotValueOf:an,isNull:a,isNullish:l,isNumber:o,isNumeric:v,isOdd:function(n){return!!v(n)&&0!=n%2},isPositive:on,isString:N,isTruthy:j,isUndefined:c,isValueOf:S,lengthEquals:s,lengthNotEquals:C,lessThan:A,lessThanOrEquals:b,longerThan:function(n,t){return n.length>Number(t)},longerThanOrEquals:function(n,t){return n.length>=Number(t)},lt:A,lte:b,matches:B,notEquals:Y,notInside:_,notMatches:cn,numberEquals:P,numberNotEquals:ln,shorterThan:function(n,t){return n.length<Number(t)},shorterThanOrEquals:function(n,t){return n.length<=Number(t)},startsWith:W},hn=function(n){function t(t,e){var u,s,f=i();return t=D({},f||{},null!==(u=r(n,t,f))&&void 0!==u?u:t),u=o.ctx=Object.freeze(t),o.ancestry.unshift(u),e=e(u),o.ancestry.shift(),o.ctx=null!==(s=o.ancestry[0])&&void 0!==s?s:null,e}function i(){return o.ctx}var o={ancestry:[]};return{bind:function(n,r){return function(){for(var e=[],u=0;u<arguments.length;u++)e[u]=arguments[u];return t(n,(function(){return r.apply(void 0,e)}))}},run:t,use:i,useX:function(n){var t;return null!==(t=o.ctx)&&void 0!==t?t:u(e(n,"Context was used after it was closed"))}}}((function(n,t){var r={value:n.value,meta:n.meta||{}};return t?n.set?D(r,{parent:function(){return t?{value:t.value,meta:t.meta,parent:t.parent}:t}}):t:D(r,{parent:F})}));return X={context:function(){return hn.useX()},extend:function(n){D(Nn,n)}},J()?new Proxy(D(U,X),{get:function(n,t){return t in n?n[t]:Nn[t]?V(t):void 0}}):(k((function(n){X[n]=V(n)})),D(U,X)),function(){function t(t){return hn.run({value:t},(function(){return e(n(r,(function(n,r){try{var e=n.run(t)}catch(n){e=K(!1)}e.pass||r(e)})),K(!0))}))}for(var r=[],i=0;i<arguments.length;i++)r[i]=arguments[i];return Object.assign((function(n){if(!(n=t(n)).pass){if(!f(n.message))throw n.message;u()}}),{run:t,test:function(n){return t(n).pass}})}}));