n4s 5.0.0 → 5.0.2

package/dist/es/n4s.development.js

@@ -1,15 +1,43 @@
-import { bindNot, isStringValue, numberEquals, greaterThan, isArray, isNumeric, isNullish, isBoolean, isEmpty, isNotArray, isNotEmpty, isNotNull, isNotNullish, isNotNumeric, isNotUndefined, isNull, isPositive, isUndefined, lengthEquals, lengthNotEquals, longerThan, numberNotEquals, isFunction, assign, defaultTo, optionalFunctionValue, invariant, StringObject, mapFirst } from 'vest-utils';
+import { assign, bindNot, isStringValue, numberEquals, greaterThan, isArray, isNumeric, isNullish, isBoolean, isEmpty, isNotArray, isNotEmpty, isNotNull, isNotNullish, isNotNumeric, isNotUndefined, isNull, isPositive, isUndefined, lengthEquals, lengthNotEquals, longerThan, numberNotEquals, defaultTo, optionalFunctionValue, invariant, StringObject, mapFirst } from 'vest-utils';
 import { createCascade } from 'context';
 
+const ctx = createCascade((ctxRef, parentContext) => {
+    const base = {
+        value: ctxRef.value,
+        meta: ctxRef.meta || {},
+    };
+    if (!parentContext) {
+        return assign(base, {
+            parent: emptyParent,
+        });
+    }
+    else if (ctxRef.set) {
+        return assign(base, {
+            parent: () => stripContext(parentContext),
+        });
+    }
+    return parentContext;
+});
+function stripContext(ctx) {
+    return {
+        value: ctx.value,
+        meta: ctx.meta,
+        parent: ctx.parent,
+    };
+}
+function emptyParent() {
+    return null;
+}
+
 function endsWith(value, arg1) {
     return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
 }
-var doesNotEndWith = bindNot(endsWith);
+const doesNotEndWith = bindNot(endsWith);
 
 function equals(value, arg1) {
     return value === arg1;
 }
-var notEquals = bindNot(equals);
+const notEquals = bindNot(equals);
 
 function greaterThanOrEquals(value, gte) {
     return numberEquals(value, gte) || greaterThan(value, gte);
@@ -25,7 +53,7 @@ function inside(value, arg1) {
     }
     return false;
 }
