@nhtio/validation 0.1.0-master-cb87a6f9 → 0.1.0-master-fe5983b7

package/index.cjs

@@ -3764,16 +3764,65 @@ var require_extend$1 = __commonJSMin((exports) => {
 		};
 	};
 });
+var import_applyToDefaults, import_assert, import_bench, import_block, import_clone, import_contain, import_deepEqual, import_assertError, import_escapeHeaderAttribute, import_escapeHtml, import_escapeJson, import_escapeRegex, import_flatten, import_ignore, import_intersect, import_isPromise, import_merge, import_once, import_reach, import_reachTemplate, import_stringify, import_wait;
+var init_lib = __esmMin(() => {
+	import_applyToDefaults = __toESM(require_applyToDefaults(), 1);
+	import_assert = __toESM(require_assert$1(), 1);
+	import_bench = __toESM(require_bench(), 1);
+	import_block = __toESM(require_block(), 1);
+	import_clone = __toESM(require_clone$1(), 1);
+	import_contain = __toESM(require_contain(), 1);
+	import_deepEqual = __toESM(require_deepEqual(), 1);
+	import_assertError = __toESM(require_assertError(), 1);
+	import_escapeHeaderAttribute = __toESM(require_escapeHeaderAttribute(), 1);
+	import_escapeHtml = __toESM(require_escapeHtml(), 1);
+	import_escapeJson = __toESM(require_escapeJson(), 1);
+	import_escapeRegex = __toESM(require_escapeRegex(), 1);
+	import_flatten = __toESM(require_flatten$1(), 1);
+	import_ignore = __toESM(require_ignore(), 1);
+	import_intersect = __toESM(require_intersect(), 1);
+	import_isPromise = __toESM(require_isPromise(), 1);
+	import_merge = __toESM(require_merge(), 1);
+	import_once = __toESM(require_once(), 1);
+	import_reach = __toESM(require_reach(), 1);
+	import_reachTemplate = __toESM(require_reachTemplate(), 1);
+	import_stringify = __toESM(require_stringify(), 1);
+	import_wait = __toESM(require_wait(), 1);
+});
 var require_manifest = __commonJSMin((exports) => {
 	init_dist$1();
-	const { assert: assert$46, clone: clone$14 } = require_lib$4();
-	const Common$19 = require_common$3();
-	const Messages$5 = require_messages();
-	const Ref$9 = require_ref$2();
-	const Template$5 = require_template();
+	var import_schemas$1 = __toESM(require_schemas());
+	var import_template$2 = __toESM(require_template());
+	var import_ref$2 = __toESM(require_ref$2());
+	var import_messages$2 = __toESM(require_messages());
+	var import_common$2 = __toESM(require_common$3());
+	init_lib();
+	const Common$19 = import_common$2.default;
+	const Messages$5 = import_messages$2.default;
+	const Ref$9 = import_ref$2.default;
+	const Template$5 = import_template$2.default;
+	const ManifestDescriptionCache = new WeakMap();
+	var ManifestItemCacheClass = class {
+		#items = new WeakMap();
+		get(item, options = {}) {
+			const cached = this.#items.get(item);
+			if (cached) return cached.get(options);
+		}
+		set(item, options = {}, value) {
+			if (!this.#items.has(item)) this.#items.set(item, new WeakMap());
+			this.#items.get(item).set(options, value);
+		}
+		setAndReturn(item, options = {}, value) {
+			this.set(item, options, value);
+			return value;
+		}
+	};
+	const ManifestItemCache = new ManifestItemCacheClass();
 	let Schemas$3;
 	const internals$20 = {};
 	exports.describe = function(schema$2) {
+		const cached = ManifestDescriptionCache.get(schema$2);
+		if (cached) return cached;
 		const def = schema$2._definition;
 		const desc$1 = {
 			type: schema$2.type,
@@ -3783,7 +3832,7 @@ var require_manifest = __commonJSMin((exports) => {
 		for (const flag in schema$2._flags) if (flag[0] !== "_") desc$1.flags[flag] = internals$20.describe(schema$2._flags[flag]);
 		if (!Object.keys(desc$1.flags).length) delete desc$1.flags;
 		if (schema$2._preferences) {
-			desc$1.preferences = clone$14(schema$2._preferences, { shallow: ["messages"] });
+			desc$1.preferences = (0, import_clone.default)(schema$2._preferences, { shallow: ["messages"] });
 			delete desc$1.preferences[Common$19.symbols.prefs];
 			if (desc$1.preferences.messages) desc$1.preferences.messages = Messages$5.decompile(desc$1.preferences.messages);
 		}
@@ -3808,7 +3857,7 @@ var require_manifest = __commonJSMin((exports) => {
 		if (!desc$1.rules.length) delete desc$1.rules;
 		for (const term in schema$2.$_terms) {
 			if (term[0] === "_") continue;
-			assert$46(!desc$1[term], "Cannot describe schema due to internal name conflict with", term);
+			(0, import_assert.default)(!desc$1[term], "Cannot describe schema due to internal name conflict with", term);
 			const items = schema$2.$_terms[term];
 			if (!items) continue;
 			if (items instanceof Map) {
@@ -3819,7 +3868,7 @@ var require_manifest = __commonJSMin((exports) => {
 				desc$1[term] = items.describe();
 				continue;
 			}
-			assert$46(def.terms[term], "Term", term, "missing configuration");
+			(0, import_assert.default)(def.terms[term], "Term", term, "missing configuration");
 			const manifest = def.terms[term].manifest;
 			const mapped = typeof manifest === "object";
 			if (!items.length && !mapped) continue;
@@ -3832,31 +3881,34 @@ var require_manifest = __commonJSMin((exports) => {
 				continue;
 			}
 			if (manifest === "single") {
-				assert$46(normalized.length === 1, "Term", term, "contains more than one item");
+				(0, import_assert.default)(normalized.length === 1, "Term", term, "contains more than one item");
 				desc$1[term] = normalized[0];
 				continue;
 			}
 			desc$1[term] = normalized;
 		}
 		internals$20.validate(schema$2.$_root, desc$1);
+		ManifestDescriptionCache.set(schema$2, desc$1);
 		return desc$1;
 	};
 	internals$20.describe = function(item, options = {}) {
-		if (Array.isArray(item)) return item.map(internals$20.describe);
-		if (item === Common$19.symbols.deepDefault) return { special: "deep" };
-		if (typeof item !== "object" || item === null) return item;
-		if (options.assign === "options") return clone$14(item);
-		if (Buffer$1 && Buffer$1.isBuffer(item)) return { buffer: item.toString("binary") };
-		if (item instanceof Date) return item.toISOString();
-		if (item instanceof Error) return item;
+		const cached = ManifestItemCache.get(item, options);
+		if (cached) return cached;
+		if (Array.isArray(item)) return ManifestItemCache.setAndReturn(item, options, item.map(internals$20.describe));
+		if (item === Common$19.symbols.deepDefault) return ManifestItemCache.setAndReturn(item, options, { special: "deep" });
+		if (typeof item !== "object" || item === null) return ManifestItemCache.setAndReturn(item, options, item);
+		if (options.assign === "options") return ManifestItemCache.setAndReturn(item, options, (0, import_clone.default)(item));
+		if (Buffer$1 && Buffer$1.isBuffer(item)) return ManifestItemCache.setAndReturn(item, options, { buffer: item.toString("binary") });
+		if (item instanceof Date) return ManifestItemCache.setAndReturn(item, options, item.toISOString());
+		if (item instanceof Error) return ManifestItemCache.setAndReturn(item, options, item);
 		if (item instanceof RegExp) {
-			if (options.assign === "regex") return item.toString();
-			return { regex: item.toString() };
+			if (options.assign === "regex") return ManifestItemCache.setAndReturn(item, options, item.toString());
+			return ManifestItemCache.setAndReturn(item, options, { regex: item.toString() });
 		}
-		if (item[Common$19.symbols.literal]) return { function: item.literal };
+		if (item[Common$19.symbols.literal]) return ManifestItemCache.setAndReturn(item, options, { function: item.literal });
 		if (typeof item.describe === "function") {
-			if (options.assign === "ref") return item.describe().ref;
-			return item.describe();
+			if (options.assign === "ref") return ManifestItemCache.setAndReturn(item, options, item.describe().ref);
+			return ManifestItemCache.setAndReturn(item, options, item.describe());
 		}
 		const normalized = {};
 		for (const key in item) {
@@ -3864,7 +3916,7 @@ var require_manifest = __commonJSMin((exports) => {
 			if (value === void 0) continue;
 			normalized[key] = internals$20.describe(value, { assign: key });
 		}
-		return normalized;
+		return ManifestItemCache.setAndReturn(item, options, normalized);
 	};
 	exports.build = function(joi, desc$1) {
 		const builder = new internals$20.Builder(joi);
@@ -3880,14 +3932,14 @@ var require_manifest = __commonJSMin((exports) => {
 			const def = schema$2._definition;
 			if (desc$1.flags) for (const flag in desc$1.flags) {
 				const setter = def.flags[flag] && def.flags[flag].setter || flag;
-				assert$46(typeof schema$2[setter] === "function", "Invalid flag", flag, "for type", desc$1.type);
+				(0, import_assert.default)(typeof schema$2[setter] === "function", "Invalid flag", flag, "for type", desc$1.type);
 				schema$2 = schema$2[setter](this.build(desc$1.flags[flag]));
 			}
 			if (desc$1.preferences) schema$2 = schema$2.preferences(this.build(desc$1.preferences));
 			if (desc$1.allow) schema$2 = schema$2.allow(...this.build(desc$1.allow));
 			if (desc$1.invalid) schema$2 = schema$2.invalid(...this.build(desc$1.invalid));
 			if (desc$1.rules) for (const rule of desc$1.rules) {
-				assert$46(typeof schema$2[rule.name] === "function", "Invalid rule", rule.name, "for type", desc$1.type);
+				(0, import_assert.default)(typeof schema$2[rule.name] === "function", "Invalid rule", rule.name, "for type", desc$1.type);
 				const args$1 = [];
 				if (rule.args) {
 					const built = {};
@@ -3895,10 +3947,10 @@ var require_manifest = __commonJSMin((exports) => {
 					const keys$10 = Object.keys(built);
 					const definition = def.rules[rule.name].args;
 					if (definition) {
-						assert$46(keys$10.length <= definition.length, "Invalid number of arguments for", desc$1.type, rule.name, "(expected up to", definition.length, ", found", keys$10.length, ")");
+						(0, import_assert.default)(keys$10.length <= definition.length, "Invalid number of arguments for", desc$1.type, rule.name, "(expected up to", definition.length, ", found", keys$10.length, ")");
 						for (const { name: name$2 } of definition) args$1.push(built[name$2]);
 					} else {
-						assert$46(keys$10.length === 1, "Invalid number of arguments for", desc$1.type, rule.name, "(expected up to 1, found", keys$10.length, ")");
+						(0, import_assert.default)(keys$10.length === 1, "Invalid number of arguments for", desc$1.type, rule.name, "(expected up to 1, found", keys$10.length, ")");
 						args$1.push(built[keys$10[0]]);
 					}
 				}
@@ -3918,7 +3970,7 @@ var require_manifest = __commonJSMin((exports) => {
 					"rules",
 					"type"
 				].includes(key)) continue;
-				assert$46(def.terms[key], "Term", key, "missing configuration");
+				(0, import_assert.default)(def.terms[key], "Term", key, "missing configuration");
 				const manifest = def.terms[key].manifest;
 				if (manifest === "schema") {
 					terms[key] = desc$1[key].map((item) => this.parse(item));
@@ -3951,13 +4003,13 @@ var require_manifest = __commonJSMin((exports) => {
 			if (desc$1 === null) return null;
 			if (Array.isArray(desc$1)) return desc$1.map((item) => this.build(item));
 			if (desc$1 instanceof Error) return desc$1;
-			if (options.assign === "options") return clone$14(desc$1);
+			if (options.assign === "options") return (0, import_clone.default)(desc$1);
 			if (options.assign === "regex") return internals$20.regex(desc$1);
 			if (options.assign === "ref") return Ref$9.build(desc$1);
 			if (typeof desc$1 !== "object") return desc$1;
 			if (Object.keys(desc$1).length === 1) {
 				if (desc$1.buffer) {
-					assert$46(Buffer$1, "Buffers are not supported");
+					(0, import_assert.default)(Buffer$1, "Buffers are not supported");
 					return Buffer$1 && Buffer$1.from(desc$1.buffer, "binary");
 				}
 				if (desc$1.function) return {
@@ -3968,10 +4020,10 @@ var require_manifest = __commonJSMin((exports) => {
 				if (desc$1.ref) return Ref$9.build(desc$1.ref);
 				if (desc$1.regex) return internals$20.regex(desc$1.regex);
 				if (desc$1.special) {
-					assert$46(["deep"].includes(desc$1.special), "Unknown special value", desc$1.special);
+					(0, import_assert.default)(["deep"].includes(desc$1.special), "Unknown special value", desc$1.special);
 					return Common$19.symbols.deepDefault;
 				}
-				if (desc$1.value) return clone$14(desc$1.value);
+				if (desc$1.value) return (0, import_clone.default)(desc$1.value);
 			}
 			if (desc$1.type) return this.parse(desc$1);
 			if (desc$1.template) return Template$5.build(desc$1);
@@ -3987,7 +4039,7 @@ var require_manifest = __commonJSMin((exports) => {
 		return new RegExp(exp, flags);
 	};
 	internals$20.validate = function(joi, desc$1) {
-		Schemas$3 = Schemas$3 || require_schemas();
+		Schemas$3 = Schemas$3 || import_schemas$1.default;
 		joi.assert(desc$1, Schemas$3.description);
 	};
 });
@@ -4006,7 +4058,7 @@ var require_lib$2 = __commonJSMin((exports) => {
 	};
 });
 var require_trace = __commonJSMin((exports) => {
-	const { deepEqual: deepEqual$4 } = require_lib$4();
+	const { deepEqual: deepEqual$3 } = require_lib$4();
 	const Pinpoint = require_lib$2();
 	const Errors$7 = require_errors$2();
 	const internals$19 = {
@@ -4162,7 +4214,7 @@ var require_trace = __commonJSMin((exports) => {
 			state.mainstay.debug.push(log$1);
 		}
 		value(state, by, from$2, to, name$2) {
-			if (!state.mainstay.debug || deepEqual$4(from$2, to)) return;
+			if (!state.mainstay.debug || deepEqual$3(from$2, to)) return;
 			const log$1 = {
 				type: "value",
 				by,
@@ -4221,7 +4273,7 @@ var require_trace = __commonJSMin((exports) => {
 		return name$2;
 	};
 	internals$19.sub = function(paths, skipped) {
-		for (const path of paths) for (const skip of skipped) if (deepEqual$4(path.slice(0, skip.length), skip)) return true;
+		for (const path of paths) for (const skip of skipped) if (deepEqual$3(path.slice(0, skip.length), skip)) return true;
 		return false;
 	};
 	internals$19.debug = function(state, event) {
@@ -4232,7 +4284,7 @@ var require_trace = __commonJSMin((exports) => {
 	};
 });
 var require_modify = __commonJSMin((exports) => {
-	const { assert: assert$45 } = require_lib$4();
+	const { assert: assert$44 } = require_lib$4();
 	const Common$18 = require_common$3();
 	const Ref$8 = require_ref$2();
 	const internals$18 = {};
@@ -4252,11 +4304,11 @@ var require_modify = __commonJSMin((exports) => {
 		concat(source) {
 			if (source._schemaChain) this._schemaChain = true;
 			for (const [id, value] of source._byId.entries()) {
-				assert$45(!this._byKey.has(id), "Schema id conflicts with existing key:", id);
+				assert$44(!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$45(!this._byId.has(key), "Schema key conflicts with existing id:", key);
+				assert$44(!this._byId.has(key), "Schema key conflicts with existing id:", key);
 				this._byKey.set(key, value);
 			}
 		}
@@ -4268,7 +4320,7 @@ var require_modify = __commonJSMin((exports) => {
 				id: tail$5.id,
 				schema: adjuster(tail$5.schema)
 			};
-			assert$45(Common$18.isSchema(adjusted.schema), "adjuster function failed to return a joi schema type");
+			assert$44(Common$18.isSchema(adjusted.schema), "adjuster function failed to return a joi schema type");
 			for (const node of chain) adjusted = {
 				id: node.id,
 				schema: internals$18.fork(node.schema, adjusted.id, adjusted.schema)
@@ -4287,7 +4339,7 @@ var require_modify = __commonJSMin((exports) => {
 		reach(path, behind = []) {
 			const current = path[0];
 			const node = this._get(current);
-			assert$45(node, "Schema does not contain path", [...behind, ...path].join("."));
+			assert$44(node, "Schema does not contain path", [...behind, ...path].join("."));
 			const forward = path.slice(1);
 			if (!forward.length) return node.schema;
 			return node.schema._ids.reach(forward, [...behind, current]);
@@ -4298,16 +4350,16 @@ var require_modify = __commonJSMin((exports) => {
 			const id = schema$2._flags.id;
 			if (id) {
 				const existing = this._byId.get(id);
-				assert$45(!existing || existing.schema === schema$2, "Cannot add different schemas with the same id:", id);
-				assert$45(!this._byKey.has(id), "Schema id conflicts with existing key:", id);
+				assert$44(!existing || existing.schema === schema$2, "Cannot add different schemas with the same id:", id);
+				assert$44(!this._byKey.has(id), "Schema id conflicts with existing key:", id);
 				this._byId.set(id, {
 					schema: schema$2,
 					id
 				});
 			}
 			if (key) {
-				assert$45(!this._byKey.has(key), "Schema already contains key:", key);
-				assert$45(!this._byId.has(key), "Schema key conflicts with existing id:", key);
+				assert$44(!this._byKey.has(key), "Schema already contains key:", key);
+				assert$44(!this._byId.has(key), "Schema key conflicts with existing id:", key);
 				this._byKey.set(key, {
 					schema: schema$2,
 					id: key
@@ -4322,7 +4374,7 @@ var require_modify = __commonJSMin((exports) => {
 		_collect(path, behind = [], nodes = []) {
 			const current = path[0];
 			const node = this._get(current);
-			assert$45(node, "Schema does not contain path", [...behind, ...path].join("."));
+			assert$44(node, "Schema does not contain path", [...behind, ...path].join("."));
 			nodes = [node, ...nodes];
 			const forward = path.slice(1);
 			if (!forward.length) return nodes;
@@ -4419,7 +4471,7 @@ var require_modify = __commonJSMin((exports) => {
 	};
 });
 var require_state$1 = __commonJSMin((exports, module) => {
-	const { clone: clone$13, reach: reach$3 } = require_lib$4();
+	const { clone: clone$12, reach: reach$2 } = require_lib$4();
 	const Common$17 = require_common$3();
 	const internals$17 = { value: Symbol("value") };
 	module.exports = internals$17.State = class {
@@ -4446,7 +4498,7 @@ var require_state$1 = __commonJSMin((exports, module) => {
 			this.mainstay.shadow.set(this.path, value, reason);
 		}
 		snapshot() {
-			if (this.mainstay.shadow) this._snapshot = clone$13(this.mainstay.shadow.node(this.path));
+			if (this.mainstay.shadow) this._snapshot = clone$12(this.mainstay.shadow.node(this.path));
 			this.mainstay.snapshot();
 		}
 		restore() {
@@ -4494,13 +4546,13 @@ var require_state$1 = __commonJSMin((exports, module) => {
 		}
 		node(path) {
 			if (!this._values) return;
-			return reach$3(this._values, path, { iterables: true });
+			return reach$2(this._values, path, { iterables: true });
 		}
 		override(path, node) {
 			if (!this._values) return;
 			const parents = path.slice(0, -1);
 			const own = path[path.length - 1];
-			const parent = reach$3(this._values, parents, { iterables: true });
+			const parent = reach$2(this._values, parents, { iterables: true });
 			if (node) {
 				parent.set(own, node);
 				return;
@@ -4510,7 +4562,7 @@ var require_state$1 = __commonJSMin((exports, module) => {
 	};
 });
 var require_validator = __commonJSMin((exports) => {
-	const { assert: assert$44, clone: clone$12, ignore: ignore$1, reach: reach$2 } = require_lib$4();
+	const { assert: assert$43, clone: clone$11, ignore, reach: reach$1 } = require_lib$4();
 	const Common$16 = require_common$3();
 	const Errors$6 = require_errors$2();
 	const State = require_state$1();
@@ -4518,12 +4570,12 @@ var require_validator = __commonJSMin((exports) => {
 	exports.entry = function(value, schema$2, prefs) {
 		let settings = Common$16.defaults;
 		if (prefs) {
-			assert$44(prefs.warnings === void 0, "Cannot override warnings preference in synchronous validation");
-			assert$44(prefs.artifacts === void 0, "Cannot override artifacts preference in synchronous validation");
+			assert$43(prefs.warnings === void 0, "Cannot override warnings preference in synchronous validation");
+			assert$43(prefs.artifacts === void 0, "Cannot override artifacts preference in synchronous validation");
 			settings = Common$16.preferences(Common$16.defaults, prefs);
 		}
 		const result = internals$16.entry(value, schema$2, settings);
-		assert$44(!result.mainstay.externals.length, "Schema with external rules must use validateAsync()");
+		assert$43(!result.mainstay.externals.length, "Schema with external rules must use validateAsync()");
 		const outcome = { value: result.value };
 		if (result.error) outcome.error = result.error;
 		if (result.mainstay.warnings.length) outcome.warning = Errors$6.details(result.mainstay.warnings);
@@ -4550,7 +4602,7 @@ var require_validator = __commonJSMin((exports) => {
 				let key;
 				let parent;
 				const ancestors = path.length ? [root$11] : [];
-				const original = path.length ? reach$2(value, path) : value;
+				const original = path.length ? reach$1(value, path) : value;
 				if (path.length) {
 					key = path[path.length - 1];
 					let current = root$11;
@@ -4665,7 +4717,7 @@ var require_validator = __commonJSMin((exports) => {
 	internals$16.tracer = function(schema$2, prefs) {
 		if (schema$2.$_root._tracer) return { tracer: schema$2.$_root._tracer._register(schema$2) };
 		if (prefs.debug) {
-			assert$44(schema$2.$_root.trace, "Debug mode not supported");
+			assert$43(schema$2.$_root.trace, "Debug mode not supported");
 			return {
 				tracer: schema$2.$_root.trace()._register(schema$2),
 				cleanup: true
@@ -4855,7 +4907,7 @@ var require_validator = __commonJSMin((exports) => {
 		if (errors.length && schema$2._flags.error) if (typeof schema$2._flags.error === "function") {
 			errors = schema$2._flags.error(errors);
 			if (!Array.isArray(errors)) errors = [errors];
-			for (const error of errors) assert$44(error instanceof Error || error instanceof Errors$6.Report, "error() must return an Error object");
+			for (const error of errors) assert$43(error instanceof Error || error instanceof Errors$6.Report, "error() must return an Error object");
 		} else errors = [schema$2._flags.error];
 		if (value === void 0) {
 			const defaulted = internals$16.default("default", value, errors, helpers$8);
@@ -4907,7 +4959,7 @@ var require_validator = __commonJSMin((exports) => {
 		state.mainstay.tracer.log(schema$2, state, "rule", flag, "full");
 		if (!source) return source;
 		if (typeof source === "function") {
-			const args$1 = source.length ? [clone$12(state.ancestors[0]), helpers$8] : [];
+			const args$1 = source.length ? [clone$11(state.ancestors[0]), helpers$8] : [];
 			try {
 				return source(...args$1);
 			} catch (err$1) {
@@ -4918,7 +4970,7 @@ var require_validator = __commonJSMin((exports) => {
 		if (typeof source !== "object") return source;
 		if (source[Common$16.symbols.literal]) return source.literal;
 		if (Common$16.isResolvable(source)) return source.resolve(value, state, prefs);
-		return clone$12(source);
+		return clone$11(source);
 	};
 	internals$16.trim = function(value, schema$2) {
 		if (typeof value !== "string") return value;
@@ -4928,12 +4980,12 @@ var require_validator = __commonJSMin((exports) => {
 	};
 	internals$16.ignore = {
 		active: false,
-		debug: ignore$1,
-		entry: ignore$1,
-		filter: ignore$1,
-		log: ignore$1,
-		resolve: ignore$1,
-		value: ignore$1
+		debug: ignore,
+		entry: ignore,
+		filter: ignore,
+		log: ignore,
+		resolve: ignore,
+		value: ignore
 	};
 	internals$16.errorsArray = function() {
 		const errors = [];
@@ -4942,7 +4994,7 @@ var require_validator = __commonJSMin((exports) => {
 	};
 });
 var require_values$1 = __commonJSMin((exports, module) => {
-	const { assert: assert$43, deepEqual: deepEqual$3 } = require_lib$4();
+	const { assert: assert$42, deepEqual: deepEqual$2 } = require_lib$4();
 	const Common$15 = require_common$3();
 	const internals$15 = {};
 	module.exports = internals$15.Values = class {
@@ -4997,7 +5049,7 @@ var require_values$1 = __commonJSMin((exports, module) => {
 			}
 			if (!this._refs.size && typeof value !== "object") return false;
 			if (typeof value === "object") {
-				for (const item of this._values) if (deepEqual$3(item, value)) return { value: item };
+				for (const item of this._values) if (deepEqual$2(item, value)) return { value: item };
 			}
 			if (state) for (const ref of this._refs) {
 				const resolved = ref.resolve(value, state, prefs, null, { in: true });
@@ -5010,7 +5062,7 @@ var require_values$1 = __commonJSMin((exports, module) => {
 							value: item,
 							ref
 						};
-					} else if (deepEqual$3(item, value)) return {
+					} else if (deepEqual$2(item, value)) return {
 						value: item,
 						ref
 					};
@@ -5035,7 +5087,7 @@ var require_values$1 = __commonJSMin((exports, module) => {
 			return set;
 		}
 		concat(source) {
-			assert$43(!source._override, "Cannot concat override set of values");
+			assert$42(!source._override, "Cannot concat override set of values");
 			const set = new internals$15.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
 			set._override = this._override;
 			return set;
@@ -5059,7 +5111,7 @@ var require_values$1 = __commonJSMin((exports, module) => {
 	};
 });
 var require_base$2 = __commonJSMin((exports, module) => {
-	const { assert: assert$42, clone: clone$11, deepEqual: deepEqual$2, merge: merge$3 } = require_lib$4();
+	const { assert: assert$41, clone: clone$10, deepEqual: deepEqual$1, merge: merge$2 } = require_lib$4();
 	const Cache$2 = require_cache();
 	const Common$14 = require_common$3();
 	const Compile$6 = require_compile();
@@ -5097,7 +5149,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			};
 		}
 		describe() {
-			assert$42(typeof Manifest$2.describe === "function", "Manifest functionality disabled");
+			assert$41(typeof Manifest$2.describe === "function", "Manifest functionality disabled");
 			return Manifest$2.describe(this);
 		}
 		allow(...values$3) {
@@ -5105,13 +5157,13 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return this._values(values$3, "_valids");
 		}
 		alter(targets) {
-			assert$42(targets && typeof targets === "object" && !Array.isArray(targets), "Invalid targets argument");
-			assert$42(!this._inRuleset(), "Cannot set alterations inside a ruleset");
+			assert$41(targets && typeof targets === "object" && !Array.isArray(targets), "Invalid targets argument");
+			assert$41(!this._inRuleset(), "Cannot set alterations inside a ruleset");
 			const obj = this.clone();
 			obj.$_terms.alterations = obj.$_terms.alterations || [];
 			for (const target in targets) {
 				const adjuster = targets[target];
-				assert$42(typeof adjuster === "function", "Alteration adjuster for", target, "must be a function");
+				assert$41(typeof adjuster === "function", "Alteration adjuster for", target, "must be a function");
 				obj.$_terms.alterations.push({
 					target,
 					adjuster
@@ -5121,20 +5173,20 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return obj;
 		}
 		artifact(id) {
-			assert$42(id !== void 0, "Artifact cannot be undefined");
-			assert$42(!this._cache, "Cannot set an artifact with a rule cache");
+			assert$41(id !== void 0, "Artifact cannot be undefined");
+			assert$41(!this._cache, "Cannot set an artifact with a rule cache");
 			return this.$_setFlag("artifact", id);
 		}
 		cast(to) {
-			assert$42(to === false || typeof to === "string", "Invalid to value");
-			assert$42(to === false || this._definition.cast[to], "Type", this.type, "does not support casting to", to);
+			assert$41(to === false || typeof to === "string", "Invalid to value");
+			assert$41(to === false || this._definition.cast[to], "Type", this.type, "does not support casting to", to);
 			return this.$_setFlag("cast", to === false ? void 0 : to);
 		}
 		default(value, options) {
 			return this._default("default", value, options);
 		}
 		description(desc$1) {
-			assert$42(desc$1 && typeof desc$1 === "string", "Description must be a non-empty string");
+			assert$41(desc$1 && typeof desc$1 === "string", "Description must be a non-empty string");
 			return this.$_setFlag("description", desc$1);
 		}
 		empty(schema$2) {
@@ -5143,12 +5195,12 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return obj.$_setFlag("empty", schema$2, { clone: false });
 		}
 		error(err$1) {
-			assert$42(err$1, "Missing error");
-			assert$42(err$1 instanceof Error || typeof err$1 === "function", "Must provide a valid Error object or a function");
+			assert$41(err$1, "Missing error");
+			assert$41(err$1 instanceof Error || typeof err$1 === "function", "Must provide a valid Error object or a function");
 			return this.$_setFlag("error", err$1);
 		}
 		example(example, options = {}) {
-			assert$42(example !== void 0, "Missing example");
+			assert$41(example !== void 0, "Missing example");
 			Common$14.assertOptions(options, ["override"]);
 			return this._inner("examples", example, {
 				single: true,
@@ -5157,12 +5209,12 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		}
 		external(method$1, description$2) {
 			if (typeof method$1 === "object") {
-				assert$42(!description$2, "Cannot combine options with description");
+				assert$41(!description$2, "Cannot combine options with description");
 				description$2 = method$1.description;
 				method$1 = method$1.method;
 			}
-			assert$42(typeof method$1 === "function", "Method must be a function");
-			assert$42(description$2 === void 0 || description$2 && typeof description$2 === "string", "Description must be a non-empty string");
+			assert$41(typeof method$1 === "function", "Method must be a function");
+			assert$41(description$2 === void 0 || description$2 && typeof description$2 === "string", "Description must be a non-empty string");
 			return this._inner("externals", {
 				method: method$1,
 				description: description$2
@@ -5176,46 +5228,46 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		}
 		id(id) {
 			if (!id) return this.$_setFlag("id", void 0);
-			assert$42(typeof id === "string", "id must be a non-empty string");
-			assert$42(/^[^\.]+$/.test(id), "id cannot contain period character");
+			assert$41(typeof id === "string", "id must be a non-empty string");
+			assert$41(/^[^\.]+$/.test(id), "id cannot contain period character");
 			return this.$_setFlag("id", id);
 		}
 		invalid(...values$3) {
 			return this._values(values$3, "_invalids");
 		}
 		label(name$2) {
-			assert$42(name$2 && typeof name$2 === "string", "Label name must be a non-empty string");
+			assert$41(name$2 && typeof name$2 === "string", "Label name must be a non-empty string");
 			return this.$_setFlag("label", name$2);
 		}
 		meta(meta) {
-			assert$42(meta !== void 0, "Meta cannot be undefined");
+			assert$41(meta !== void 0, "Meta cannot be undefined");
 			return this._inner("metas", meta, { single: true });
 		}
 		note(...notes) {
-			assert$42(notes.length, "Missing notes");
-			for (const note of notes) assert$42(note && typeof note === "string", "Notes must be non-empty strings");
+			assert$41(notes.length, "Missing notes");
+			for (const note of notes) assert$41(note && typeof note === "string", "Notes must be non-empty strings");
 			return this._inner("notes", notes);
 		}
 		only(mode = true) {
-			assert$42(typeof mode === "boolean", "Invalid mode:", mode);
+			assert$41(typeof mode === "boolean", "Invalid mode:", mode);
 			return this.$_setFlag("only", mode);
 		}
 		optional() {
 			return this.presence("optional");
 		}
 		prefs(prefs) {
-			assert$42(prefs, "Missing preferences");
-			assert$42(prefs.context === void 0, "Cannot override context");
-			assert$42(prefs.externals === void 0, "Cannot override externals");
-			assert$42(prefs.warnings === void 0, "Cannot override warnings");
-			assert$42(prefs.debug === void 0, "Cannot override debug");
+			assert$41(prefs, "Missing preferences");
+			assert$41(prefs.context === void 0, "Cannot override context");
+			assert$41(prefs.externals === void 0, "Cannot override externals");
+			assert$41(prefs.warnings === void 0, "Cannot override warnings");
+			assert$41(prefs.debug === void 0, "Cannot override debug");
 			Common$14.checkPreferences(prefs);
 			const obj = this.clone();
 			obj._preferences = Common$14.preferences(obj._preferences, prefs);
 			return obj;
 		}
 		presence(mode) {
-			assert$42([
+			assert$41([
 				"optional",
 				"required",
 				"forbidden"
@@ -5226,7 +5278,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return this.$_setFlag("result", enabled ? "raw" : void 0);
 		}
 		result(mode) {
-			assert$42(["raw", "strip"].includes(mode), "Unknown result mode", mode);
+			assert$41(["raw", "strip"].includes(mode), "Unknown result mode", mode);
 			return this.$_setFlag("result", mode);
 		}
 		required() {
@@ -5242,12 +5294,12 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return this.$_setFlag("result", enabled ? "strip" : void 0);
 		}
 		tag(...tags$1) {
-			assert$42(tags$1.length, "Missing tags");
-			for (const tag of tags$1) assert$42(tag && typeof tag === "string", "Tags must be non-empty strings");
+			assert$41(tags$1.length, "Missing tags");
+			for (const tag of tags$1) assert$41(tag && typeof tag === "string", "Tags must be non-empty strings");
 			return this._inner("tags", tags$1);
 		}
 		unit(name$2) {
-			assert$42(name$2 && typeof name$2 === "string", "Unit name must be a non-empty string");
+			assert$41(name$2 && typeof name$2 === "string", "Unit name must be a non-empty string");
 			return this.$_setFlag("unit", name$2);
 		}
 		valid(...values$3) {
@@ -5263,17 +5315,17 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			if (!["any", "link"].includes(obj.type)) {
 				const conditions = when.is ? [when] : when.switch;
 				for (const item of conditions) {
-					assert$42(!item.then || item.then.type === "any" || item.then.type === obj.type, "Cannot combine", obj.type, "with", item.then && item.then.type);
-					assert$42(!item.otherwise || item.otherwise.type === "any" || item.otherwise.type === obj.type, "Cannot combine", obj.type, "with", item.otherwise && item.otherwise.type);
+					assert$41(!item.then || item.then.type === "any" || item.then.type === obj.type, "Cannot combine", obj.type, "with", item.then && item.then.type);
+					assert$41(!item.otherwise || item.otherwise.type === "any" || item.otherwise.type === obj.type, "Cannot combine", obj.type, "with", item.otherwise && item.otherwise.type);
 				}
 			}
 			obj.$_terms.whens.push(when);
 			return obj.$_mutateRebuild();
 		}
 		cache(cache$2) {
-			assert$42(!this._inRuleset(), "Cannot set caching inside a ruleset");
-			assert$42(!this._cache, "Cannot override schema cache");
-			assert$42(this._flags.artifact === void 0, "Cannot cache a rule with an artifact");
+			assert$41(!this._inRuleset(), "Cannot set caching inside a ruleset");
+			assert$41(!this._cache, "Cannot override schema cache");
+			assert$41(this._flags.artifact === void 0, "Cannot cache a rule with an artifact");
 			const obj = this.clone();
 			obj._cache = cache$2 || Cache$2.provider.provision();
 			obj.$_temp.ruleset = false;
@@ -5284,10 +5336,10 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return this._assign(obj);
 		}
 		concat(source) {
-			assert$42(Common$14.isSchema(source), "Invalid schema object");
-			assert$42(this.type === "any" || source.type === "any" || source.type === this.type, "Cannot merge type", this.type, "with another type:", source.type);
-			assert$42(!this._inRuleset(), "Cannot concatenate onto a schema with open ruleset");
-			assert$42(!source._inRuleset(), "Cannot concatenate a schema with open ruleset");
+			assert$41(Common$14.isSchema(source), "Invalid schema object");
+			assert$41(this.type === "any" || source.type === "any" || source.type === this.type, "Cannot merge type", this.type, "with another type:", source.type);
+			assert$41(!this._inRuleset(), "Cannot concatenate onto a schema with open ruleset");
+			assert$41(!source._inRuleset(), "Cannot concatenate a schema with open ruleset");
 			let obj = this.clone();
 			if (this.type === "any" && source.type !== "any") {
 				const tmpObj = source.clone();
@@ -5311,13 +5363,13 @@ var require_base$2 = __commonJSMin((exports, module) => {
 				obj._flags.empty = obj._flags.empty.concat(source._flags.empty);
 				const flags = Object.assign({}, source._flags);
 				delete flags.empty;
-				merge$3(obj._flags, flags);
+				merge$2(obj._flags, flags);
 			} else if (source._flags.empty) {
 				obj._flags.empty = source._flags.empty;
 				const flags = Object.assign({}, source._flags);
 				delete flags.empty;
-				merge$3(obj._flags, flags);
-			} else merge$3(obj._flags, source._flags);
+				merge$2(obj._flags, flags);
+			} else merge$2(obj._flags, source._flags);
 			for (const key in source.$_terms) {
 				const terms = source.$_terms[key];
 				if (!terms) {
@@ -5334,7 +5386,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return obj.$_mutateRebuild();
 		}
 		extend(options) {
-			assert$42(!options.base, "Cannot extend type with another base");
+			assert$41(!options.base, "Cannot extend type with another base");
 			return Extend$2.type(this, options);
 		}
 		extract(path) {
@@ -5342,7 +5394,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return this._ids.reach(path);
 		}
 		fork(paths, adjuster) {
-			assert$42(!this._inRuleset(), "Cannot fork inside a ruleset");
+			assert$41(!this._inRuleset(), "Cannot fork inside a ruleset");
 			let obj = this;
 			for (let path of [].concat(paths)) {
 				path = Array.isArray(path) ? path : path.split(".");
@@ -5366,16 +5418,16 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		rule(options) {
 			const def = this._definition;
 			Common$14.assertOptions(options, Object.keys(def.modifiers));
-			assert$42(this.$_temp.ruleset !== false, "Cannot apply rules to empty ruleset or the last rule added does not support rule properties");
+			assert$41(this.$_temp.ruleset !== false, "Cannot apply rules to empty ruleset or the last rule added does not support rule properties");
 			const start = this.$_temp.ruleset === null ? this._rules.length - 1 : this.$_temp.ruleset;
-			assert$42(start >= 0 && start < this._rules.length, "Cannot apply rules to empty ruleset");
+			assert$41(start >= 0 && start < this._rules.length, "Cannot apply rules to empty ruleset");
 			const obj = this.clone();
 			for (let i$4 = start; i$4 < obj._rules.length; ++i$4) {
 				const original = obj._rules[i$4];
-				const rule = clone$11(original);
+				const rule = clone$10(original);
 				for (const name$2 in options) {
 					def.modifiers[name$2](rule, options[name$2]);
-					assert$42(rule.name === original.name, "Cannot change rule name");
+					assert$41(rule.name === original.name, "Cannot change rule name");
 				}
 				obj._rules[i$4] = rule;
 				if (obj._singleRules.get(rule.name) === original) obj._singleRules.set(rule.name, rule);
@@ -5384,7 +5436,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return obj.$_mutateRebuild();
 		}
 		get ruleset() {
-			assert$42(!this._inRuleset(), "Cannot start a new ruleset without closing the previous one");
+			assert$41(!this._inRuleset(), "Cannot start a new ruleset without closing the previous one");
 			const obj = this.clone();
 			obj.$_temp.ruleset = obj._rules.length;
 			return obj;
@@ -5394,12 +5446,12 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		}
 		tailor(targets) {
 			targets = [].concat(targets);
-			assert$42(!this._inRuleset(), "Cannot tailor inside a ruleset");
+			assert$41(!this._inRuleset(), "Cannot tailor inside a ruleset");
 			let obj = this;
 			if (this.$_terms.alterations) {
 				for (const { target, adjuster } of this.$_terms.alterations) if (targets.includes(target)) {
 					obj = adjuster(obj);
-					assert$42(Common$14.isSchema(obj), "Alteration adjuster for", target, "failed to return a schema object");
+					assert$41(Common$14.isSchema(obj), "Alteration adjuster for", target, "failed to return a schema object");
 				}
 			}
 			obj = obj.$_modify({
@@ -5420,18 +5472,18 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		}
 		$_addRule(options) {
 			if (typeof options === "string") options = { name: options };
-			assert$42(options && typeof options === "object", "Invalid options");
-			assert$42(options.name && typeof options.name === "string", "Invalid rule name");
-			for (const key in options) assert$42(key[0] !== "_", "Cannot set private rule properties");
+			assert$41(options && typeof options === "object", "Invalid options");
+			assert$41(options.name && typeof options.name === "string", "Invalid rule name");
+			for (const key in options) assert$41(key[0] !== "_", "Cannot set private rule properties");
 			const rule = Object.assign({}, options);
 			rule._resolve = [];
 			rule.method = rule.method || rule.name;
 			const definition = this._definition.rules[rule.method];
 			const args$1 = rule.args;
-			assert$42(definition, "Unknown rule", rule.method);
+			assert$41(definition, "Unknown rule", rule.method);
 			const obj = this.clone();
 			if (args$1) {
-				assert$42(Object.keys(args$1).length === 1 || Object.keys(args$1).length === this._definition.rules[rule.name].args.length, "Invalid rule definition for", this.type, rule.name);
+				assert$41(Object.keys(args$1).length === 1 || Object.keys(args$1).length === this._definition.rules[rule.name].args.length, "Invalid rule definition for", this.type, rule.name);
 				for (const key in args$1) {
 					let arg = args$1[key];
 					if (definition.argsByName) {
@@ -5446,7 +5498,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 							}
 							if (resolver.assert) {
 								const error = Common$14.validateArg(arg, key, resolver);
-								assert$42(!error, error, "or reference");
+								assert$41(!error, error, "or reference");
 							}
 						}
 					}
@@ -5503,7 +5555,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return Modify.schema(this, options) || this;
 		}
 		$_mutateRebuild() {
-			assert$42(!this._inRuleset(), "Cannot add this rule inside a ruleset");
+			assert$41(!this._inRuleset(), "Cannot add this rule inside a ruleset");
 			this._refs.reset();
 			this._ids.reset();
 			const each$5 = (item, { source, name: name$2, path, key }) => {
@@ -5532,10 +5584,10 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return this._refs.roots();
 		}
 		$_setFlag(name$2, value, options = {}) {
-			assert$42(name$2[0] === "_" || !this._inRuleset(), "Cannot set flag inside a ruleset");
+			assert$41(name$2[0] === "_" || !this._inRuleset(), "Cannot set flag inside a ruleset");
 			const flag = this._definition.flags[name$2] || {};
-			if (deepEqual$2(value, flag.default)) value = void 0;
-			if (deepEqual$2(value, this._flags[name$2])) return this;
+			if (deepEqual$1(value, flag.default)) value = void 0;
+			if (deepEqual$1(value, this._flags[name$2])) return this;
 			const obj = options.clone !== false ? this.clone() : this;
 			if (value !== void 0) {
 				obj._flags[name$2] = value;
@@ -5560,7 +5612,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			target._valids = this._valids && this._valids.clone();
 			target._invalids = this._invalids && this._invalids.clone();
 			target._rules = this._rules.slice();
-			target._singleRules = clone$11(this._singleRules, { shallow: true });
+			target._singleRules = clone$10(this._singleRules, { shallow: true });
 			target._refs = this._refs.clone();
 			target._flags = Object.assign({}, this._flags);
 			target._cache = null;
@@ -5582,8 +5634,8 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		}
 		_default(flag, value, options = {}) {
 			Common$14.assertOptions(options, "literal");
-			assert$42(value !== void 0, "Missing", flag, "value");
-			assert$42(typeof value === "function" || !options.literal, "Only function value supports literal option");
+			assert$41(value !== void 0, "Missing", flag, "value");
+			assert$41(typeof value === "function" || !options.literal, "Only function value supports literal option");
 			if (typeof value === "function" && options.literal) value = {
 				[Common$14.symbols.literal]: true,
 				literal: value
@@ -5644,7 +5696,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			};
 		}
 		_inner(type, values$3, options = {}) {
-			assert$42(!this._inRuleset(), `Cannot set ${type} inside a ruleset`);
+			assert$41(!this._inRuleset(), `Cannot set ${type} inside a ruleset`);
 			const obj = this.clone();
 			if (!obj.$_terms[type] || options.override) obj.$_terms[type] = [];
 			if (options.single) obj.$_terms[type].push(values$3);
@@ -5684,13 +5736,13 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			if (!obj[key]) return obj;
 			if (override) obj[key].override();
 			for (const value of values$3) {
-				assert$42(value !== void 0, "Cannot call allow/valid/invalid with undefined");
-				assert$42(value !== Common$14.symbols.override, "Override must be the first value");
+				assert$41(value !== void 0, "Cannot call allow/valid/invalid with undefined");
+				assert$41(value !== Common$14.symbols.override, "Override must be the first value");
 				const other = key === "_invalids" ? "_valids" : "_invalids";
 				if (obj[other]) {
 					obj[other].remove(value);
 					if (!obj[other].length) {
-						assert$42(key === "_valids" || !obj._flags.only, "Setting invalid value", value, "leaves schema rejecting all values due to previous valid rule");
+						assert$41(key === "_valids" || !obj._flags.only, "Setting invalid value", value, "leaves schema rejecting all values due to previous valid rule");
 						obj[other] = null;
 					}
 				}
@@ -5737,7 +5789,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 	module.exports = new internals$14.Base();
 });
 var require_any = __commonJSMin((exports, module) => {
-	const { assert: assert$41 } = require_lib$4();
+	const { assert: assert$40 } = require_lib$4();
 	const Base$3 = require_base$2();
 	const Common$13 = require_common$3();
 	const Messages$3 = require_messages();
@@ -5757,8 +5809,8 @@ var require_any = __commonJSMin((exports, module) => {
 		rules: {
 			custom: {
 				method(method$1, description$2) {
-					assert$41(typeof method$1 === "function", "Method must be a function");
-					assert$41(description$2 === void 0 || description$2 && typeof description$2 === "string", "Description must be a non-empty string");
+					assert$40(typeof method$1 === "function", "Method must be a function");
+					assert$40(description$2 === void 0 || description$2 && typeof description$2 === "string", "Description must be a non-empty string");
 					return this.$_addRule({
 						name: "custom",
 						args: {
@@ -5781,7 +5833,7 @@ var require_any = __commonJSMin((exports, module) => {
 				return this.prefs({ messages: messages$3 });
 			} },
 			shared: { method(schema$2) {
-				assert$41(Common$13.isSchema(schema$2) && schema$2._flags.id, "Schema must be a schema with an id");
+				assert$40(Common$13.isSchema(schema$2) && schema$2._flags.id, "Schema must be a schema with an id");
 				const obj = this.clone();
 				obj.$_terms.shared = obj.$_terms.shared || [];
 				obj.$_terms.shared.push(schema$2);
@@ -5790,7 +5842,7 @@ var require_any = __commonJSMin((exports, module) => {
 			} },
 			warning: {
 				method(code$2, local) {
-					assert$41(code$2 && typeof code$2 === "string", "Invalid warning code");
+					assert$40(code$2 && typeof code$2 === "string", "Invalid warning code");
 					return this.$_addRule({
 						name: "warning",
 						args: {
@@ -5874,7 +5926,7 @@ var require_any = __commonJSMin((exports, module) => {
 	});
 });
 var require_alternatives = __commonJSMin((exports, module) => {
-	const { assert: assert$40, merge: merge$2 } = require_lib$4();
+	const { assert: assert$39, merge: merge$1 } = require_lib$4();
 	const Any$9 = require_any();
 	const Common$12 = require_common$3();
 	const Compile$5 = require_compile();
@@ -5926,7 +5978,7 @@ var require_alternatives = __commonJSMin((exports, module) => {
 						return v$1.schema.type === "object" || v$1.schema.type === "alternatives" && isAnyObj(v$1.schema);
 					});
 				};
-				return isAnyObj(schema$2) ? { value: matched.reduce((acc, v$1) => merge$2(acc, v$1, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
+				return isAnyObj(schema$2) ? { value: matched.reduce((acc, v$1) => merge$1(acc, v$1, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
 			}
 			const errors = [];
 			for (let i$4 = 0; i$4 < schema$2.$_terms.matches.length; ++i$4) {
@@ -5961,9 +6013,9 @@ var require_alternatives = __commonJSMin((exports, module) => {
 		},
 		rules: {
 			conditional: { method(condition, options) {
-				assert$40(!this._flags._endedSwitch, "Unreachable condition");
-				assert$40(!this._flags.match, "Cannot combine match mode", this._flags.match, "with conditional rule");
-				assert$40(options.break === void 0, "Cannot use break option with alternatives conditional");
+				assert$39(!this._flags._endedSwitch, "Unreachable condition");
+				assert$39(!this._flags.match, "Cannot combine match mode", this._flags.match, "with conditional rule");
+				assert$39(options.break === void 0, "Cannot use break option with alternatives conditional");
 				const obj = this.clone();
 				const match$2 = Compile$5.when(obj, condition, options);
 				const conditions = match$2.is ? [match$2] : match$2.switch;
@@ -5975,18 +6027,18 @@ var require_alternatives = __commonJSMin((exports, module) => {
 				return obj.$_mutateRebuild();
 			} },
 			match: { method(mode) {
-				assert$40([
+				assert$39([
 					"any",
 					"one",
 					"all"
 				].includes(mode), "Invalid alternatives match mode", mode);
-				if (mode !== "any") for (const match$2 of this.$_terms.matches) assert$40(match$2.schema, "Cannot combine match mode", mode, "with conditional rules");
+				if (mode !== "any") for (const match$2 of this.$_terms.matches) assert$39(match$2.schema, "Cannot combine match mode", mode, "with conditional rules");
 				return this.$_setFlag("match", mode);
 			} },
 			try: { method(...schemas) {
-				assert$40(schemas.length, "Missing alternative schemas");
+				assert$39(schemas.length, "Missing alternative schemas");
 				Common$12.verifyFlat(schemas, "try");
-				assert$40(!this._flags._endedSwitch, "Unreachable condition");
+				assert$39(!this._flags._endedSwitch, "Unreachable condition");
 				const obj = this.clone();
 				for (const schema$2 of schemas) obj.$_terms.matches.push({ schema: obj.$_compile(schema$2) });
 				return obj.$_mutateRebuild();
@@ -6084,7 +6136,7 @@ var require_alternatives = __commonJSMin((exports, module) => {
 	};
 });
 var require_array = __commonJSMin((exports, module) => {
-	const { assert: assert$39, deepEqual: deepEqual$1, reach: reach$1 } = require_lib$4();
+	const { assert: assert$38, deepEqual, reach } = require_lib$4();
 	const Any$8 = require_any();
 	const Common$11 = require_common$3();
 	const Compile$4 = require_compile();
@@ -6380,7 +6432,7 @@ var require_array = __commonJSMin((exports, module) => {
 			} },
 			single: { method(enabled) {
 				const value = enabled === void 0 ? true : !!enabled;
-				assert$39(!value || !this._flags._arrayItems, "Cannot specify single rule when array has array items");
+				assert$38(!value || !this._flags._arrayItems, "Cannot specify single rule when array has array items");
 				return this.$_setFlag("single", value);
 			} },
 			sort: {
@@ -6389,7 +6441,7 @@ var require_array = __commonJSMin((exports, module) => {
 					const settings = { order: options.order || "ascending" };
 					if (options.by) {
 						settings.by = Compile$4.ref(options.by, { ancestor: 0 });
-						assert$39(!settings.by.ancestor, "Cannot sort by ancestor");
+						assert$38(!settings.by.ancestor, "Cannot sort by ancestor");
 					}
 					return this.$_addRule({
 						name: "sort",
@@ -6415,7 +6467,7 @@ var require_array = __commonJSMin((exports, module) => {
 			} },
 			unique: {
 				method(comparator, options = {}) {
-					assert$39(!comparator || typeof comparator === "function" || typeof comparator === "string", "comparator must be a function or a string");
+					assert$38(!comparator || typeof comparator === "function" || typeof comparator === "string", "comparator must be a function or a string");
 					Common$11.assertOptions(options, ["ignoreUndefined", "separator"]);
 					const rule = {
 						name: "unique",
@@ -6441,12 +6493,12 @@ var require_array = __commonJSMin((exports, module) => {
 						function: new Map(),
 						custom: new Map()
 					};
-					const compare$16 = comparator || deepEqual$1;
+					const compare$16 = comparator || deepEqual;
 					const ignoreUndefined = options.ignoreUndefined;
 					for (let i$4 = 0; i$4 < value.length; ++i$4) {
-						const item = path ? reach$1(value[i$4], path) : value[i$4];
+						const item = path ? reach(value[i$4], path) : value[i$4];
 						const records = comparator ? found.custom : found[typeof item];
-						assert$39(records, "Failed to find unique map container for type", typeof item);
+						assert$38(records, "Failed to find unique map container for type", typeof item);
 						if (records instanceof Map) {
 							const entries = records.entries();
 							let current;
@@ -6574,7 +6626,7 @@ var require_array = __commonJSMin((exports, module) => {
 	};
 	internals$12.validateSingle = function(type, obj) {
 		if (type.type === "array" || type._flags._arrayItems) {
-			assert$39(!obj._flags.single, "Cannot specify array item with single rule enabled");
+			assert$38(!obj._flags.single, "Cannot specify array item with single rule enabled");
 			obj.$_setFlag("_arrayItems", true, { clone: false });
 		}
 	};
@@ -6613,7 +6665,7 @@ var require_array = __commonJSMin((exports, module) => {
 	};
 });
 var require_boolean = __commonJSMin((exports, module) => {
-	const { assert: assert$38 } = require_lib$4();
+	const { assert: assert$37 } = require_lib$4();
 	const Any$7 = require_any();
 	const Common$10 = require_common$3();
 	const Values = require_values$1();
@@ -6656,7 +6708,7 @@ var require_boolean = __commonJSMin((exports, module) => {
 				obj.$_terms.truthy = obj.$_terms.truthy || new Values();
 				for (let i$4 = 0; i$4 < values$3.length; ++i$4) {
 					const value = values$3[i$4];
-					assert$38(value !== void 0, "Cannot call truthy with undefined");
+					assert$37(value !== void 0, "Cannot call truthy with undefined");
 					obj.$_terms.truthy.add(value);
 				}
 				return obj;
@@ -6667,7 +6719,7 @@ var require_boolean = __commonJSMin((exports, module) => {
 				obj.$_terms.falsy = obj.$_terms.falsy || new Values();
 				for (let i$4 = 0; i$4 < values$3.length; ++i$4) {
 					const value = values$3[i$4];
-					assert$38(value !== void 0, "Cannot call falsy with undefined");
+					assert$37(value !== void 0, "Cannot call falsy with undefined");
 					obj.$_terms.falsy.add(value);
 				}
 				return obj;
@@ -6699,7 +6751,7 @@ var require_boolean = __commonJSMin((exports, module) => {
 	});
 });
 var require_date = __commonJSMin((exports, module) => {
-	const { assert: assert$37 } = require_lib$4();
+	const { assert: assert$36 } = require_lib$4();
 	const Any$6 = require_any();
 	const Common$9 = require_common$3();
 	const Template$4 = require_template();
@@ -6749,7 +6801,7 @@ var require_date = __commonJSMin((exports, module) => {
 				}]
 			},
 			format: { method(format) {
-				assert$37([
+				assert$36([
 					"iso",
 					"javascript",
 					"unix"
@@ -6792,7 +6844,7 @@ var require_date = __commonJSMin((exports, module) => {
 				});
 			} },
 			timestamp: { method(type = "javascript") {
-				assert$37(["javascript", "unix"].includes(type), "\"type\" must be one of \"javascript, unix\"");
+				assert$36(["javascript", "unix"].includes(type), "\"type\" must be one of \"javascript, unix\"");
 				return this.format(type);
 			} }
 		},
@@ -6846,7 +6898,7 @@ var require_date = __commonJSMin((exports, module) => {
 	};
 });
 var require_lib$1 = __commonJSMin((exports) => {
-	const { assert: assert$36 } = require_lib$4();
+	const { assert: assert$35 } = require_lib$4();
 	const internals$9 = {};
 	exports.Sorter = class {
 		constructor() {
@@ -6859,10 +6911,10 @@ var require_lib$1 = __commonJSMin((exports) => {
 			const after = [].concat(options.after ?? []);
 			const group = options.group ?? "?";
 			const sort$2 = options.sort ?? 0;
-			assert$36(!before.includes(group), `Item cannot come before itself: ${group}`);
-			assert$36(!before.includes("?"), "Item cannot come before unassociated items");
-			assert$36(!after.includes(group), `Item cannot come after itself: ${group}`);
-			assert$36(!after.includes("?"), "Item cannot come after unassociated items");
+			assert$35(!before.includes(group), `Item cannot come before itself: ${group}`);
+			assert$35(!before.includes("?"), "Item cannot come before unassociated items");
+			assert$35(!after.includes(group), `Item cannot come after itself: ${group}`);
+			assert$35(!after.includes("?"), "Item cannot come after unassociated items");
 			if (!Array.isArray(nodes)) nodes = [nodes];
 			for (const node of nodes) {
 				const item = {
@@ -6877,7 +6929,7 @@ var require_lib$1 = __commonJSMin((exports) => {
 			}
 			if (!options.manual) {
 				const valid$2 = this._sort();
-				assert$36(valid$2, "item", group !== "?" ? `added into group ${group}` : "", "created a dependencies error");
+				assert$35(valid$2, "item", group !== "?" ? `added into group ${group}` : "", "created a dependencies error");
 			}
 			return this.nodes;
 		}
@@ -6887,12 +6939,12 @@ var require_lib$1 = __commonJSMin((exports) => {
 			this._items.sort(internals$9.mergeSort);
 			for (let i$4 = 0; i$4 < this._items.length; ++i$4) this._items[i$4].seq = i$4;
 			const valid$2 = this._sort();
-			assert$36(valid$2, "merge created a dependencies error");
+			assert$35(valid$2, "merge created a dependencies error");
 			return this.nodes;
 		}
 		sort() {
 			const valid$2 = this._sort();
-			assert$36(valid$2, "sort created a dependencies error");
+			assert$35(valid$2, "sort created a dependencies error");
 			return this.nodes;
 		}
 		_sort() {
@@ -6969,7 +7021,7 @@ var require_lib$1 = __commonJSMin((exports) => {
 	};
 });
 var require_keys$1 = __commonJSMin((exports, module) => {
-	const { applyToDefaults: applyToDefaults$1, assert: assert$35, clone: Clone } = require_lib$4();
+	const { applyToDefaults, assert: assert$34, clone: Clone } = require_lib$4();
 	const Topo = require_lib$1();
 	const Any$5 = require_any();
 	const Common$8 = require_common$3();
@@ -7070,7 +7122,7 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 			assert: {
 				method(subject, schema$2, message) {
 					if (!Template$3.isTemplate(subject)) subject = Compile$3.ref(subject);
-					assert$35(message === void 0 || typeof message === "string", "Message must be a string");
+					assert$34(message === void 0 || typeof message === "string", "Message must be a string");
 					schema$2 = this.$_compile(schema$2, { appendPath: true });
 					const obj = this.$_addRule({
 						name: "assert",
@@ -7102,7 +7154,7 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 			},
 			instance: {
 				method(constructor, name$2) {
-					assert$35(typeof constructor === "function", "constructor must be a function");
+					assert$34(typeof constructor === "function", "constructor must be a function");
 					name$2 = name$2 || constructor.name;
 					return this.$_addRule({
 						name: "instance",
@@ -7122,8 +7174,8 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 				args: ["constructor", "name"]
 			},
 			keys: { method(schema$2) {
-				assert$35(schema$2 === void 0 || typeof schema$2 === "object", "Object schema must be a valid object");
-				assert$35(!Common$8.isSchema(schema$2), "Object schema cannot be a joi schema");
+				assert$34(schema$2 === void 0 || typeof schema$2 === "object", "Object schema must be a valid object");
+				assert$34(!Common$8.isSchema(schema$2), "Object schema cannot be a joi schema");
 				const obj = this.clone();
 				if (!schema$2) obj.$_terms.keys = null;
 				else if (!Object.keys(schema$2).length) obj.$_terms.keys = new internals$8.Keys();
@@ -7188,9 +7240,9 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 			pattern: { method(pattern, schema$2, options = {}) {
 				const isRegExp$3 = pattern instanceof RegExp;
 				if (!isRegExp$3) pattern = this.$_compile(pattern, { appendPath: true });
-				assert$35(schema$2 !== void 0, "Invalid rule");
+				assert$34(schema$2 !== void 0, "Invalid rule");
 				Common$8.assertOptions(options, ["fallthrough", "matches"]);
-				if (isRegExp$3) assert$35(!pattern.flags.includes("g") && !pattern.flags.includes("y"), "pattern should not use global or sticky mode");
+				if (isRegExp$3) assert$34(!pattern.flags.includes("g") && !pattern.flags.includes("y"), "pattern should not use global or sticky mode");
 				schema$2 = this.$_compile(schema$2, { appendPath: true });
 				const obj = this.clone();
 				obj.$_terms.patterns = obj.$_terms.patterns || [];
@@ -7228,9 +7280,9 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 				}
 			},
 			rename: { method(from$2, to, options = {}) {
-				assert$35(typeof from$2 === "string" || from$2 instanceof RegExp, "Rename missing the from argument");
-				assert$35(typeof to === "string" || to instanceof Template$3, "Invalid rename to argument");
-				assert$35(to !== from$2, "Cannot rename key to same name:", from$2);
+				assert$34(typeof from$2 === "string" || from$2 instanceof RegExp, "Rename missing the from argument");
+				assert$34(typeof to === "string" || to instanceof Template$3, "Invalid rename to argument");
+				assert$34(to !== from$2, "Cannot rename key to same name:", from$2);
 				Common$8.assertOptions(options, [
 					"alias",
 					"ignoreUndefined",
@@ -7239,12 +7291,12 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 				]);
 				const obj = this.clone();
 				obj.$_terms.renames = obj.$_terms.renames || [];
-				for (const rename of obj.$_terms.renames) assert$35(rename.from !== from$2, "Cannot rename the same key multiple times");
+				for (const rename of obj.$_terms.renames) assert$34(rename.from !== from$2, "Cannot rename the same key multiple times");
 				if (to instanceof Template$3) obj.$_mutateRegister(to);
 				obj.$_terms.renames.push({
 					from: from$2,
 					to,
-					options: applyToDefaults$1(internals$8.renameDefaults, options)
+					options: applyToDefaults(internals$8.renameDefaults, options)
 				});
 				return obj;
 			} },
@@ -7356,14 +7408,14 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 		return clone$20;
 	};
 	internals$8.dependency = function(schema$2, rel, key, peers, options) {
-		assert$35(key === null || typeof key === "string", rel, "key must be a strings");
+		assert$34(key === null || typeof key === "string", rel, "key must be a strings");
 		if (!options) options = peers.length > 1 && typeof peers[peers.length - 1] === "object" ? peers.pop() : {};
 		Common$8.assertOptions(options, ["separator", "isPresent"]);
 		peers = [].concat(peers);
 		const separator = Common$8.default(options.separator, ".");
 		const paths = [];
 		for (const peer of peers) {
-			assert$35(typeof peer === "string", rel, "peers must be strings");
+			assert$34(typeof peer === "string", rel, "peers must be strings");
 			paths.push(Compile$3.ref(peer, {
 				separator,
 				ancestor: 0,
@@ -7660,7 +7712,7 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 	};
 });
 var require_function = __commonJSMin((exports, module) => {
-	const { assert: assert$34 } = require_lib$4();
+	const { assert: assert$33 } = require_lib$4();
 	const Keys$1 = require_keys$1();
 	module.exports = Keys$1.extend({
 		type: "function",
@@ -7668,7 +7720,7 @@ var require_function = __commonJSMin((exports, module) => {
 		rules: {
 			arity: {
 				method(n$4) {
-					assert$34(Number.isSafeInteger(n$4) && n$4 >= 0, "n must be a positive integer");
+					assert$33(Number.isSafeInteger(n$4) && n$4 >= 0, "n must be a positive integer");
 					return this.$_addRule({
 						name: "arity",
 						args: { n: n$4 }
@@ -7690,7 +7742,7 @@ var require_function = __commonJSMin((exports, module) => {
 			},
 			minArity: {
 				method(n$4) {
-					assert$34(Number.isSafeInteger(n$4) && n$4 > 0, "n must be a strict positive integer");
+					assert$33(Number.isSafeInteger(n$4) && n$4 > 0, "n must be a strict positive integer");
 					return this.$_addRule({
 						name: "minArity",
 						args: { n: n$4 }
@@ -7703,7 +7755,7 @@ var require_function = __commonJSMin((exports, module) => {
 			},
 			maxArity: {
 				method(n$4) {
-					assert$34(Number.isSafeInteger(n$4) && n$4 >= 0, "n must be a positive integer");
+					assert$33(Number.isSafeInteger(n$4) && n$4 >= 0, "n must be a positive integer");
 					return this.$_addRule({
 						name: "maxArity",
 						args: { n: n$4 }
@@ -7724,7 +7776,7 @@ var require_function = __commonJSMin((exports, module) => {
 	});
 });
 var require_link = __commonJSMin((exports, module) => {
-	const { assert: assert$33 } = require_lib$4();
+	const { assert: assert$32 } = require_lib$4();
 	const Any$4 = require_any();
 	const Common$7 = require_common$3();
 	const Compile$2 = require_compile();
@@ -7742,7 +7794,7 @@ var require_link = __commonJSMin((exports, module) => {
 			return schema$2.ref(ref);
 		},
 		validate(value, { schema: schema$2, state, prefs }) {
-			assert$33(schema$2.$_terms.link, "Uninitialized link schema");
+			assert$32(schema$2.$_terms.link, "Uninitialized link schema");
 			const linked = internals$7.generate(schema$2, value, state, prefs);
 			const ref = schema$2.$_terms.link[0].ref;
 			return linked.$_validate(value, state.nest(linked, `link:${ref.display}:${linked.type}`), prefs);
@@ -7752,10 +7804,10 @@ var require_link = __commonJSMin((exports, module) => {
 		},
 		rules: {
 			ref: { method(ref) {
-				assert$33(!this.$_terms.link, "Cannot reinitialize schema");
+				assert$32(!this.$_terms.link, "Cannot reinitialize schema");
 				ref = Compile$2.ref(ref);
-				assert$33(ref.type === "value" || ref.type === "local", "Invalid reference type:", ref.type);
-				assert$33(ref.type === "local" || ref.ancestor === "root" || ref.ancestor > 0, "Link cannot reference itself");
+				assert$32(ref.type === "value" || ref.type === "local", "Invalid reference type:", ref.type);
+				assert$32(ref.type === "local" || ref.ancestor === "root" || ref.ancestor > 0, "Link cannot reference itself");
 				const obj = this.clone();
 				obj.$_terms.link = [{ ref }];
 				return obj;
@@ -7765,16 +7817,16 @@ var require_link = __commonJSMin((exports, module) => {
 			} }
 		},
 		overrides: { concat(source) {
-			assert$33(this.$_terms.link, "Uninitialized link schema");
-			assert$33(Common$7.isSchema(source), "Invalid schema object");
-			assert$33(source.type !== "link", "Cannot merge type link with another link");
+			assert$32(this.$_terms.link, "Uninitialized link schema");
+			assert$32(Common$7.isSchema(source), "Invalid schema object");
+			assert$32(source.type !== "link", "Cannot merge type link with another link");
 			const obj = this.clone();
 			if (!obj.$_terms.whens) obj.$_terms.whens = [];
 			obj.$_terms.whens.push({ concat: source });
 			return obj.$_mutateRebuild();
 		} },
 		manifest: { build(obj, desc$1) {
-			assert$33(desc$1.link, "Invalid link description missing link");
+			assert$32(desc$1.link, "Invalid link description missing link");
 			return obj.ref(desc$1.link);
 		} }
 	});
@@ -7824,11 +7876,11 @@ var require_link = __commonJSMin((exports, module) => {
 	};
 	internals$7.assert = function(condition, message, ref, schema$2, state, prefs) {
 		if (condition) return;
-		assert$33(false, `"${Errors$2.label(schema$2._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
+		assert$32(false, `"${Errors$2.label(schema$2._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
 	};
 });
 var require_number = __commonJSMin((exports, module) => {
-	const { assert: assert$32 } = require_lib$4();
+	const { assert: assert$31 } = require_lib$4();
 	const Any$3 = require_any();
 	const Common$6 = require_common$3();
 	const internals$6 = {
@@ -8004,7 +8056,7 @@ var require_number = __commonJSMin((exports, module) => {
 			} },
 			precision: {
 				method(limit) {
-					assert$32(Number.isSafeInteger(limit), "limit must be an integer");
+					assert$31(Number.isSafeInteger(limit), "limit must be an integer");
 					return this.$_addRule({
 						name: "precision",
 						args: { limit }
@@ -8023,7 +8075,7 @@ var require_number = __commonJSMin((exports, module) => {
 			},
 			sign: {
 				method(sign$2) {
-					assert$32(["negative", "positive"].includes(sign$2), "Invalid sign", sign$2);
+					assert$31(["negative", "positive"].includes(sign$2), "Invalid sign", sign$2);
 					return this.$_addRule({
 						name: "sign",
 						args: { sign: sign$2 }
@@ -8035,7 +8087,7 @@ var require_number = __commonJSMin((exports, module) => {
 				}
 			},
 			unsafe: { method(enabled = true) {
-				assert$32(typeof enabled === "boolean", "enabled must be a boolean");
+				assert$31(typeof enabled === "boolean", "enabled must be a boolean");
 				return this.$_setFlag("unsafe", enabled);
 			} }
 		},
@@ -9369,10 +9421,10 @@ var require_types = __commonJSMin((exports) => {
 	exports.isArgumentsObject = isArgumentsObject;
 	exports.isGeneratorFunction = isGeneratorFunction;
 	exports.isTypedArray = isTypedArray$7;
-	function isPromise$2(input) {
+	function isPromise$1(input) {
 		return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function";
 	}
-	exports.isPromise = isPromise$2;
+	exports.isPromise = isPromise$1;
 	function isArrayBufferView$1(value) {
 		if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) return ArrayBuffer.isView(value);
 		return isTypedArray$7(value) || isDataView(value);
@@ -10056,31 +10108,6 @@ var init_email = __esmMin(() => {
 		"(?:\\xf0[\\x90-\\xbf][\\x80-\\xbf]{2})|(?:[\\xf1-\\xf3][\\x80-\\xbf]{3})|(?:\\xf4[\\x80-\\x8f][\\x80-\\xbf]{2})"
 	].join("|"));
 });
-var import_applyToDefaults, import_assert, import_bench, import_block, import_clone, import_contain, import_deepEqual, import_assertError, import_escapeHeaderAttribute, import_escapeHtml, import_escapeJson, import_escapeRegex, import_flatten, import_ignore, import_intersect, import_isPromise, import_merge, import_once, import_reach, import_reachTemplate, import_stringify, import_wait;
-var init_lib = __esmMin(() => {
-	import_applyToDefaults = __toESM(require_applyToDefaults(), 1);
-	import_assert = __toESM(require_assert$1(), 1);
-	import_bench = __toESM(require_bench(), 1);
-	import_block = __toESM(require_block(), 1);
-	import_clone = __toESM(require_clone$1(), 1);
-	import_contain = __toESM(require_contain(), 1);
-	import_deepEqual = __toESM(require_deepEqual(), 1);
-	import_assertError = __toESM(require_assertError(), 1);
-	import_escapeHeaderAttribute = __toESM(require_escapeHeaderAttribute(), 1);
-	import_escapeHtml = __toESM(require_escapeHtml(), 1);
-	import_escapeJson = __toESM(require_escapeJson(), 1);
-	import_escapeRegex = __toESM(require_escapeRegex(), 1);
-	import_flatten = __toESM(require_flatten$1(), 1);
-	import_ignore = __toESM(require_ignore(), 1);
-	import_intersect = __toESM(require_intersect(), 1);
-	import_isPromise = __toESM(require_isPromise(), 1);
-	import_merge = __toESM(require_merge(), 1);
-	import_once = __toESM(require_once(), 1);
-	import_reach = __toESM(require_reach(), 1);
-	import_reachTemplate = __toESM(require_reachTemplate(), 1);
-	import_stringify = __toESM(require_stringify(), 1);
-	import_wait = __toESM(require_wait(), 1);
-});
 function generate$1() {
 	const rfc3986$1 = {};
 	const hexDigit = "\\dA-Fa-f";
@@ -13703,20 +13730,6 @@ Object.defineProperty(import_errors$1.default, "template", { value: function(val
 	if (!messages$3[code$2]) return messages$3["*"];
 	return messages$3[code$2];
 } });
-var import_manifest$1 = __toESM(require_manifest());
-const ManifestDescriptionCache = new WeakMap();
-const originalDescribe = import_manifest$1.default.describe;
-Object.defineProperty(import_manifest$1.default, "describe", {
-	value: function(schema$2) {
-		const cached = ManifestDescriptionCache.get(schema$2);
-		if (cached) return cached;
-		const result = originalDescribe.call(this, schema$2);
-		ManifestDescriptionCache.set(schema$2, result);
-		return result;
-	},
-	writable: true,
-	configurable: true
-});
 const json = (root$11) => {
 	return root$11;
 };
@@ -45702,14 +45715,6 @@ var RootFactory = class RootFactory {
 	static generate(root$11, schema$2, args$1) {
 		(0, import_assert.default)(root$11, "Must be invoked on a Joi instance.");
 		const cloned = schema$2.clone();
-		const originalDescribe$1 = cloned.describe.bind(cloned);
-		cloned.describe = function() {
-			const cached = RootFactory.$_cachedDescriptions.get(this);
-			if (cached) return cached;
-			const result = originalDescribe$1();
-			RootFactory.$_cachedDescriptions.set(this, result);
-			return result;
-		};
 		cloned.$_root = root$11;
 		if (!cloned._definition.args || !args$1.length) return cloned;
 		return cloned._definition.args(cloned, ...args$1);
@@ -143176,7 +143181,7 @@ const encode = (schema$2, options = {}) => {
 		});
 	}
 	const json$1 = JSON.stringify({
-		version: "0.1.0-master-cb87a6f9",
+		version: "0.1.0-master-fe5983b7",
 		schema: description$2
 	}, (key, value) => {
 		if (typeof value === "bigint") return value.toString();
@@ -143224,9 +143229,9 @@ const decode = (base64, options = {}) => {
 	});
 	if (!isPlainObject(description$2) || !("version" in description$2) || !("schema" in description$2) || typeof description$2.version !== "string" || !isPlainObject(description$2.schema)) throw new TypeError("Not a valid encoded schema");
 	const { version: schemaVersion, schema: schema$2 } = description$2;
-	if (import_semver.valid("0.1.0-master-cb87a6f9")) {
+	if (import_semver.valid("0.1.0-master-fe5983b7")) {
 		if (!import_semver.valid(import_semver.coerce(schemaVersion))) throw new TypeError(`Invalid schema version: ${schemaVersion}`);
-		if (import_semver.gt(import_semver.coerce(schemaVersion), "0.1.0-master-cb87a6f9")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 0.1.0-master-cb87a6f9`);
+		if (import_semver.gt(import_semver.coerce(schemaVersion), "0.1.0-master-fe5983b7")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 0.1.0-master-fe5983b7`);
 	}
 	return validator.build(schema$2);
 };
@@ -144680,7 +144685,7 @@ init_esm();
 var import_lib = __toESM(require_lib$3());
 var import_lib$1 = __toESM(require_lib$2());
 var import_lib$2 = __toESM(require_lib());
-const version = "0.1.0-master-cb87a6f9";
+const version = "0.1.0-master-fe5983b7";
 Object.defineProperty(exports, "ValidationError", {
 	enumerable: true,
 	get: function() {