joi 17.13.2 → 18.0.0

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;
         }
     },
 
@@ -328,10 +351,13 @@ internals.errors = function (failures, { error, state }) {
         const [type, code] = report.code.split('.');
         if (code !== 'base') {
             complex.push({ type: schema.type, report });
-            continue;
         }
-
-        valids.add(type);
+        else if (report.code === 'object.base') {
+            valids.add(report.local.type);
+        }
+        else {
+            valids.add(type);
+        }
     }
 
     // All errors are base types or valids

package/lib/types/any.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Base = require('../base');
 const Common = require('../common');
@@ -36,8 +36,8 @@ module.exports = Base.extend({
         custom: {
             method(method, description) {
 
-                Assert(typeof method === 'function', 'Method must be a function');
-                Assert(description === undefined || description && typeof description === 'string', 'Description must be a non-empty string');
+                assert(typeof method === 'function', 'Method must be a function');
+                assert(description === undefined || description && typeof description === 'string', 'Description must be a non-empty string');
 
                 return this.$_addRule({ name: 'custom', args: { method, description } });
             },
@@ -64,7 +64,7 @@ module.exports = Base.extend({
         shared: {
             method(schema) {
 
-                Assert(Common.isSchema(schema) && schema._flags.id, 'Schema must be a schema with an id');
+                assert(Common.isSchema(schema) && schema._flags.id, 'Schema must be a schema with an id');
 
                 const obj = this.clone();
                 obj.$_terms.shared = obj.$_terms.shared || [];
@@ -77,7 +77,7 @@ module.exports = Base.extend({
         warning: {
             method(code, local) {
 
-                Assert(code && typeof code === 'string', 'Invalid warning code');
+                assert(code && typeof code === 'string', 'Invalid warning code');
 
                 return this.$_addRule({ name: 'warning', args: { code, local }, warn: true });
             },

package/lib/types/array.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const DeepEqual = require('@hapi/hoek/lib/deepEqual');
-const Reach = require('@hapi/hoek/lib/reach');
+const { assert, deepEqual, reach } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -417,7 +415,7 @@ module.exports = Any.extend({
             method(enabled) {
 
                 const value = enabled === undefined ? true : !!enabled;
-                Assert(!value || !this._flags._arrayItems, 'Cannot specify single rule when array has array items');
+                assert(!value || !this._flags._arrayItems, 'Cannot specify single rule when array has array items');
 
                 return this.$_setFlag('single', value);
             }
@@ -434,7 +432,7 @@ module.exports = Any.extend({
 
                 if (options.by) {
                     settings.by = Compile.ref(options.by, { ancestor: 0 });
-                    Assert(!settings.by.ancestor, 'Cannot sort by ancestor');
+                    assert(!settings.by.ancestor, 'Cannot sort by ancestor');
                 }
 
                 return this.$_addRule({ name: 'sort', args: { options: settings } });
@@ -474,7 +472,7 @@ module.exports = Any.extend({
         unique: {
             method(comparator, options = {}) {
 
-                Assert(!comparator || typeof comparator === 'function' || typeof comparator === 'string', 'comparator must be a function or a string');
+                assert(!comparator || typeof comparator === 'function' || typeof comparator === 'string', 'comparator must be a function or a string');
                 Common.assertOptions(options, ['ignoreUndefined', 'separator']);
 
                 const rule = { name: 'unique', args: { options, comparator } };
@@ -504,13 +502,13 @@ module.exports = Any.extend({
                     custom: new Map()
                 };
 
-                const compare = comparator || DeepEqual;
+                const compare = comparator || deepEqual;
                 const ignoreUndefined = options.ignoreUndefined;
 
                 for (let i = 0; i < value.length; ++i) {
-                    const item = path ? Reach(value[i], path) : value[i];
+                    const item = path ? reach(value[i], path) : value[i];
                     const records = comparator ? found.custom : found[typeof item];
-                    Assert(records, 'Failed to find unique map container for type', typeof item);
+                    assert(records, 'Failed to find unique map container for type', typeof item);
 
                     if (records instanceof Map) {
                         const entries = records.entries();
@@ -565,6 +563,30 @@ module.exports = Any.extend({
         }
     },
 
+    overrides: {
+
+        isAsync() {
+
+            if (this.$_terms.externals?.length) {
+                return true;
+            }
+
+            for (const item of this.$_terms.items) {
+                if (item.isAsync()) {
+                    return true;
+                }
+            }
+
+            for (const item of this.$_terms.ordered) {
+                if (item.isAsync()) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    },
+
     cast: {
         set: {
             from: Array.isArray,
@@ -727,7 +749,7 @@ internals.validateSingle = function (type, obj) {
     if (type.type === 'array' ||
         type._flags._arrayItems) {
 
-        Assert(!obj._flags.single, 'Cannot specify array item with single rule enabled');
+        assert(!obj._flags.single, 'Cannot specify array item with single rule enabled');
         obj.$_setFlag('_arrayItems', true, { clone: false });
     }
 };

package/lib/types/binary.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -21,7 +21,7 @@ module.exports = Any.extend({
                 try {
                     return { value: Buffer.from(value, schema._flags.encoding) };
                 }
-                catch (ignoreErr) { }
+                catch { }
             }
         }
     },
@@ -37,7 +37,7 @@ module.exports = Any.extend({
         encoding: {
             method(encoding) {
 
-                Assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
+                assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
 
                 return this.$_setFlag('encoding', encoding);
             }

package/lib/types/boolean.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -76,7 +76,7 @@ module.exports = Any.extend({
                 for (let i = 0; i < values.length; ++i) {
                     const value = values[i];
 
-                    Assert(value !== undefined, 'Cannot call truthy with undefined');
+                    assert(value !== undefined, 'Cannot call truthy with undefined');
                     obj.$_terms.truthy.add(value);
                 }
 
@@ -95,7 +95,7 @@ module.exports = Any.extend({
                 for (let i = 0; i < values.length; ++i) {
                     const value = values[i];
 
-                    Assert(value !== undefined, 'Cannot call falsy with undefined');
+                    assert(value !== undefined, 'Cannot call falsy with undefined');
                     obj.$_terms.falsy.add(value);
                 }