n4s 5.0.1 → 5.0.2

package/dist/cjs/n4s.development.js

@@ -1,213 +1,155 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
+var vestUtils = require('vest-utils');
 var context = require('context');
 
-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());
-}
-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);
+    return vestUtils.isNullish(value) || (vestUtils.isStringValue(value) && !value.trim());
 }
-var lengthNotEquals = bindNot(lengthEquals);
+const isNotBlank = vestUtils.bindNot(isBlank);
 
-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);
+}
+
+function isNumber(value) {
+    return Boolean(typeof value === 'number');
 }
-var isPositive = bindNot(isNegative);
+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);
+const isFalsy = vestUtils.bindNot(isTruthy);
 
-function lessThan(value, lt) {
-    return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
-}
-
-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 +161,92 @@ function condition(value, callback) {
 }
 
 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 +256,112 @@ function passing() {
     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 +395,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) {
-            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,10 +411,10 @@ function genEnforce() {
             }
             // 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;