-var notInside = bindNot(inside);
+const notInside = bindNot(inside);
 
 function lessThan(value, lt) {
     return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
@@ -38,19 +66,19 @@ function lessThanOrEquals(value, lte) {
 function isBetween(value, min, max) {
     return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
 }
-var isNotBetween = bindNot(isBetween);
+const isNotBetween = bindNot(isBetween);
 
 function isBlank(value) {
     return isNullish(value) || (isStringValue(value) && !value.trim());
 }
-var isNotBlank = bindNot(isBlank);
+const isNotBlank = bindNot(isBlank);
 
-var isNotBoolean = bindNot(isBoolean);
+const isNotBoolean = bindNot(isBoolean);
 
 /**
  * Validates that a given value is an even number
  */
-var isEven = function (value) {
+const isEven = (value) => {
     if (isNumeric(value)) {
         return value % 2 === 0;
     }
@@ -60,12 +88,12 @@ var isEven = function (value) {
 function isKeyOf(key, obj) {
     return key in obj;
 }
-var isNotKeyOf = bindNot(isKeyOf);
+const isNotKeyOf = bindNot(isKeyOf);
 
 function isNaN(value) {
     return Number.isNaN(value);
 }
-var isNotNaN = bindNot(isNaN);
+const isNotNaN = bindNot(isNaN);
 
 function isNegative(value) {
     return lessThan(value, 0);
@@ -74,37 +102,37 @@ function isNegative(value) {
 function isNumber(value) {
     return Boolean(typeof value === 'number');
 }
-var isNotNumber = bindNot(isNumber);
+const isNotNumber = bindNot(isNumber);
 
 /**
  * Validates that a given value is an odd number
  */
-var isOdd = function (value) {
+const isOdd = (value) => {
     if (isNumeric(value)) {
         return value % 2 !== 0;
     }
     return false;
 };
 
-var isNotString = bindNot(isStringValue);
+const isNotString = bindNot(isStringValue);
 
 function isTruthy(value) {
     return !!value;
 }
-var isFalsy = bindNot(isTruthy);
+const isFalsy = bindNot(isTruthy);
 
 function isValueOf(value, objectToCheck) {
     if (isNullish(objectToCheck)) {
         return false;
     }
-    for (var key in objectToCheck) {
+    for (const key in objectToCheck) {
         if (objectToCheck[key] === value) {
             return true;
         }
     }
     return false;
 }
-var isNotValueOf = bindNot(isValueOf);
+const isNotValueOf = bindNot(isValueOf);
 
 function longerThanOrEquals(value, arg1) {
     return greaterThanOrEquals(value.length, arg1);
@@ -117,11 +145,9 @@ function matches(value, regex) {
     else if (isStringValue(regex)) {
         return new RegExp(regex).test(value);
     }
-    else {
-        return false;
-    }
+    return false;
 }
-var notMatches = bindNot(matches);
+const notMatches = bindNot(matches);
 
 function condition(value, callback) {
     try {
@@ -143,156 +169,82 @@ function shorterThanOrEquals(value, arg1) {
 function startsWith(value, arg1) {
     return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
 }
-var doesNotStartWith = bindNot(startsWith);
+const 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,
+        condition,
+        doesNotEndWith,
+        doesNotStartWith,
+        endsWith,
+        equals,
+        greaterThan,
+        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,
-        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,
+        inside,
+        isArray,
+        isBetween,
+        isBlank,
+        isBoolean,
+        isEmpty,
+        isEven,
+        isFalsy,
+        isKeyOf,
+        isNaN,
+        isNegative,
+        isNotArray,
+        isNotBetween,
+        isNotBlank,
+        isNotBoolean,
+        isNotEmpty,
+        isNotKeyOf,
+        isNotNaN,
+        isNotNull,
+        isNotNullish,
+        isNotNumber,
+        isNotNumeric,
+        isNotString,
+        isNotUndefined,
+        isNotValueOf,
+        isNull,
+        isNullish,
+        isNumber,
+        isNumeric,
+        isOdd,
+        isPositive,
         isString: isStringValue,
-        isTruthy: isTruthy,
-        isUndefined: isUndefined,
-        isValueOf: isValueOf,
-        lengthEquals: lengthEquals,
-        lengthNotEquals: lengthNotEquals,
-        lessThan: lessThan,
-        lessThanOrEquals: lessThanOrEquals,
-        longerThan: longerThan,
-        longerThanOrEquals: longerThanOrEquals,
+        isTruthy,
+        isUndefined,
+        isValueOf,
+        lengthEquals,
+        lengthNotEquals,
+        lessThan,
+        lessThanOrEquals,
+        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,
+        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 = createCascade(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 };
+    const output = { pass };
     if (message) {
         output.message = message;
     }
@@ -308,124 +260,106 @@ 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 (isBoolean(result)) {
         return ruleReturn(result);
     }
-    else {
-        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
-    }
+    return ruleReturn(result.pass, optionalFunctionValue(result.message, ruleName, value, ...args));
 }
 function validateResult(result) {
     // if result is boolean, or if result.pass is boolean
     invariant(isBoolean(result) || (result && isBoolean(result.pass)), 'Incorrect return value for rule: ' + JSON.stringify(result));
 }
 
+// eslint-disable-next-line max-lines-per-function
 function enforceEager(value) {
-    var target = {};
-    // 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) {
-            // We then wrap the rule with `genRuleCall` that adds the base enforce behavior
-            target[ruleName] = genRuleCall(target, ruleFn, ruleName);
-        });
-        return target;
-    }
+    const target = {
+        message,
+    };
+    let customMessage = undefined;
     // We create a proxy intercepting access to the target object (which is empty).
-    var proxy = new Proxy(target, {
-        get: function (_, ruleName) {
+    const proxy = new Proxy(target, {
+        get: (_, key) => {
             // On property access, we identify if it is a rule or not.
-            var rule = getRule(ruleName);
+            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];
-            }
+        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 (!isNullish(customMessage))
+                    return StringObject(customMessage);
+                if (isNullish(transformedResult.message)) {
+                    return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;
+                }
+                return 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.
-            invariant(transformedResult.pass, isNullish(transformedResult.message)
-                ? "enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value))
-                : StringObject(transformedResult.message));
+            invariant(transformedResult.pass, enforceMessage());
             return target;
         };
     }
+    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, false)), ruleName, value], args, false));
-            });
-            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(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 = 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;
         };
@@ -459,16 +393,14 @@ 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) => {
             assign(baseRules, customRules);
-            handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
-        }
+        },
     };
-    handleNoProxy();
     return new Proxy(assign(enforceEager, target), {
-        get: function (target, key) {
+        get: (target, key) => {
             if (key in target) {
                 return target[key];
             }
@@ -477,18 +409,9 @@ function genEnforce() {
             }
             // Only on the first rule access - start the chain of calls
             return genEnforceLazy(key);
-        }
+        },
     });
-    function handleNoProxy() {
-        if (!isProxySupported()) {
-            eachEnforceRule(function (ruleName) {
-                // Only on the first rule access - start the chain of calls
-                target[ruleName] = genEnforceLazy(ruleName);
-            });
-            return assign(enforceEager, target);
-        }
-    }
 }
-var enforce = genEnforce();
+const enforce = genEnforce();
 
 export { ctx, enforce };

package/dist/es/n4s.production.js

@@ -1 +1 @@
-import{createCascade as n}from"context";import{bindNot as t,isStringValue as r,numberEquals as e,greaterThan as u,isArray as i,isNumeric as o,isNullish as a,isBoolean as s,isEmpty as f,isNotArray as c,isNotEmpty as l,isNotNull as v,isNotNullish as N,isNotNumeric as h,isNotUndefined as p,isNull as g,isPositive as m,isUndefined as y,lengthEquals as d,lengthNotEquals as E,longerThan as x,numberNotEquals as O,isFunction as q,assign as T,defaultTo as b,optionalFunctionValue as w,invariant as B,StringObject as W,mapFirst as P}from"vest-utils";function S(n,t){return r(n)&&r(t)&&n.endsWith(t)}var A=t(S);function k(n,t){return n===t}var I=t(k);function J(n,t){return e(n,t)||u(n,t)}function K(n,t){return!!(i(t)||r(t)&&r(n))&&-1!==t.indexOf(n)}var R=t(K);function U(n,t){return o(n)&&o(t)&&Number(n)<Number(t)}function V(n,t){return e(n,t)||U(n,t)}function F(n,t,r){return J(n,t)&&V(n,r)}var M=t(F);function X(n){return a(n)||r(n)&&!n.trim()}var j=t(X),z=t(s);function C(n,t){return n in t}var D=t(C);function G(n){return Number.isNaN(n)}var H=t(G);function L(n){return"number"==typeof n}var Q=t(L),Y=t(r);function Z(n){return!!n}var $=t(Z);function _(n,t){if(a(t))return!1;for(var r in t)if(t[r]===n)return!0;return!1}var nn=t(_);function tn(n,t){return t instanceof RegExp?t.test(n):!!r(t)&&new RegExp(t).test(n)}var rn=t(tn);function en(n,t){return r(n)&&r(t)&&n.startsWith(t)}var un={condition:function(n,t){try{return t(n)}catch(n){return!1}},doesNotEndWith:A,doesNotStartWith:t(en),endsWith:S,equals:k,greaterThan:u,greaterThanOrEquals:J,gt:u,gte:J,inside:K,isArray:i,isBetween:F,isBlank:X,isBoolean:s,isEmpty:f,isEven:function(n){return!!o(n)&&0==n%2},isFalsy:$,isKeyOf:C,isNaN:G,isNegative:function(n){return U(n,0)},isNotArray:c,isNotBetween:M,isNotBlank:j,isNotBoolean:z,isNotEmpty:l,isNotKeyOf:D,isNotNaN:H,isNotNull:v,isNotNullish:N,isNotNumber:Q,isNotNumeric:h,isNotString:Y,isNotUndefined:p,isNotValueOf:nn,isNull:g,isNullish:a,isNumber:L,isNumeric:o,isOdd:function(n){return!!o(n)&&0!=n%2},isPositive:m,isString:r,isTruthy:Z,isUndefined:y,isValueOf:_,lengthEquals:d,lengthNotEquals:E,lessThan:U,lessThanOrEquals:V,longerThan:x,longerThanOrEquals:function(n,t){return J(n.length,t)},lt:U,lte:V,matches:tn,notEquals:I,notInside:R,notMatches:rn,numberEquals:e,numberNotEquals:O,shorterThan:function(n,t){return U(n.length,t)},shorterThanOrEquals:function(n,t){return V(n.length,t)},startsWith:en};function on(n){for(var t in un){var r=un[t];q(r)&&n(t,r)}}var an=n((function(n,t){var r={value:n.value,meta:n.meta||{}};return t?n.set?T(r,{parent:function(){return t?{value:t.value,meta:t.meta,parent:t.parent}:t}}):t:T(r,{parent:sn})}));function sn(){return null}function fn(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 cn(){try{return q(Proxy)}catch(n){return!1}}function ln(n,t){return n={pass:n},t&&(n.message=t),n}function vn(n,t,r){for(var e=[],u=3;u<arguments.length;u++)e[u-3]=arguments[u];return B(s(n)||n&&s(n.pass),"Incorrect return value for rule: "+JSON.stringify(n)),s(n)?ln(n):ln(n.pass,w.apply(void 0,fn([n.message,t,r],e,!1)))}function Nn(n){function t(t,r,e){return function(){for(var u=[],i=0;i<arguments.length;i++)u[i]=arguments[i];return i=an.run({value:n},(function(){return vn.apply(void 0,fn([r.apply(void 0,fn([n],u,!1)),e,n],u,!1))})),B(i.pass,a(i.message)?"enforce/".concat(e," failed with ").concat(JSON.stringify(n)):W(i.message)),t}}var r={};if(!cn())return on((function(n,e){r[n]=t(r,e,n)})),r;var e=new Proxy(r,{get:function(n,r){if(n=un[r])return t(e,n,r)}});return e}function hn(n){var t,r=[];return function n(e){return function(){for(var u=[],i=0;i<arguments.length;i++)u[i]=arguments[i];var o=un[e];r.push((function(n){return vn.apply(void 0,fn([o.apply(void 0,fn([n],u,!1)),e,n],u,!1))}));var a={run:function(n){return b(P(r,(function(r,e){var u,i=an.run({value:n},(function(){return r(n)}));e(!i.pass,ln(!!i.pass,null!==(u=w(t,n,i.message))&&void 0!==u?u:i.message))})),ln(!0))},test:function(n){return a.run(n).pass},message:function(n){return n&&(t=n),a}};return cn()?a=new Proxy(a,{get:function(t,r){return un[r]?n(r):t[r]}}):(on((function(t){a[t]=n(t)})),a)}}(n)}var pn=function(){function n(){if(!cn())return on((function(n){t[n]=hn(n)})),T(Nn,t)}var t={context:function(){return an.useX()},extend:function(t){T(un,t),n()}};return n(),new Proxy(T(Nn,t),{get:function(n,t){return t in n?n[t]:un[t]?hn(t):void 0}})}();export{an as ctx,pn as enforce};
+import{assign as n,bindNot as t,isStringValue as e,numberEquals as r,greaterThan as s,isArray as u,isNumeric as o,isNullish as i,isBoolean as c,isEmpty as a,isNotArray as f,isNotEmpty as l,isNotNull as N,isNotNullish as m,isNotNumeric as g,isNotUndefined as h,isNull as p,isPositive as d,isUndefined as y,lengthEquals as E,lengthNotEquals as v,longerThan as O,numberNotEquals as q,defaultTo as x,optionalFunctionValue as T,invariant as b,StringObject as w,mapFirst as B}from"vest-utils";import{createCascade as W}from"context";const S=W(((t,e)=>{const r={value:t.value,meta:t.meta||{}};return e?t.set?n(r,{parent:()=>function(n){return{value:n.value,meta:n.meta,parent:n.parent}}(e)}):e:n(r,{parent:P})}));function P(){return null}function k(n,t){return e(n)&&e(t)&&n.endsWith(t)}const A=t(k);function I(n,t){return n===t}const J=t(I);function K(n,t){return r(n,t)||s(n,t)}function R(n,t){return(u(t)||!(!e(t)||!e(n)))&&-1!==t.indexOf(n)}const U=t(R);function V(n,t){return o(n)&&o(t)&&Number(n)<Number(t)}function $(n,t){return r(n,t)||V(n,t)}function F(n,t,e){return K(n,t)&&$(n,e)}const M=t(F);function X(n){return i(n)||e(n)&&!n.trim()}const j=t(X),z=t(c),C=n=>!!o(n)&&n%2==0;function D(n,t){return n in t}const G=t(D);function H(n){return Number.isNaN(n)}const L=t(H);function Q(n){return V(n,0)}function Y(n){return Boolean("number"==typeof n)}const Z=t(Y),_=n=>!!o(n)&&n%2!=0,nn=t(e);function tn(n){return!!n}const en=t(tn);function rn(n,t){if(i(t))return!1;for(const e in t)if(t[e]===n)return!0;return!1}const sn=t(rn);function un(n,t){return K(n.length,t)}function on(n,t){return t instanceof RegExp?t.test(n):!!e(t)&&new RegExp(t).test(n)}const cn=t(on);function an(n,t){try{return t(n)}catch(n){return!1}}function fn(n,t){return V(n.length,t)}function ln(n,t){return $(n.length,t)}function Nn(n,t){return e(n)&&e(t)&&n.startsWith(t)}const mn=t(Nn);const gn={condition:an,doesNotEndWith:A,doesNotStartWith:mn,endsWith:k,equals:I,greaterThan:s,greaterThanOrEquals:K,gt:s,gte:K,inside:R,isArray:u,isBetween:F,isBlank:X,isBoolean:c,isEmpty:a,isEven:C,isFalsy:en,isKeyOf:D,isNaN:H,isNegative:Q,isNotArray:f,isNotBetween:M,isNotBlank:j,isNotBoolean:z,isNotEmpty:l,isNotKeyOf:G,isNotNaN:L,isNotNull:N,isNotNullish:m,isNotNumber:Z,isNotNumeric:g,isNotString:nn,isNotUndefined:h,isNotValueOf:sn,isNull:p,isNullish:i,isNumber:Y,isNumeric:o,isOdd:_,isPositive:d,isString:e,isTruthy:tn,isUndefined:y,isValueOf:rn,lengthEquals:E,lengthNotEquals:v,lessThan:V,lessThanOrEquals:$,longerThan:O,longerThanOrEquals:un,lt:V,lte:$,matches:on,notEquals:J,notInside:U,notMatches:cn,numberEquals:r,numberNotEquals:q,shorterThan:fn,shorterThanOrEquals:ln,startsWith:Nn};function hn(n){return gn[n]}function pn(n,t){const e={pass:n};return t&&(e.message=t),e}function dn(n){return x(n,pn(!0))}function yn(n,t,e,...r){return function(n){b(c(n)||n&&c(n.pass),"Incorrect return value for rule: "+JSON.stringify(n))}(n),c(n)?pn(n):pn(n.pass,T(n.message,t,e,...r))}function En(n){const t={message:function(n){return e=n,r}};let e;const r=new Proxy(t,{get:(s,u)=>{const o=hn(u);return o?function(t,r,s){return function(...u){const o=S.run({value:n},(()=>yn(r(n,...u),s,n,...u)));function c(){return i(e)?i(o.message)?`enforce/${s} failed with ${JSON.stringify(n)}`:w(o.message):w(e)}return b(o.pass,c()),t}}(r,o,u):t[u]}});return r}const vn=function(){const t={context:()=>S.useX(),extend:t=>{n(gn,t)}};return new Proxy(n(En,t),{get:(n,t)=>t in n?n[t]:hn(t)?function(n){const t=[];let e;return function n(r){return(...s)=>{const u=hn(r);t.push((n=>yn(u(n,...s),r,n,...s)));let o={run:n=>dn(B(t,((t,r)=>{var s;const u=S.run({value:n},(()=>t(n)));r(!u.pass,pn(!!u.pass,null!==(s=T(e,n,u.message))&&void 0!==s?s:u.message))}))),test:n=>o.run(n).pass,message:n=>(n&&(e=n),o)};return o=new Proxy(o,{get:(t,e)=>hn(e)?n(e):t[e]}),o}}(n)}(t):void 0})}();export{S as ctx,vn as enforce};