joi 17.13.3 → 18.0.1

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 });
 };

package/lib/types/symbol.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 
@@ -62,17 +62,17 @@ module.exports = Any.extend({
                     iterable = Object.entries(iterable);
                 }
 
-                Assert(iterable && iterable[Symbol.iterator], 'Iterable must be an iterable or object');
+                assert(iterable && iterable[Symbol.iterator], 'Iterable must be an iterable or object');
 
                 const obj = this.clone();
 
                 const symbols = [];
                 for (const entry of iterable) {
-                    Assert(entry && entry[Symbol.iterator], 'Entry must be an iterable');
+                    assert(entry && entry[Symbol.iterator], 'Entry must be an iterable');
                     const [key, value] = entry;
 
-                    Assert(typeof key !== 'object' && typeof key !== 'function' && typeof key !== 'symbol', 'Key must not be of type object, function, or Symbol');
-                    Assert(typeof value === 'symbol', 'Value must be a Symbol');
+                    assert(typeof key !== 'object' && typeof key !== 'function' && typeof key !== 'symbol', 'Key must not be of type object, function, or Symbol');
+                    assert(typeof value === 'symbol', 'Value must be a Symbol');
 
                     obj.$_terms.map.set(key, value);
                     symbols.push(value);

package/lib/validator.js

@@ -1,9 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
-const Ignore = require('@hapi/hoek/lib/ignore');
-const Reach = require('@hapi/hoek/lib/reach');
+const { assert, clone, ignore, reach } = require('@hapi/hoek');
 
 const Common = require('./common');
 const Errors = require('./errors');
@@ -19,13 +16,13 @@ exports.entry = function (value, schema, prefs) {
 
     let settings = Common.defaults;
     if (prefs) {
-        Assert(prefs.warnings === undefined, 'Cannot override warnings preference in synchronous validation');
-        Assert(prefs.artifacts === undefined, 'Cannot override artifacts preference in synchronous validation');
+        assert(prefs.warnings === undefined, 'Cannot override warnings preference in synchronous validation');
+        assert(prefs.artifacts === undefined, 'Cannot override artifacts preference in synchronous validation');
         settings = Common.preferences(Common.defaults, prefs);
     }
 
     const result = internals.entry(value, schema, settings);
-    Assert(!result.mainstay.externals.length, 'Schema with external rules must use validateAsync()');
+    assert(!result.mainstay.externals.length, 'Schema with external rules must use validateAsync()');
     const outcome = { value: result.value };
 
     if (result.error) {
@@ -76,7 +73,7 @@ exports.entryAsync = async function (value, schema, prefs) {
             let parent;
 
             const ancestors = path.length ? [root] : [];
-            const original = path.length ? Reach(value, path) : value;
+            const original = path.length ? reach(value, path) : value;
 
             if (path.length) {
                 key = path[path.length - 1];
@@ -189,6 +186,17 @@ exports.entryAsync = async function (value, schema, prefs) {
 };
 
 
+exports.standard = function (value, schema) {
+
+
+    if (schema.isAsync()) {
+        return exports.entryAsync(value, schema);
+    }
+
+    return exports.entry(value, schema);
+};
+
+
 internals.Mainstay = class {
 
     constructor(tracer, debug, links) {
@@ -259,7 +267,7 @@ internals.tracer = function (schema, prefs) {
     }
 
     if (prefs.debug) {
-        Assert(schema.$_root.trace, 'Debug mode not supported');
+        assert(schema.$_root.trace, 'Debug mode not supported');
         return { tracer: schema.$_root.trace()._register(schema), cleanup: true };
     }
 
@@ -575,7 +583,7 @@ internals.finalize = function (value, errors, helpers) {
             }
 
             for (const error of errors) {
-                Assert(error instanceof Error || error instanceof Errors.Report, 'error() must return an Error object');
+                assert(error instanceof Error || error instanceof Errors.Report, 'error() must return an Error object');
             }
         }
         else {
@@ -687,7 +695,7 @@ internals.default = function (flag, value, errors, helpers) {
     }
 
     if (typeof source === 'function') {
-        const args = source.length ? [Clone(state.ancestors[0]), helpers] : [];
+        const args = source.length ? [clone(state.ancestors[0]), helpers] : [];
 
         try {
             return source(...args);
@@ -710,7 +718,7 @@ internals.default = function (flag, value, errors, helpers) {
         return source.resolve(value, state, prefs);
     }
 
-    return Clone(source);
+    return clone(source);
 };
 
 
@@ -733,12 +741,12 @@ internals.trim = function (value, schema) {
 
 internals.ignore = {
     active: false,
-    debug: Ignore,
-    entry: Ignore,
-    filter: Ignore,
-    log: Ignore,
-    resolve: Ignore,
-    value: Ignore
+    debug: ignore,
+    entry: ignore,
+    filter: ignore,
+    log: ignore,
+    resolve: ignore,
+    value: ignore
 };
 
 

package/lib/values.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const DeepEqual = require('@hapi/hoek/lib/deepEqual');
+const { assert, deepEqual } = require('@hapi/hoek');
 
 const Common = require('./common');
 
@@ -132,7 +131,7 @@ module.exports = internals.Values = class {
 
         if (typeof value === 'object') {
             for (const item of this._values) {
-                if (DeepEqual(item, value)) {
+                if (deepEqual(item, value)) {
                     return { value: item };
                 }
             }
@@ -165,7 +164,7 @@ module.exports = internals.Values = class {
                         }
                     }
                     else {
-                        if (DeepEqual(item, value)) {
+                        if (deepEqual(item, value)) {
                             return { value: item, ref };
                         }
                     }
@@ -209,7 +208,7 @@ module.exports = internals.Values = class {
 
     concat(source) {
 
-        Assert(!source._override, 'Cannot concat override set of values');
+        assert(!source._override, 'Cannot concat override set of values');
 
         const set = new internals.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
         set._override = this._override;

package/package.json

@@ -1,8 +1,14 @@
 {
     "name": "joi",
     "description": "Object schema validation",
-    "version": "17.13.3",
-    "repository": "git://github.com/hapijs/joi",
+    "version": "18.0.1",
+    "repository": {
+        "url": "git://github.com/hapijs/joi",
+        "type": "git"
+    },
+    "engines": {
+        "node": ">= 20"
+    },
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
     "browser": "dist/joi-browser.min.js",
@@ -15,19 +21,22 @@
         "validation"
     ],
     "dependencies": {
-        "@hapi/hoek": "^9.3.0",
-        "@hapi/topo": "^5.1.0",
-        "@sideway/address": "^4.1.5",
-        "@sideway/formula": "^3.0.1",
-        "@sideway/pinpoint": "^2.0.0"
+        "@hapi/address": "^5.1.1",
+        "@hapi/formula": "^3.0.2",
+        "@hapi/hoek": "^11.0.7",
+        "@hapi/pinpoint": "^2.0.1",
+        "@hapi/tlds": "^1.1.1",
+        "@hapi/topo": "^6.0.2",
+        "@standard-schema/spec": "^1.0.0"
     },
     "devDependencies": {
-        "@hapi/bourne": "2.x.x",
-        "@hapi/code": "8.x.x",
+        "@hapi/bourne": "^3.0.0",
+        "@hapi/code": "^9.0.3",
+        "@hapi/eslint-plugin": "^7.0.0",
         "@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x",
-        "@hapi/lab": "^25.1.3",
-        "@types/node": "^14.18.63",
-        "typescript": "4.3.x"
+        "@hapi/lab": "^26.0.0",
+        "@types/node": "^20.17.47",
+        "typescript": "^5.8.3"
     },
     "scripts": {
         "prepublishOnly": "cd browser && npm install && npm run build",