joi 17.13.2 → 18.0.0

package/lib/types/date.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');
@@ -78,7 +78,7 @@ module.exports = Any.extend({
         format: {
             method(format) {
 
-                Assert(['iso', 'javascript', 'unix'].includes(format), 'Unknown date format', format);
+                assert(['iso', 'javascript', 'unix'].includes(format), 'Unknown date format', format);
 
                 return this.$_setFlag('format', format);
             }
@@ -122,7 +122,7 @@ module.exports = Any.extend({
         timestamp: {
             method(type = 'javascript') {
 
-                Assert(['javascript', 'unix'].includes(type), '"type" must be one of "javascript, unix"');
+                assert(['javascript', 'unix'].includes(type), '"type" must be one of "javascript, unix"');
 
                 return this.format(type);
             }

package/lib/types/function.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Keys = require('./keys');
 
@@ -20,7 +20,7 @@ module.exports = Keys.extend({
         arity: {
             method(n) {
 
-                Assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
+                assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
 
                 return this.$_addRule({ name: 'arity', args: { n } });
             },
@@ -52,7 +52,7 @@ module.exports = Keys.extend({
         minArity: {
             method(n) {
 
-                Assert(Number.isSafeInteger(n) && n > 0, 'n must be a strict positive integer');
+                assert(Number.isSafeInteger(n) && n > 0, 'n must be a strict positive integer');
 
                 return this.$_addRule({ name: 'minArity', args: { n } });
             },
@@ -69,7 +69,7 @@ module.exports = Keys.extend({
         maxArity: {
             method(n) {
 
-                Assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
+                assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
 
                 return this.$_addRule({ name: 'maxArity', args: { n } });
             },

package/lib/types/keys.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const ApplyToDefaults = require('@hapi/hoek/lib/applyToDefaults');
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
+const { applyToDefaults, assert, clone: Clone } = require('@hapi/hoek');
 const Topo = require('@hapi/topo');
 
 const Any = require('./any');
@@ -199,7 +197,7 @@ module.exports = Any.extend({
                     subject = Compile.ref(subject);
                 }
 
-                Assert(message === undefined || typeof message === 'string', 'Message must be a string');
+                assert(message === undefined || typeof message === 'string', 'Message must be a string');
 
                 schema = this.$_compile(schema, { appendPath: true });
 
@@ -225,7 +223,7 @@ module.exports = Any.extend({
         instance: {
             method(constructor, name) {
 
-                Assert(typeof constructor === 'function', 'constructor must be a function');
+                assert(typeof constructor === 'function', 'constructor must be a function');
 
                 name = name || constructor.name;
 
@@ -245,8 +243,8 @@ module.exports = Any.extend({
         keys: {
             method(schema) {
 
-                Assert(schema === undefined || typeof schema === 'object', 'Object schema must be a valid object');
-                Assert(!Common.isSchema(schema), 'Object schema cannot be a joi schema');
+                assert(schema === undefined || typeof schema === 'object', 'Object schema must be a valid object');
+                assert(!Common.isSchema(schema), 'Object schema cannot be a joi schema');
 
                 const obj = this.clone();
 
@@ -337,11 +335,11 @@ module.exports = Any.extend({
                     pattern = this.$_compile(pattern, { appendPath: true });
                 }
 
-                Assert(schema !== undefined, 'Invalid rule');
+                assert(schema !== undefined, 'Invalid rule');
                 Common.assertOptions(options, ['fallthrough', 'matches']);
 
                 if (isRegExp) {
-                    Assert(!pattern.flags.includes('g') && !pattern.flags.includes('y'), 'pattern should not use global or sticky mode');
+                    assert(!pattern.flags.includes('g') && !pattern.flags.includes('y'), 'pattern should not use global or sticky mode');
                 }
 
                 schema = this.$_compile(schema, { appendPath: true });
@@ -402,9 +400,9 @@ module.exports = Any.extend({
         rename: {
             method(from, to, options = {}) {
 
-                Assert(typeof from === 'string' || from instanceof RegExp, 'Rename missing the from argument');
-                Assert(typeof to === 'string' || to instanceof Template, 'Invalid rename to argument');
-                Assert(to !== from, 'Cannot rename key to same name:', from);
+                assert(typeof from === 'string' || from instanceof RegExp, 'Rename missing the from argument');
+                assert(typeof to === 'string' || to instanceof Template, 'Invalid rename to argument');
+                assert(to !== from, 'Cannot rename key to same name:', from);
 
                 Common.assertOptions(options, ['alias', 'ignoreUndefined', 'override', 'multiple']);
 
@@ -412,7 +410,7 @@ module.exports = Any.extend({
 
                 obj.$_terms.renames = obj.$_terms.renames || [];
                 for (const rename of obj.$_terms.renames) {
-                    Assert(rename.from !== from, 'Cannot rename the same key multiple times');
+                    assert(rename.from !== from, 'Cannot rename the same key multiple times');
                 }
 
                 if (to instanceof Template) {
@@ -422,7 +420,7 @@ module.exports = Any.extend({
                 obj.$_terms.renames.push({
                     from,
                     to,
-                    options: ApplyToDefaults(internals.renameDefaults, options)
+                    options: applyToDefaults(internals.renameDefaults, options)
                 });
 
                 return obj;
@@ -486,6 +484,31 @@ module.exports = Any.extend({
             }
 
             return this.$_parent('default', value, options);
+        },
+
+        isAsync() {
+
+            if (this.$_terms.externals?.length) {
+                return true;
+            }
+
+            if (this.$_terms.keys?.length) {
+                for (const key of this.$_terms.keys) {
+                    if (key.schema.isAsync()) {
+                        return true;
+                    }
+                }
+            }
+
+            if (this.$_terms.patterns?.length) {
+                for (const pattern of this.$_terms.patterns) {
+                    if (pattern.rule.isAsync()) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
         }
     },
 
@@ -589,7 +612,7 @@ internals.clone = function (value, prefs) {
 
 internals.dependency = function (schema, rel, key, peers, options) {
 
-    Assert(key === null || typeof key === 'string', rel, 'key must be a strings');
+    assert(key === null || typeof key === 'string', rel, 'key must be a strings');
 
     // Extract options from peers array
 
@@ -606,7 +629,7 @@ internals.dependency = function (schema, rel, key, peers, options) {
     const separator = Common.default(options.separator, '.');
     const paths = [];
     for (const peer of peers) {
-        Assert(typeof peer === 'string', rel, 'peers must be strings');
+        assert(typeof peer === 'string', rel, 'peers must be strings');
         paths.push(Compile.ref(peer, { separator, ancestor: 0, prefix: false }));
     }
 

package/lib/types/link.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');
@@ -31,7 +31,7 @@ module.exports = Any.extend({
 
     validate(value, { schema, state, prefs }) {
 
-        Assert(schema.$_terms.link, 'Uninitialized link schema');
+        assert(schema.$_terms.link, 'Uninitialized link schema');
 
         const linked = internals.generate(schema, value, state, prefs);
         const ref = schema.$_terms.link[0].ref;
@@ -48,12 +48,12 @@ module.exports = Any.extend({
         ref: {
             method(ref) {
 
-                Assert(!this.$_terms.link, 'Cannot reinitialize schema');
+                assert(!this.$_terms.link, 'Cannot reinitialize schema');
 
                 ref = Compile.ref(ref);
 
-                Assert(ref.type === 'value' || ref.type === 'local', 'Invalid reference type:', ref.type);
-                Assert(ref.type === 'local' || ref.ancestor === 'root' || ref.ancestor > 0, 'Link cannot reference itself');
+                assert(ref.type === 'value' || ref.type === 'local', 'Invalid reference type:', ref.type);
+                assert(ref.type === 'local' || ref.ancestor === 'root' || ref.ancestor > 0, 'Link cannot reference itself');
 
                 const obj = this.clone();
                 obj.$_terms.link = [{ ref }];
@@ -73,9 +73,9 @@ module.exports = Any.extend({
 
         concat(source) {
 
-            Assert(this.$_terms.link, 'Uninitialized link schema');
-            Assert(Common.isSchema(source), 'Invalid schema object');
-            Assert(source.type !== 'link', 'Cannot merge type link with another link');
+            assert(this.$_terms.link, 'Uninitialized link schema');
+            assert(Common.isSchema(source), 'Invalid schema object');
+            assert(source.type !== 'link', 'Cannot merge type link with another link');
 
             const obj = this.clone();
 
@@ -92,7 +92,7 @@ module.exports = Any.extend({
 
         build(obj, desc) {
 
-            Assert(desc.link, 'Invalid link description missing link');
+            assert(desc.link, 'Invalid link description missing link');
             return obj.ref(desc.link);
         }
     }
@@ -115,7 +115,7 @@ internals.generate = function (schema, value, state, prefs) {
     try {
         linked = path.length ? perspective.$_reach(path) : perspective;
     }
-    catch (ignoreErr) {
+    catch {
         internals.assert(false, 'to non-existing schema', ref, schema, state, prefs);
     }
 
@@ -164,5 +164,5 @@ internals.assert = function (condition, message, ref, schema, state, prefs) {
         return;
     }
 
-    Assert(false, `"${Errors.label(schema._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
+    assert(false, `"${Errors.label(schema._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
 };

package/lib/types/number.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');
@@ -251,7 +251,7 @@ module.exports = Any.extend({
         precision: {
             method(limit) {
 
-                Assert(Number.isSafeInteger(limit), 'limit must be an integer');
+                assert(Number.isSafeInteger(limit), 'limit must be an integer');
 
                 return this.$_addRule({ name: 'precision', args: { limit } });
             },
@@ -271,7 +271,7 @@ module.exports = Any.extend({
         sign: {
             method(sign) {
 
-                Assert(['negative', 'positive'].includes(sign), 'Invalid sign', sign);
+                assert(['negative', 'positive'].includes(sign), 'Invalid sign', sign);
 
                 return this.$_addRule({ name: 'sign', args: { sign } });
             },
@@ -290,7 +290,7 @@ module.exports = Any.extend({
         unsafe: {
             method(enabled = true) {
 
-                Assert(typeof enabled === 'boolean', 'enabled must be a boolean');
+                assert(typeof enabled === 'boolean', 'enabled must be a boolean');
 
                 return this.$_setFlag('unsafe', enabled);
             }

package/lib/types/string.js

@@ -1,19 +1,15 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Domain = require('@sideway/address/lib/domain');
-const Email = require('@sideway/address/lib/email');
-const Ip = require('@sideway/address/lib/ip');
-const EscapeRegex = require('@hapi/hoek/lib/escapeRegex');
-const Tlds = require('@sideway/address/lib/tlds');
-const Uri = require('@sideway/address/lib/uri');
+const { assert, escapeRegex } = require('@hapi/hoek');
+const { isDomainValid, isEmailValid, ipRegex, uriRegex } = require('@hapi/address');
+const Tlds = require('@hapi/tlds');
 
 const Any = require('./any');
 const Common = require('../common');
 
 
 const internals = {
-    tlds: Tlds instanceof Set ? { tlds: { allow: Tlds, deny: null } } : false,              // $lab:coverage:ignore$
+    tlds: Tlds.tlds instanceof Set ? { tlds: { allow: Tlds.tlds, deny: null } } : false,              // $lab:coverage:ignore$
     base64Regex: {
         // paddingRequired
         true: {
@@ -32,7 +28,7 @@ const internals = {
         withOptionalPrefix: /^(?:0x)?[0-9a-f]+$/i,
         withoutPrefix: /^[0-9a-f]+$/i
     },
-    ipRegex: Ip.regex({ cidr: 'forbidden' }).regex,
+    ipRegex: ipRegex({ cidr: 'forbidden' }).regex,
     isoDurationRegex: /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/,
 
     guidBrackets: {
@@ -171,8 +167,8 @@ module.exports = Any.extend({
                 Common.assertOptions(options, ['paddingRequired', 'urlSafe']);
 
                 options = { urlSafe: false, paddingRequired: true, ...options };
-                Assert(typeof options.paddingRequired === 'boolean', 'paddingRequired must be boolean');
-                Assert(typeof options.urlSafe === 'boolean', 'urlSafe must be boolean');
+                assert(typeof options.paddingRequired === 'boolean', 'paddingRequired must be boolean');
+                assert(typeof options.urlSafe === 'boolean', 'urlSafe must be boolean');
 
                 return this.$_addRule({ name: 'base64', args: { options } });
             },
@@ -190,7 +186,7 @@ module.exports = Any.extend({
         case: {
             method(direction) {
 
-                Assert(['lower', 'upper'].includes(direction), 'Invalid case:', direction);
+                assert(['lower', 'upper'].includes(direction), 'Invalid case:', direction);
 
                 return this.$_addRule({ name: 'case', args: { direction } });
             },
@@ -240,7 +236,7 @@ module.exports = Any.extend({
                 Common.assertOptions(options, ['paddingRequired']);
 
                 options = { paddingRequired: true, ...options };
-                Assert(typeof options.paddingRequired === 'boolean', 'paddingRequired must be boolean');
+                assert(typeof options.paddingRequired === 'boolean', 'paddingRequired must be boolean');
 
                 return this.$_addRule({ name: 'dataUri', args: { options } });
             },
@@ -271,7 +267,7 @@ module.exports = Any.extend({
             method(options) {
 
                 if (options) {
-                    Common.assertOptions(options, ['allowFullyQualified', 'allowUnicode', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
+                    Common.assertOptions(options, ['allowFullyQualified', 'allowUnicode', 'allowUnderscore', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
                 }
 
                 const address = internals.addressOptions(options);
@@ -279,7 +275,7 @@ module.exports = Any.extend({
             },
             validate(value, helpers, args, { address }) {
 
-                if (Domain.isValid(value, address)) {
+                if (isDomainValid(value, address)) {
                     return value;
                 }
 
@@ -291,10 +287,10 @@ module.exports = Any.extend({
             method(options = {}) {
 
                 Common.assertOptions(options, ['allowFullyQualified', 'allowUnicode', 'ignoreLength', 'maxDomainSegments', 'minDomainSegments', 'multiple', 'separator', 'tlds']);
-                Assert(options.multiple === undefined || typeof options.multiple === 'boolean', 'multiple option must be an boolean');
+                assert(options.multiple === undefined || typeof options.multiple === 'boolean', 'multiple option must be an boolean');
 
                 const address = internals.addressOptions(options);
-                const regex = new RegExp(`\\s*[${options.separator ? EscapeRegex(options.separator) : ','}]\\s*`);
+                const regex = new RegExp(`\\s*[${options.separator ? escapeRegex(options.separator) : ','}]\\s*`);
 
                 return this.$_addRule({ name: 'email', args: { options }, regex, address });
             },
@@ -303,7 +299,7 @@ module.exports = Any.extend({
                 const emails = options.multiple ? value.split(regex) : [value];
                 const invalids = [];
                 for (const email of emails) {
-                    if (!Email.isValid(email, address)) {
+                    if (!isEmailValid(email, address)) {
                         invalids.push(email);
                     }
                 }
@@ -320,37 +316,72 @@ module.exports = Any.extend({
             alias: 'uuid',
             method(options = {}) {
 
-                Common.assertOptions(options, ['version', 'separator']);
+                Common.assertOptions(options, ['version', 'separator', 'wrapper']);
+
+                assert(
+                    options.wrapper === undefined ||
+                    typeof options.wrapper === 'boolean' ||
+                    (typeof options.wrapper === 'string' && typeof internals.guidBrackets[options.wrapper] === 'string'),
+                    `"wrapper" must be true, false, or one of "${Object.keys(internals.guidBrackets).filter(Boolean).join('", "')}"`
+                );
 
                 let versionNumbers = '';
 
                 if (options.version) {
                     const versions = [].concat(options.version);
 
-                    Assert(versions.length >= 1, 'version must have at least 1 valid version specified');
+                    assert(versions.length >= 1, 'version must have at least 1 valid version specified');
                     const set = new Set();
 
                     for (let i = 0; i < versions.length; ++i) {
                         const version = versions[i];
-                        Assert(typeof version === 'string', 'version at position ' + i + ' must be a string');
+                        assert(typeof version === 'string', 'version at position ' + i + ' must be a string');
                         const versionNumber = internals.guidVersions[version.toLowerCase()];
-                        Assert(versionNumber, 'version at position ' + i + ' must be one of ' + Object.keys(internals.guidVersions).join(', '));
-                        Assert(!set.has(versionNumber), 'version at position ' + i + ' must not be a duplicate');
+                        assert(versionNumber, 'version at position ' + i + ' must be one of ' + Object.keys(internals.guidVersions).join(', '));
+                        assert(!set.has(versionNumber), 'version at position ' + i + ' must not be a duplicate');
 
                         versionNumbers += versionNumber;
                         set.add(versionNumber);
                     }
                 }
 
-                Assert(internals.guidSeparators.has(options.separator), 'separator must be one of true, false, "-", or ":"');
+                assert(internals.guidSeparators.has(options.separator), 'separator must be one of true, false, "-", or ":"');
                 const separator = options.separator === undefined ? '[:-]?' :
                     options.separator === true ? '[:-]' :
                         options.separator === false ? '[]?' : `\\${options.separator}`;
 
-                const regex = new RegExp(`^([\\[{\\(]?)[0-9A-F]{8}(${separator})[0-9A-F]{4}\\2?[${versionNumbers || '0-9A-F'}][0-9A-F]{3}\\2?[${versionNumbers ? '89AB' : '0-9A-F'}][0-9A-F]{3}\\2?[0-9A-F]{12}([\\]}\\)]?)$`, 'i');
+                let wrapperStart;
+                let wrapperEnd;
+
+                if (options.wrapper === undefined) {
+                    wrapperStart = '[\\[{\\(]?';
+                    wrapperEnd = '[\\]}\\)]?';
+                }
+                else if (options.wrapper === true) {
+                    wrapperStart = '[\\[{\\(]';
+                    wrapperEnd = '[\\]}\\)]';
+                }
+                else if (options.wrapper === false) {
+                    wrapperStart = '';
+                    wrapperEnd = '';
+                }
+                else {
+                    wrapperStart = escapeRegex(options.wrapper);
+                    wrapperEnd = escapeRegex(internals.guidBrackets[options.wrapper]);
+                }
+
+                const regex = new RegExp(
+                    `^(${wrapperStart})[0-9A-F]{8}(${separator})[0-9A-F]{4}\\2?[${
+                        versionNumbers || '0-9A-F'
+                    }][0-9A-F]{3}\\2?[${
+                        versionNumbers ? '89AB' : '0-9A-F'
+                    }][0-9A-F]{3}\\2?[0-9A-F]{12}(${wrapperEnd})$`,
+                    'i'
+                );
 
                 return this.$_addRule({ name: 'guid', args: { options }, regex });
             },
+
             validate(value, helpers, args, { regex }) {
 
                 const results = regex.exec(value);
@@ -359,9 +390,10 @@ module.exports = Any.extend({
                     return helpers.error('string.guid');
                 }
 
-                // Matching braces
+                const open = results[1];
+                const close = results[results.length - 1];
 
-                if (internals.guidBrackets[results[1]] !== results[results.length - 1]) {
+                if ((open || close) && internals.guidBrackets[open] !== close) {
                     return helpers.error('string.guid');
                 }
 
@@ -375,8 +407,8 @@ module.exports = Any.extend({
                 Common.assertOptions(options, ['byteAligned', 'prefix']);
 
                 options = { byteAligned: false, prefix: false, ...options };
-                Assert(typeof options.byteAligned === 'boolean', 'byteAligned must be boolean');
-                Assert(typeof options.prefix === 'boolean' || options.prefix === 'optional', 'prefix must be boolean or "optional"');
+                assert(typeof options.byteAligned === 'boolean', 'byteAligned must be boolean');
+                assert(typeof options.prefix === 'boolean' || options.prefix === 'optional', 'prefix must be boolean or "optional"');
 
                 return this.$_addRule({ name: 'hex', args: { options } });
             },
@@ -408,7 +440,7 @@ module.exports = Any.extend({
             },
             validate(value, helpers) {
 
-                if (Domain.isValid(value, { minDomainSegments: 1 }) ||
+                if (isDomainValid(value, { minDomainSegments: 1 }) ||
                     internals.ipRegex.test(value)) {
 
                     return value;
@@ -430,7 +462,7 @@ module.exports = Any.extend({
 
                 Common.assertOptions(options, ['cidr', 'version']);
 
-                const { cidr, versions, regex } = Ip.regex(options);
+                const { cidr, versions, regex } = ipRegex(options);
                 const version = options.version ? versions : undefined;
                 return this.$_addRule({ name: 'ip', args: { options: { cidr, version } }, regex });
             },
@@ -529,7 +561,7 @@ module.exports = Any.extend({
         normalize: {
             method(form = 'NFC') {
 
-                Assert(internals.normalizationForms.includes(form), 'normalization form must be one of ' + internals.normalizationForms.join(', '));
+                assert(internals.normalizationForms.includes(form), 'normalization form must be one of ' + internals.normalizationForms.join(', '));
 
                 return this.$_addRule({ name: 'normalize', args: { form } });
             },
@@ -548,8 +580,8 @@ module.exports = Any.extend({
             alias: 'regex',
             method(regex, options = {}) {
 
-                Assert(regex instanceof RegExp, 'regex must be a RegExp');
-                Assert(!regex.flags.includes('g') && !regex.flags.includes('y'), 'regex should not use global or sticky mode');
+                assert(regex instanceof RegExp, 'regex must be a RegExp');
+                assert(!regex.flags.includes('g') && !regex.flags.includes('y'), 'regex should not use global or sticky mode');
 
                 if (typeof options === 'string') {
                     options = { name: options };
@@ -578,11 +610,11 @@ module.exports = Any.extend({
             method(pattern, replacement) {
 
                 if (typeof pattern === 'string') {
-                    pattern = new RegExp(EscapeRegex(pattern), 'g');
+                    pattern = new RegExp(escapeRegex(pattern), 'g');
                 }
 
-                Assert(pattern instanceof RegExp, 'pattern must be a RegExp');
-                Assert(typeof replacement === 'string', 'replacement must be a String');
+                assert(pattern instanceof RegExp, 'pattern must be a RegExp');
+                assert(typeof replacement === 'string', 'replacement must be a String');
 
                 const obj = this.clone();
 
@@ -613,7 +645,7 @@ module.exports = Any.extend({
         trim: {
             method(enabled = true) {
 
-                Assert(typeof enabled === 'boolean', 'enabled must be a boolean');
+                assert(typeof enabled === 'boolean', 'enabled must be a boolean');
 
                 return this.$_addRule({ name: 'trim', args: { enabled } });
             },
@@ -633,7 +665,7 @@ module.exports = Any.extend({
         truncate: {
             method(enabled = true) {
 
-                Assert(typeof enabled === 'boolean', 'enabled must be a boolean');
+                assert(typeof enabled === 'boolean', 'enabled must be a boolean');
 
                 return this.$_setFlag('truncate', enabled);
             }
@@ -655,7 +687,7 @@ module.exports = Any.extend({
                     Common.assertOptions(options.domain, ['allowFullyQualified', 'allowUnicode', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
                 }
 
-                const { regex, scheme } = Uri.regex(options);
+                const { regex, scheme } = uriRegex(options);
                 const domain = options.domain ? internals.addressOptions(options.domain) : null;
                 return this.$_addRule({ name: 'uri', args: { options }, regex, domain, scheme });
             },
@@ -679,7 +711,7 @@ module.exports = Any.extend({
                     const matched = match[1] || match[2];
                     if (domain &&
                         (!options.allowRelative || matched) &&
-                        !Domain.isValid(matched, domain)) {
+                        !isDomainValid(matched, domain)) {
 
                         return helpers.error('string.domain', { value: matched });
                     }
@@ -760,12 +792,12 @@ internals.addressOptions = function (options) {
 
     // minDomainSegments
 
-    Assert(options.minDomainSegments === undefined ||
+    assert(options.minDomainSegments === undefined ||
         Number.isSafeInteger(options.minDomainSegments) && options.minDomainSegments > 0, 'minDomainSegments must be a positive integer');
 
     // maxDomainSegments
 
-    Assert(options.maxDomainSegments === undefined ||
+    assert(options.maxDomainSegments === undefined ||
         Number.isSafeInteger(options.maxDomainSegments) && options.maxDomainSegments > 0, 'maxDomainSegments must be a positive integer');
 
     // tlds
@@ -777,11 +809,11 @@ internals.addressOptions = function (options) {
     if (options.tlds === true ||
         options.tlds === undefined) {
 
-        Assert(internals.tlds, 'Built-in TLD list disabled');
+        assert(internals.tlds, 'Built-in TLD list disabled');
         return Object.assign({}, options, internals.tlds);
     }
 
-    Assert(typeof options.tlds === 'object', 'tlds must be true, false, or an object');
+    assert(typeof options.tlds === 'object', 'tlds must be true, false, or an object');
 
     const deny = options.tlds.deny;
     if (deny) {
@@ -789,19 +821,19 @@ internals.addressOptions = function (options) {
             options = Object.assign({}, options, { tlds: { deny: new Set(deny) } });
         }
 
-        Assert(options.tlds.deny instanceof Set, 'tlds.deny must be an array, Set, or boolean');
-        Assert(!options.tlds.allow, 'Cannot specify both tlds.allow and tlds.deny lists');
+        assert(options.tlds.deny instanceof Set, 'tlds.deny must be an array, Set, or boolean');
+        assert(!options.tlds.allow, 'Cannot specify both tlds.allow and tlds.deny lists');
         internals.validateTlds(options.tlds.deny, 'tlds.deny');
         return options;
     }
 
     const allow = options.tlds.allow;
     if (!allow) {
-        return options;
+        return { ...options, tlds: false };
     }
 
     if (allow === true) {
-        Assert(internals.tlds, 'Built-in TLD list disabled');
+        assert(internals.tlds, 'Built-in TLD list disabled');
         return Object.assign({}, options, internals.tlds);
     }
 
@@ -809,7 +841,7 @@ internals.addressOptions = function (options) {
         options = Object.assign({}, options, { tlds: { allow: new Set(allow) } });
     }
 
-    Assert(options.tlds.allow instanceof Set, 'tlds.allow must be an array, Set, or boolean');
+    assert(options.tlds.allow instanceof Set, 'tlds.allow must be an array, Set, or boolean');
     internals.validateTlds(options.tlds.allow, 'tlds.allow');
     return options;
 };
@@ -818,7 +850,7 @@ internals.addressOptions = function (options) {
 internals.validateTlds = function (set, source) {
 
     for (const tld of set) {
-        Assert(Domain.isValid(tld, { minDomainSegments: 1, maxDomainSegments: 1 }), `${source} must contain valid top level domain names`);
+        assert(isDomainValid(tld, { minDomainSegments: 1, maxDomainSegments: 1 }), `${source} must contain valid top level domain names`);
     }
 };
 
@@ -844,7 +876,7 @@ internals.isoDate = function (value) {
 
 internals.length = function (schema, name, limit, operator, encoding) {
 
-    Assert(!encoding || Buffer && Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);      // $lab:coverage:ignore$
+    assert(!encoding || Buffer && Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);      // $lab:coverage:ignore$
 
     return schema.$_addRule({ name, method: 'length', args: { limit, encoding }, operator });
 };