vest 4.5.0 → 4.6.2-dev-fcaa09

package/types/vest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vest.d.ts","sourceRoot":"","sources":["../src/vest.ts","../src/core/suite/produce/summaryGenerators/SuiteSummaryTypes.ts","../src/core/test/lib/shouldUseErrorAsMessage.ts","../src/hooks/optionalFields.ts","../src/core/isolate/isolateCursor.ts","../src/core/isolate/IsolateTypes.ts","../src/hooks/mode/Modes.ts","../src/core/isolate/generateIsolate.ts","../src/core/ctx/ctx.ts","../src/core/isolate/isolateHooks.ts","../src/core/test/key.ts","../src/core/isolate/isolate.ts","../src/core/suite/produce/summaryGenerators/helpers/matchingFieldName.ts","../src/core/suite/hasRemainingTests.ts","../src/core/suite/produce/produceSuiteRunResult.ts","../src/core/test/omitOptionalFields.ts","../src/core/test/lib/removeTestFromState.ts","../src/core/suite/produce/runCallbacks.ts","../src/core/vestBus.ts","../src/core/suite/create.ts","../src/core/suite/produce/Severity.ts","../src/core/suite/produce/summaryGenerators/helpers/matchingGroupName.ts","../src/core/suite/produce/summaryGenerators/helpers/nonMatchingSeverityProfile.ts","../src/core/suite/produce/summaryGenerators/hasFailuresByTestObjects.ts","../src/core/suite/produce/summaryGenerators/shouldAddValidProperty.ts","../src/core/suite/produce/summaryGenerators/genTestsSummary.ts","../src/core/suite/produce/summarySelectors/collectFailures.ts","../src/core/suite/produce/summarySelectors/suiteSelectors.ts","../src/core/suite/produce/produceSuiteResult.ts","../src/core/state/createStateRef.ts","../src/core/state/stateHooks.ts","../src/core/test/VestTest.ts","../src/core/isolate/isolates/each.ts","../src/hooks/hookErrors.ts","../src/core/isolate/isolates/skipWhen.ts","../src/hooks/exclusive.ts","../src/core/isolate/isolates/group.ts","../src/hooks/include.ts","../src/hooks/mode/mode.ts","../src/core/isolate/isolates/omitWhen.ts","../src/core/test/lib/isSameProfileTest.ts","../src/core/test/lib/cancelOverriddenPendingTest.ts","../src/core/test/runAsyncTest.ts","../src/core/test/runSyncTest.ts","../src/core/test/lib/registerTest.ts","../src/core/test/lib/useTestAtCursor.ts","../src/core/test/lib/registerPrevRunTest.ts","../src/core/test/test.memo.ts","../src/core/test/test.ts","../src/hooks/warn.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoB9B,QAAA,MAAM,OAAO,qBAAqB,CAAC;AAEnC,OAAO,wIAiBN,CAAC;AAEF,YAAY,8DAA8D,CAAC"}

package/dist/cjs/compose.js

@@ -1,7 +0,0 @@
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./compose.production.js');
-} else {
-  module.exports = require('./compose.development.js');
-}

package/dist/cjs/compounds.js

@@ -1,7 +0,0 @@
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./compounds.production.js');
-} else {
-  module.exports = require('./compounds.development.js');
-}

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

@@ -1,60 +0,0 @@
-'use strict';
-
-var vestUtils = require('vest-utils');
-var n4s = require('n4s');
-
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToPassing(callback) {
-    return vestUtils.defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-/* eslint-disable max-lines-per-function */
-function compose() {
-    var composites = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        composites[_i] = arguments[_i];
-    }
-    return vestUtils.assign(function (value) {
-        var res = run(value);
-        vestUtils.invariant(res.pass, vestUtils.StringObject(res.message));
-    }, {
-        run: run,
-        test: function (value) { return run(value).pass; }
-    });
-    function run(value) {
-        return n4s.ctx.run({ value: value }, function () {
-            return defaultToPassing(vestUtils.mapFirst(composites, function (composite, breakout) {
-                /* HACK: Just a small white lie. ~~HELP WANTED~~.
-                   The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.
-                   The problem is that lazy rules can't really be passed to this function due to some generic hell
-                   so we're limiting it to a small set of functions.
-                */
-                var res = runLazyRule(composite, value);
-                breakout(!res.pass, res);
-            }));
-        });
-    }
-}
-
-module.exports = compose;

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

@@ -1 +0,0 @@
-"use strict";var n=require("vest-utils"),t=require("n4s");function r(n,t){return n={pass:n},t&&(n.message=t),n}function u(t){return n.defaultTo(t,r(!0))}function e(n,t){try{return n.run(t)}catch(n){return r(!1)}}module.exports=function(){function r(r){return t.ctx.run({value:r},(function(){return u(n.mapFirst(s,(function(n,t){t(!(n=e(n,r)).pass,n)})))}))}for(var s=[],i=0;i<arguments.length;i++)s[i]=arguments[i];return n.assign((function(t){t=r(t),n.invariant(t.pass,n.StringObject(t.message))}),{run:r,test:function(n){return r(n).pass}})};

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

