vest 3.2.8-dev-6d7c74 → 3.2.8

package/dist/umd/vest.development.js

@@ -1,1622 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}));
-}(this, (function (exports) { 'use strict';
-
-    /*! *****************************************************************************
-    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.
-    ***************************************************************************** */
-    var __assign = function () {
-      __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-
-          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-
-        return t;
-      };
-
-      return __assign.apply(this, arguments);
-    };
-    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);
-    }
-
-    var assign = Object.assign;
-
-    function mapFirst(array, callback) {
-        var broke = false;
-        var breakoutValue = null;
-        for (var i = 0; i < array.length; i++) {
-            callback(array[i], breakout);
-            if (broke) {
-                return breakoutValue;
-            }
-        }
-        function breakout(value) {
-            broke = true;
-            breakoutValue = value;
-        }
-    }
-
-    /**
-     * Throws a timed out error.
-     */
-    function throwError(message, type) {
-        if (type === void 0) { type = Error; }
-        throw new type(message);
-    }
-
-    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
-     */
-    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);
-
-    function failing() {
-        return { pass: false };
-    }
-    function passing() {
-        return { pass: true };
-    }
-
-    function anyOf(value) {
-        var _a;
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        return ((_a = mapFirst(rules, function (rule, breakout) {
-            var res = rule.run(value);
-            if (res.pass) {
-                breakout(res);
-            }
-        })) !== null && _a !== void 0 ? _a : failing);
-    }
-
-    function noneOf(value) {
-        var _a;
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        return ((_a = mapFirst(rules, function (rule, breakout) {
-            var res = rule.run(value);
-            if (res.pass) {
-                breakout(failing());
-            }
-        })) !== null && _a !== void 0 ? _a : passing());
-    }
-
-    function oneOf(value) {
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        var passing = [];
-        rules.every(function (rule) {
-            if (passing.length > 1) {
-                return false;
-            }
-            var result = rule.run(value);
-            if (result.pass) {
-                passing.push(result);
-            }
-            return result.pass;
-        });
-        return { pass: passing.length === 1 };
-    }
-
-    function allOf(value) {
-        var _a;
-        var rules = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            rules[_i - 1] = arguments[_i];
-        }
-        return ((_a = mapFirst(rules, function (rule, breakout) {
-            var res = rule.run(value);
-            if (!res.pass) {
-                breakout(res);
-            }
-        })) !== null && _a !== void 0 ? _a : passing());
-    }
-
-    var compounds = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        anyOf: anyOf,
-        noneOf: noneOf,
-        oneOf: oneOf,
-        allOf: allOf
-    });
-
-    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);
-    }
-
-    function inside(value, arg1) {
-        if (Array.isArray(arg1) && /^[s|n|b]/.test(typeof value)) {
-            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);
-
-    // 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 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 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 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);
-
-    function isNull(value) {
-        return value === null;
-    }
-    var isNotNull = bindNot(isNull);
-
-    /**
-     * 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 isUndefined(value) {
-        return value === undefined;
-    }
-    var isNotUndefined = bindNot(isUndefined);
-
-    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 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
-    function rules() {
-        return {
-            doesNotEndWith: doesNotEndWith,
-            doesNotStartWith: doesNotStartWith,
-            endsWith: endsWith,
-            equals: equals,
-            greaterThan: greaterThan,
-            greaterThanOrEquals: greaterThanOrEquals,
-            gt: greaterThan,
-            gte: greaterThanOrEquals,
-            inside: inside,
-            isArray: isArray,
-            isBetween: isBetween,
-            isBoolean: isBoolean,
-            isEmpty: isEmpty,
-            isEven: isEven,
-            isFalsy: isFalsy,
-            isNaN: isNaN$1,
-            isNegative: isNegative,
-            isNotArray: isNotArray,
-            isNotBetween: isNotBetween,
-            isNotBoolean: isNotBoolean,
-            isNotEmpty: isNotEmpty,
-            isNotNaN: isNotNaN,
-            isNotNull: isNotNull,
-            isNotNumber: isNotNumber,
-            isNotNumeric: isNotNumeric,
-            isNotString: isNotString,
-            isNotUndefined: isNotUndefined,
-            isNull: isNull,
-            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,
-            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) {
-        var _a;
-        return ((_a = baseRules[ruleName]) !== null && _a !== void 0 ? _a : compounds[ruleName] // eslint-disable-line import/namespace
-        );
-    }
-
-    function isFunction(value) {
-        return typeof value === 'function';
-    }
-
-    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;
-    }
-
-    /**
-     * 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];
-        }
-        var defaultResult = getDefaultResult(value);
-        validateResult(result);
-        // if result is boolean
-        if (isBoolean(result)) {
-            return {
-                pass: result
-            };
-        }
-        else {
-            return __assign(__assign(__assign({}, defaultResult), { pass: result.pass }), (result.message && {
-                message: 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 getDefaultResult(value) {
-        return {
-            message: "invalid " + typeof value + " value"
-        };
-    }
-
-    function EnforceBase(value) {
-        var proxy = new Proxy({}, {
-            get: function (_, ruleName) {
-                var rule = getRule(ruleName);
-                if (rule) {
-                    return function () {
-                        var args = [];
-                        for (var _i = 0; _i < arguments.length; _i++) {
-                            args[_i] = arguments[_i];
-                        }
-                        var transformedResult = transformResult.apply(void 0, __spreadArray([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 {
-                                throw transformedResult.message;
-                            }
-                        }
-                        return proxy;
-                    };
-                }
-            }
-        });
-        return proxy;
-    }
-    var enforce = new Proxy(EnforceBase, {
-        get: function (_, key) {
-            var registeredRules = [];
-            if (key === 'extend') {
-                return function extend(customRules) {
-                    assign(baseRules, customRules);
-                };
-            }
-            if (!getRule(key)) {
-                return;
-            }
-            return addRegisteredRule(key);
-            function addRegisteredRule(ruleName) {
-                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 = new Proxy({}, {
-                        get: function (_, key) {
-                            if (getRule(key)) {
-                                return addRegisteredRule(key);
-                            }
-                            if (key === 'run') {
-                                return function (value) {
-                                    var _a;
-                                    return ((_a = mapFirst(registeredRules, function (rule, breakout) {
-                                        var res = rule(value);
-                                        if (!res.pass) {
-                                            breakout(res);
-                                        }
-                                    })) !== null && _a !== void 0 ? _a : passing());
-                                };
-                            }
-                            if (key === 'test') {
-                                return function (value) { return proxy.run(value).pass; };
-                            }
-                        }
-                    });
-                    return proxy;
-                };
-            }
-        }
-    });
-
-    function asArray(possibleArg) {
-        return [].concat(possibleArg);
-    }
-
-    /**
-     * @returns a unique numeric id.
-     */
-    var genId = (function (n) { return function () {
-        return "" + n++;
-    }; })(0);
-
-    function createState(onStateChange) {
-        var state = {
-            references: []
-        };
-        var registrations = [];
-        return {
-            registerStateKey: registerStateKey,
-            reset: reset
-        };
-        /**
-         * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-         *
-         * @example
-         *
-         * const useColor = state.registerStateKey("blue");
-         *
-         * let [color, setColor] = useColor(); // -> ["blue", Function]
-         *
-         * setColor("green");
-         *
-         * useColor()[0]; -> "green"
-         */
-        function registerStateKey(initialState, onUpdate) {
-            var key = registrations.length;
-            registrations.push([initialState, onUpdate]);
-            return initKey(key, initialState);
-        }
-        function reset() {
-            state.references = [];
-            registrations.forEach(function (_a, index) {
-                var initialValue = _a[0];
-                return initKey(index, initialValue);
-            });
-        }
-        function initKey(key, initialState) {
-            current().push();
-            set(key, optionalFunctionValue(initialState));
-            return function useStateKey() {
-                return [
-                    current()[key],
-                    function (nextState) {
-                        return set(key, optionalFunctionValue(nextState, current()[key]));
-                    },
-                ];
-            };
-        }
-        function current() {
-            return state.references;
-        }
-        function set(index, value) {
-            var prevValue = state.references[index];
-            state.references[index] = value;
-            var _a = registrations[index], onUpdate = _a[1];
-            if (isFunction(onUpdate)) {
-                onUpdate(value, prevValue);
-            }
-            if (isFunction(onStateChange)) {
-                onStateChange();
-            }
-        }
-    }
-
-    function createStateRef(state, _a) {
-        var suiteId = _a.suiteId;
-        return {
-            carryOverTests: state.registerStateKey(function () { return []; }),
-            lagging: state.registerStateKey(function () { return []; }),
-            optionalFields: state.registerStateKey(function () { return ({}); }),
-            pending: state.registerStateKey(function () { return []; }),
-            skippedTests: state.registerStateKey(function () { return []; }),
-            suiteId: state.registerStateKey(function () { return suiteId; }),
-            testCallbacks: state.registerStateKey(function () { return ({
-                fieldCallbacks: {},
-                doneCallbacks: []
-            }); }),
-            testObjects: state.registerStateKey(function () { return []; })
-        };
-    }
-
-    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(errorMessage !== null && errorMessage !== void 0 ? errorMessage : 'Context was used after it was closed'));
-        }
-        function run(ctxRef, fn) {
-            var _a;
-            var parentContext = use();
-            var out = __assign(__assign({}, (parentContext ? parentContext : {})), ((_a = init === null || init === void 0 ? void 0 : 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) {
-        return parentContext
-            ? null
-            : assign({}, {
-                exclusion: {
-                    tests: {},
-                    groups: {}
-                }
-            }, ctxRef);
-    });
-
-    /**
-     * Creates a cache function
-     */
-    function createCache(maxSize) {
-        if (maxSize === void 0) { maxSize = 10; }
-        var cacheStorage = [];
-        /**
-         * @param {any[]} deps  dependency array.
-         * @param {Function}    cache action function.
-         */
-        var cache = function (deps, cacheAction) {
-            var cacheHit = cache.get(deps);
-            // cache hit is not null
-            if (cacheHit) {
-                return cacheHit[1];
-            }
-            var result = cacheAction();
-            cacheStorage.unshift([deps.concat(), result]);
-            if (cacheStorage.length > maxSize) {
-                cacheStorage.length = maxSize;
-            }
-            return result;
-        };
-        /**
-         * Retrieves an item from the cache.
-         * @param {deps} deps Dependency array
-         */
-        cache.get = function (deps) {
-            return cacheStorage[cacheStorage.findIndex(function (_a) {
-                var cachedDeps = _a[0];
-                return lengthEquals(deps, cachedDeps.length) &&
-                    deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-            })] || null;
-        };
-        return cache;
-    }
-
-    function useCarryOverTests() {
-        return useStateRef().carryOverTests();
-    }
-    function usePending() {
-        return useStateRef().pending();
-    }
-    function useLagging() {
-        return useStateRef().lagging();
-    }
-    function useSuiteId() {
-        return useStateRef().suiteId();
-    }
-    function useTestCallbacks() {
-        return useStateRef().testCallbacks();
-    }
-    function useTestObjects() {
-        return useStateRef().testObjects();
-    }
-    function useSkippedTests() {
-        return useStateRef().skippedTests();
-    }
-    function useOptionalFields() {
-        return useStateRef().optionalFields();
-    }
-    function useStateRef() {
-        return ctx.useX().stateRef;
-    }
-
-    /**
-     * Checks if a given tests, or the suite as a whole still have remaining tests.
-     */
-    function hasRemainingTests(fieldName) {
-        var pending = usePending()[0];
-        var lagging = useLagging()[0];
-        var allIncomplete = pending.concat(lagging);
-        if (isEmpty(allIncomplete)) {
-            return false;
-        }
-        if (fieldName) {
-            return allIncomplete.some(function (testObject) { return testObject.fieldName === fieldName; });
-        }
-        return isNotEmpty(allIncomplete);
-    }
-
-    /**
-     * Reads the testObjects list and gets full validation result from it.
-     */
-    function genTestsSummary() {
-        var testObjects = useTestObjects()[0];
-        var skippedTests = useSkippedTests()[0];
-        var summary = {
-            errorCount: 0,
-            groups: {},
-            testCount: 0,
-            tests: {},
-            warnCount: 0
-        };
-        appendSummary(testObjects);
-        appendSummary(skippedTests, true);
-        return countFailures(summary);
-        function appendSummary(testObjects, skipped) {
-            testObjects.forEach(function (testObject) {
-                var fieldName = testObject.fieldName, groupName = testObject.groupName;
-                summary.tests[fieldName] = genTestObject(summary.tests, testObject, skipped);
-                if (groupName) {
-                    summary.groups[groupName] = summary.groups[groupName] || {};
-                    summary.groups[groupName][fieldName] = genTestObject(summary.groups[groupName], testObject, skipped);
-                }
-            });
-        }
-    }
-    /**
-     * Counts the failed tests and adds global counters
-     */
-    function countFailures(summary) {
-        for (var test in summary.tests) {
-            summary.errorCount += summary.tests[test].errorCount;
-            summary.warnCount += summary.tests[test].warnCount;
-            summary.testCount += summary.tests[test].testCount;
-        }
-        return summary;
-    }
-    function genTestObject(summaryKey, testObject, skipped) {
-        var fieldName = testObject.fieldName, isWarning = testObject.isWarning, failed = testObject.failed, message = testObject.message;
-        summaryKey[fieldName] = summaryKey[fieldName] || {
-            errorCount: 0,
-            warnCount: 0,
-            testCount: 0
-        };
-        var testKey = summaryKey[fieldName];
-        if (skipped) {
-            return testKey;
-        }
-        summaryKey[fieldName].testCount++;
-        // Adds to severity group
-        function addTo(countKey, group) {
-            testKey[countKey]++;
-            if (message) {
-                testKey[group] = (testKey[group] || []).concat(message);
-            }
-        }
-        if (failed) {
-            if (isWarning) {
-                addTo('warnCount', 'warnings');
-            }
-            else {
-                addTo('errorCount', 'errors');
-            }
-        }
-        return testKey;
-    }
-
-    function nonMatchingFieldName(testObject, fieldName) {
-        return !!(fieldName && testObject.fieldName !== fieldName);
-    }
-
-    function either(a, b) {
-        return !!a !== !!b;
-    }
-
-    /**
-     * Checks that a given test object matches the currently specified severity level
-     */
-    function nonMatchingSeverityProfile(severity, testObject) {
-        return either(severity === 'warnings', testObject.isWarning);
-    }
-
-    function collectFailureMessages(severity, testObjects, options) {
-        var _a;
-        if (options === void 0) { options = {}; }
-        var _b = options || {}, group = _b.group, fieldName = _b.fieldName;
-        var res = testObjects.reduce(function (collector, testObject) {
-            if (noMatch(testObject, severity, group, fieldName)) {
-                return collector;
-            }
-            if (!testObject.failed) {
-                return collector;
-            }
-            collector[testObject.fieldName] = (collector[testObject.fieldName] || []).concat(testObject.message || []);
-            return collector;
-        }, __assign({}, (fieldName && (_a = {}, _a[fieldName] = [], _a))));
-        return res;
-    }
-    function noGroupMatch(testObject, groupName) {
-        return !!(groupName && testObject.groupName !== groupName);
-    }
-    function noMatch(testObject, severity, group, fieldName) {
-        if (noGroupMatch(testObject, group)) {
-            return true;
-        }
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return true;
-        }
-        if (nonMatchingSeverityProfile(severity, testObject)) {
-            return true;
-        }
-        return false;
-    }
-
-    function getErrors(fieldName) {
-        return getFailures('errors', fieldName);
-    }
-    function getWarnings(fieldName) {
-        return getFailures('warnings', fieldName);
-    }
-    /**
-     * @returns suite or field's errors or warnings.
-     */
-    function getFailures(severityKey, fieldName) {
-        var testObjects = useTestObjects()[0];
-        var failureMessages = collectFailureMessages(severityKey, testObjects, {
-            fieldName: fieldName
-        });
-        if (fieldName) {
-            return failureMessages[fieldName];
-        }
-        return failureMessages;
-    }
-
-    function getErrorsByGroup(groupName, fieldName) {
-        var errors = getByGroup('errors', groupName, fieldName);
-        if (fieldName) {
-            return errors[fieldName];
-        }
-        return errors;
-    }
-    function getWarningsByGroup(groupName, fieldName) {
-        var errors = getByGroup('warnings', groupName, fieldName);
-        if (fieldName) {
-            return errors[fieldName];
-        }
-        return errors;
-    }
-    /**
-     * Gets failure messages by group.
-     */
-    function getByGroup(severityKey, group, fieldName) {
-        if (!group) {
-            throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
-        }
-        var testObjects = useTestObjects()[0];
-        var failureMessages = collectFailureMessages(severityKey, testObjects, {
-            group: group,
-            fieldName: fieldName
-        });
-        return failureMessages;
-    }
-
-    /**
-     * Determines whether a certain test profile has failures.
-     */
-    function hasFailuresLogic(testObject, severityKey, fieldName) {
-        if (!testObject.failed) {
-            return false;
-        }
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return false;
-        }
-        if (nonMatchingSeverityProfile(severityKey, testObject)) {
-            return false;
-        }
-        return true;
-    }
-
-    function hasErrors(fieldName) {
-        return has('errors', fieldName);
-    }
-    function hasWarnings(fieldName) {
-        return has('warnings', fieldName);
-    }
-    function has(severityKey, fieldName) {
-        var testObjects = useTestObjects()[0];
-        return testObjects.some(function (testObject) {
-            return hasFailuresLogic(testObject, severityKey, fieldName);
-        });
-    }
-
-    function hasErrorsByGroup(groupName, fieldName) {
-        return hasByGroup('errors', groupName, fieldName);
-    }
-    function hasWarningsByGroup(groupName, fieldName) {
-        return hasByGroup('warnings', groupName, fieldName);
-    }
-    /**
-     * Checks whether there are failures in a given group.
-     */
-    function hasByGroup(severityKey, group, fieldName) {
-        var testObjects = useTestObjects()[0];
-        return testObjects.some(function (testObject) {
-            if (group !== testObject.groupName) {
-                return false;
-            }
-            return hasFailuresLogic(testObject, severityKey, fieldName);
-        });
-    }
-
-    function isValid(result) {
-        if (result.hasErrors()) {
-            return false;
-        }
-        var testObjects = useTestObjects()[0];
-        if (isEmpty(testObjects)) {
-            return false;
-        }
-        var pending = usePending()[0];
-        var lagging = useLagging()[0];
-        if (isNotEmpty(pending.concat(lagging).filter(function (testObject) { return !testObject.isWarning; }))) {
-            return false;
-        }
-        return noMissingRequiredTestRuns(result);
-    }
-    function noMissingRequiredTestRuns(result) {
-        var optionalFields = useOptionalFields()[0];
-        for (var test in result.tests) {
-            if (!optionalFields[test] && result.tests[test].testCount === 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    var cache$1 = createCache(20);
-    function produceDraft() {
-        var testObjects = useTestObjects()[0];
-        var ctxRef = { stateRef: useStateRef() };
-        return cache$1([testObjects], ctx.bind(ctxRef, function () {
-            return __assign(__assign({}, genTestsSummary()), { getErrors: ctx.bind(ctxRef, getErrors), getErrorsByGroup: ctx.bind(ctxRef, getErrorsByGroup), getWarnings: ctx.bind(ctxRef, getWarnings), getWarningsByGroup: ctx.bind(ctxRef, getWarningsByGroup), hasErrors: ctx.bind(ctxRef, hasErrors), hasErrorsByGroup: ctx.bind(ctxRef, hasErrorsByGroup), hasWarnings: ctx.bind(ctxRef, hasWarnings), hasWarningsByGroup: ctx.bind(ctxRef, hasWarningsByGroup), isValid: ctx.bind(ctxRef, function () { return isValid(produceDraft()); }) });
-        }));
-    }
-
-    var cache = createCache(20);
-    function produceFullResult() {
-        var testObjects = useTestObjects()[0];
-        var ctxRef = { stateRef: useStateRef() };
-        return cache([testObjects], ctx.bind(ctxRef, function () {
-            return assign({}, produceDraft(), {
-                done: ctx.bind(ctxRef, done)
-            });
-        }));
-    }
-    function shouldSkipDoneRegistration(callback, fieldName, output) {
-        // If we do not have any test runs for the current field
-        return !!(!isFunction(callback) ||
-            (fieldName &&
-                (!output.tests[fieldName] || output.tests[fieldName].testCount === 0)));
-    }
-    function shouldRunDoneCallback(fieldName) {
-        // is suite finished || field name exists, and test is finished;
-        return !!(!hasRemainingTests() ||
-            (fieldName && !hasRemainingTests(fieldName)));
-    }
-    /**
-     * Registers done callbacks.
-     * @register {Object} Vest output object.
-     */
-    var done = function done() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var _a = args.reverse(), callback = _a[0], fieldName = _a[1];
-        var stateRef = useStateRef();
-        var output = produceFullResult();
-        if (shouldSkipDoneRegistration(callback, fieldName, output)) {
-            return output;
-        }
-        var deferredCallback = ctx.bind({ stateRef: stateRef }, function () {
-            return callback(produceDraft());
-        });
-        if (shouldRunDoneCallback(fieldName)) {
-            deferredCallback();
-            return output;
-        }
-        var _b = useTestCallbacks(), setTestCallbacks = _b[1];
-        setTestCallbacks(function (current) {
-            if (fieldName) {
-                current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(deferredCallback);
-            }
-            else {
-                current.doneCallbacks.push(deferredCallback);
-            }
-            return current;
-        });
-        return output;
-    };
-
-    function create(suiteCallback) {
-        if (!isFunction(suiteCallback)) {
-            throwError('Suite initialization error. Expected `tests` to be a function.');
-        }
-        var handlers = [];
-        var state = createState(function () {
-            handlers.forEach(function (fn) {
-                return fn({
-                    suiteState: stateRef,
-                    type: 'suiteStateUpdate'
-                });
-            });
-        });
-        var stateRef = createStateRef(state, { suiteId: genId() });
-        var suite = assign(ctx.bind({ stateRef: stateRef }, function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var previousTestObjects = useTestObjects()[0];
-            var _a = useCarryOverTests(), setCarryOverTests = _a[1];
-            var pending = usePending()[0];
-            var _b = useLagging(), prevLagging = _b[0], setLagging = _b[1];
-            state.reset();
-            setCarryOverTests(function () { return previousTestObjects; });
-            // Move all the active pending tests to the lagging array
-            setLagging(pending.concat(prevLagging));
-            // Run the consumer's callback
-            suiteCallback.apply(void 0, args);
-            var res = produceFullResult();
-            return res;
-        }), {
-            get: ctx.bind({ stateRef: stateRef }, produceDraft),
-            remove: ctx.bind({ stateRef: stateRef }, function (name) {
-                var testObjects = useTestObjects()[0];
-                // We're mutating the array in `cancel`, so we have to first copy it.
-                asArray(testObjects).forEach(function (testObject) {
-                    if (testObject.fieldName === name) {
-                        testObject.cancel();
-                    }
-                });
-            }),
-            reset: state.reset,
-            subscribe: function (handler) {
-                if (!isFunction(handler))
-                    return;
-                handlers.push(handler);
-                handler({
-                    type: 'suiteSubscribeInit',
-                    suiteState: stateRef
-                });
-            }
-        });
-        return suite;
-    }
-
-    /**
-     * Error message to display when a hook was called outside of context.
-     */
-    var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
-
-    /**
-     * Adds a field or multiple fields to inclusion group.
-     */
-    function only(item) {
-        return addTo('only', 'tests', item);
-    }
-    only.group = function (item) { return addTo('only', 'groups', item); };
-    /**
-     * Adds a field or multiple fields to exclusion group.
-     * @param {String[]|String} item Item to be added to exclusion group.
-     */
-    function skip(item) {
-        return addTo('skip', 'tests', item);
-    }
-    skip.group = function (item) { return addTo('skip', 'groups', item); };
-    //Checks whether a certain test profile excluded by any of the exclusion groups.
-    // eslint-disable-next-line complexity
-    function isExcluded(testObject) {
-        var fieldName = testObject.fieldName, groupName = testObject.groupName;
-        var context = ctx.useX();
-        var exclusion = context.exclusion;
-        var keyTests = exclusion.tests;
-        var testValue = keyTests[fieldName];
-        // if test is skipped
-        // no need to proceed
-        if (testValue === false) {
-            return true;
-        }
-        var isTestIncluded = testValue === true;
-        // If inside a group
-        if (groupName) {
-            if (isGroupExcluded(groupName)) {
-                return true; // field excluded by group
-                // if group is `only`ed
-            }
-            else if (exclusion.groups[groupName] === true) {
-                if (isTestIncluded) {
-                    return false;
-                }
-                // If there is _ANY_ `only`ed test (and we already know this one isn't)
-                if (hasIncludedTests(keyTests)) {
-                    return true; // Excluded implicitly
-                }
-                return keyTests[fieldName] === false;
-            }
-        }
-        // if field is only'ed
-        if (isTestIncluded) {
-            return false;
-        }
-        // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
-        // Otherwise return false
-        return hasIncludedTests(keyTests);
-    }
-    /**
-     * Checks whether a given group is excluded from running.
-     * @param {String} groupName
-     * @return {Boolean}
-     */
-    function isGroupExcluded(groupName) {
-        var context = ctx.useX();
-        var exclusion = context.exclusion;
-        var keyGroups = exclusion.groups;
-        var groupPresent = hasOwnProperty(keyGroups, groupName);
-        // When group is either only'ed or skipped
-        if (groupPresent) {
-            // Return true if group is skipped and false if only'ed
-            return keyGroups[groupName] === false;
-        }
-        // Group is not present
-        for (var group in keyGroups) {
-            // If any other group is only'ed
-            if (keyGroups[group] === true) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Adds fields to a specified exclusion group.
-     */
-    function addTo(exclusionGroup, itemType, item) {
-        var context = ctx.useX(ERROR_HOOK_CALLED_OUTSIDE);
-        if (!item) {
-            return;
-        }
-        asArray(item).forEach(function (itemName) {
-            if (!isStringValue(itemName)) {
-                return;
-            }
-            context.exclusion[itemType][itemName] = exclusionGroup === 'only';
-        });
-    }
-    /**
-     * Checks if context has included tests
-     */
-    function hasIncludedTests(keyTests) {
-        for (var test in keyTests) {
-            if (keyTests[test] === true) {
-                return true; // excluded implicitly
-            }
-        }
-        return false;
-    }
-
-    /**
-     * @type {String} Error message to display when `warn` gets called outside of a test.
-     */
-    var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
-        ;
-    /**
-     * Sets a running test to warn only mode.
-     */
-    function warn() {
-        var ctx$1 = ctx.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-        if (!ctx$1.currentTest) {
-            throwError(ERROR_OUTSIDE_OF_TEST);
-            return;
-        }
-        ctx$1.currentTest.warn();
-    }
-
-    /**
-     * Runs a group callback.
-     */
-    function group(groupName, tests) {
-        if (!isStringValue(groupName)) {
-            throwGroupError(groupName);
-        }
-        if (!isFunction(tests)) {
-            throwGroupError(tests);
-        }
-        // Running with the context applied
-        ctx.bind({ groupName: groupName }, tests)();
-    }
-    function throwGroupError(value) {
-        throwError("group initialization error. Expected \"" + value + "\" to be a string."
-            );
-    }
-
-    function optional(optionals) {
-        var _a = useOptionalFields(), setOptionalFields = _a[1];
-        setOptionalFields(function (state) {
-            asArray(optionals).forEach(function (optionalField) {
-                state[optionalField] = true;
-            });
-            return state;
-        });
-    }
-
-    /**
-     * Removes first found element from array
-     * WARNING: Mutates array
-     */
-    function removeElementFromArray(array, element) {
-        var index = array.indexOf(element);
-        if (index !== -1) {
-            array.splice(index, 1);
-        }
-        return array;
-    }
-
-    function isSameProfileTest(testObject1, testObject2) {
-        return (testObject1.fieldName === testObject2.fieldName &&
-            testObject1.groupName === testObject2.groupName);
-    }
-
-    /**
-     * Sets a test as pending in the state.
-     */
-    function setPending(testObject) {
-        var _a = useLagging(), lagging = _a[0], setLagging = _a[1];
-        var _b = usePending(), setPending = _b[1];
-        var nextLagging = asArray(lagging).reduce(function (lagging, laggingTestObject) {
-            /**
-             * If the test is of the same profile
-             * (same name + same group) we cancel
-             * it. Otherwise, it is lagging.
-             */
-            if (isSameProfileTest(testObject, laggingTestObject) &&
-                // This last case handles memoized tests
-                // because that retain their od across runs
-                laggingTestObject.id !== testObject.id) {
-                laggingTestObject.cancel();
-            }
-            else {
-                lagging.push(laggingTestObject);
-            }
-            return lagging;
-        }, []);
-        setLagging(function () { return nextLagging; });
-        setPending(function (pending) { return pending.concat(testObject); });
-    }
-    /**
-     * Removes a tests from the pending and lagging arrays.
-     */
-    function removePending(testObject) {
-        var _a = usePending(), setPending = _a[1];
-        var _b = useLagging(), setLagging = _b[1];
-        setPending(function (setPending) { return removeElementFromArray(setPending, testObject); });
-        setLagging(function (lagging) { return removeElementFromArray(lagging, testObject); });
-    }
-
-    /**
-     * Removes test object from suite state
-     */
-    function removeTestFromState (testObject) {
-        var _a = useTestObjects(), setTestObjects = _a[1];
-        setTestObjects(function (testObjects) {
-            // using asArray to clear the cache.
-            return asArray(removeElementFromArray(testObjects, testObject));
-        });
-    }
-
-    var VestTest = /** @class */ (function () {
-        function VestTest(fieldName, testFn, _a) {
-            var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName;
-            this.id = genId();
-            this.failed = false;
-            this.isWarning = false;
-            this.canceled = false;
-            this.fieldName = fieldName;
-            this.testFn = testFn;
-            if (groupName) {
-                this.groupName = groupName;
-            }
-            if (message) {
-                this.message = message;
-            }
-        }
-        VestTest.prototype.run = function () {
-            var result;
-            try {
-                result = this.testFn();
-            }
-            catch (error) {
-                if (isUndefined(this.message) && isStringValue(error)) {
-                    this.message = error;
-                }
-                result = false;
-            }
-            if (result === false) {
-                this.fail();
-            }
-            return result;
-        };
-        VestTest.prototype.fail = function () {
-            this.failed = true;
-        };
-        VestTest.prototype.warn = function () {
-            this.isWarning = true;
-        };
-        VestTest.prototype.cancel = function () {
-            this.canceled = true;
-            removePending(this);
-            removeTestFromState(this);
-        };
-        VestTest.prototype.valueOf = function () {
-            return this.failed !== true;
-        };
-        return VestTest;
-    }());
-
-    function partition(array, predicate) {
-        return array.reduce(function (partitions, value, number) {
-            partitions[predicate(value, number, array) ? 0 : 1].push(value);
-            return partitions;
-        }, [[], []]);
-    }
-
-    function mergeCarryOverTests(testObject) {
-        var _a = useCarryOverTests(), carryOverTests = _a[0], setCarryOverTests = _a[1];
-        var _b = useTestObjects(), setTestObjects = _b[1];
-        var _c = partition(carryOverTests, function (carryOverTest) { return isSameProfileTest(carryOverTest, testObject); }), moveToTestObjects = _c[0], keepInCarryOvers = _c[1];
-        setCarryOverTests(function () { return keepInCarryOvers; });
-        setTestObjects(function (testObjects) { return testObjects.concat(moveToTestObjects); });
-    }
-
-    function isPromise(value) {
-        return value && isFunction(value.then);
-    }
-
-    /**
-     * Stores test object inside suite state.
-     */
-    var addTestToState = (function (testObject) {
-        var _a = useTestObjects(), setTestObjects = _a[1];
-        setTestObjects(function (testObjects) { return testObjects.concat(testObject); });
-    });
-
-    function callEach(arr) {
-        return arr.forEach(function (fn) { return fn(); });
-    }
-
-    /**
-     * Runs async test.
-     */
-    function runAsyncTest(testObject) {
-        var asyncTest = testObject.asyncTest, message = testObject.message;
-        if (!isPromise(asyncTest))
-            return;
-        var stateRef = useStateRef();
-        var done = ctx.bind({ stateRef: stateRef }, function () {
-            removePending(testObject);
-            // This is for cases in which the suite state was already reset
-            if (testObject.canceled) {
-                return;
-            }
-            // Perform required done callback calls and cleanups after the test is finished
-            runDoneCallbacks(testObject.fieldName);
-        });
-        var fail = ctx.bind({ stateRef: stateRef }, function (rejectionMessage) {
-            testObject.message = isStringValue(rejectionMessage)
-                ? rejectionMessage
-                : message;
-            testObject.fail();
-            // Spreading the array to invalidate the cache
-            var _a = useTestObjects(), setTestObjects = _a[1];
-            setTestObjects(function (testObjects) { return testObjects.slice(); });
-            done();
-        });
-        try {
-            asyncTest.then(done, fail);
-        }
-        catch (e) {
-            fail();
-        }
-    }
-    /**
-     * Runs done callback when async tests are finished running.
-     */
-    function runDoneCallbacks(fieldName) {
-        var _a = useTestCallbacks()[0], fieldCallbacks = _a.fieldCallbacks, doneCallbacks = _a.doneCallbacks;
-        if (fieldName) {
-            if (!hasRemainingTests(fieldName) &&
-                Array.isArray(fieldCallbacks[fieldName])) {
-                callEach(fieldCallbacks[fieldName]);
-            }
-        }
-        if (!hasRemainingTests()) {
-            callEach(doneCallbacks);
-        }
-    }
-
-    /**
-     * Runs sync tests - or extracts promise.
-     */
-    function runSyncTest(testObject) {
-        return ctx.run({ currentTest: testObject }, function () {
-            var result;
-            try {
-                result = testObject.testFn();
-            }
-            catch (e) {
-                if (isUndefined(testObject.message) && isStringValue(e)) {
-                    testObject.message = e;
-                }
-                result = false;
-            }
-            if (result === false) {
-                testObject.fail();
-            }
-            return result;
-        });
-    }
-
-    /**
-     * Registers test, if async - adds to pending array
-     */
-    function registerTest(testObject) {
-        addTestToState(testObject);
-        // Run test callback.
-        // If a promise is returned, set as async and
-        // Move to pending list.
-        var result = runSyncTest(testObject);
-        try {
-            // try catch for safe property access
-            // in case object is an enforce chain
-            if (isPromise(result)) {
-                testObject.asyncTest = result;
-                setPending(testObject);
-                runAsyncTest(testObject);
-            }
-        }
-        catch (_a) {
-            {
-                throwError("Your test function " + testObject.fieldName + " returned " + JSON.stringify(result) + ". Only \"false\" or a Promise are supported. Return values may cause unexpected behavior.");
-            }
-        }
-    }
-
-    /* eslint-disable jest/no-export */
-    function bindTestEach(test) {
-        /**
-         * Run multiple tests using a parameter table
-         */
-        function each(table) {
-            if (!Array.isArray(table)) {
-                throwError('test.each: Expected table to be an array.');
-            }
-            function eachReturn(fieldName) {
-                var args = [];
-                for (var _i = 1; _i < arguments.length; _i++) {
-                    args[_i - 1] = arguments[_i];
-                }
-                var _a = args.reverse(), testFn = _a[0], message = _a[1];
-                return table.map(function (item) {
-                    item = asArray(item);
-                    return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item)), optionalFunctionValue.apply(void 0, __spreadArray([message], item)), function () { return testFn.apply(void 0, item); });
-                });
-            }
-            return eachReturn;
-        }
-        return each;
-    }
-
-    /* eslint-disable jest/no-export */
-    function bindTestMemo(test) {
-        var cache = createCache(100); // arbitrary cache size
-        function memo(fieldName) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            var suiteId = useSuiteId()[0];
-            var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
-            // Implicit dependency for more specificity
-            var dependencies = [suiteId, fieldName].concat(deps);
-            var cached = cache.get(dependencies);
-            if (isNull(cached)) {
-                // Cache miss. Start fresh
-                return cache(dependencies, function () { return test(fieldName, msg, testFn); });
-            }
-            var testObject = cached[1];
-            if (isExcluded(testObject)) {
-                return testObject;
-            }
-            addTestToState(testObject);
-            if (testObject && isPromise(testObject.asyncTest)) {
-                setPending(testObject);
-                runAsyncTest(testObject);
-            }
-            return testObject;
-        }
-        return memo;
-    }
-
-    function testBase(fieldName) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var _a = args.reverse(), testFn = _a[0], message = _a[1];
-        var _b = useSkippedTests(), setSkippedTests = _b[1];
-        var context = ctx.use();
-        var testObject = new VestTest(fieldName, testFn, {
-            message: message,
-            groupName: context === null || context === void 0 ? void 0 : context.groupName
-        });
-        if (isExcluded(testObject)) {
-            setSkippedTests(function (skippedTests) { return skippedTests.concat(testObject); });
-            mergeCarryOverTests(testObject);
-            return testObject;
-        }
-        if (!isFunction(testFn)) {
-            return testObject;
-        }
-        registerTest(testObject);
-        return testObject;
-    }
-    var test = assign(testBase, {
-        each: bindTestEach(testBase),
-        memo: bindTestMemo(testBase)
-    });
-
-    var VERSION = "3.2.8-dev-6d7c74";
-
-    exports.VERSION = VERSION;
-    exports.create = create;
-    exports.enforce = enforce;
-    exports.group = group;
-    exports.only = only;
-    exports.optional = optional;
-    exports.skip = skip;
-    exports.test = test;
-    exports.warn = warn;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-})));