vest 4.0.1 → 4.0.2

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

@@ -1,8 +1,7 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('n4s')) :
-  typeof define === 'function' && define.amd ? define(['n4s'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.n4s));
-}(this, (function (n4s) { 'use strict';
+(function (factory) {
+  typeof define === 'function' && define.amd ? define(factory) :
+  factory();
+}((function () { 'use strict';
 
   function mapFirst(array, callback) {
       var broke = false;
@@ -91,6 +90,626 @@
       }));
   }
 
+  var assign = Object.assign;
+
+  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);
+      };
+  }
+
+  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);
+
+  /**
+   * 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);
+
+  /**
+   * 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);
+          }
+      }
+  }
+
+  /**
+   * Throws a timed out error.
+   */
+  function throwError(devMessage, productionMessage) {
+      throw new Error(devMessage );
+  }
+
+  // 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;
+      }
+  }
+
+  /**
+   * 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);
+          }
+      });
+  }
+  var enforce = genEnforce();
+
   function noneOf(value) {
       var rules = [];
       for (var _i = 1; _i < arguments.length; _i++) {
@@ -104,14 +723,6 @@
       }));
   }
 
-  function lengthEquals(value, arg1) {
-      return value.length === Number(arg1);
-  }
-
-  function longerThan(value, arg1) {
-      return value.length > Number(arg1);
-  }
-
   var REQUIRED_COUNT = 1;
   function oneOf(value) {
       var rules = [];
@@ -131,6 +742,6 @@
       return ruleReturn(lengthEquals(passing, REQUIRED_COUNT));
   }
 
-  n4s.enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });
+  enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });
 
 })));

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

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