@@ -1,92 +0,0 @@
-'use strict';
-
-var vestUtils = require('vest-utils');
-var n4s = require('n4s');
-
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToFailing(callback) {
-    return vestUtils.defaultTo(callback, failing());
-}
-function defaultToPassing(callback) {
-    return vestUtils.defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-function allOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToPassing(vestUtils.mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        breakout(!res.pass, res);
-    }));
-}
-
-function anyOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToFailing(vestUtils.mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        breakout(res.pass, res);
-    }));
-}
-
-function noneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToPassing(vestUtils.mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        breakout(res.pass, failing());
-    }));
-}
-
-function equals(value, arg1) {
-    return value === arg1;
-}
-vestUtils.bindNot(equals);
-
-var REQUIRED_COUNT = 1;
-function oneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    var passingCount = 0;
-    rules.some(function (rule) {
-        var res = runLazyRule(rule, value);
-        if (res.pass) {
-            passingCount++;
-        }
-        if (vestUtils.greaterThan(passingCount, REQUIRED_COUNT)) {
-            return false;
-        }
-    });
-    return ruleReturn(equals(passingCount, REQUIRED_COUNT));
-}
-
-n4s.enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });

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

@@ -1 +0,0 @@
-"use strict";var n=require("vest-utils"),r=require("n4s");function t(n,r){return n={pass:n},r&&(n.message=r),n}function e(){return t(!1)}function u(r){return n.defaultTo(r,e())}function f(r){return n.defaultTo(r,t(!0))}function o(n,r){try{return n.run(r)}catch(n){return e()}}function i(n,r){return n===r}n.bindNot(i);r.enforce.extend({allOf:function(r){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return f(n.mapFirst(t,(function(n,t){t(!(n=o(n,r)).pass,n)})))},anyOf:function(r){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return u(n.mapFirst(t,(function(n,t){t((n=o(n,r)).pass,n)})))},noneOf:function(r){for(var t=[],u=1;u<arguments.length;u++)t[u-1]=arguments[u];return f(n.mapFirst(t,(function(n,t){t((n=o(n,r)).pass,e())})))},oneOf:function(r){for(var e=[],u=1;u<arguments.length;u++)e[u-1]=arguments[u];var f=0;return e.some((function(t){if(o(t,r).pass&&f++,n.greaterThan(f,1))return!1})),t(i(f,1))}});

package/dist/cjs/enforce/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}

package/dist/cjs/enforce/schema.development.js

@@ -1,92 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var vestUtils = require('vest-utils');
-var n4s = require('n4s');
-
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToPassing(callback) {
-    return vestUtils.defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-function isArrayOf(inputArray, currentRule) {
-    return defaultToPassing(vestUtils.mapFirst(inputArray, function (currentValue, breakout, index) {
-        var res = n4s.ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
-        breakout(!res.pass, res);
-    }));
-}
-
-function loose(inputObject, shapeObject) {
-    var _loop_1 = function (key) {
-        var currentValue = inputObject[key];
-        var currentRule = shapeObject[key];
-        var res = n4s.ctx.run({ value: currentValue, set: true, meta: { key: key } }, function () {
-            return runLazyRule(currentRule, currentValue);
-        });
-        if (!res.pass) {
-            return { value: res };
-        }
-    };
-    for (var key in shapeObject) {
-        var state_1 = _loop_1(key);
-        if (typeof state_1 === "object")
-            return state_1.value;
-    }
-    return passing();
-}
-
-function optional(value, ruleChain) {
-    if (vestUtils.isNullish(value)) {
-        return passing();
-    }
-    return runLazyRule(ruleChain, value);
-}
-
-function shape(inputObject, shapeObject) {
-    var baseRes = loose(inputObject, shapeObject);
-    if (!baseRes.pass) {
-        return baseRes;
-    }
-    for (var key in inputObject) {
-        if (!vestUtils.hasOwnProperty(shapeObject, key)) {
-            return failing();
-        }
-    }
-    return passing();
-}
-
-// Help needed improving the typings of this file.
-// Ideally, we'd be able to extend ShapeObject, but that's not possible.
-function partial(shapeObject) {
-    var output = {};
-    for (var key in shapeObject) {
-        output[key] = n4s.enforce.optional(shapeObject[key]);
-    }
-    return output;
-}
-
-n4s.enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
-
-exports.partial = partial;

package/dist/cjs/enforce/schema.production.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("vest-utils"),n=require("n4s");function e(r,n){return r={pass:r},n&&(r.message=n),r}function t(){return e(!1)}function u(){return e(!0)}function i(r,n){try{return r.run(n)}catch(r){return t()}}function o(r,e){var t,o=function(t){var u=r[t],o=e[t];if(!(t=n.ctx.run({value:u,set:!0,meta:{key:t}},(function(){return i(o,u)}))).pass)return{value:t}};for(t in e){var a=o(t);if("object"==typeof a)return a.value}return u()}n.enforce.extend({isArrayOf:function(e,t){return function(n){return r.defaultTo(n,u())}(r.mapFirst(e,(function(r,e,u){e(!(u=n.ctx.run({value:r,set:!0,meta:{index:u}},(function(){return i(t,r)}))).pass,u)})))},loose:o,optional:function(n,e){return r.isNullish(n)?u():i(e,n)},shape:function(n,e){var i=o(n,e);if(!i.pass)return i;for(var a in n)if(!r.hasOwnProperty(e,a))return t();return u()}}),exports.partial=function(r){var e,t={};for(e in r)t[e]=n.enforce.optional(r[e]);return t};

package/dist/cjs/schema.js

@@ -1,7 +0,0 @@
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./schema.production.js');
-} else {
-  module.exports = require('./schema.development.js');
-}

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

