joi 17.1.1 → 17.2.0

package/lib/manifest.js

@@ -256,7 +256,7 @@ internals.Builder = class {
 
         // Type
 
-        let schema = this.joi[desc.type]();
+        let schema = this.joi[desc.type]()._bare();
         const def = schema._definition;
 
         // Flags

package/lib/ref.js

@@ -25,7 +25,7 @@ const internals = {
 exports.create = function (key, options = {}) {
 
     Assert(typeof key === 'string', 'Invalid reference key:', key);
-    Common.assertOptions(options, ['adjust', 'ancestor', 'in', 'iterables', 'map', 'prefix', 'separator']);
+    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');
 
     const ref = Object.assign({}, internals.defaults, options);
@@ -77,7 +77,7 @@ exports.create = function (key, options = {}) {
 
 exports.in = function (key, options = {}) {
 
-    return exports.create(key, Object.assign({}, options, { in: true }));
+    return exports.create(key, { ...options, in: true });
 };
 
 
@@ -93,8 +93,8 @@ internals.Ref = class {
 
         Assert(typeof options === 'object', 'Invalid reference construction');
         Common.assertOptions(options, [
-            'adjust', 'ancestor', 'in', 'iterables', 'map', 'path', 'separator', 'type',    // Copied
-            'depth', 'key', 'root', 'display'                                               // Overridden
+            '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');
@@ -211,8 +211,10 @@ internals.Ref = class {
             ref.map = [...this.map];
         }
 
-        for (const key of ['adjust', 'iterables']) {
-            if (this[key] !== null) {
+        for (const key of ['adjust', 'iterables', 'render']) {
+            if (this[key] !== null &&
+                this[key] !== undefined) {
+
                 ref[key] = this[key];
             }
         }

package/lib/schemas.js

@@ -17,6 +17,7 @@ internals.wrap = Joi.string()
 exports.preferences = Joi.object({
     allowUnknown: Joi.boolean(),
     abortEarly: Joi.boolean(),
+    artifacts: Joi.boolean(),
     cache: Joi.boolean(),
     context: Joi.object(),
     convert: Joi.boolean(),
@@ -89,6 +90,10 @@ exports.extension = Joi.object({
     ])
         .required(),
     args: Joi.function(),
+    cast: Joi.object().pattern(internals.nameRx, Joi.object({
+        from: Joi.function().maxArity(1).required(),
+        to: Joi.function().minArity(1).maxArity(2).required()
+    })),
     base: Joi.object().schema()
         .when('type', { is: Joi.object().regex(), then: Joi.forbidden() }),
     coerce: [
@@ -157,7 +162,8 @@ internals.desc = {
             map: Joi.array().items(Joi.array().length(2)).min(1),
             adjust: Joi.function(),
             iterables: Joi.boolean(),
-            in: Joi.boolean()
+            in: Joi.boolean(),
+            render: Joi.boolean()
         })
             .required()
     }),
@@ -244,6 +250,7 @@ exports.description = Joi.object({
     preferences: {
         allowUnknown: Joi.boolean(),
         abortEarly: Joi.boolean(),
+        artifacts: Joi.boolean(),
         cache: Joi.boolean(),
         convert: Joi.boolean(),
         dateFormat: ['date', 'iso', 'string', 'time', 'utc'],

package/lib/template.js

@@ -78,8 +78,13 @@ module.exports = exports = internals.Template = class {
                 continue;
             }
 
-            const variable = part.slice(raw ? 0 : 1, end);
-            const dynamic = this._ref(internals.decode(variable), raw);
+            let variable = part.slice(raw ? 0 : 1, end);
+            const wrapped = variable[0] === ':';
+            if (wrapped) {
+                variable = variable.slice(1);
+            }
+
+            const dynamic = this._ref(internals.decode(variable), { raw, wrapped });
             processed.push(dynamic);
             if (typeof dynamic !== 'string') {
                 refs = true;
@@ -184,11 +189,10 @@ module.exports = exports = internals.Template = class {
             }
             else {
                 const rendered = this._part(part, /* context -> [*/ value, state, prefs, local, options /*] */);
-                const string = internals.stringify(rendered, prefs, options.errors);
+                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 ends = part.ref && part.ref.type === 'local' && part.ref.key === 'label' && prefs.errors.wrap.label;
-                    parts.push(internals.wrap(result, ends));
+                    parts.push(internals.wrap(result, part.wrapped && prefs.errors.wrap.label));
                 }
             }
         }
@@ -196,7 +200,7 @@ module.exports = exports = internals.Template = class {
         return parts.join('');
     }
 
-    _ref(content, raw) {
+    _ref(content, { raw, wrapped }) {
 
         const refs = [];
         const reference = (variable) => {
@@ -216,7 +220,8 @@ module.exports = exports = internals.Template = class {
 
         if (formula.single) {
             if (formula.single.type === 'reference') {
-                return { ref: refs[0], raw, refs };
+                const ref = refs[0];
+                return { ref, raw, refs, wrapped: wrapped || ref.type === 'local' && ref.key === 'label' };
             }
 
             return internals.stringify(formula.single.value);
@@ -302,10 +307,18 @@ internals.wrap = function (value, ends) {
 };
 
 
-internals.stringify = function (value, prefs, options) {
+internals.stringify = function (value, original, state, prefs, local, options) {
 
     const type = typeof value;
 
+    let skipWrap = false;
+    if (Ref.isRef(value) &&
+        value.render) {
+
+        skipWrap = value.in;
+        value = value.resolve(original, state, prefs, local, { in: value.in, ...options });
+    }
+
     if (value === null) {
         return 'null';
     }
@@ -344,7 +357,11 @@ internals.stringify = function (value, prefs, options) {
 
     let partial = '';
     for (const item of value) {
-        partial = partial + (partial.length ? ', ' : '') + internals.stringify(item, prefs, options);
+        partial = partial + (partial.length ? ', ' : '') + internals.stringify(item, original, state, prefs, local, options);
+    }
+
+    if (skipWrap) {
+        return partial;
     }
 
     return internals.wrap(partial, prefs.errors.wrap.array);

package/lib/types/alternatives.js

@@ -183,7 +183,7 @@ module.exports = Any.extend({
 
         label(name) {
 
-            const obj = this.$_super.label(name);
+            const obj = this.$_parent('label', name);
             const each = (item, source) => (source.path[0] !== 'is' ? item.label(name) : undefined);
             return obj.$_modify({ each, ref: false });
         }

package/lib/types/any.js

@@ -167,7 +167,7 @@ module.exports = Base.extend({
         'any.failover': '{{#label}} threw an error when running failover method',
         'any.invalid': '{{#label}} contains an invalid value',
         'any.only': '{{#label}} must be {if(#valids.length == 1, "", "one of ")}{{#valids}}',
-        'any.ref': '{{#label}} {{#arg}} references "{{#ref}}" which {{#reason}}',
+        'any.ref': '{{#label}} {{#arg}} references {{:#ref}} which {{#reason}}',
         'any.required': '{{#label}} is required',
         'any.unknown': '{{#label}} is not allowed'
     }

package/lib/types/array.js

@@ -114,7 +114,7 @@ module.exports = Any.extend({
 
                 return obj.$_mutateRebuild();
             },
-            validate(value, { schema, error, state, prefs }) {
+            validate(value, { schema, error, state, prefs, errorsArray }) {
 
                 const requireds = schema.$_terms._requireds.slice();
                 const ordereds = schema.$_terms.ordered.slice();
@@ -123,7 +123,8 @@ module.exports = Any.extend({
                 const wasArray = !value[Common.symbols.arraySingle];
                 delete value[Common.symbols.arraySingle];
 
-                const errors = [];
+                const errors = errorsArray();
+
                 let il = value.length;
                 for (let i = 0; i < il; ++i) {
                     const item = value[i];
@@ -611,7 +612,7 @@ module.exports = Any.extend({
     messages: {
         'array.base': '{{#label}} must be an array',
         'array.excludes': '{{#label}} contains an excluded value',
-        'array.hasKnown': '{{#label}} does not contain at least one required match for type "{#patternLabel}"',
+        'array.hasKnown': '{{#label}} does not contain at least one required match for type {:#patternLabel}',
         'array.hasUnknown': '{{#label}} does not contain at least one required match',
         'array.includes': '{{#label}} does not match any of the allowed types',
         'array.includesRequiredBoth': '{{#label}} does not contain {{#knownMisses}} and {{#unknownMisses}} other required value(s)',

package/lib/types/date.js

@@ -149,10 +149,10 @@ module.exports = Any.extend({
     messages: {
         'date.base': '{{#label}} must be a valid date',
         'date.format': '{{#label}} must be in {msg("date.format." + #format) || #format} format',
-        'date.greater': '{{#label}} must be greater than "{{#limit}}"',
-        'date.less': '{{#label}} must be less than "{{#limit}}"',
-        'date.max': '{{#label}} must be less than or equal to "{{#limit}}"',
-        'date.min': '{{#label}} must be larger than or equal to "{{#limit}}"',
+        'date.greater': '{{#label}} must be greater than {{:#limit}}',
+        'date.less': '{{#label}} must be less than {{:#limit}}',
+        'date.max': '{{#label}} must be less than or equal to {{:#limit}}',
+        'date.min': '{{#label}} must be greater than or equal to {{:#limit}}',
 
         // Messages used in date.format
 

package/lib/types/keys.js

@@ -27,6 +27,7 @@ module.exports = Any.extend({
     type: '_keys',
 
     properties: {
+
         typeof: 'object'
     },
 
@@ -478,7 +479,7 @@ module.exports = Any.extend({
                 value = Common.symbols.deepDefault;
             }
 
-            return this.$_super.default(value, options);
+            return this.$_parent('default', value, options);
         }
     },
 
@@ -528,22 +529,22 @@ module.exports = Any.extend({
         'object.and': '{{#label}} contains {{#presentWithLabels}} without its required peers {{#missingWithLabels}}',
         'object.assert': '{{#label}} is invalid because {if(#subject.key, `"` + #subject.key + `" failed to ` + (#message || "pass the assertion test"), #message || "the assertion failed")}',
         'object.base': '{{#label}} must be of type {{#type}}',
-        'object.instance': '{{#label}} must be an instance of "{{#type}}"',
+        'object.instance': '{{#label}} must be an instance of {{:#type}}',
         'object.length': '{{#label}} must have {{#limit}} key{if(#limit == 1, "", "s")}',
         'object.max': '{{#label}} must have less than or equal to {{#limit}} key{if(#limit == 1, "", "s")}',
         'object.min': '{{#label}} must have at least {{#limit}} key{if(#limit == 1, "", "s")}',
         'object.missing': '{{#label}} must contain at least one of {{#peersWithLabels}}',
-        'object.nand': '"{{#mainWithLabel}}" must not exist simultaneously with {{#peersWithLabels}}',
+        'object.nand': '{{:#mainWithLabel}} must not exist simultaneously with {{#peersWithLabels}}',
         'object.oxor': '{{#label}} contains a conflict between optional exclusive peers {{#peersWithLabels}}',
         'object.pattern.match': '{{#label}} keys failed to match pattern requirements',
         'object.refType': '{{#label}} must be a Joi reference',
         'object.regex': '{{#label}} must be a RegExp object',
-        'object.rename.multiple': '{{#label}} cannot rename "{{#from}}" because multiple renames are disabled and another key was already renamed to "{{#to}}"',
-        'object.rename.override': '{{#label}} cannot rename "{{#from}}" because override is disabled and target "{{#to}}" exists',
+        'object.rename.multiple': '{{#label}} cannot rename {{:#from}} because multiple renames are disabled and another key was already renamed to {{:#to}}',
+        'object.rename.override': '{{#label}} cannot rename {{:#from}} because override is disabled and target {{:#to}} exists',
         'object.schema': '{{#label}} must be a Joi schema of {{#type}} type',
         'object.unknown': '{{#label}} is not allowed',
-        'object.with': '"{{#mainWithLabel}}" missing required peer "{{#peerWithLabel}}"',
-        'object.without': '"{{#mainWithLabel}}" conflict with forbidden peer "{{#peerWithLabel}}"',
+        'object.with': '{{:#mainWithLabel}} missing required peer {{:#peerWithLabel}}',
+        'object.without': '{{:#mainWithLabel}} conflict with forbidden peer {{:#peerWithLabel}}',
         'object.xor': '{{#label}} contains a conflict between exclusive peers {{#peersWithLabels}}'
     }
 });

package/lib/types/number.js

@@ -284,7 +284,7 @@ module.exports = Any.extend({
         'number.integer': '{{#label}} must be an integer',
         'number.less': '{{#label}} must be less than {{#limit}}',
         'number.max': '{{#label}} must be less than or equal to {{#limit}}',
-        'number.min': '{{#label}} must be larger than or equal to {{#limit}}',
+        'number.min': '{{#label}} must be greater than or equal to {{#limit}}',
         'number.multiple': '{{#label}} must be a multiple of {{#multiple}}',
         'number.negative': '{{#label}} must be a negative number',
         'number.port': '{{#label}} must be a valid port',
@@ -312,10 +312,14 @@ internals.normalizeExponent = function (str) {
 internals.normalizeDecimal = function (str) {
 
     str = str
+        // Remove leading plus signs
         .replace(/^\+/, '')
-        .replace(/\.0+$/, '')
+        // Remove trailing zeros if there is a decimal point and unecessary decimal points
+        .replace(/\.0*$/, '')
+        // Add a integer 0 if the numbers starts with a decimal point
         .replace(/^(-?)\.([^\.]*)$/, '$10.$2')
-        .replace(/^(-?)0+([1-9])/, '$1$2');
+        // Remove leading zeros
+        .replace(/^(-?)0+([0-9])/, '$1$2');
 
     if (str.includes('.') &&
         str.endsWith('0')) {

package/lib/types/string.js

@@ -41,8 +41,8 @@ const internals = {
         uuidv4: '4',
         uuidv5: '5'
     },
+    guidSeparators: new Set([undefined, true, false, '-', ':']),
 
-    cidrPresences: ['required', 'optional', 'forbidden'],
     normalizationForms: ['NFC', 'NFD', 'NFKC', 'NFKD']
 };
 
@@ -257,7 +257,7 @@ module.exports = Any.extend({
             method(options) {
 
                 if (options) {
-                    Common.assertOptions(options, ['allowUnicode', 'minDomainSegments', 'tlds']);
+                    Common.assertOptions(options, ['allowUnicode', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
                 }
 
                 const address = internals.addressOptions(options);
@@ -276,7 +276,7 @@ module.exports = Any.extend({
         email: {
             method(options = {}) {
 
-                Common.assertOptions(options, ['allowUnicode', 'ignoreLength', 'minDomainSegments', 'multiple', 'separator', 'tlds']);
+                Common.assertOptions(options, ['allowUnicode', 'ignoreLength', 'maxDomainSegments', 'minDomainSegments', 'multiple', 'separator', 'tlds']);
                 Assert(options.multiple === undefined || typeof options.multiple === 'boolean', 'multiple option must be an boolean');
 
                 const address = internals.addressOptions(options);
@@ -306,7 +306,7 @@ module.exports = Any.extend({
             alias: 'uuid',
             method(options = {}) {
 
-                Common.assertOptions(options, ['version']);
+                Common.assertOptions(options, ['version', 'separator']);
 
                 let versionNumbers = '';
 
@@ -328,7 +328,12 @@ module.exports = Any.extend({
                     }
                 }
 
-                const regex = new RegExp(`^([\\[{\\(]?)[0-9A-F]{8}([:-]?)[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');
+                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');
 
                 return this.$_addRule({ name: 'guid', args: { options }, regex });
             },
@@ -627,7 +632,7 @@ module.exports = Any.extend({
                 Common.assertOptions(options, ['allowRelative', 'allowQuerySquareBrackets', 'domain', 'relativeOnly', 'scheme']);
 
                 if (options.domain) {
-                    Common.assertOptions(options.domain, ['allowUnicode', 'minDomainSegments', 'tlds']);
+                    Common.assertOptions(options.domain, ['allowUnicode', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
                 }
 
                 const { regex, scheme } = Uri.regex(options);
@@ -702,10 +707,10 @@ module.exports = Any.extend({
         'string.min': '{{#label}} length must be at least {{#limit}} characters long',
         'string.normalize': '{{#label}} must be unicode normalized in the {{#form}} form',
         'string.token': '{{#label}} must only contain alpha-numeric and underscore characters',
-        'string.pattern.base': '{{#label}} with value "{[.]}" fails to match the required pattern: {{#regex}}',
-        'string.pattern.name': '{{#label}} with value "{[.]}" fails to match the {{#name}} pattern',
-        'string.pattern.invert.base': '{{#label}} with value "{[.]}" matches the inverted pattern: {{#regex}}',
-        'string.pattern.invert.name': '{{#label}} with value "{[.]}" matches the inverted {{#name}} pattern',
+        'string.pattern.base': '{{#label}} with value {:[.]} fails to match the required pattern: {{#regex}}',
+        'string.pattern.name': '{{#label}} with value {:[.]} fails to match the {{#name}} pattern',
+        'string.pattern.invert.base': '{{#label}} with value {:[.]} matches the inverted pattern: {{#regex}}',
+        'string.pattern.invert.name': '{{#label}} with value {:[.]} matches the inverted {{#name}} pattern',
         'string.trim': '{{#label}} must not have leading or trailing whitespace',
         'string.uri': '{{#label}} must be a valid uri',
         'string.uriCustomScheme': '{{#label}} must be a valid uri with a scheme matching the {{#scheme}} pattern',
@@ -728,6 +733,11 @@ internals.addressOptions = function (options) {
     Assert(options.minDomainSegments === undefined ||
         Number.isSafeInteger(options.minDomainSegments) && options.minDomainSegments > 0, 'minDomainSegments must be a positive integer');
 
+    // maxDomainSegments
+
+    Assert(options.maxDomainSegments === undefined ||
+        Number.isSafeInteger(options.maxDomainSegments) && options.maxDomainSegments > 0, 'maxDomainSegments must be a positive integer');
+
     // tlds
 
     if (options.tlds === false) {
@@ -751,6 +761,7 @@ internals.addressOptions = function (options) {
 
         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;
     }
 
@@ -769,16 +780,29 @@ internals.addressOptions = function (options) {
     }
 
     Assert(options.tlds.allow instanceof Set, 'tlds.allow must be an array, Set, or boolean');
+    internals.validateTlds(options.tlds.allow, 'tlds.allow');
     return 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`);
+    }
+};
+
+
 internals.isoDate = function (value) {
 
     if (!Common.isIsoDate(value)) {
         return null;
     }
 
+    if (/.*T.*[+-]\d\d$/.test(value)) {             // Add missing trailing zeros to timeshift
+        value += '00';
+    }
+
     const date = new Date(value);
     if (isNaN(date.getTime())) {
         return null;

package/lib/validator.js

@@ -20,6 +20,7 @@ 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');
         settings = Common.preferences(Common.defaults, prefs);
     }
 
@@ -39,6 +40,10 @@ exports.entry = function (value, schema, prefs) {
         outcome.debug = result.mainstay.debug;
     }
 
+    if (result.mainstay.artifacts) {
+        outcome.artifacts = result.mainstay.artifacts;
+    }
+
     return outcome;
 };
 
@@ -98,7 +103,8 @@ exports.entryAsync = async function (value, schema, prefs) {
     }
 
     if (!settings.warnings &&
-        !settings.debug) {
+        !settings.debug &&
+        !settings.artifacts) {
 
         return result.value;
     }
@@ -112,6 +118,10 @@ exports.entryAsync = async function (value, schema, prefs) {
         outcome.debug = mainstay.debug;
     }
 
+    if (mainstay.artifacts) {
+        outcome.artifacts = mainstay.artifacts;
+    }
+
     return outcome;
 };
 
@@ -190,6 +200,7 @@ exports.validate = function (value, schema, state, prefs, overrides = {}) {
         schema,
         state,
         error: createError,
+        errorsArray: internals.errorsArray,
         warn: (code, local, localState) => state.mainstay.warnings.push(createError(code, local, localState)),
         message: (messages, local) => schema.$_createError('custom', value, local, state, prefs, { messages })
     };
@@ -244,7 +255,7 @@ exports.validate = function (value, schema, state, prefs, overrides = {}) {
 
     // Presence requirements (required, optional, forbidden)
 
-    const presence = overrides.presence || schema._flags.presence || (schema._flags._endedSwitch ? 'ignore' : prefs.presence);
+    const presence = overrides.presence || schema._flags.presence || (schema._flags._endedSwitch ? null : prefs.presence);
     if (value === undefined) {
         if (presence === 'forbidden') {
             return internals.finalize(value, null, helpers);
@@ -416,7 +427,7 @@ internals.rule = function (ret, rule) {
     }
 
     if (Array.isArray(ret) &&
-        (ret[0] instanceof Errors.Report || ret[0] instanceof Error)) {
+        ret[Common.symbols.errors]) {
 
         ret.forEach((report) => internals.error(report, rule));
         return { errors: ret, value: null };
@@ -523,6 +534,20 @@ internals.finalize = function (value, errors, helpers) {
         schema._cache.set(helpers.original, result);
     }
 
+    // Artifacts
+
+    if (value !== undefined &&
+        !result.errors &&
+        schema._flags.artifact !== undefined) {
+
+        state.mainstay.artifacts = state.mainstay.artifacts || new Map();
+        if (!state.mainstay.artifacts.has(schema._flags.artifact)) {
+            state.mainstay.artifacts.set(schema._flags.artifact, []);
+        }
+
+        state.mainstay.artifacts.get(schema._flags.artifact).push(state.path);
+    }
+
     return result;
 };
 
@@ -615,3 +640,11 @@ internals.ignore = {
     resolve: Ignore,
     value: Ignore
 };
+
+
+internals.errorsArray = function () {
+
+    const errors = [];
+    errors[Common.symbols.errors] = true;
+    return errors;
+};

package/package.json

@@ -1,35 +1,36 @@
 {
-  "name": "joi",
-  "description": "Object schema validation",
-  "version": "17.1.1",
-  "repository": "git://github.com/sideway/joi",
-  "main": "lib/index.js",
-  "browser": "dist/joi-browser.min.js",
-  "files": [
-    "lib/**/*",
-    "dist/*"
-  ],
-  "keywords": [
-    "schema",
-    "validation"
-  ],
-  "dependencies": {
-    "@hapi/address": "^4.0.1",
-    "@hapi/formula": "^2.0.0",
-    "@hapi/hoek": "^9.0.0",
-    "@hapi/pinpoint": "^2.0.0",
-    "@hapi/topo": "^5.0.0"
-  },
-  "devDependencies": {
-    "@hapi/bourne": "2.x.x",
-    "@hapi/code": "8.x.x",
-    "@hapi/lab": "22.x.x",
-    "@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x"
-  },
-  "scripts": {
-    "prepublishOnly": "cd browser && npm install && npm run build",
-    "test": "lab -t 100 -a @hapi/code -L",
-    "test-cov-html": "lab -r html -o coverage.html -a @hapi/code"
-  },
-  "license": "BSD-3-Clause"
+    "name": "joi",
+    "description": "Object schema validation",
+    "version": "17.2.0",
+    "repository": "git://github.com/sideway/joi",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "browser": "dist/joi-browser.min.js",
+    "files": [
+        "lib/**/*",
+        "dist/*"
+    ],
+    "keywords": [
+        "schema",
+        "validation"
+    ],
+    "dependencies": {
+        "@hapi/address": "^4.1.0",
+        "@hapi/formula": "^2.0.0",
+        "@hapi/hoek": "^9.0.0",
+        "@hapi/pinpoint": "^2.0.0",
+        "@hapi/topo": "^5.0.0"
+    },
+    "devDependencies": {
+        "@hapi/bourne": "2.x.x",
+        "@hapi/code": "8.x.x",
+        "@hapi/lab": "23.x.x",
+        "@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x"
+    },
+    "scripts": {
+        "prepublishOnly": "cd browser && npm install && npm run build",
+        "test": "lab -t 100 -a @hapi/code -L -Y",
+        "test-cov-html": "lab -r html -o coverage.html -a @hapi/code"
+    },
+    "license": "BSD-3-Clause"
 }