joi 17.13.3 → 18.0.1

package/lib/index.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
+const { assert, clone } = require('@hapi/hoek');
 
 const Cache = require('./cache');
 const Common = require('./common');
@@ -54,7 +53,7 @@ internals.root = function () {
     for (const type of root._types) {
         root[type] = function (...args) {
 
-            Assert(!args.length || ['alternatives', 'link', 'object'].includes(type), 'The', type, 'type does not allow arguments');
+            assert(!args.length || ['alternatives', 'link', 'object'].includes(type), 'The', type, 'type does not allow arguments');
             return internals.generate(this, internals.types[type], args);
         };
     }
@@ -109,7 +108,7 @@ internals.methods = {
 
     build(desc) {
 
-        Assert(typeof Manifest.build === 'function', 'Manifest functionality disabled');
+        assert(typeof Manifest.build === 'function', 'Manifest functionality disabled');
         return Manifest.build(this, desc);
     },
 
@@ -125,12 +124,12 @@ internals.methods = {
 
     defaults(modifier) {
 
-        Assert(typeof modifier === 'function', 'modifier must be a function');
+        assert(typeof modifier === 'function', 'modifier must be a function');
 
         const joi = Object.assign({}, this);
         for (const type of joi._types) {
             const schema = modifier(joi[type]());
-            Assert(Common.isSchema(schema), 'modifier must return a valid schema object');
+            assert(Common.isSchema(schema), 'modifier must return a valid schema object');
 
             joi[type] = function (...args) {
 
@@ -152,7 +151,7 @@ internals.methods = {
 
         Schemas = Schemas || require('./schemas');
 
-        Assert(extensions.length, 'You need to provide at least one extension');
+        assert(extensions.length, 'You need to provide at least one extension');
         this.assert(extensions, Schemas.extensions);
 
         const joi = Object.assign({}, this);
@@ -167,7 +166,7 @@ internals.methods = {
 
             const expanded = internals.expandExtension(extension, joi);
             for (const item of expanded) {
-                Assert(joi[item.type] === undefined || joi._types.has(item.type), 'Cannot override name', item.type);
+                assert(joi[item.type] === undefined || joi._types.has(item.type), 'Cannot override name', item.type);
 
                 const base = item.base || this.any();
                 const schema = Extend.type(base, item);
@@ -236,7 +235,7 @@ internals.assert = function (value, schema, annotate, args /* [message], [option
     const display = annotate && typeof error.annotate === 'function' ? error.annotate() : error.message;
 
     if (error instanceof Errors.ValidationError === false) {
-        error = Clone(error);
+        error = clone(error);
     }
 
     error.message = message ? `${message} ${display}` : display;
@@ -246,7 +245,7 @@ internals.assert = function (value, schema, annotate, args /* [message], [option
 
 internals.generate = function (root, schema, args) {
 
-    Assert(root, 'Must be invoked on a Joi instance.');
+    assert(root, 'Must be invoked on a Joi instance.');
 
     schema.$_root = root;
 

package/lib/manifest.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
+const { assert, clone } = require('@hapi/hoek');
 
 const Common = require('./common');
 const Messages = require('./messages');
@@ -41,7 +40,7 @@ exports.describe = function (schema) {
     // Preferences
 
     if (schema._preferences) {
-        desc.preferences = Clone(schema._preferences, { shallow: ['messages'] });
+        desc.preferences = clone(schema._preferences, { shallow: ['messages'] });
         delete desc.preferences[Common.symbols.prefs];
         if (desc.preferences.messages) {
             desc.preferences.messages = Messages.decompile(desc.preferences.messages);
@@ -106,7 +105,7 @@ exports.describe = function (schema) {
             continue;
         }
 
-        Assert(!desc[term], 'Cannot describe schema due to internal name conflict with', term);
+        assert(!desc[term], 'Cannot describe schema due to internal name conflict with', term);
 
         const items = schema.$_terms[term];
         if (!items) {
@@ -126,7 +125,7 @@ exports.describe = function (schema) {
             continue;
         }
 
-        Assert(def.terms[term], 'Term', term, 'missing configuration');
+        assert(def.terms[term], 'Term', term, 'missing configuration');
         const manifest = def.terms[term].manifest;
         const mapped = typeof manifest === 'object';
         if (!items.length &&
@@ -155,7 +154,7 @@ exports.describe = function (schema) {
         // Single
 
         if (manifest === 'single') {
-            Assert(normalized.length === 1, 'Term', term, 'contains more than one item');
+            assert(normalized.length === 1, 'Term', term, 'contains more than one item');
             desc[term] = normalized[0];
             continue;
         }
@@ -187,7 +186,7 @@ internals.describe = function (item, options = {}) {
     }
 
     if (options.assign === 'options') {
-        return Clone(item);
+        return clone(item);
     }
 
     if (Buffer && Buffer.isBuffer(item)) {                          // $lab:coverage:ignore$
@@ -264,7 +263,7 @@ internals.Builder = class {
         if (desc.flags) {
             for (const flag in desc.flags) {
                 const setter = def.flags[flag] && def.flags[flag].setter || flag;
-                Assert(typeof schema[setter] === 'function', 'Invalid flag', flag, 'for type', desc.type);
+                assert(typeof schema[setter] === 'function', 'Invalid flag', flag, 'for type', desc.type);
                 schema = schema[setter](this.build(desc.flags[flag]));
             }
         }
@@ -289,7 +288,7 @@ internals.Builder = class {
 
         if (desc.rules) {
             for (const rule of desc.rules) {
-                Assert(typeof schema[rule.name] === 'function', 'Invalid rule', rule.name, 'for type', desc.type);
+                assert(typeof schema[rule.name] === 'function', 'Invalid rule', rule.name, 'for type', desc.type);
 
                 const args = [];
                 if (rule.args) {
@@ -301,13 +300,13 @@ internals.Builder = class {
                     const keys = Object.keys(built);
                     const definition = def.rules[rule.name].args;
                     if (definition) {
-                        Assert(keys.length <= definition.length, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to', definition.length, ', found', keys.length, ')');
+                        assert(keys.length <= definition.length, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to', definition.length, ', found', keys.length, ')');
                         for (const { name } of definition) {
                             args.push(built[name]);
                         }
                     }
                     else {
-                        Assert(keys.length === 1, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to 1, found', keys.length, ')');
+                        assert(keys.length === 1, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to 1, found', keys.length, ')');
                         args.push(built[keys[0]]);
                     }
                 }
@@ -339,7 +338,7 @@ internals.Builder = class {
                 continue;
             }
 
-            Assert(def.terms[key], 'Term', key, 'missing configuration');
+            assert(def.terms[key], 'Term', key, 'missing configuration');
             const manifest = def.terms[key].manifest;
 
             if (manifest === 'schema') {
@@ -394,7 +393,7 @@ internals.Builder = class {
         }
 
         if (options.assign === 'options') {
-            return Clone(desc);
+            return clone(desc);
         }
 
         if (options.assign === 'regex') {
@@ -411,7 +410,7 @@ internals.Builder = class {
 
         if (Object.keys(desc).length === 1) {
             if (desc.buffer) {
-                Assert(Buffer, 'Buffers are not supported');
+                assert(Buffer, 'Buffers are not supported');
                 return Buffer && Buffer.from(desc.buffer, 'binary');                    // $lab:coverage:ignore$
             }
 
@@ -432,12 +431,12 @@ internals.Builder = class {
             }
 
             if (desc.special) {
-                Assert(['deep'].includes(desc.special), 'Unknown special value', desc.special);
+                assert(['deep'].includes(desc.special), 'Unknown special value', desc.special);
                 return Common.symbols.deepDefault;
             }
 
             if (desc.value) {
-                return Clone(desc.value);
+                return clone(desc.value);
             }
         }
 

package/lib/messages.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
+const { assert, clone } = require('@hapi/hoek');
 
 const Template = require('./template');
 
@@ -14,22 +13,22 @@ exports.compile = function (messages, target) {
     // Single value string ('plain error message', 'template {error} message')
 
     if (typeof messages === 'string') {
-        Assert(!target, 'Cannot set single message string');
+        assert(!target, 'Cannot set single message string');
         return new Template(messages);
     }
 
     // Single value template
 
     if (Template.isTemplate(messages)) {
-        Assert(!target, 'Cannot set single message template');
+        assert(!target, 'Cannot set single message template');
         return messages;
     }
 
     // By error code { 'number.min': <string | template> }
 
-    Assert(typeof messages === 'object' && !Array.isArray(messages), 'Invalid message options');
+    assert(typeof messages === 'object' && !Array.isArray(messages), 'Invalid message options');
 
-    target = target ? Clone(target) : {};
+    target = target ? clone(target) : {};
 
     for (let code in messages) {
         const message = messages[code];
@@ -48,7 +47,7 @@ exports.compile = function (messages, target) {
 
         // By language { english: { 'number.min': <string | template> } }
 
-        Assert(typeof message === 'object' && !Array.isArray(message), 'Invalid message for', code);
+        assert(typeof message === 'object' && !Array.isArray(message), 'Invalid message for', code);
 
         const language = code;
         target[language] = target[language] || {};
@@ -63,7 +62,7 @@ exports.compile = function (messages, target) {
                 continue;
             }
 
-            Assert(typeof localized === 'string', 'Invalid message for', code, 'in', language);
+            assert(typeof localized === 'string', 'Invalid message for', code, 'in', language);
             target[language][code] = new Template(localized);
         }
     }
@@ -135,7 +134,7 @@ exports.merge = function (base, extended) {
 
     // By error code { 'number.min': <string | template> }
 
-    const target = Clone(base);
+    const target = clone(base);
 
     for (let code in extended) {
         const message = extended[code];
@@ -154,7 +153,7 @@ exports.merge = function (base, extended) {
 
         // By language { english: { 'number.min': <string | template> } }
 
-        Assert(typeof message === 'object' && !Array.isArray(message), 'Invalid message for', code);
+        assert(typeof message === 'object' && !Array.isArray(message), 'Invalid message for', code);
 
         const language = code;
         target[language] = target[language] || {};
@@ -169,7 +168,7 @@ exports.merge = function (base, extended) {
                 continue;
             }
 
-            Assert(typeof localized === 'string', 'Invalid message for', code, 'in', language);
+            assert(typeof localized === 'string', 'Invalid message for', code, 'in', language);
             target[language][code] = new Template(localized);
         }
     }

package/lib/modify.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Common = require('./common');
 const Ref = require('./ref');
@@ -35,12 +35,12 @@ exports.Ids = internals.Ids = class {
         }
 
         for (const [id, value] of source._byId.entries()) {
-            Assert(!this._byKey.has(id), 'Schema id conflicts with existing key:', id);
+            assert(!this._byKey.has(id), 'Schema id conflicts with existing key:', id);
             this._byId.set(id, value);
         }
 
         for (const [key, value] of source._byKey.entries()) {
-            Assert(!this._byId.has(key), 'Schema key conflicts with existing id:', key);
+            assert(!this._byId.has(key), 'Schema key conflicts with existing id:', key);
             this._byKey.set(key, value);
         }
     }
@@ -52,7 +52,7 @@ exports.Ids = internals.Ids = class {
         const tail = chain.shift();
         let adjusted = { id: tail.id, schema: adjuster(tail.schema) };
 
-        Assert(Common.isSchema(adjusted.schema), 'adjuster function failed to return a joi schema type');
+        assert(Common.isSchema(adjusted.schema), 'adjuster function failed to return a joi schema type');
 
         for (const node of chain) {
             adjusted = { id: node.id, schema: internals.fork(node.schema, adjusted.id, adjusted.schema) };
@@ -82,7 +82,7 @@ exports.Ids = internals.Ids = class {
 
         const current = path[0];
         const node = this._get(current);
-        Assert(node, 'Schema does not contain path', [...behind, ...path].join('.'));
+        assert(node, 'Schema does not contain path', [...behind, ...path].join('.'));
 
         const forward = path.slice(1);
         if (!forward.length) {
@@ -109,15 +109,15 @@ exports.Ids = internals.Ids = class {
         const id = schema._flags.id;
         if (id) {
             const existing = this._byId.get(id);
-            Assert(!existing || existing.schema === schema, 'Cannot add different schemas with the same id:', id);
-            Assert(!this._byKey.has(id), 'Schema id conflicts with existing key:', id);
+            assert(!existing || existing.schema === schema, 'Cannot add different schemas with the same id:', id);
+            assert(!this._byKey.has(id), 'Schema id conflicts with existing key:', id);
 
             this._byId.set(id, { schema, id });
         }
 
         if (key) {
-            Assert(!this._byKey.has(key), 'Schema already contains key:', key);
-            Assert(!this._byId.has(key), 'Schema key conflicts with existing id:', key);
+            assert(!this._byKey.has(key), 'Schema already contains key:', key);
+            assert(!this._byId.has(key), 'Schema key conflicts with existing id:', key);
 
             this._byKey.set(key, { schema, id: key });
         }
@@ -134,7 +134,7 @@ exports.Ids = internals.Ids = class {
 
         const current = path[0];
         const node = this._get(current);
-        Assert(node, 'Schema does not contain path', [...behind, ...path].join('.'));
+        assert(node, 'Schema does not contain path', [...behind, ...path].join('.'));
 
         nodes = [node, ...nodes];
 

package/lib/ref.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
-const Reach = require('@hapi/hoek/lib/reach');
+const { assert, clone, reach } = require('@hapi/hoek');
 
 const Common = require('./common');
 
@@ -24,9 +22,9 @@ const internals = {
 
 exports.create = function (key, options = {}) {
 
-    Assert(typeof key === 'string', 'Invalid reference key:', key);
+    assert(typeof key === 'string', 'Invalid reference key:', key);
     Common.assertOptions(options, ['adjust', 'ancestor', 'in', 'iterables', 'map', 'prefix', 'render', 'separator']);
-    Assert(!options.prefix || typeof options.prefix === 'object', 'options.prefix must be of type object');
+    assert(!options.prefix || typeof options.prefix === 'object', 'options.prefix must be of type object');
 
     const ref = Object.assign({}, internals.defaults, options);
     delete ref.prefix;
@@ -38,7 +36,7 @@ exports.create = function (key, options = {}) {
 
     if (ref.type === 'value') {
         if (context.root) {
-            Assert(!separator || key[0] !== separator, 'Cannot specify relative path with root prefix');
+            assert(!separator || key[0] !== separator, 'Cannot specify relative path with root prefix');
             ref.ancestor = 'root';
             if (!key) {
                 key = null;
@@ -53,7 +51,7 @@ exports.create = function (key, options = {}) {
         }
         else {
             if (ref.ancestor !== undefined) {
-                Assert(!separator || !key || key[0] !== separator, 'Cannot combine prefix with ancestor option');
+                assert(!separator || !key || key[0] !== separator, 'Cannot combine prefix with ancestor option');
             }
             else {
                 const [ancestor, slice] = internals.ancestor(key, separator);
@@ -91,20 +89,20 @@ internals.Ref = class {
 
     constructor(options) {
 
-        Assert(typeof options === 'object', 'Invalid reference construction');
+        assert(typeof options === 'object', 'Invalid reference construction');
         Common.assertOptions(options, [
             'adjust', 'ancestor', 'in', 'iterables', 'map', 'path', 'render', 'separator', 'type',  // Copied
             'depth', 'key', 'root', 'display'                                                       // Overridden
         ]);
 
-        Assert([false, undefined].includes(options.separator) || typeof options.separator === 'string' && options.separator.length === 1, 'Invalid separator');
-        Assert(!options.adjust || typeof options.adjust === 'function', 'options.adjust must be a function');
-        Assert(!options.map || Array.isArray(options.map), 'options.map must be an array');
-        Assert(!options.map || !options.adjust, 'Cannot set both map and adjust options');
+        assert([false, undefined].includes(options.separator) || typeof options.separator === 'string' && options.separator.length === 1, 'Invalid separator');
+        assert(!options.adjust || typeof options.adjust === 'function', 'options.adjust must be a function');
+        assert(!options.map || Array.isArray(options.map), 'options.map must be an array');
+        assert(!options.map || !options.adjust, 'Cannot set both map and adjust options');
 
         Object.assign(this, internals.defaults, options);
 
-        Assert(this.type === 'value' || this.ancestor === undefined, 'Non-value references cannot reference ancestors');
+        assert(this.type === 'value' || this.ancestor === undefined, 'Non-value references cannot reference ancestors');
 
         if (Array.isArray(this.map)) {
             this.map = new Map(this.map);
@@ -119,7 +117,7 @@ internals.Ref = class {
 
     resolve(value, state, prefs, local, options = {}) {
 
-        Assert(!this.in || options.in, 'Invalid in() reference usage');
+        assert(!this.in || options.in, 'Invalid in() reference usage');
 
         if (this.type === 'global') {
             return this._resolve(prefs.context, state, options);
@@ -137,7 +135,7 @@ internals.Ref = class {
             return this._resolve(state.ancestors[state.ancestors.length - 1], state, options);
         }
 
-        Assert(this.ancestor <= state.ancestors.length, 'Invalid reference exceeds the schema root:', this.display);
+        assert(this.ancestor <= state.ancestors.length, 'Invalid reference exceeds the schema root:', this.display);
         return this._resolve(state.ancestors[this.ancestor - 1], state, options);
     }
 
@@ -153,7 +151,7 @@ internals.Ref = class {
         }
 
         if (resolved === undefined) {
-            resolved = Reach(target, this.path, { iterables: this.iterables, functions: true });
+            resolved = reach(target, this.path, { iterables: this.iterables, functions: true });
         }
 
         if (this.adjust) {
@@ -398,7 +396,7 @@ exports.Manager = class {
     clone() {
 
         const copy = new exports.Manager();
-        copy.refs = Clone(this.refs);
+        copy.refs = clone(this.refs);
         return copy;
     }
 

package/lib/state.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Clone = require('@hapi/hoek/lib/clone');
-const Reach = require('@hapi/hoek/lib/reach');
+const { clone, reach } = require('@hapi/hoek');
 
 const Common = require('./common');
 
@@ -53,7 +52,7 @@ module.exports = internals.State = class {
     snapshot() {
 
         if (this.mainstay.shadow) {
-            this._snapshot = Clone(this.mainstay.shadow.node(this.path));
+            this._snapshot = clone(this.mainstay.shadow.node(this.path));
         }
 
         this.mainstay.snapshot();
@@ -141,7 +140,7 @@ internals.Shadow = class {
             return;
         }
 
-        return Reach(this._values, path, { iterables: true });
+        return reach(this._values, path, { iterables: true });
     }
 
     override(path, node) {
@@ -152,7 +151,7 @@ internals.Shadow = class {
 
         const parents = path.slice(0, -1);
         const own = path[path.length - 1];
-        const parent = Reach(this._values, parents, { iterables: true });
+        const parent = reach(this._values, parents, { iterables: true });
 
         if (node) {
             parent.set(own, node);

package/lib/template.js

@@ -1,9 +1,7 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
-const EscapeHtml = require('@hapi/hoek/lib/escapeHtml');
-const Formula = require('@sideway/formula');
+const { assert, clone, escapeHtml } = require('@hapi/hoek');
+const Formula = require('@hapi/formula');
 
 const Common = require('./common');
 const Errors = require('./errors');
@@ -30,8 +28,8 @@ module.exports = exports = internals.Template = class {
 
     constructor(source, options) {
 
-        Assert(typeof source === 'string', 'Template source must be a string');
-        Assert(!source.includes('\u0000') && !source.includes('\u0001'), 'Template source cannot contain reserved control characters');
+        assert(typeof source === 'string', 'Template source must be a string');
+        assert(!source.includes('\u0000') && !source.includes('\u0001'), 'Template source cannot contain reserved control characters');
 
         this.source = source;
         this.rendered = source;
@@ -40,11 +38,11 @@ module.exports = exports = internals.Template = class {
 
         if (options) {
             const { functions, ...opts } = options;
-            this._settings = Object.keys(opts).length ? Clone(opts) : undefined;
+            this._settings = Object.keys(opts).length ? clone(opts) : undefined;
             this._functions = functions;
             if (this._functions) {
-                Assert(Object.keys(this._functions).every((key) => typeof key === 'string'), 'Functions keys must be strings');
-                Assert(Object.values(this._functions).every((key) => typeof key === 'function'), 'Functions values must be functions');
+                assert(Object.keys(this._functions).every((key) => typeof key === 'string'), 'Functions keys must be strings');
+                assert(Object.values(this._functions).every((key) => typeof key === 'function'), 'Functions values must be functions');
             }
         }
         else {
@@ -208,7 +206,7 @@ module.exports = exports = internals.Template = class {
                 const rendered = this._part(part, /* context -> [*/ value, state, prefs, local, options /*] */);
                 const string = internals.stringify(rendered, value, state, prefs, local, options);
                 if (string !== undefined) {
-                    const result = part.raw || (options.errors && options.errors.escapeHtml) === false ? string : EscapeHtml(string);
+                    const result = part.raw || (options.errors && options.errors.escapeHtml) === false ? string : escapeHtml(string);
                     parts.push(internals.wrap(result, part.wrapped && prefs.errors.wrap.label));
                 }
             }

package/lib/trace.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const DeepEqual = require('@hapi/hoek/lib/deepEqual');
-const Pinpoint = require('@sideway/pinpoint');
+const { deepEqual } = require('@hapi/hoek');
+const Pinpoint = require('@hapi/pinpoint');
 
 const Errors = require('./errors');
 
@@ -232,7 +232,7 @@ internals.Store = class {
     value(state, by, from, to, name) {
 
         if (!state.mainstay.debug ||
-            DeepEqual(from, to)) {
+            deepEqual(from, to)) {
 
             return;
         }
@@ -327,7 +327,7 @@ internals.sub = function (paths, skipped) {
 
     for (const path of paths) {
         for (const skip of skipped) {
-            if (DeepEqual(path.slice(0, skip.length), skip)) {
+            if (deepEqual(path.slice(0, skip.length), skip)) {
                 return true;
             }
         }

package/lib/types/alternatives.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Merge = require('@hapi/hoek/lib/merge');
+const { assert, merge } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -97,7 +96,7 @@ module.exports = Any.extend({
                 });
             };
 
-            return isAnyObj(schema) ? { value: matched.reduce((acc, v) => Merge(acc, v, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
+            return isAnyObj(schema) ? { value: matched.reduce((acc, v) => merge(acc, v, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
         }
 
         // Match any
@@ -152,9 +151,9 @@ module.exports = Any.extend({
         conditional: {
             method(condition, options) {
 
-                Assert(!this._flags._endedSwitch, 'Unreachable condition');
-                Assert(!this._flags.match, 'Cannot combine match mode', this._flags.match, 'with conditional rule');
-                Assert(options.break === undefined, 'Cannot use break option with alternatives conditional');
+                assert(!this._flags._endedSwitch, 'Unreachable condition');
+                assert(!this._flags.match, 'Cannot combine match mode', this._flags.match, 'with conditional rule');
+                assert(options.break === undefined, 'Cannot use break option with alternatives conditional');
 
                 const obj = this.clone();
 
@@ -177,11 +176,11 @@ module.exports = Any.extend({
         match: {
             method(mode) {
 
-                Assert(['any', 'one', 'all'].includes(mode), 'Invalid alternatives match mode', mode);
+                assert(['any', 'one', 'all'].includes(mode), 'Invalid alternatives match mode', mode);
 
                 if (mode !== 'any') {
                     for (const match of this.$_terms.matches) {
-                        Assert(match.schema, 'Cannot combine match mode', mode, 'with conditional rules');
+                        assert(match.schema, 'Cannot combine match mode', mode, 'with conditional rules');
                     }
                 }
 
@@ -192,10 +191,10 @@ module.exports = Any.extend({
         try: {
             method(...schemas) {
 
-                Assert(schemas.length, 'Missing alternative schemas');
+                assert(schemas.length, 'Missing alternative schemas');
                 Common.verifyFlat(schemas, 'try');
 
-                Assert(!this._flags._endedSwitch, 'Unreachable condition');
+                assert(!this._flags._endedSwitch, 'Unreachable condition');
 
                 const obj = this.clone();
                 for (const schema of schemas) {
@@ -218,6 +217,30 @@ module.exports = Any.extend({
             };
 
             return obj.$_modify({ each, ref: false });
+        },
+
+        isAsync() {
+
+            if (this.$_terms.externals?.length) {
+                return true;
+            }
+
+            for (const match of this.$_terms.matches) {
+
+                if (match.schema?.isAsync()) {
+                    return true;
+                }
+
+                if (match.then?.isAsync()) {
+                    return true;
+                }
+
+                if (match.otherwise?.isAsync()) {
+                    return true;
+                }
+            }
+
+            return false;
         }
     },