@@ -1,58 +0,0 @@
-import { defaultTo, assign, mapFirst, invariant, StringObject } from 'vest-utils';
-import { ctx } from 'n4s';
-
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToPassing(callback) {
-    return defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-/* eslint-disable max-lines-per-function */
-function compose() {
-    var composites = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        composites[_i] = arguments[_i];
-    }
-    return assign(function (value) {
-        var res = run(value);
-        invariant(res.pass, StringObject(res.message));
-    }, {
-        run: run,
-        test: function (value) { return run(value).pass; }
-    });
-    function run(value) {
-        return ctx.run({ value: value }, function () {
-            return defaultToPassing(mapFirst(composites, function (composite, breakout) {
-                /* HACK: Just a small white lie. ~~HELP WANTED~~.
-                   The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.
-                   The problem is that lazy rules can't really be passed to this function due to some generic hell
-                   so we're limiting it to a small set of functions.
-                */
-                var res = runLazyRule(composite, value);
-                breakout(!res.pass, res);
-            }));
-        });
-    }
-}
-
-export default compose;

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

@@ -1 +0,0 @@
-import{ctx as n}from"n4s";import{defaultTo as t,assign as r,mapFirst as u,invariant as s,StringObject as e}from"vest-utils";function o(n,t){return n={pass:n},t&&(n.message=t),n}export default function(){function a(r){return n.run({value:r},(function(){return t(u(f,(function(n,t){try{var u=n.run(r)}catch(n){u=o(!1)}t(!u.pass,u)})),o(!0))}))}for(var f=[],i=0;i<arguments.length;i++)f[i]=arguments[i];return r((function(n){n=a(n),s(n.pass,e(n.message))}),{run:a,test:function(n){return a(n).pass}})}

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

@@ -1,90 +0,0 @@
-import { defaultTo, mapFirst, bindNot, greaterThan } from 'vest-utils';
-import { enforce } from 'n4s';
-
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToFailing(callback) {
-    return defaultTo(callback, failing());
-}
-function defaultToPassing(callback) {
-    return defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-function allOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToPassing(mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        breakout(!res.pass, res);
-    }));
-}
-
-function anyOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToFailing(mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        breakout(res.pass, res);
-    }));
-}
-
-function noneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    return defaultToPassing(mapFirst(rules, function (rule, breakout) {
-        var res = runLazyRule(rule, value);
-        breakout(res.pass, failing());
-    }));
-}
-
-function equals(value, arg1) {
-    return value === arg1;
-}
-bindNot(equals);
-
-var REQUIRED_COUNT = 1;
-function oneOf(value) {
-    var rules = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rules[_i - 1] = arguments[_i];
-    }
-    var passingCount = 0;
-    rules.some(function (rule) {
-        var res = runLazyRule(rule, value);
-        if (res.pass) {
-            passingCount++;
-        }
-        if (greaterThan(passingCount, REQUIRED_COUNT)) {
-            return false;
-        }
-    });
-    return ruleReturn(equals(passingCount, REQUIRED_COUNT));
-}
-
-enforce.extend({ allOf: allOf, anyOf: anyOf, noneOf: noneOf, oneOf: oneOf });

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

@@ -1 +0,0 @@
-import{enforce as n}from"n4s";import{defaultTo as r,mapFirst as t,bindNot as f,greaterThan as o}from"vest-utils";function u(n,r){return n={pass:n},r&&(n.message=r),n}function e(n,r){try{return n.run(r)}catch(n){return u(!1)}}f((function(n,r){return n===r})),n.extend({allOf:function(n){for(var f=[],o=1;o<arguments.length;o++)f[o-1]=arguments[o];return r(t(f,(function(r,t){t(!(r=e(r,n)).pass,r)})),u(!0))},anyOf:function(n){for(var f=[],o=1;o<arguments.length;o++)f[o-1]=arguments[o];return r(t(f,(function(r,t){t((r=e(r,n)).pass,r)})),u(!1))},noneOf:function(n){for(var f=[],o=1;o<arguments.length;o++)f[o-1]=arguments[o];return r(t(f,(function(r,t){t((r=e(r,n)).pass,u(!1))})),u(!0))},oneOf:function(n){for(var r=[],t=1;t<arguments.length;t++)r[t-1]=arguments[t];var f=0;return r.some((function(r){if(e(r,n).pass&&f++,o(f,1))return!1})),u(1===f)}});

package/dist/es/enforce/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/es/enforce/schema.development.js

@@ -1,88 +0,0 @@
-import { defaultTo, mapFirst, isNullish, hasOwnProperty } from 'vest-utils';
-import { ctx, enforce } from 'n4s';
-
-function ruleReturn(pass, message) {
-    var output = { pass: pass };
-    if (message) {
-        output.message = message;
-    }
-    return output;
-}
-function failing() {
-    return ruleReturn(false);
-}
-function passing() {
-    return ruleReturn(true);
-}
-function defaultToPassing(callback) {
-    return defaultTo(callback, passing());
-}
-
-function runLazyRule(lazyRule, currentValue) {
-    try {
-        return lazyRule.run(currentValue);
-    }
-    catch (_a) {
-        return failing();
-    }
-}
-
-function isArrayOf(inputArray, currentRule) {
-    return defaultToPassing(mapFirst(inputArray, function (currentValue, breakout, index) {
-        var res = ctx.run({ value: currentValue, set: true, meta: { index: index } }, function () { return runLazyRule(currentRule, currentValue); });
-        breakout(!res.pass, res);
-    }));
-}
-
-function loose(inputObject, shapeObject) {
-    var _loop_1 = function (key) {
-        var currentValue = inputObject[key];
-        var currentRule = shapeObject[key];
-        var res = ctx.run({ value: currentValue, set: true, meta: { key: key } }, function () {
-            return runLazyRule(currentRule, currentValue);
-        });
-        if (!res.pass) {
-            return { value: res };
-        }
-    };
-    for (var key in shapeObject) {
-        var state_1 = _loop_1(key);
-        if (typeof state_1 === "object")
-            return state_1.value;
-    }
-    return passing();
-}
-
-function optional(value, ruleChain) {
-    if (isNullish(value)) {
-        return passing();
-    }
-    return runLazyRule(ruleChain, value);
-}
-
-function shape(inputObject, shapeObject) {
-    var baseRes = loose(inputObject, shapeObject);
-    if (!baseRes.pass) {
-        return baseRes;
-    }
-    for (var key in inputObject) {
-        if (!hasOwnProperty(shapeObject, key)) {
-            return failing();
-        }
-    }
-    return passing();
-}
-
-// Help needed improving the typings of this file.
-// Ideally, we'd be able to extend ShapeObject, but that's not possible.
-function partial(shapeObject) {
-    var output = {};
-    for (var key in shapeObject) {
-        output[key] = enforce.optional(shapeObject[key]);
-    }
-    return output;
-}
-
-enforce.extend({ isArrayOf: isArrayOf, loose: loose, optional: optional, shape: shape });
-
-export { partial };

package/dist/es/enforce/schema.production.js

@@ -1 +0,0 @@
-import{ctx as r,enforce as n}from"n4s";import{defaultTo as t,mapFirst as e,isNullish as u,hasOwnProperty as o}from"vest-utils";function i(r,n){return r={pass:r},n&&(r.message=n),r}function a(r,n){try{return r.run(n)}catch(r){return i(!1)}}function f(n,t){function e(e){var u=n[e],o=t[e];if(!(e=r.run({value:u,set:!0,meta:{key:e}},(function(){return a(o,u)}))).pass)return{value:e}}for(var u in t){var o=e(u);if("object"==typeof o)return o.value}return i(!0)}n.extend({isArrayOf:function(n,u){return t(e(n,(function(n,t,e){t(!(e=r.run({value:n,set:!0,meta:{index:e}},(function(){return a(u,n)}))).pass,e)})),i(!0))},loose:f,optional:function(r,n){return u(r)?i(!0):a(n,r)},shape:function(r,n){var t=f(r,n);if(!t.pass)return t;for(var e in r)if(!o(n,e))return i(!1);return i(!0)}});export function partial(r){var t,e={};for(t in r)e[t]=n.optional(r[t]);return e}