@nhtio/validation 2.20251203.0 → 2.20251203.1

package/index.mjs

@@ -33,7 +33,7 @@ var __require = ((x) => typeof require !== "undefined" ? require : typeof Proxy
 	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
 });
 var require_assertError = __commonJSMin((exports, module) => {
-	module.exports = class AssertError$4 extends Error {
+	module.exports = class AssertError$3 extends Error {
 		name = "AssertError";
 		constructor(message, ctor) {
 			super(message || "Unknown error");
@@ -51,7 +51,7 @@ var require_stringify = __commonJSMin((exports, module) => {
 	};
 });
 var require_assert$1 = __commonJSMin((exports, module) => {
-	const AssertError$3 = require_assertError();
+	const AssertError$2 = require_assertError();
 	const Stringify = require_stringify();
 	const assert$54 = module.exports = function(condition, ...args$1) {
 		if (condition) return;
@@ -59,7 +59,7 @@ var require_assert$1 = __commonJSMin((exports, module) => {
 		const msgs = args$1.filter((arg) => arg !== "").map((arg) => {
 			return typeof arg === "string" ? arg : arg instanceof Error ? arg.message : Stringify(arg);
 		});
-		throw new AssertError$3(msgs.join(" "), assert$54);
+		throw new AssertError$2(msgs.join(" "), assert$54);
 	};
 });
 var dist_exports = {};
@@ -247,15 +247,15 @@ var init_dist$1 = __esmMin(() => {
 	* @author   Feross Aboukhadijeh <https://feross.org>
 	* @license  MIT
 	*/
-	(function(exports$4) {
+	(function(exports$1) {
 		const base64 = base64Js;
 		const ieee754$1 = ieee754;
 		const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
-		exports$4.Buffer = Buffer$27;
-		exports$4.SlowBuffer = SlowBuffer$1;
-		exports$4.INSPECT_MAX_BYTES = 50;
+		exports$1.Buffer = Buffer$27;
+		exports$1.SlowBuffer = SlowBuffer$1;
+		exports$1.INSPECT_MAX_BYTES = 50;
 		const K_MAX_LENGTH = 2147483647;
-		exports$4.kMaxLength = K_MAX_LENGTH;
+		exports$1.kMaxLength = K_MAX_LENGTH;
 		const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
 		Buffer$27.TYPED_ARRAY_SUPPORT = typedArraySupport();
 		if (!Buffer$27.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
@@ -554,7 +554,7 @@ var init_dist$1 = __esmMin(() => {
 		};
 		Buffer$27.prototype.inspect = function inspect$5() {
 			let str = "";
-			const max$4 = exports$4.INSPECT_MAX_BYTES;
+			const max$4 = exports$1.INSPECT_MAX_BYTES;
 			str = this.toString("hex", 0, max$4).replace(/(.{2})/g, "$1 ").trim();
 			if (this.length > max$4) str += " ... ";
 			return "<Buffer " + str + ">";
@@ -1506,26 +1506,26 @@ var init_dist$1 = __esmMin(() => {
 	transcode = buffer$1.transcode;
 });
 var require_reach = __commonJSMin((exports, module) => {
-	const Assert$6 = require_assert$1();
-	const internals$42 = {};
+	const Assert$5 = require_assert$1();
+	const internals$41 = {};
 	module.exports = function(obj, chain, options) {
 		if (chain === false || chain === null || chain === void 0) return obj;
 		options = options || {};
 		if (typeof options === "string") options = { separator: options };
 		const isChainArray = Array.isArray(chain);
-		Assert$6(!isChainArray || !options.separator, "Separator option is not valid for array-based chain");
+		Assert$5(!isChainArray || !options.separator, "Separator option is not valid for array-based chain");
 		const path = isChainArray ? chain : chain.split(options.separator || ".");
 		let ref = obj;
 		for (let i$1 = 0; i$1 < path.length; ++i$1) {
 			let key = path[i$1];
-			const type = options.iterables && internals$42.iterables(ref);
+			const type = options.iterables && internals$41.iterables(ref);
 			if (Array.isArray(ref) || type === "set") {
 				const number = Number(key);
 				if (Number.isInteger(number)) key = number < 0 ? ref.length + number : number;
 			}
 			if (!ref || typeof ref === "function" && options.functions === false || !type && ref[key] === void 0) {
-				Assert$6(!options.strict || i$1 + 1 === path.length, "Missing segment", key, "in reach path ", chain);
-				Assert$6(typeof ref === "object" || options.functions === true || typeof ref !== "function", "Invalid segment", key, "in reach path ", chain);
+				Assert$5(!options.strict || i$1 + 1 === path.length, "Missing segment", key, "in reach path ", chain);
+				Assert$5(typeof ref === "object" || options.functions === true || typeof ref !== "function", "Invalid segment", key, "in reach path ", chain);
 				ref = options.default;
 				break;
 			}
@@ -1535,14 +1535,14 @@ var require_reach = __commonJSMin((exports, module) => {
 		}
 		return ref;
 	};
-	internals$42.iterables = function(ref) {
+	internals$41.iterables = function(ref) {
 		if (ref instanceof Set) return "set";
 		if (ref instanceof Map) return "map";
 	};
 });
 var require_types$1 = __commonJSMin((exports, module) => {
 	init_dist$1();
-	const internals$41 = {};
+	const internals$40 = {};
 	exports = module.exports = {
 		array: Array.prototype,
 		buffer: Buffer$1 && Buffer$1.prototype,
@@ -1557,7 +1557,7 @@ var require_types$1 = __commonJSMin((exports, module) => {
 		weakMap: WeakMap.prototype,
 		weakSet: WeakSet.prototype
 	};
-	internals$41.typeMap = new Map([
+	internals$40.typeMap = new Map([
 		["[object Error]", exports.error],
 		["[object Map]", exports.map],
 		["[object Promise]", exports.promise],
@@ -1573,7 +1573,7 @@ var require_types$1 = __commonJSMin((exports, module) => {
 		if (obj instanceof RegExp) return exports.regex;
 		if (obj instanceof Error) return exports.error;
 		const objName = Object.prototype.toString.call(obj);
-		return internals$41.typeMap.get(objName) || exports.generic;
+		return internals$40.typeMap.get(objName) || exports.generic;
 	};
 });
 var require_utils$7 = __commonJSMin((exports) => {
@@ -1586,7 +1586,7 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 	const Reach$2 = require_reach();
 	const Types$1 = require_types$1();
 	const Utils$3 = require_utils$7();
-	const internals$40 = {
+	const internals$39 = {
 		needsProtoHack: new Set([
 			Types$1.set,
 			Types$1.map,
@@ -1595,12 +1595,12 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 		]),
 		structuredCloneExists: typeof structuredClone === "function"
 	};
-	module.exports = internals$40.clone = function(obj, options = {}, _seen = null) {
+	module.exports = internals$39.clone = function(obj, options = {}, _seen = null) {
 		if (typeof obj !== "object" || obj === null) return obj;
-		let clone$20 = internals$40.clone;
+		let clone$20 = internals$39.clone;
 		let seen = _seen;
 		if (options.shallow) {
-			if (options.shallow !== true) return internals$40.cloneWithShallow(obj, options);
+			if (options.shallow !== true) return internals$39.cloneWithShallow(obj, options);
 			clone$20 = (value) => value;
 		} else if (seen) {
 			const lookup$1 = seen.get(obj);
@@ -1613,7 +1613,7 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 			case Types$1.regex:
 			case Types$1.url: return new baseProto.constructor(obj);
 		}
-		const newObj = internals$40.base(obj, baseProto, options);
+		const newObj = internals$39.base(obj, baseProto, options);
 		if (newObj === obj) return obj;
 		if (seen) seen.set(obj, newObj);
 		if (baseProto === Types$1.set) for (const value of obj) newObj.add(clone$20(value, options, seen));
@@ -1625,7 +1625,7 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 				newObj.length = obj.length;
 				continue;
 			}
-			if (internals$40.structuredCloneExists && baseProto === Types$1.error && key === "stack") continue;
+			if (internals$39.structuredCloneExists && baseProto === Types$1.error && key === "stack") continue;
 			const descriptor = Object.getOwnPropertyDescriptor(obj, key);
 			if (descriptor) if (descriptor.get || descriptor.set) Object.defineProperty(newObj, key, descriptor);
 			else if (descriptor.enumerable) newObj[key] = clone$20(obj[key], options, seen);
@@ -1644,7 +1644,7 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 		}
 		return newObj;
 	};
-	internals$40.cloneWithShallow = function(source, options) {
+	internals$39.cloneWithShallow = function(source, options) {
 		const keys$10 = options.shallow;
 		options = Object.assign({}, options);
 		options.shallow = false;
@@ -1653,11 +1653,11 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 			const ref = Reach$2(source, key);
 			if (typeof ref === "object" || typeof ref === "function") seen.set(ref, ref);
 		}
-		return internals$40.clone(source, options, seen);
+		return internals$39.clone(source, options, seen);
 	};
-	internals$40.base = function(obj, baseProto, options) {
+	internals$39.base = function(obj, baseProto, options) {
 		if (options.prototype === false) {
-			if (internals$40.needsProtoHack.has(baseProto)) return new baseProto.constructor();
+			if (internals$39.needsProtoHack.has(baseProto)) return new baseProto.constructor();
 			return baseProto === Types$1.array ? [] : {};
 		}
 		const proto = Object.getPrototypeOf(obj);
@@ -1666,12 +1666,12 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 			const newObj = [];
 			if (proto !== baseProto) Object.setPrototypeOf(newObj, proto);
 			return newObj;
-		} else if (baseProto === Types$1.error && internals$40.structuredCloneExists && (proto === baseProto || Error.isPrototypeOf(proto.constructor))) {
+		} else if (baseProto === Types$1.error && internals$39.structuredCloneExists && (proto === baseProto || Error.isPrototypeOf(proto.constructor))) {
 			const err = structuredClone(obj);
 			if (Object.getPrototypeOf(err) !== proto) Object.setPrototypeOf(err, proto);
 			return err;
 		}
-		if (internals$40.needsProtoHack.has(baseProto)) {
+		if (internals$39.needsProtoHack.has(baseProto)) {
 			const newObj = new proto.constructor();
 			if (proto !== baseProto) Object.setPrototypeOf(newObj, proto);
 			return newObj;
@@ -1681,20 +1681,20 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 });
 var require_merge = __commonJSMin((exports, module) => {
 	init_dist$1();
-	const Assert$5 = require_assert$1();
+	const Assert$4 = require_assert$1();
 	const Clone$2 = require_clone$1();
 	const Utils$2 = require_utils$7();
-	const internals$39 = {};
-	module.exports = internals$39.merge = function(target, source, options) {
-		Assert$5(target && typeof target === "object", "Invalid target value: must be an object");
-		Assert$5(source === null || source === void 0 || typeof source === "object", "Invalid source value: must be null, undefined, or an object");
+	const internals$38 = {};
+	module.exports = internals$38.merge = function(target, source, options) {
+		Assert$4(target && typeof target === "object", "Invalid target value: must be an object");
+		Assert$4(source === null || source === void 0 || typeof source === "object", "Invalid source value: must be null, undefined, or an object");
 		if (!source) return target;
 		options = Object.assign({
 			nullOverride: true,
 			mergeArrays: true
 		}, options);
 		if (Array.isArray(source)) {
-			Assert$5(Array.isArray(target), "Cannot merge array onto an object");
+			Assert$4(Array.isArray(target), "Cannot merge array onto an object");
 			if (!options.mergeArrays) target.length = 0;
 			for (let i$1 = 0; i$1 < source.length; ++i$1) target.push(Clone$2(source[i$1], { symbols: options.symbols }));
 			return target;
@@ -1707,7 +1707,7 @@ var require_merge = __commonJSMin((exports, module) => {
 			if (value && typeof value === "object") {
 				if (target[key] === value) continue;
 				if (!target[key] || typeof target[key] !== "object" || Array.isArray(target[key]) !== Array.isArray(value) || value instanceof Date || Buffer$1 && Buffer$1.isBuffer(value) || value instanceof RegExp) target[key] = Clone$2(value, { symbols: options.symbols });
-				else internals$39.merge(target[key], value, options);
+				else internals$38.merge(target[key], value, options);
 			} else if (value !== null && value !== void 0) target[key] = value;
 			else if (options.nullOverride) target[key] = value;
 		}
@@ -1715,17 +1715,17 @@ var require_merge = __commonJSMin((exports, module) => {
 	};
 });
 var require_applyToDefaults = __commonJSMin((exports, module) => {
-	const Assert$4 = require_assert$1();
+	const Assert$3 = require_assert$1();
 	const Clone$1 = require_clone$1();
 	const Merge = require_merge();
 	const Reach$1 = require_reach();
-	const internals$38 = {};
+	const internals$37 = {};
 	module.exports = function(defaults$3, source, options = {}) {
-		Assert$4(defaults$3 && typeof defaults$3 === "object", "Invalid defaults value: must be an object");
-		Assert$4(!source || source === true || typeof source === "object", "Invalid source value: must be true, falsy or an object");
-		Assert$4(typeof options === "object", "Invalid options: must be an object");
+		Assert$3(defaults$3 && typeof defaults$3 === "object", "Invalid defaults value: must be an object");
+		Assert$3(!source || source === true || typeof source === "object", "Invalid source value: must be true, falsy or an object");
+		Assert$3(typeof options === "object", "Invalid options: must be an object");
 		if (!source) return null;
-		if (options.shallow) return internals$38.applyToDefaultsWithShallow(defaults$3, source, options);
+		if (options.shallow) return internals$37.applyToDefaultsWithShallow(defaults$3, source, options);
 		const copy$1 = Clone$1(defaults$3);
 		if (source === true) return copy$1;
 		const nullOverride = options.nullOverride !== void 0 ? options.nullOverride : false;
@@ -1734,9 +1734,9 @@ var require_applyToDefaults = __commonJSMin((exports, module) => {
 			mergeArrays: false
 		});
 	};
-	internals$38.applyToDefaultsWithShallow = function(defaults$3, source, options) {
+	internals$37.applyToDefaultsWithShallow = function(defaults$3, source, options) {
 		const keys$10 = options.shallow;
-		Assert$4(Array.isArray(keys$10), "Invalid keys");
+		Assert$3(Array.isArray(keys$10), "Invalid keys");
 		const seen = new Map();
 		const merge$4 = source === true ? null : new Set();
 		for (let key of keys$10) {
@@ -1747,14 +1747,14 @@ var require_applyToDefaults = __commonJSMin((exports, module) => {
 		}
 		const copy$1 = Clone$1(defaults$3, {}, seen);
 		if (!merge$4) return copy$1;
-		for (const key of merge$4) internals$38.reachCopy(copy$1, source, key);
+		for (const key of merge$4) internals$37.reachCopy(copy$1, source, key);
 		const nullOverride = options.nullOverride !== void 0 ? options.nullOverride : false;
 		return Merge(copy$1, source, {
 			nullOverride,
 			mergeArrays: false
 		});
 	};
-	internals$38.reachCopy = function(dst, src$1, path) {
+	internals$37.reachCopy = function(dst, src$1, path) {
 		for (const segment of path) {
 			if (!(segment in src$1)) return;
 			const val = src$1[segment];
@@ -1905,17 +1905,17 @@ var init_dist = __esmMin(() => {
 });
 var require_bench = __commonJSMin((exports, module) => {
 	init_dist();
-	const internals$37 = {};
-	module.exports = internals$37.Bench = class {
+	const internals$36 = {};
+	module.exports = internals$36.Bench = class {
 		constructor() {
 			this.ts = 0;
 			this.reset();
 		}
 		reset() {
-			this.ts = internals$37.Bench.now();
+			this.ts = internals$36.Bench.now();
 		}
 		elapsed() {
-			return internals$37.Bench.now() - this.ts;
+			return internals$36.Bench.now() - this.ts;
 		}
 		static now() {
 			const ts = process$1.hrtime();
@@ -1935,12 +1935,12 @@ var require_block = __commonJSMin((exports, module) => {
 var require_deepEqual = __commonJSMin((exports, module) => {
 	init_dist$1();
 	const Types = require_types$1();
-	const internals$36 = { mismatched: null };
+	const internals$35 = { mismatched: null };
 	module.exports = function(obj, ref, options) {
 		options = Object.assign({ prototype: true }, options);
-		return !!internals$36.isDeepEqual(obj, ref, options, []);
+		return !!internals$35.isDeepEqual(obj, ref, options, []);
 	};
-	internals$36.isDeepEqual = function(obj, ref, options, seen) {
+	internals$35.isDeepEqual = function(obj, ref, options, seen) {
 		if (obj === ref) return obj !== 0 || 1 / obj === 1 / ref;
 		const type = typeof obj;
 		if (type !== typeof ref) return false;
@@ -1948,32 +1948,32 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 		if (type === "function") {
 			if (!options.deepFunction || obj.toString() !== ref.toString()) return false;
 		} else if (type !== "object") return obj !== obj && ref !== ref;
-		const instanceType = internals$36.getSharedType(obj, ref, !!options.prototype);
+		const instanceType = internals$35.getSharedType(obj, ref, !!options.prototype);
 		switch (instanceType) {
 			case Types.buffer: return Buffer$1 && Buffer$1.prototype.equals.call(obj, ref);
 			case Types.promise: return obj === ref;
 			case Types.regex:
 			case Types.url: return obj.toString() === ref.toString();
-			case internals$36.mismatched: return false;
+			case internals$35.mismatched: return false;
 		}
 		for (let i$1 = seen.length - 1; i$1 >= 0; --i$1) if (seen[i$1].isSame(obj, ref)) return true;
-		seen.push(new internals$36.SeenEntry(obj, ref));
+		seen.push(new internals$35.SeenEntry(obj, ref));
 		try {
-			return !!internals$36.isDeepEqualObj(instanceType, obj, ref, options, seen);
+			return !!internals$35.isDeepEqualObj(instanceType, obj, ref, options, seen);
 		} finally {
 			seen.pop();
 		}
 	};
-	internals$36.getSharedType = function(obj, ref, checkPrototype) {
+	internals$35.getSharedType = function(obj, ref, checkPrototype) {
 		if (checkPrototype) {
-			if (Object.getPrototypeOf(obj) !== Object.getPrototypeOf(ref)) return internals$36.mismatched;
+			if (Object.getPrototypeOf(obj) !== Object.getPrototypeOf(ref)) return internals$35.mismatched;
 			return Types.getInternalProto(obj);
 		}
 		const type = Types.getInternalProto(obj);
-		if (type !== Types.getInternalProto(ref)) return internals$36.mismatched;
+		if (type !== Types.getInternalProto(ref)) return internals$35.mismatched;
 		return type;
 	};
-	internals$36.valueOf = function(obj) {
+	internals$35.valueOf = function(obj) {
 		const objValueOf = obj.valueOf;
 		if (objValueOf === void 0) return obj;
 		try {
@@ -1982,15 +1982,15 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 			return err;
 		}
 	};
-	internals$36.hasOwnEnumerableProperty = function(obj, key) {
+	internals$35.hasOwnEnumerableProperty = function(obj, key) {
 		return Object.prototype.propertyIsEnumerable.call(obj, key);
 	};
-	internals$36.isSetSimpleEqual = function(obj, ref) {
+	internals$35.isSetSimpleEqual = function(obj, ref) {
 		for (const entry of Set.prototype.values.call(obj)) if (!Set.prototype.has.call(ref, entry)) return false;
 		return true;
 	};
-	internals$36.isDeepEqualObj = function(instanceType, obj, ref, options, seen) {
-		const { isDeepEqual: isDeepEqual$2, valueOf, hasOwnEnumerableProperty } = internals$36;
+	internals$35.isDeepEqualObj = function(instanceType, obj, ref, options, seen) {
+		const { isDeepEqual: isDeepEqual$2, valueOf, hasOwnEnumerableProperty } = internals$35;
 		const { keys: keys$10, getOwnPropertySymbols: getOwnPropertySymbols$1 } = Object;
 		if (instanceType === Types.array) if (options.part) {
 			for (const objValue of obj) for (const refValue of ref) if (isDeepEqual$2(objValue, refValue, options, seen)) return true;
@@ -2001,7 +2001,7 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 		}
 		else if (instanceType === Types.set) {
 			if (obj.size !== ref.size) return false;
-			if (!internals$36.isSetSimpleEqual(obj, ref)) {
+			if (!internals$35.isSetSimpleEqual(obj, ref)) {
 				const ref2 = new Set(Set.prototype.values.call(ref));
 				for (const objEntry of Set.prototype.values.call(obj)) {
 					if (ref2.delete(objEntry)) continue;
@@ -2054,7 +2054,7 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 		}
 		return true;
 	};
-	internals$36.SeenEntry = class {
+	internals$35.SeenEntry = class {
 		constructor(obj, ref) {
 			this.obj = obj;
 			this.ref = ref;
@@ -2070,20 +2070,20 @@ var require_escapeRegex = __commonJSMin((exports, module) => {
 	};
 });
 var require_contain = __commonJSMin((exports, module) => {
-	const Assert$3 = require_assert$1();
+	const Assert$2 = require_assert$1();
 	const DeepEqual = require_deepEqual();
 	const EscapeRegex = require_escapeRegex();
 	const Utils$1 = require_utils$7();
-	const internals$35 = {};
+	const internals$34 = {};
 	module.exports = function(ref, values$3, options = {}) {
 		if (typeof values$3 !== "object") values$3 = [values$3];
-		Assert$3(!Array.isArray(values$3) || values$3.length, "Values array cannot be empty");
-		if (typeof ref === "string") return internals$35.string(ref, values$3, options);
-		if (Array.isArray(ref)) return internals$35.array(ref, values$3, options);
-		Assert$3(typeof ref === "object", "Reference must be string or an object");
-		return internals$35.object(ref, values$3, options);
+		Assert$2(!Array.isArray(values$3) || values$3.length, "Values array cannot be empty");
+		if (typeof ref === "string") return internals$34.string(ref, values$3, options);
+		if (Array.isArray(ref)) return internals$34.array(ref, values$3, options);
+		Assert$2(typeof ref === "object", "Reference must be string or an object");
+		return internals$34.object(ref, values$3, options);
 	};
-	internals$35.array = function(ref, values$3, options) {
+	internals$34.array = function(ref, values$3, options) {
 		if (!Array.isArray(values$3)) values$3 = [values$3];
 		if (!ref.length) return false;
 		if (options.only && options.once && ref.length !== values$3.length) return false;
@@ -2097,7 +2097,7 @@ var require_contain = __commonJSMin((exports, module) => {
 				hits: 0
 			});
 		} else {
-			compare$16 = compare$16 ?? internals$35.compare(options);
+			compare$16 = compare$16 ?? internals$34.compare(options);
 			let found = false;
 			for (const [key, existing] of map$8.entries()) if (compare$16(key, value)) {
 				++existing.allowed;
@@ -2114,7 +2114,7 @@ var require_contain = __commonJSMin((exports, module) => {
 			let match$2;
 			if (!options.deep || !item || typeof item !== "object") match$2 = map$8.get(item);
 			else {
-				compare$16 = compare$16 ?? internals$35.compare(options);
+				compare$16 = compare$16 ?? internals$34.compare(options);
 				for (const [key, existing] of map$8.entries()) if (compare$16(key, item)) {
 					match$2 = existing;
 					break;
@@ -2133,14 +2133,14 @@ var require_contain = __commonJSMin((exports, module) => {
 		}
 		return !!hits;
 	};
-	internals$35.object = function(ref, values$3, options) {
-		Assert$3(options.once === void 0, "Cannot use option once with object");
+	internals$34.object = function(ref, values$3, options) {
+		Assert$2(options.once === void 0, "Cannot use option once with object");
 		const keys$10 = Utils$1.keys(ref, options);
 		if (!keys$10.length) return false;
-		if (Array.isArray(values$3)) return internals$35.array(keys$10, values$3, options);
+		if (Array.isArray(values$3)) return internals$34.array(keys$10, values$3, options);
 		const symbols = Object.getOwnPropertySymbols(values$3).filter((sym) => values$3.propertyIsEnumerable(sym));
 		const targets = [...Object.keys(values$3), ...symbols];
-		const compare$16 = internals$35.compare(options);
+		const compare$16 = internals$34.compare(options);
 		const set = new Set(targets);
 		for (const key of keys$10) {
 			if (!set.has(key)) {
@@ -2153,12 +2153,12 @@ var require_contain = __commonJSMin((exports, module) => {
 		if (set.size) return options.part ? set.size < targets.length : false;
 		return true;
 	};
-	internals$35.string = function(ref, values$3, options) {
+	internals$34.string = function(ref, values$3, options) {
 		if (ref === "") return values$3.length === 1 && values$3[0] === "" || !options.once && !values$3.some((v$1) => v$1 !== "");
 		const map$8 = new Map();
 		const patterns = [];
 		for (const value of values$3) {
-			Assert$3(typeof value === "string", "Cannot compare string reference to non-string value");
+			Assert$2(typeof value === "string", "Cannot compare string reference to non-string value");
 			if (value) {
 				const existing = map$8.get(value);
 				if (existing) ++existing.allowed;
@@ -2187,8 +2187,8 @@ var require_contain = __commonJSMin((exports, module) => {
 		}
 		return !!any;
 	};
-	internals$35.compare = function(options) {
-		if (!options.deep) return internals$35.shallow;
+	internals$34.compare = function(options) {
+		if (!options.deep) return internals$34.shallow;
 		const hasOnly = options.only !== void 0;
 		const hasPart = options.part !== void 0;
 		const flags = {
@@ -2197,40 +2197,40 @@ var require_contain = __commonJSMin((exports, module) => {
 		};
 		return (a$2, b) => DeepEqual(a$2, b, flags);
 	};
-	internals$35.shallow = function(a$2, b) {
+	internals$34.shallow = function(a$2, b) {
 		return a$2 === b;
 	};
 });
 var require_escapeHeaderAttribute = __commonJSMin((exports, module) => {
-	const Assert$2 = require_assert$1();
+	const Assert$1 = require_assert$1();
 	module.exports = function(attribute) {
-		Assert$2(/^[ \w\!#\$%&'\(\)\*\+,\-\.\/\:;<\=>\?@\[\]\^`\{\|\}~\"\\]*$/.test(attribute), "Bad attribute value (" + attribute + ")");
+		Assert$1(/^[ \w\!#\$%&'\(\)\*\+,\-\.\/\:;<\=>\?@\[\]\^`\{\|\}~\"\\]*$/.test(attribute), "Bad attribute value (" + attribute + ")");
 		return attribute.replace(/\\/g, "\\\\").replace(/\"/g, "\\\"");
 	};
 });
 var require_escapeHtml = __commonJSMin((exports, module) => {
-	const internals$34 = {};
+	const internals$33 = {};
 	module.exports = function(input) {
 		if (!input) return "";
 		let escaped = "";
 		for (let i$1 = 0; i$1 < input.length; ++i$1) {
 			const charCode = input.charCodeAt(i$1);
-			if (internals$34.isSafe(charCode)) escaped += input[i$1];
-			else escaped += internals$34.escapeHtmlChar(charCode);
+			if (internals$33.isSafe(charCode)) escaped += input[i$1];
+			else escaped += internals$33.escapeHtmlChar(charCode);
 		}
 		return escaped;
 	};
-	internals$34.escapeHtmlChar = function(charCode) {
-		const namedEscape = internals$34.namedHtml.get(charCode);
+	internals$33.escapeHtmlChar = function(charCode) {
+		const namedEscape = internals$33.namedHtml.get(charCode);
 		if (namedEscape) return namedEscape;
 		if (charCode >= 256) return "&#" + charCode + ";";
 		const hexValue = charCode.toString(16).padStart(2, "0");
 		return `&#x${hexValue};`;
 	};
-	internals$34.isSafe = function(charCode) {
-		return internals$34.safeCharCodes.has(charCode);
+	internals$33.isSafe = function(charCode) {
+		return internals$33.safeCharCodes.has(charCode);
 	};
-	internals$34.namedHtml = new Map([
+	internals$33.namedHtml = new Map([
 		[38, "&amp;"],
 		[60, "&lt;"],
 		[62, "&gt;"],
@@ -2242,22 +2242,22 @@ var require_escapeHtml = __commonJSMin((exports, module) => {
 		[169, "&copy;"],
 		[174, "&reg;"]
 	]);
-	internals$34.safeCharCodes = function() {
+	internals$33.safeCharCodes = function() {
 		const safe = new Set();
 		for (let i$1 = 32; i$1 < 123; ++i$1) if (i$1 >= 97 || i$1 >= 65 && i$1 <= 90 || i$1 >= 48 && i$1 <= 57 || i$1 === 32 || i$1 === 46 || i$1 === 44 || i$1 === 45 || i$1 === 58 || i$1 === 95) safe.add(i$1);
 		return safe;
 	}();
 });
 var require_escapeJson = __commonJSMin((exports, module) => {
-	const internals$33 = {};
+	const internals$32 = {};
 	module.exports = function(input) {
 		if (!input) return "";
-		return input.replace(/[<>&\u2028\u2029]/g, internals$33.escape);
+		return input.replace(/[<>&\u2028\u2029]/g, internals$32.escape);
 	};
-	internals$33.escape = function(char) {
-		return internals$33.replacements.get(char);
+	internals$32.escape = function(char) {
+		return internals$32.replacements.get(char);
 	};
-	internals$33.replacements = new Map([
+	internals$32.replacements = new Map([
 		["<", "\\u003c"],
 		[">", "\\u003e"],
 		["&", "\\u0026"],
@@ -2266,29 +2266,29 @@ var require_escapeJson = __commonJSMin((exports, module) => {
 	]);
 });
 var require_flatten$1 = __commonJSMin((exports, module) => {
-	const internals$32 = {};
-	module.exports = internals$32.flatten = function(array, target) {
+	const internals$31 = {};
+	module.exports = internals$31.flatten = function(array, target) {
 		const result = target || [];
-		for (const entry of array) if (Array.isArray(entry)) internals$32.flatten(entry, result);
+		for (const entry of array) if (Array.isArray(entry)) internals$31.flatten(entry, result);
 		else result.push(entry);
 		return result;
 	};
 });
 var require_intersect = __commonJSMin((exports, module) => {
-	const internals$31 = {};
+	const internals$30 = {};
 	module.exports = function(array1, array2, options = {}) {
 		if (!array1 || !array2) return options.first ? null : [];
 		const common$4 = [];
 		const hash$4 = Array.isArray(array1) ? new Set(array1) : array1;
 		const found = new Set();
-		for (const value of array2) if (internals$31.has(hash$4, value) && !found.has(value)) {
+		for (const value of array2) if (internals$30.has(hash$4, value) && !found.has(value)) {
 			if (options.first) return value;
 			common$4.push(value);
 			found.add(value);
 		}
 		return options.first ? null : common$4;
 	};
-	internals$31.has = function(ref, key) {
+	internals$30.has = function(ref, key) {
 		if (typeof ref.has === "function") return ref.has(key);
 		return ref[key] !== void 0;
 	};
@@ -2299,9 +2299,9 @@ var require_isPromise = __commonJSMin((exports, module) => {
 	};
 });
 var require_once = __commonJSMin((exports, module) => {
-	const internals$30 = { wrapped: Symbol("wrapped") };
+	const internals$29 = { wrapped: Symbol("wrapped") };
 	module.exports = function(method$1) {
-		if (method$1[internals$30.wrapped]) return method$1;
+		if (method$1[internals$29.wrapped]) return method$1;
 		let once$4 = false;
 		const wrappedFn = function(...args$1) {
 			if (!once$4) {
@@ -2309,7 +2309,7 @@ var require_once = __commonJSMin((exports, module) => {
 				method$1(...args$1);
 			}
 		};
-		wrappedFn[internals$30.wrapped] = true;
+		wrappedFn[internals$29.wrapped] = true;
 		return wrappedFn;
 	};
 });
@@ -2323,7 +2323,7 @@ var require_reachTemplate = __commonJSMin((exports, module) => {
 	};
 });
 var require_wait = __commonJSMin((exports, module) => {
-	const internals$29 = { maxTimer: 2 ** 31 - 1 };
+	const internals$28 = { maxTimer: 2 ** 31 - 1 };
 	module.exports = function(timeout$5, returnValue, options) {
 		if (typeof timeout$5 === "bigint") timeout$5 = Number(timeout$5);
 		if (timeout$5 >= Number.MAX_SAFE_INTEGER) timeout$5 = Infinity;
@@ -2331,7 +2331,7 @@ var require_wait = __commonJSMin((exports, module) => {
 		return new Promise((resolve) => {
 			const _setTimeout = options ? options.setTimeout : setTimeout;
 			const activate = () => {
-				const time = Math.min(timeout$5, internals$29.maxTimer);
+				const time = Math.min(timeout$5, internals$28.maxTimer);
 				timeout$5 -= time;
 				_setTimeout(() => timeout$5 > 0 ? activate() : resolve(returnValue), time);
 			};
@@ -2363,8 +2363,169 @@ var require_lib$4 = __commonJSMin((exports) => {
 	exports.stringify = require_stringify();
 	exports.wait = require_wait();
 });
+var package_exports$1 = {};
+__export(package_exports$1, {
+	browser: () => browser,
+	default: () => package_default$1,
+	dependencies: () => dependencies$1,
+	description: () => description$1,
+	devDependencies: () => devDependencies$1,
+	engines: () => engines,
+	files: () => files$1,
+	keywords: () => keywords$1,
+	license: () => license$1,
+	main: () => main$1,
+	name: () => name$2,
+	repository: () => repository$1,
+	scripts: () => scripts$1,
+	types: () => types,
+	version: () => version$3
+});
+var name$2, description$1, version$3, repository$1, engines, main$1, types, browser, files$1, keywords$1, dependencies$1, devDependencies$1, scripts$1, license$1, package_default$1;
+var init_package$1 = __esmMin(() => {
+	name$2 = "joi";
+	description$1 = "Object schema validation";
+	version$3 = "18.0.2";
+	repository$1 = {
+		"url": "git://github.com/hapijs/joi",
+		"type": "git"
+	};
+	engines = { "node": ">= 20" };
+	main$1 = "lib/index.js";
+	types = "lib/index.d.ts";
+	browser = "dist/joi-browser.min.js";
+	files$1 = ["lib/**/*", "dist/*"];
+	keywords$1 = ["schema", "validation"];
+	dependencies$1 = {
+		"@hapi/address": "^5.1.1",
+		"@hapi/formula": "^3.0.2",
+		"@hapi/hoek": "^11.0.7",
+		"@hapi/pinpoint": "^2.0.1",
+		"@hapi/tlds": "^1.1.1",
+		"@hapi/topo": "^6.0.2",
+		"@standard-schema/spec": "^1.0.0"
+	};
+	devDependencies$1 = {
+		"@hapi/bourne": "^3.0.0",
+		"@hapi/code": "^9.0.3",
+		"@hapi/eslint-plugin": "^7.0.0",
+		"@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x",
+		"@hapi/lab": "^26.0.0",
+		"@types/node": "^20.17.47",
+		"typescript": "^5.8.3"
+	};
+	scripts$1 = {
+		"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$1 = "BSD-3-Clause";
+	package_default$1 = {
+		name: name$2,
+		description: description$1,
+		version: version$3,
+		repository: repository$1,
+		engines,
+		main: main$1,
+		types,
+		browser,
+		files: files$1,
+		keywords: keywords$1,
+		dependencies: dependencies$1,
+		devDependencies: devDependencies$1,
+		scripts: scripts$1,
+		license: license$1
+	};
+});
+var require_cache = __commonJSMin((exports) => {
+	const { assert: assert$53, clone: clone$19 } = require_lib$4();
+	const Common$25 = require_common$3();
+	const internals$27 = {
+		max: 1e3,
+		supported: new Set([
+			"undefined",
+			"boolean",
+			"number",
+			"string"
+		])
+	};
+	exports.provider = { provision(options) {
+		return new internals$27.Cache(options);
+	} };
+	internals$27.Cache = class {
+		constructor(options = {}) {
+			Common$25.assertOptions(options, ["max"]);
+			assert$53(options.max === void 0 || options.max && options.max > 0 && isFinite(options.max), "Invalid max cache size");
+			this._max = options.max || internals$27.max;
+			this._map = new Map();
+			this._list = new internals$27.List();
+		}
+		get length() {
+			return this._map.size;
+		}
+		set(key, value) {
+			if (key !== null && !internals$27.supported.has(typeof key)) return;
+			let node = this._map.get(key);
+			if (node) {
+				node.value = value;
+				this._list.first(node);
+				return;
+			}
+			node = this._list.unshift({
+				key,
+				value
+			});
+			this._map.set(key, node);
+			this._compact();
+		}
+		get(key) {
+			const node = this._map.get(key);
+			if (node) {
+				this._list.first(node);
+				return clone$19(node.value);
+			}
+		}
+		_compact() {
+			if (this._map.size > this._max) {
+				const node = this._list.pop();
+				this._map.delete(node.key);
+			}
+		}
+	};
+	internals$27.List = class {
+		constructor() {
+			this.tail = null;
+			this.head = null;
+		}
+		unshift(node) {
+			node.next = null;
+			node.prev = this.head;
+			if (this.head) this.head.next = node;
+			this.head = node;
+			if (!this.tail) this.tail = node;
+			return node;
+		}
+		first(node) {
+			if (node === this.head) return;
+			this._remove(node);
+			this.unshift(node);
+		}
+		pop() {
+			return this._remove(this.tail);
+		}
+		_remove(node) {
+			const { next, prev } = node;
+			next.prev = prev;
+			if (prev) prev.next = next;
+			if (node === this.tail) this.tail = next;
+			node.prev = null;
+			node.next = null;
+			return node;
+		}
+	};
+});
 var require_lib$3 = __commonJSMin((exports) => {
-	const internals$28 = {
+	const internals$26 = {
 		operators: [
 			"!",
 			"^",
@@ -2430,7 +2591,7 @@ var require_lib$3 = __commonJSMin((exports) => {
 	};
 	exports.Parser = class {
 		constructor(string, options = {}) {
-			if (!options[internals$28.settings] && options.constants) for (const constant$3 in options.constants) {
+			if (!options[internals$26.settings] && options.constants) for (const constant$3 in options.constants) {
 				const value = options.constants[constant$3];
 				if (value !== null && ![
 					"boolean",
@@ -2438,8 +2599,8 @@ var require_lib$3 = __commonJSMin((exports) => {
 					"string"
 				].includes(typeof value)) throw new Error(`Formula constant ${constant$3} contains invalid ${typeof value} value type`);
 			}
-			this.settings = options[internals$28.settings] ? options : Object.assign({
-				[internals$28.settings]: true,
+			this.settings = options[internals$26.settings] ? options : Object.assign({
+				[internals$26.settings]: true,
 				constants: {},
 				functions: {}
 			}, options);
@@ -2481,12 +2642,12 @@ var require_lib$3 = __commonJSMin((exports) => {
 						type: "literal",
 						value: current
 					});
-				} else if (internals$28.operatorCharacters.includes(current)) if (last$2 && last$2.type === "operator" && internals$28.operators.includes(last$2.value + current)) last$2.value += current;
+				} else if (internals$26.operatorCharacters.includes(current)) if (last$2 && last$2.type === "operator" && internals$26.operators.includes(last$2.value + current)) last$2.value += current;
 				else parts.push({
 					type: "operator",
 					value: current
 				});
-				else if (current.match(internals$28.numberRx)) parts.push({
+				else if (current.match(internals$26.numberRx)) parts.push({
 					type: "constant",
 					value: parseFloat(current)
 				});
@@ -2495,7 +2656,7 @@ var require_lib$3 = __commonJSMin((exports) => {
 					value: this.settings.constants[current]
 				});
 				else {
-					if (!current.match(internals$28.tokenRx)) throw new Error(`Formula contains invalid token: ${current}`);
+					if (!current.match(internals$26.tokenRx)) throw new Error(`Formula contains invalid token: ${current}`);
 					parts.push({
 						type: "reference",
 						value: current
@@ -2515,11 +2676,11 @@ var require_lib$3 = __commonJSMin((exports) => {
 				if (!parenthesis) flush(c);
 				else current += c;
 			} else current += c;
-			else if (c in internals$28.literals) literal = internals$28.literals[c];
+			else if (c in internals$26.literals) literal = internals$26.literals[c];
 			else if (c === "(") {
 				flush();
 				++parenthesis;
-			} else if (internals$28.operatorCharacters.includes(c)) {
+			} else if (internals$26.operatorCharacters.includes(c)) {
 				flush();
 				current = c;
 				flush();
@@ -2536,9 +2697,9 @@ var require_lib$3 = __commonJSMin((exports) => {
 			let operator$1 = false;
 			for (const part of parts) {
 				if (part.type === "operator") {
-					if (internals$28.operatorsPrefix.includes(part.value)) continue;
+					if (internals$26.operatorsPrefix.includes(part.value)) continue;
 					if (!operator$1) throw new Error("Formula contains an operator in invalid position");
-					if (!internals$28.operators.includes(part.value)) throw new Error(`Formula contains an unknown operator ${part.value}`);
+					if (!internals$26.operators.includes(part.value)) throw new Error(`Formula contains an unknown operator ${part.value}`);
 				} else if (operator$1) throw new Error("Formula missing expected operator");
 				operator$1 = !operator$1;
 			}
@@ -2552,11 +2713,11 @@ var require_lib$3 = __commonJSMin((exports) => {
 				value: parts[0].value
 			};
 			this._parts = parts.map((part) => {
-				if (part.type === "operator") return internals$28.operatorsPrefix.includes(part.value) ? part : part.value;
+				if (part.type === "operator") return internals$26.operatorsPrefix.includes(part.value) ? part : part.value;
 				if (part.type !== "reference") return part.value;
 				if (this.settings.tokenRx && !this.settings.tokenRx.test(part.value)) throw new Error(`Formula contains invalid reference ${part.value}`);
 				if (this.settings.reference) return this.settings.reference(part.value);
-				return internals$28.reference(part.value);
+				return internals$26.reference(part.value);
 			});
 		}
 		_subFormula(string, name$3) {
@@ -2577,9 +2738,9 @@ var require_lib$3 = __commonJSMin((exports) => {
 					if (literal) {
 						current += c;
 						if (c === literal) literal = false;
-					} else if (c in internals$28.literals && !parenthesis) {
+					} else if (c in internals$26.literals && !parenthesis) {
 						current += c;
-						literal = internals$28.literals[c];
+						literal = internals$26.literals[c];
 					} else if (c === "," && !parenthesis) flush();
 					else {
 						current += c;
@@ -2603,47 +2764,47 @@ var require_lib$3 = __commonJSMin((exports) => {
 				if (part && part.type === "operator") {
 					const current = parts[i$1 + 1];
 					parts.splice(i$1 + 1, 1);
-					const value = internals$28.evaluate(current, context);
-					parts[i$1] = internals$28.single(part.value, value);
+					const value = internals$26.evaluate(current, context);
+					parts[i$1] = internals$26.single(part.value, value);
 				}
 			}
-			internals$28.operatorsOrder.forEach((set) => {
+			internals$26.operatorsOrder.forEach((set) => {
 				for (let i$1 = 1; i$1 < parts.length - 1;) if (set.includes(parts[i$1])) {
 					const operator$1 = parts[i$1];
-					const left = internals$28.evaluate(parts[i$1 - 1], context);
-					const right = internals$28.evaluate(parts[i$1 + 1], context);
+					const left = internals$26.evaluate(parts[i$1 - 1], context);
+					const right = internals$26.evaluate(parts[i$1 + 1], context);
 					parts.splice(i$1, 2);
-					const result = internals$28.calculate(operator$1, left, right);
+					const result = internals$26.calculate(operator$1, left, right);
 					parts[i$1 - 1] = result === 0 ? 0 : result;
 				} else i$1 += 2;
 			});
-			return internals$28.evaluate(parts[0], context);
+			return internals$26.evaluate(parts[0], context);
 		}
 	};
-	exports.Parser.prototype[internals$28.symbol] = true;
-	internals$28.reference = function(name$3) {
+	exports.Parser.prototype[internals$26.symbol] = true;
+	internals$26.reference = function(name$3) {
 		return function(context) {
 			return context && context[name$3] !== void 0 ? context[name$3] : null;
 		};
 	};
-	internals$28.evaluate = function(part, context) {
+	internals$26.evaluate = function(part, context) {
 		if (part === null) return null;
 		if (typeof part === "function") return part(context);
-		if (part[internals$28.symbol]) return part.evaluate(context);
+		if (part[internals$26.symbol]) return part.evaluate(context);
 		return part;
 	};
-	internals$28.single = function(operator$1, value) {
+	internals$26.single = function(operator$1, value) {
 		if (operator$1 === "!") return value ? false : true;
 		const negative = -value;
 		if (negative === 0) return 0;
 		return negative;
 	};
-	internals$28.calculate = function(operator$1, left, right) {
-		if (operator$1 === "??") return internals$28.exists(left) ? left : right;
+	internals$26.calculate = function(operator$1, left, right) {
+		if (operator$1 === "??") return internals$26.exists(left) ? left : right;
 		if (typeof left === "string" || typeof right === "string") {
 			if (operator$1 === "+") {
-				left = internals$28.exists(left) ? left : "";
-				right = internals$28.exists(right) ? right : "";
+				left = internals$26.exists(left) ? left : "";
+				right = internals$26.exists(right) ? right : "";
 				return left + right;
 			}
 		} else switch (operator$1) {
@@ -2666,267 +2827,17 @@ var require_lib$3 = __commonJSMin((exports) => {
 		}
 		return null;
 	};
-	internals$28.exists = function(value) {
+	internals$26.exists = function(value) {
 		return value !== null && value !== void 0;
 	};
 });
-var require_ref$2 = __commonJSMin((exports) => {
-	const { assert: assert$53, clone: clone$19, reach: reach$4 } = require_lib$4();
-	const Common$25 = require_common$3();
-	let Template$7;
-	const internals$27 = {
-		symbol: Symbol("ref"),
-		defaults: {
-			adjust: null,
-			in: false,
-			iterables: null,
-			map: null,
-			separator: ".",
-			type: "value"
-		}
-	};
-	exports.create = function(key, options = {}) {
-		assert$53(typeof key === "string", "Invalid reference key:", key);
-		Common$25.assertOptions(options, [
-			"adjust",
-			"ancestor",
-			"in",
-			"iterables",
-			"map",
-			"prefix",
-			"render",
-			"separator"
-		]);
-		assert$53(!options.prefix || typeof options.prefix === "object", "options.prefix must be of type object");
-		const ref = Object.assign({}, internals$27.defaults, options);
-		delete ref.prefix;
-		const separator = ref.separator;
-		const context = internals$27.context(key, separator, options.prefix);
-		ref.type = context.type;
-		key = context.key;
-		if (ref.type === "value") {
-			if (context.root) {
-				assert$53(!separator || key[0] !== separator, "Cannot specify relative path with root prefix");
-				ref.ancestor = "root";
-				if (!key) key = null;
-			}
-			if (separator && separator === key) {
-				key = null;
-				ref.ancestor = 0;
-			} else if (ref.ancestor !== void 0) assert$53(!separator || !key || key[0] !== separator, "Cannot combine prefix with ancestor option");
-			else {
-				const [ancestor, slice$1] = internals$27.ancestor(key, separator);
-				if (slice$1) {
-					key = key.slice(slice$1);
-					if (key === "") key = null;
-				}
-				ref.ancestor = ancestor;
-			}
-		}
-		ref.path = separator ? key === null ? [] : key.split(separator) : [key];
-		return new internals$27.Ref(ref);
-	};
-	exports.in = function(key, options = {}) {
-		return exports.create(key, {
-			...options,
-			in: true
-		});
-	};
-	exports.isRef = function(ref) {
-		return ref ? !!ref[Common$25.symbols.ref] : false;
-	};
-	internals$27.Ref = class {
-		constructor(options) {
-			assert$53(typeof options === "object", "Invalid reference construction");
-			Common$25.assertOptions(options, [
-				"adjust",
-				"ancestor",
-				"in",
-				"iterables",
-				"map",
-				"path",
-				"render",
-				"separator",
-				"type",
-				"depth",
-				"key",
-				"root",
-				"display"
-			]);
-			assert$53([false, void 0].includes(options.separator) || typeof options.separator === "string" && options.separator.length === 1, "Invalid separator");
-			assert$53(!options.adjust || typeof options.adjust === "function", "options.adjust must be a function");
-			assert$53(!options.map || Array.isArray(options.map), "options.map must be an array");
-			assert$53(!options.map || !options.adjust, "Cannot set both map and adjust options");
-			Object.assign(this, internals$27.defaults, options);
-			assert$53(this.type === "value" || this.ancestor === void 0, "Non-value references cannot reference ancestors");
-			if (Array.isArray(this.map)) this.map = new Map(this.map);
-			this.depth = this.path.length;
-			this.key = this.path.length ? this.path.join(this.separator) : null;
-			this.root = this.path[0];
-			this.updateDisplay();
-		}
-		resolve(value, state, prefs, local, options = {}) {
-			assert$53(!this.in || options.in, "Invalid in() reference usage");
-			if (this.type === "global") return this._resolve(prefs.context, state, options);
-			if (this.type === "local") return this._resolve(local, state, options);
-			if (!this.ancestor) return this._resolve(value, state, options);
-			if (this.ancestor === "root") return this._resolve(state.ancestors[state.ancestors.length - 1], state, options);
-			assert$53(this.ancestor <= state.ancestors.length, "Invalid reference exceeds the schema root:", this.display);
-			return this._resolve(state.ancestors[this.ancestor - 1], state, options);
-		}
-		_resolve(target, state, options) {
-			let resolved;
-			if (this.type === "value" && state.mainstay.shadow && options.shadow !== false) resolved = state.mainstay.shadow.get(this.absolute(state));
-			if (resolved === void 0) resolved = reach$4(target, this.path, {
-				iterables: this.iterables,
-				functions: true
-			});
-			if (this.adjust) resolved = this.adjust(resolved);
-			if (this.map) {
-				const mapped = this.map.get(resolved);
-				if (mapped !== void 0) resolved = mapped;
-			}
-			if (state.mainstay) state.mainstay.tracer.resolve(state, this, resolved);
-			return resolved;
-		}
-		toString() {
-			return this.display;
-		}
-		absolute(state) {
-			return [...state.path.slice(0, -this.ancestor), ...this.path];
-		}
-		clone() {
-			return new internals$27.Ref(this);
-		}
-		describe() {
-			const ref = { path: this.path };
-			if (this.type !== "value") ref.type = this.type;
-			if (this.separator !== ".") ref.separator = this.separator;
-			if (this.type === "value" && this.ancestor !== 1) ref.ancestor = this.ancestor;
-			if (this.map) ref.map = [...this.map];
-			for (const key of [
-				"adjust",
-				"iterables",
-				"render"
-			]) if (this[key] !== null && this[key] !== void 0) ref[key] = this[key];
-			if (this.in !== false) ref.in = true;
-			return { ref };
-		}
-		updateDisplay() {
-			const key = this.key !== null ? this.key : "";
-			if (this.type !== "value") {
-				this.display = `ref:${this.type}:${key}`;
-				return;
-			}
-			if (!this.separator) {
-				this.display = `ref:${key}`;
-				return;
-			}
-			if (!this.ancestor) {
-				this.display = `ref:${this.separator}${key}`;
-				return;
-			}
-			if (this.ancestor === "root") {
-				this.display = `ref:root:${key}`;
-				return;
-			}
-			if (this.ancestor === 1) {
-				this.display = `ref:${key || ".."}`;
-				return;
-			}
-			const lead = new Array(this.ancestor + 1).fill(this.separator).join("");
-			this.display = `ref:${lead}${key || ""}`;
-		}
-	};
-	internals$27.Ref.prototype[Common$25.symbols.ref] = true;
-	exports.build = function(desc$1) {
-		desc$1 = Object.assign({}, internals$27.defaults, desc$1);
-		if (desc$1.type === "value" && desc$1.ancestor === void 0) desc$1.ancestor = 1;
-		return new internals$27.Ref(desc$1);
-	};
-	internals$27.context = function(key, separator, prefix = {}) {
-		key = key.trim();
-		if (prefix) {
-			const globalp = prefix.global === void 0 ? "$" : prefix.global;
-			if (globalp !== separator && key.startsWith(globalp)) return {
-				key: key.slice(globalp.length),
-				type: "global"
-			};
-			const local = prefix.local === void 0 ? "#" : prefix.local;
-			if (local !== separator && key.startsWith(local)) return {
-				key: key.slice(local.length),
-				type: "local"
-			};
-			const root$11 = prefix.root === void 0 ? "/" : prefix.root;
-			if (root$11 !== separator && key.startsWith(root$11)) return {
-				key: key.slice(root$11.length),
-				type: "value",
-				root: true
-			};
-		}
-		return {
-			key,
-			type: "value"
-		};
-	};
-	internals$27.ancestor = function(key, separator) {
-		if (!separator) return [1, 0];
-		if (key[0] !== separator) return [1, 0];
-		if (key[1] !== separator) return [0, 1];
-		let i$1 = 2;
-		while (key[i$1] === separator) ++i$1;
-		return [i$1 - 1, i$1];
-	};
-	exports.toSibling = 0;
-	exports.toParent = 1;
-	exports.Manager = class {
-		constructor() {
-			this.refs = [];
-		}
-		register(source, target) {
-			if (!source) return;
-			target = target === void 0 ? exports.toParent : target;
-			if (Array.isArray(source)) {
-				for (const ref of source) this.register(ref, target);
-				return;
-			}
-			if (Common$25.isSchema(source)) {
-				for (const item of source._refs.refs) if (item.ancestor - target >= 0) this.refs.push({
-					ancestor: item.ancestor - target,
-					root: item.root
-				});
-				return;
-			}
-			if (exports.isRef(source) && source.type === "value" && source.ancestor - target >= 0) this.refs.push({
-				ancestor: source.ancestor - target,
-				root: source.root
-			});
-			Template$7 = Template$7 || require_template();
-			if (Template$7.isTemplate(source)) this.register(source.refs(), target);
-		}
-		get length() {
-			return this.refs.length;
-		}
-		clone() {
-			const copy$1 = new exports.Manager();
-			copy$1.refs = clone$19(this.refs);
-			return copy$1;
-		}
-		reset() {
-			this.refs = [];
-		}
-		roots() {
-			return this.refs.filter((ref) => !ref.ancestor).map((ref) => ref.root);
-		}
-	};
-});
 var require_template = __commonJSMin((exports, module) => {
 	const { assert: assert$52, clone: clone$18, escapeHtml: escapeHtml$1 } = require_lib$4();
 	const Formula = require_lib$3();
 	const Common$24 = require_common$3();
 	const Errors$8 = require_errors$2();
 	const Ref$12 = require_ref$2();
-	const internals$26 = {
+	const internals$25 = {
 		symbol: Symbol("template"),
 		opens: new Array(1e3).join("\0"),
 		closes: new Array(1e3).join("
"),
@@ -2938,7 +2849,7 @@ var require_template = __commonJSMin((exports, module) => {
 			utc: Date.prototype.toUTCString
 		}
 	};
-	module.exports = exports = internals$26.Template = class {
+	module.exports = exports = internals$25.Template = class {
 		constructor(source, options) {
 			assert$52(typeof source === "string", "Template source must be a string");
 			assert$52(!source.includes("\0") && !source.includes("
"), "Template source cannot contain reserved control characters");
@@ -2961,8 +2872,8 @@ var require_template = __commonJSMin((exports, module) => {
 		}
 		_parse() {
 			if (!this.source.includes("{")) return;
-			const encoded = internals$26.encode(this.source);
-			const parts = internals$26.split(encoded);
+			const encoded = internals$25.encode(this.source);
+			const parts = internals$25.split(encoded);
 			let refs = false;
 			const processed = [];
 			const head$1 = parts.shift();
@@ -2972,20 +2883,20 @@ var require_template = __commonJSMin((exports, module) => {
 				const ender = raw ? "}" : "}}";
 				const end = part.indexOf(ender);
 				if (end === -1 || part[1] === "{") {
-					processed.push(`{${internals$26.decode(part)}`);
+					processed.push(`{${internals$25.decode(part)}`);
 					continue;
 				}
 				let variable = part.slice(raw ? 0 : 1, end);
 				const wrapped = variable[0] === ":";
 				if (wrapped) variable = variable.slice(1);
-				const dynamic = this._ref(internals$26.decode(variable), {
+				const dynamic = this._ref(internals$25.decode(variable), {
 					raw,
 					wrapped
 				});
 				processed.push(dynamic);
 				if (typeof dynamic !== "string") refs = true;
 				const rest = part.slice(end + ender.length);
-				if (rest) processed.push(internals$26.decode(rest));
+				if (rest) processed.push(internals$25.decode(rest));
 			}
 			if (!refs) {
 				this.rendered = processed.join("");
@@ -2994,7 +2905,7 @@ var require_template = __commonJSMin((exports, module) => {
 			this._template = processed;
 		}
 		static date(date, prefs) {
-			return internals$26.dateFormat[prefs.dateFormat].call(date);
+			return internals$25.dateFormat[prefs.dateFormat].call(date);
 		}
 		describe(options = {}) {
 			if (!this._settings && options.compact) return this.source;
@@ -3004,7 +2915,7 @@ var require_template = __commonJSMin((exports, module) => {
 			return desc$1;
 		}
 		static build(desc$1) {
-			return new internals$26.Template(desc$1.template, desc$1.options || desc$1.functions ? {
+			return new internals$25.Template(desc$1.template, desc$1.options || desc$1.functions ? {
 				...desc$1.options,
 				functions: desc$1.functions
 			} : void 0);
@@ -3035,10 +2946,10 @@ var require_template = __commonJSMin((exports, module) => {
 			for (const part of this._template) if (typeof part === "string") parts.push(part);
 			else {
 				const rendered = this._part(part, value, state, prefs, local, options);
-				const string = internals$26.stringify(rendered, value, state, prefs, local, options);
+				const string = internals$25.stringify(rendered, value, state, prefs, local, options);
 				if (string !== void 0) {
 					const result = part.raw || (options.errors && options.errors.escapeHtml) === false ? string : escapeHtml$1(string);
-					parts.push(internals$26.wrap(result, part.wrapped && prefs.errors.wrap.label));
+					parts.push(internals$25.wrap(result, part.wrapped && prefs.errors.wrap.label));
 				}
 			}
 			return parts.join("");
@@ -3055,13 +2966,13 @@ var require_template = __commonJSMin((exports, module) => {
 			};
 			try {
 				const functions = this._functions ? {
-					...internals$26.functions,
+					...internals$25.functions,
 					...this._functions
-				} : internals$26.functions;
+				} : internals$25.functions;
 				var formula = new Formula.Parser(content, {
 					reference,
 					functions,
-					constants: internals$26.constants
+					constants: internals$25.constants
 				});
 			} catch (err) {
 				err.message = `Invalid template variable "${content}" fails due to: ${err.message}`;
@@ -3077,7 +2988,7 @@ var require_template = __commonJSMin((exports, module) => {
 						wrapped: wrapped || ref.type === "local" && ref.key === "label"
 					};
 				}
-				return internals$26.stringify(formula.single.value);
+				return internals$25.stringify(formula.single.value);
 			}
 			return {
 				formula,
@@ -3089,19 +3000,19 @@ var require_template = __commonJSMin((exports, module) => {
 			return this.source;
 		}
 	};
-	internals$26.Template.prototype[Common$24.symbols.template] = true;
-	internals$26.Template.prototype.isImmutable = true;
-	internals$26.encode = function(string) {
+	internals$25.Template.prototype[Common$24.symbols.template] = true;
+	internals$25.Template.prototype.isImmutable = true;
+	internals$25.encode = function(string) {
 		return string.replace(/\\(\{+)/g, ($0, $1) => {
-			return internals$26.opens.slice(0, $1.length);
+			return internals$25.opens.slice(0, $1.length);
 		}).replace(/\\(\}+)/g, ($0, $1) => {
-			return internals$26.closes.slice(0, $1.length);
+			return internals$25.closes.slice(0, $1.length);
 		});
 	};
-	internals$26.decode = function(string) {
+	internals$25.decode = function(string) {
 		return string.replace(/\u0000/g, "{").replace(/\u0001/g, "}");
 	};
-	internals$26.split = function(string) {
+	internals$25.split = function(string) {
 		const parts = [];
 		let current = "";
 		for (let i$1 = 0; i$1 < string.length; ++i$1) {
@@ -3119,12 +3030,12 @@ var require_template = __commonJSMin((exports, module) => {
 		parts.push(current);
 		return parts;
 	};
-	internals$26.wrap = function(value, ends) {
+	internals$25.wrap = function(value, ends) {
 		if (!ends) return value;
 		if (ends.length === 1) return `${ends}${value}${ends}`;
 		return `${ends[0]}${value}${ends[1]}`;
 	};
-	internals$26.stringify = function(value, original, state, prefs, local, options = {}) {
+	internals$25.stringify = function(value, original, state, prefs, local, options = {}) {
 		const type = typeof value;
 		const wrap$2 = prefs && prefs.errors && prefs.errors.wrap || {};
 		let skipWrap = false;
@@ -3136,10 +3047,10 @@ var require_template = __commonJSMin((exports, module) => {
 			});
 		}
 		if (value === null) return "null";
-		if (type === "string") return internals$26.wrap(value, options.arrayItems && wrap$2.string);
+		if (type === "string") return internals$25.wrap(value, options.arrayItems && wrap$2.string);
 		if (type === "number" || type === "function" || type === "symbol") return value.toString();
 		if (type !== "object") return JSON.stringify(value);
-		if (value instanceof Date) return internals$26.Template.date(value, prefs);
+		if (value instanceof Date) return internals$25.Template.date(value, prefs);
 		if (value instanceof Map) {
 			const pairs = [];
 			for (const [key, sym] of value.entries()) pairs.push(`${key.toString()} -> ${sym.toString()}`);
@@ -3147,13 +3058,13 @@ var require_template = __commonJSMin((exports, module) => {
 		}
 		if (!Array.isArray(value)) return value.toString();
 		const values$3 = [];
-		for (const item of value) values$3.push(internals$26.stringify(item, original, state, prefs, local, {
+		for (const item of value) values$3.push(internals$25.stringify(item, original, state, prefs, local, {
 			arrayItems: true,
 			...options
 		}));
-		return internals$26.wrap(values$3.join(", "), !skipWrap && wrap$2.array);
+		return internals$25.wrap(values$3.join(", "), !skipWrap && wrap$2.array);
 	};
-	internals$26.constants = {
+	internals$25.constants = {
 		true: true,
 		false: false,
 		null: null,
@@ -3162,7 +3073,7 @@ var require_template = __commonJSMin((exports, module) => {
 		hour: 60 * 60 * 1e3,
 		day: 24 * 60 * 60 * 1e3
 	};
-	internals$26.functions = {
+	internals$25.functions = {
 		if(condition, then, otherwise) {
 			return condition ? then : otherwise;
 		},
@@ -3189,186 +3100,253 @@ var require_template = __commonJSMin((exports, module) => {
 		}
 	};
 });
-var require_messages = __commonJSMin((exports) => {
-	const { assert: assert$51, clone: clone$17 } = require_lib$4();
-	const Template$6 = require_template();
-	exports.compile = function(messages$3, target) {
-		if (typeof messages$3 === "string") {
-			assert$51(!target, "Cannot set single message string");
-			return new Template$6(messages$3);
-		}
-		if (Template$6.isTemplate(messages$3)) {
-			assert$51(!target, "Cannot set single message template");
-			return messages$3;
+var require_ref$2 = __commonJSMin((exports) => {
+	const { assert: assert$51, clone: clone$17, reach: reach$4 } = require_lib$4();
+	const Common$23 = require_common$3();
+	let Template$7;
+	const internals$24 = {
+		symbol: Symbol("ref"),
+		defaults: {
+			adjust: null,
+			in: false,
+			iterables: null,
+			map: null,
+			separator: ".",
+			type: "value"
 		}
-		assert$51(typeof messages$3 === "object" && !Array.isArray(messages$3), "Invalid message options");
-		target = target ? clone$17(target) : {};
-		for (let code$1 in messages$3) {
-			const message = messages$3[code$1];
-			if (code$1 === "root" || Template$6.isTemplate(message)) {
-				target[code$1] = message;
-				continue;
-			}
-			if (typeof message === "string") {
-				target[code$1] = new Template$6(message);
-				continue;
+	};
+	exports.create = function(key, options = {}) {
+		assert$51(typeof key === "string", "Invalid reference key:", key);
+		Common$23.assertOptions(options, [
+			"adjust",
+			"ancestor",
+			"in",
+			"iterables",
+			"map",
+			"prefix",
+			"render",
+			"separator"
+		]);
+		assert$51(!options.prefix || typeof options.prefix === "object", "options.prefix must be of type object");
+		const ref = Object.assign({}, internals$24.defaults, options);
+		delete ref.prefix;
+		const separator = ref.separator;
+		const context = internals$24.context(key, separator, options.prefix);
+		ref.type = context.type;
+		key = context.key;
+		if (ref.type === "value") {
+			if (context.root) {
+				assert$51(!separator || key[0] !== separator, "Cannot specify relative path with root prefix");
+				ref.ancestor = "root";
+				if (!key) key = null;
 			}
-			assert$51(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$1);
-			const language = code$1;
-			target[language] = target[language] || {};
-			for (code$1 in message) {
-				const localized = message[code$1];
-				if (code$1 === "root" || Template$6.isTemplate(localized)) {
-					target[language][code$1] = localized;
-					continue;
+			if (separator && separator === key) {
+				key = null;
+				ref.ancestor = 0;
+			} else if (ref.ancestor !== void 0) assert$51(!separator || !key || key[0] !== separator, "Cannot combine prefix with ancestor option");
+			else {
+				const [ancestor, slice$1] = internals$24.ancestor(key, separator);
+				if (slice$1) {
+					key = key.slice(slice$1);
+					if (key === "") key = null;
 				}
-				assert$51(typeof localized === "string", "Invalid message for", code$1, "in", language);
-				target[language][code$1] = new Template$6(localized);
+				ref.ancestor = ancestor;
 			}
 		}
-		return target;
+		ref.path = separator ? key === null ? [] : key.split(separator) : [key];
+		return new internals$24.Ref(ref);
 	};
-	exports.decompile = function(messages$3) {
-		const target = {};
-		for (let code$1 in messages$3) {
-			const message = messages$3[code$1];
-			if (code$1 === "root") {
-				target.root = message;
-				continue;
+	exports.in = function(key, options = {}) {
+		return exports.create(key, {
+			...options,
+			in: true
+		});
+	};
+	exports.isRef = function(ref) {
+		return ref ? !!ref[Common$23.symbols.ref] : false;
+	};
+	internals$24.Ref = class {
+		constructor(options) {
+			assert$51(typeof options === "object", "Invalid reference construction");
+			Common$23.assertOptions(options, [
+				"adjust",
+				"ancestor",
+				"in",
+				"iterables",
+				"map",
+				"path",
+				"render",
+				"separator",
+				"type",
+				"depth",
+				"key",
+				"root",
+				"display"
+			]);
+			assert$51([false, void 0].includes(options.separator) || typeof options.separator === "string" && options.separator.length === 1, "Invalid separator");
+			assert$51(!options.adjust || typeof options.adjust === "function", "options.adjust must be a function");
+			assert$51(!options.map || Array.isArray(options.map), "options.map must be an array");
+			assert$51(!options.map || !options.adjust, "Cannot set both map and adjust options");
+			Object.assign(this, internals$24.defaults, options);
+			assert$51(this.type === "value" || this.ancestor === void 0, "Non-value references cannot reference ancestors");
+			if (Array.isArray(this.map)) this.map = new Map(this.map);
+			this.depth = this.path.length;
+			this.key = this.path.length ? this.path.join(this.separator) : null;
+			this.root = this.path[0];
+			this.updateDisplay();
+		}
+		resolve(value, state, prefs, local, options = {}) {
+			assert$51(!this.in || options.in, "Invalid in() reference usage");
+			if (this.type === "global") return this._resolve(prefs.context, state, options);
+			if (this.type === "local") return this._resolve(local, state, options);
+			if (!this.ancestor) return this._resolve(value, state, options);
+			if (this.ancestor === "root") return this._resolve(state.ancestors[state.ancestors.length - 1], state, options);
+			assert$51(this.ancestor <= state.ancestors.length, "Invalid reference exceeds the schema root:", this.display);
+			return this._resolve(state.ancestors[this.ancestor - 1], state, options);
+		}
+		_resolve(target, state, options) {
+			let resolved;
+			if (this.type === "value" && state.mainstay.shadow && options.shadow !== false) resolved = state.mainstay.shadow.get(this.absolute(state));
+			if (resolved === void 0) resolved = reach$4(target, this.path, {
+				iterables: this.iterables,
+				functions: true
+			});
+			if (this.adjust) resolved = this.adjust(resolved);
+			if (this.map) {
+				const mapped = this.map.get(resolved);
+				if (mapped !== void 0) resolved = mapped;
 			}
-			if (Template$6.isTemplate(message)) {
-				target[code$1] = message.describe({ compact: true });
-				continue;
+			if (state.mainstay) state.mainstay.tracer.resolve(state, this, resolved);
+			return resolved;
+		}
+		toString() {
+			return this.display;
+		}
+		absolute(state) {
+			return [...state.path.slice(0, -this.ancestor), ...this.path];
+		}
+		clone() {
+			return new internals$24.Ref(this);
+		}
+		describe() {
+			const ref = { path: this.path };
+			if (this.type !== "value") ref.type = this.type;
+			if (this.separator !== ".") ref.separator = this.separator;
+			if (this.type === "value" && this.ancestor !== 1) ref.ancestor = this.ancestor;
+			if (this.map) ref.map = [...this.map];
+			for (const key of [
+				"adjust",
+				"iterables",
+				"render"
+			]) if (this[key] !== null && this[key] !== void 0) ref[key] = this[key];
+			if (this.in !== false) ref.in = true;
+			return { ref };
+		}
+		updateDisplay() {
+			const key = this.key !== null ? this.key : "";
+			if (this.type !== "value") {
+				this.display = `ref:${this.type}:${key}`;
+				return;
 			}
-			const language = code$1;
-			target[language] = {};
-			for (code$1 in message) {
-				const localized = message[code$1];
-				if (code$1 === "root") {
-					target[language].root = localized;
-					continue;
-				}
-				target[language][code$1] = localized.describe({ compact: true });
+			if (!this.separator) {
+				this.display = `ref:${key}`;
+				return;
 			}
-		}
-		return target;
-	};
-	exports.merge = function(base$3, extended) {
-		if (!base$3) return exports.compile(extended);
-		if (!extended) return base$3;
-		if (typeof extended === "string") return new Template$6(extended);
-		if (Template$6.isTemplate(extended)) return extended;
-		const target = clone$17(base$3);
-		for (let code$1 in extended) {
-			const message = extended[code$1];
-			if (code$1 === "root" || Template$6.isTemplate(message)) {
-				target[code$1] = message;
-				continue;
+			if (!this.ancestor) {
+				this.display = `ref:${this.separator}${key}`;
+				return;
 			}
-			if (typeof message === "string") {
-				target[code$1] = new Template$6(message);
-				continue;
+			if (this.ancestor === "root") {
+				this.display = `ref:root:${key}`;
+				return;
 			}
-			assert$51(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$1);
-			const language = code$1;
-			target[language] = target[language] || {};
-			for (code$1 in message) {
-				const localized = message[code$1];
-				if (code$1 === "root" || Template$6.isTemplate(localized)) {
-					target[language][code$1] = localized;
-					continue;
-				}
-				assert$51(typeof localized === "string", "Invalid message for", code$1, "in", language);
-				target[language][code$1] = new Template$6(localized);
+			if (this.ancestor === 1) {
+				this.display = `ref:${key || ".."}`;
+				return;
 			}
+			const lead = new Array(this.ancestor + 1).fill(this.separator).join("");
+			this.display = `ref:${lead}${key || ""}`;
 		}
-		return target;
 	};
-});
-var require_cache = __commonJSMin((exports) => {
-	const { assert: assert$50, clone: clone$16 } = require_lib$4();
-	const Common$23 = require_common$3();
-	const internals$25 = {
-		max: 1e3,
-		supported: new Set([
-			"undefined",
-			"boolean",
-			"number",
-			"string"
-		])
+	internals$24.Ref.prototype[Common$23.symbols.ref] = true;
+	exports.build = function(desc$1) {
+		desc$1 = Object.assign({}, internals$24.defaults, desc$1);
+		if (desc$1.type === "value" && desc$1.ancestor === void 0) desc$1.ancestor = 1;
+		return new internals$24.Ref(desc$1);
 	};
-	exports.provider = { provision(options) {
-		return new internals$25.Cache(options);
-	} };
-	internals$25.Cache = class {
-		constructor(options = {}) {
-			Common$23.assertOptions(options, ["max"]);
-			assert$50(options.max === void 0 || options.max && options.max > 0 && isFinite(options.max), "Invalid max cache size");
-			this._max = options.max || internals$25.max;
-			this._map = new Map();
-			this._list = new internals$25.List();
+	internals$24.context = function(key, separator, prefix = {}) {
+		key = key.trim();
+		if (prefix) {
+			const globalp = prefix.global === void 0 ? "$" : prefix.global;
+			if (globalp !== separator && key.startsWith(globalp)) return {
+				key: key.slice(globalp.length),
+				type: "global"
+			};
+			const local = prefix.local === void 0 ? "#" : prefix.local;
+			if (local !== separator && key.startsWith(local)) return {
+				key: key.slice(local.length),
+				type: "local"
+			};
+			const root$11 = prefix.root === void 0 ? "/" : prefix.root;
+			if (root$11 !== separator && key.startsWith(root$11)) return {
+				key: key.slice(root$11.length),
+				type: "value",
+				root: true
+			};
 		}
-		get length() {
-			return this._map.size;
+		return {
+			key,
+			type: "value"
+		};
+	};
+	internals$24.ancestor = function(key, separator) {
+		if (!separator) return [1, 0];
+		if (key[0] !== separator) return [1, 0];
+		if (key[1] !== separator) return [0, 1];
+		let i$1 = 2;
+		while (key[i$1] === separator) ++i$1;
+		return [i$1 - 1, i$1];
+	};
+	exports.toSibling = 0;
+	exports.toParent = 1;
+	exports.Manager = class {
+		constructor() {
+			this.refs = [];
 		}
-		set(key, value) {
-			if (key !== null && !internals$25.supported.has(typeof key)) return;
-			let node = this._map.get(key);
-			if (node) {
-				node.value = value;
-				this._list.first(node);
+		register(source, target) {
+			if (!source) return;
+			target = target === void 0 ? exports.toParent : target;
+			if (Array.isArray(source)) {
+				for (const ref of source) this.register(ref, target);
 				return;
 			}
-			node = this._list.unshift({
-				key,
-				value
-			});
-			this._map.set(key, node);
-			this._compact();
-		}
-		get(key) {
-			const node = this._map.get(key);
-			if (node) {
-				this._list.first(node);
-				return clone$16(node.value);
-			}
-		}
-		_compact() {
-			if (this._map.size > this._max) {
-				const node = this._list.pop();
-				this._map.delete(node.key);
+			if (Common$23.isSchema(source)) {
+				for (const item of source._refs.refs) if (item.ancestor - target >= 0) this.refs.push({
+					ancestor: item.ancestor - target,
+					root: item.root
+				});
+				return;
 			}
+			if (exports.isRef(source) && source.type === "value" && source.ancestor - target >= 0) this.refs.push({
+				ancestor: source.ancestor - target,
+				root: source.root
+			});
+			Template$7 = Template$7 || require_template();
+			if (Template$7.isTemplate(source)) this.register(source.refs(), target);
 		}
-	};
-	internals$25.List = class {
-		constructor() {
-			this.tail = null;
-			this.head = null;
-		}
-		unshift(node) {
-			node.next = null;
-			node.prev = this.head;
-			if (this.head) this.head.next = node;
-			this.head = node;
-			if (!this.tail) this.tail = node;
-			return node;
+		get length() {
+			return this.refs.length;
 		}
-		first(node) {
-			if (node === this.head) return;
-			this._remove(node);
-			this.unshift(node);
+		clone() {
+			const copy$1 = new exports.Manager();
+			copy$1.refs = clone$17(this.refs);
+			return copy$1;
 		}
-		pop() {
-			return this._remove(this.tail);
+		reset() {
+			this.refs = [];
 		}
-		_remove(node) {
-			const { next, prev } = node;
-			next.prev = prev;
-			if (prev) prev.next = next;
-			if (node === this.tail) this.tail = next;
-			node.prev = null;
-			node.next = null;
-			return node;
+		roots() {
+			return this.refs.filter((ref) => !ref.ancestor).map((ref) => ref.root);
 		}
 	};
 });
@@ -3397,27 +3375,23 @@ var init_lib = __esmMin(() => {
 	import_stringify = __toESM(require_stringify(), 1);
 	import_wait = __toESM(require_wait(), 1);
 });
-var compile_exports = {};
-__export(compile_exports, { default: () => compile_default });
-var import_ref$3, import_common$3, Common$22, Ref$11, internals$24, exports$3, compile_default;
-var init_compile = __esmMin(() => {
-	import_ref$3 = __toESM(require_ref$2());
-	import_common$3 = __toESM(require_common$3());
+var require_compile$1 = __commonJSMin((exports) => {
+	var import_ref$3 = __toESM(require_ref$2());
+	var import_common$3 = __toESM(require_common$3());
 	init_lib();
-	Common$22 = import_common$3.default;
-	Ref$11 = import_ref$3.default;
-	internals$24 = {};
-	exports$3 = {};
-	exports$3.schema = function(Joi$2, config, options = {}) {
+	const Common$22 = import_common$3.default;
+	const Ref$11 = import_ref$3.default;
+	const internals$23 = {};
+	exports.schema = function(Joi$2, config, options = {}) {
 		Common$22.assertOptions(options, ["appendPath", "override"]);
 		try {
-			return internals$24.schema(Joi$2, config, options);
+			return internals$23.schema(Joi$2, config, options);
 		} catch (err) {
 			if (options.appendPath && err.path !== void 0) err.message = `${err.message} (${err.path})`;
 			throw err;
 		}
 	};
-	internals$24.schema = function(Joi$2, config, options) {
+	internals$23.schema = function(Joi$2, config, options) {
 		(0, import_assert.default)(config !== void 0, "Invalid undefined schema");
 		if (Array.isArray(config)) {
 			(0, import_assert.default)(config.length, "Invalid empty array schema");
@@ -3427,13 +3401,13 @@ var init_compile = __esmMin(() => {
 			if (options.override !== false) return base$3.valid(Joi$2.override, ...values$3);
 			return base$3.valid(...values$3);
 		};
-		if (internals$24.simple(config)) return valid$2(Joi$2, config);
+		if (internals$23.simple(config)) return valid$2(Joi$2, config);
 		if (typeof config === "function") return Joi$2.custom(config);
 		(0, import_assert.default)(typeof config === "object", "Invalid schema content:", typeof config);
 		if (Common$22.isResolvable(config)) return valid$2(Joi$2, config);
 		if (Common$22.isSchema(config)) return config;
 		if (Array.isArray(config)) {
-			for (const item of config) if (!internals$24.simple(item)) return Joi$2.alternatives().try(...config);
+			for (const item of config) if (!internals$23.simple(item)) return Joi$2.alternatives().try(...config);
 			return valid$2(Joi$2, ...config);
 		}
 		if (config instanceof RegExp) return Joi$2.string().regex(config);
@@ -3441,23 +3415,23 @@ var init_compile = __esmMin(() => {
 		(0, import_assert.default)(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), "Schema can only contain plain objects");
 		return Joi$2.object().keys(config);
 	};
-	exports$3.ref = function(id, options) {
+	exports.ref = function(id, options) {
 		return Ref$11.isRef(id) ? id : Ref$11.create(id, options);
 	};
-	exports$3.compile = function(root$11, schema$2, options = {}) {
+	exports.compile = function(root$11, schema$2, options = {}) {
 		Common$22.assertOptions(options, ["legacy"]);
 		const any = schema$2 && schema$2[Common$22.symbols.any];
 		if (any) return schema$2;
-		if (typeof schema$2 !== "object" || !options.legacy) return exports$3.schema(root$11, schema$2, { appendPath: true });
-		const compiler = internals$24.walk(schema$2);
-		if (!compiler) return exports$3.schema(root$11, schema$2, { appendPath: true });
+		if (typeof schema$2 !== "object" || !options.legacy) return exports.schema(root$11, schema$2, { appendPath: true });
+		const compiler = internals$23.walk(schema$2);
+		if (!compiler) return exports.schema(root$11, schema$2, { appendPath: true });
 		return compiler.compile(compiler.root, schema$2);
 	};
-	internals$24.walk = function(schema$2) {
+	internals$23.walk = function(schema$2) {
 		if (typeof schema$2 !== "object") return null;
 		if (Array.isArray(schema$2)) {
 			for (const item of schema$2) {
-				const compiler = internals$24.walk(item);
+				const compiler = internals$23.walk(item);
 				if (compiler) return compiler;
 			}
 			return null;
@@ -3469,19 +3443,19 @@ var init_compile = __esmMin(() => {
 		};
 		(0, import_assert.default)(Object.getPrototypeOf(schema$2) === Object.getPrototypeOf({}), "Schema can only contain plain objects");
 		for (const key in schema$2) {
-			const compiler = internals$24.walk(schema$2[key]);
+			const compiler = internals$23.walk(schema$2[key]);
 			if (compiler) return compiler;
 		}
 		return null;
 	};
-	internals$24.simple = function(value) {
+	internals$23.simple = function(value) {
 		return value === null || [
 			"boolean",
 			"string",
 			"number"
 		].includes(typeof value);
 	};
-	exports$3.when = function(schema$2, condition, options) {
+	exports.when = function(schema$2, condition, options) {
 		if (options === void 0) {
 			(0, import_assert.default)(condition && typeof condition === "object", "Missing options");
 			options = condition;
@@ -3500,7 +3474,7 @@ var init_compile = __esmMin(() => {
 			(0, import_assert.default)(options.is === void 0, "\"is\" can not be used with a schema condition");
 			(0, import_assert.default)(options.not === void 0, "\"not\" can not be used with a schema condition");
 			(0, import_assert.default)(options.switch === void 0, "\"switch\" can not be used with a schema condition");
-			return internals$24.condition(schema$2, {
+			return internals$23.condition(schema$2, {
 				is: condition,
 				then: options.then,
 				otherwise: options.otherwise,
@@ -3521,8 +3495,8 @@ var init_compile = __esmMin(() => {
 			(0, import_assert.default)(rule$1.then !== void 0 || rule$1.otherwise !== void 0, "options must have at least one of \"then\", \"otherwise\", or \"switch\"");
 			(0, import_assert.default)(rule$1.break === void 0 || rule$1.then === void 0 || rule$1.otherwise === void 0, "Cannot specify then, otherwise, and break all together");
 			if (options.is !== void 0 && !Ref$11.isRef(options.is) && !Common$22.isSchema(options.is)) is = is.required();
-			return internals$24.condition(schema$2, {
-				ref: exports$3.ref(condition),
+			return internals$23.condition(schema$2, {
+				ref: exports.ref(condition),
 				is,
 				then: rule$1.then,
 				otherwise: rule$1.otherwise,
@@ -3534,7 +3508,7 @@ var init_compile = __esmMin(() => {
 		(0, import_assert.default)(options.not === void 0, "Cannot combine \"switch\" with \"not\"");
 		(0, import_assert.default)(options.then === void 0, "Cannot combine \"switch\" with \"then\"");
 		const rule = {
-			ref: exports$3.ref(condition),
+			ref: exports.ref(condition),
 			switch: [],
 			break: options.break
 		};
@@ -3565,18 +3539,113 @@ var init_compile = __esmMin(() => {
 		}
 		return rule;
 	};
-	internals$24.condition = function(schema$2, condition) {
+	internals$23.condition = function(schema$2, condition) {
 		for (const key of ["then", "otherwise"]) if (condition[key] === void 0) delete condition[key];
 		else condition[key] = schema$2.$_compile(condition[key]);
 		return condition;
 	};
-	compile_default = exports$3;
+});
+var require_messages = __commonJSMin((exports) => {
+	const { assert: assert$48, clone: clone$15 } = require_lib$4();
+	const Template$6 = require_template();
+	exports.compile = function(messages$3, target) {
+		if (typeof messages$3 === "string") {
+			assert$48(!target, "Cannot set single message string");
+			return new Template$6(messages$3);
+		}
+		if (Template$6.isTemplate(messages$3)) {
+			assert$48(!target, "Cannot set single message template");
+			return messages$3;
+		}
+		assert$48(typeof messages$3 === "object" && !Array.isArray(messages$3), "Invalid message options");
+		target = target ? clone$15(target) : {};
+		for (let code$1 in messages$3) {
+			const message = messages$3[code$1];
+			if (code$1 === "root" || Template$6.isTemplate(message)) {
+				target[code$1] = message;
+				continue;
+			}
+			if (typeof message === "string") {
+				target[code$1] = new Template$6(message);
+				continue;
+			}
+			assert$48(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$1);
+			const language = code$1;
+			target[language] = target[language] || {};
+			for (code$1 in message) {
+				const localized = message[code$1];
+				if (code$1 === "root" || Template$6.isTemplate(localized)) {
+					target[language][code$1] = localized;
+					continue;
+				}
+				assert$48(typeof localized === "string", "Invalid message for", code$1, "in", language);
+				target[language][code$1] = new Template$6(localized);
+			}
+		}
+		return target;
+	};
+	exports.decompile = function(messages$3) {
+		const target = {};
+		for (let code$1 in messages$3) {
+			const message = messages$3[code$1];
+			if (code$1 === "root") {
+				target.root = message;
+				continue;
+			}
+			if (Template$6.isTemplate(message)) {
+				target[code$1] = message.describe({ compact: true });
+				continue;
+			}
+			const language = code$1;
+			target[language] = {};
+			for (code$1 in message) {
+				const localized = message[code$1];
+				if (code$1 === "root") {
+					target[language].root = localized;
+					continue;
+				}
+				target[language][code$1] = localized.describe({ compact: true });
+			}
+		}
+		return target;
+	};
+	exports.merge = function(base$3, extended) {
+		if (!base$3) return exports.compile(extended);
+		if (!extended) return base$3;
+		if (typeof extended === "string") return new Template$6(extended);
+		if (Template$6.isTemplate(extended)) return extended;
+		const target = clone$15(base$3);
+		for (let code$1 in extended) {
+			const message = extended[code$1];
+			if (code$1 === "root" || Template$6.isTemplate(message)) {
+				target[code$1] = message;
+				continue;
+			}
+			if (typeof message === "string") {
+				target[code$1] = new Template$6(message);
+				continue;
+			}
+			assert$48(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$1);
+			const language = code$1;
+			target[language] = target[language] || {};
+			for (code$1 in message) {
+				const localized = message[code$1];
+				if (code$1 === "root" || Template$6.isTemplate(localized)) {
+					target[language][code$1] = localized;
+					continue;
+				}
+				assert$48(typeof localized === "string", "Invalid message for", code$1, "in", language);
+				target[language][code$1] = new Template$6(localized);
+			}
+		}
+		return target;
+	};
 });
 var require_extend$1 = __commonJSMin((exports) => {
 	const { assert: assert$47, clone: clone$14 } = require_lib$4();
 	const Common$21 = require_common$3();
-	const Messages$7 = require_messages();
-	const internals$23 = {};
+	const Messages$6 = require_messages();
+	const internals$22 = {};
 	exports.type = function(from$2, options) {
 		const base$3 = Object.getPrototypeOf(from$2);
 		const prototype = clone$14(base$3);
@@ -3585,7 +3654,7 @@ var require_extend$1 = __commonJSMin((exports) => {
 		delete def.base;
 		prototype._definition = def;
 		const parent = base$3._definition || {};
-		def.messages = Messages$7.merge(parent.messages, def.messages);
+		def.messages = Messages$6.merge(parent.messages, def.messages);
 		def.properties = Object.assign({}, parent.properties, def.properties);
 		schema$2.type = def.type;
 		def.flags = Object.assign({}, parent.flags, def.flags);
@@ -3598,7 +3667,7 @@ var require_extend$1 = __commonJSMin((exports) => {
 		}
 		def.terms = terms;
 		if (!def.args) def.args = parent.args;
-		def.prepare = internals$23.prepare(def.prepare, parent.prepare);
+		def.prepare = internals$22.prepare(def.prepare, parent.prepare);
 		if (def.coerce) {
 			if (typeof def.coerce === "function") def.coerce = { method: def.coerce };
 			if (def.coerce.from && !Array.isArray(def.coerce.from)) def.coerce = {
@@ -3606,8 +3675,8 @@ var require_extend$1 = __commonJSMin((exports) => {
 				from: [].concat(def.coerce.from)
 			};
 		}
-		def.coerce = internals$23.coerce(def.coerce, parent.coerce);
-		def.validate = internals$23.validate(def.validate, parent.validate);
+		def.coerce = internals$22.coerce(def.coerce, parent.coerce);
+		def.validate = internals$22.validate(def.validate, parent.validate);
 		const rules = Object.assign({}, parent.rules);
 		if (def.rules) for (const name$3 in def.rules) {
 			const rule = def.rules[name$3];
@@ -3662,18 +3731,18 @@ var require_extend$1 = __commonJSMin((exports) => {
 		}
 		def.cast = Object.assign({}, parent.cast, def.cast);
 		const manifest = Object.assign({}, parent.manifest, def.manifest);
-		manifest.build = internals$23.build(def.manifest && def.manifest.build, parent.manifest && parent.manifest.build);
+		manifest.build = internals$22.build(def.manifest && def.manifest.build, parent.manifest && parent.manifest.build);
 		def.manifest = manifest;
-		def.rebuild = internals$23.rebuild(def.rebuild, parent.rebuild);
+		def.rebuild = internals$22.rebuild(def.rebuild, parent.rebuild);
 		return schema$2;
 	};
-	internals$23.build = function(child, parent) {
+	internals$22.build = function(child, parent) {
 		if (!child || !parent) return child || parent;
 		return function(obj, desc$1) {
 			return parent(child(obj, desc$1), desc$1);
 		};
 	};
-	internals$23.coerce = function(child, parent) {
+	internals$22.coerce = function(child, parent) {
 		if (!child || !parent) return child || parent;
 		return {
 			from: child.from && parent.from ? [...new Set([...child.from, ...parent.from])] : null,
@@ -3694,7 +3763,7 @@ var require_extend$1 = __commonJSMin((exports) => {
 			}
 		};
 	};
-	internals$23.prepare = function(child, parent) {
+	internals$22.prepare = function(child, parent) {
 		if (!child || !parent) return child || parent;
 		return function(value, helpers$8) {
 			const prepared = child(value, helpers$8);
@@ -3705,14 +3774,14 @@ var require_extend$1 = __commonJSMin((exports) => {
 			return parent(value, helpers$8) || prepared;
 		};
 	};
-	internals$23.rebuild = function(child, parent) {
+	internals$22.rebuild = function(child, parent) {
 		if (!child || !parent) return child || parent;
 		return function(schema$2) {
 			parent(schema$2);
 			child(schema$2);
 		};
 	};
-	internals$23.validate = function(child, parent) {
+	internals$22.validate = function(child, parent) {
 		if (!child || !parent) return child || parent;
 		return function(value, helpers$8) {
 			const result = parent(value, helpers$8);
@@ -3724,16 +3793,16 @@ var require_extend$1 = __commonJSMin((exports) => {
 		};
 	};
 });
-var require_manifest = __commonJSMin((exports, module) => {
+var require_manifest = __commonJSMin((exports) => {
 	init_dist$1();
-	var import_schemas$2 = __toESM(require_schemas());
+	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$3 = __toESM(require_messages());
+	var import_messages$2 = __toESM(require_messages());
 	var import_common$2 = __toESM(require_common$3());
 	init_lib();
 	const Common$20 = import_common$2.default;
-	const Messages$6 = import_messages$3.default;
+	const Messages$5 = import_messages$2.default;
 	const Ref$10 = import_ref$2.default;
 	const Template$5 = import_template$2.default;
 	const ManifestDescriptionCache = new Map();
@@ -3753,10 +3822,9 @@ var require_manifest = __commonJSMin((exports, module) => {
 		}
 	};
 	const ManifestItemCache = new ManifestItemCacheClass();
-	let Schemas$4;
-	const internals$22 = {};
-	const exports$2 = {};
-	exports$2.describe = function(schema$2) {
+	let Schemas$3;
+	const internals$21 = {};
+	exports.describe = function(schema$2) {
 		const cached$1 = ManifestDescriptionCache.get(schema$2);
 		if (cached$1) return cached$1;
 		const def = schema$2._definition;
@@ -3765,12 +3833,12 @@ var require_manifest = __commonJSMin((exports, module) => {
 			flags: {},
 			rules: []
 		};
-		for (const flag in schema$2._flags) if (flag[0] !== "_") desc$1.flags[flag] = internals$22.describe(schema$2._flags[flag]);
+		for (const flag in schema$2._flags) if (flag[0] !== "_") desc$1.flags[flag] = internals$21.describe(schema$2._flags[flag]);
 		if (!Object.keys(desc$1.flags).length) delete desc$1.flags;
 		if (schema$2._preferences) {
 			desc$1.preferences = (0, import_clone.default)(schema$2._preferences, { shallow: ["messages"] });
 			delete desc$1.preferences[Common$20.symbols.prefs];
-			if (desc$1.preferences.messages) desc$1.preferences.messages = Messages$6.decompile(desc$1.preferences.messages);
+			if (desc$1.preferences.messages) desc$1.preferences.messages = Messages$5.decompile(desc$1.preferences.messages);
 		}
 		if (schema$2._valids) desc$1.allow = schema$2._valids.describe();
 		if (schema$2._invalids) desc$1.invalid = schema$2._invalids.describe();
@@ -3778,13 +3846,13 @@ var require_manifest = __commonJSMin((exports, module) => {
 			const ruleDef = def.rules[rule.name];
 			if (ruleDef.manifest === false) continue;
 			const item = { name: rule.name };
-			for (const custom$1 in def.modifiers) if (rule[custom$1] !== void 0) item[custom$1] = internals$22.describe(rule[custom$1]);
+			for (const custom$1 in def.modifiers) if (rule[custom$1] !== void 0) item[custom$1] = internals$21.describe(rule[custom$1]);
 			if (rule.args) {
 				item.args = {};
 				for (const key in rule.args) {
 					const arg = rule.args[key];
 					if (key === "options" && !Object.keys(arg).length) continue;
-					item.args[key] = internals$22.describe(arg, { assign: key });
+					item.args[key] = internals$21.describe(arg, { assign: key });
 				}
 				if (!Object.keys(item.args).length) delete item.args;
 			}
@@ -3809,7 +3877,7 @@ var require_manifest = __commonJSMin((exports, module) => {
 			const mapped = typeof manifest === "object";
 			if (!items.length && !mapped) continue;
 			const normalized = [];
-			for (const item of items) normalized.push(internals$22.describe(item));
+			for (const item of items) normalized.push(internals$21.describe(item));
 			if (mapped) {
 				const { from: from$2, to } = manifest.mapped;
 				desc$1[term] = {};
@@ -3823,14 +3891,14 @@ var require_manifest = __commonJSMin((exports, module) => {
 			}
 			desc$1[term] = normalized;
 		}
-		internals$22.validate(schema$2.$_root, desc$1);
+		internals$21.validate(schema$2.$_root, desc$1);
 		ManifestDescriptionCache.set(schema$2, desc$1);
 		return desc$1;
 	};
-	internals$22.describe = function(item, options = {}) {
+	internals$21.describe = function(item, options = {}) {
 		const cached$1 = ManifestItemCache.get(item, options);
 		if (cached$1) return cached$1;
-		if (Array.isArray(item)) return ManifestItemCache.setAndReturn(item, options, item.map(internals$22.describe));
+		if (Array.isArray(item)) return ManifestItemCache.setAndReturn(item, options, item.map(internals$21.describe));
 		if (item === Common$20.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));
@@ -3850,20 +3918,20 @@ var require_manifest = __commonJSMin((exports, module) => {
 		for (const key in item) {
 			const value = item[key];
 			if (value === void 0) continue;
-			normalized[key] = internals$22.describe(value, { assign: key });
+			normalized[key] = internals$21.describe(value, { assign: key });
 		}
 		return ManifestItemCache.setAndReturn(item, options, normalized);
 	};
-	exports$2.build = function(joi$1, desc$1) {
-		const builder = new internals$22.Builder(joi$1);
+	exports.build = function(joi$1, desc$1) {
+		const builder = new internals$21.Builder(joi$1);
 		return builder.parse(desc$1);
 	};
-	internals$22.Builder = class {
+	internals$21.Builder = class {
 		constructor(joi$1) {
 			this.joi = joi$1;
 		}
 		parse(desc$1) {
-			internals$22.validate(this.joi, desc$1);
+			internals$21.validate(this.joi, desc$1);
 			let schema$2 = this.joi[desc$1.type]()._bare();
 			const def = schema$2._definition;
 			if (desc$1.flags) for (const flag in desc$1.flags) {
@@ -3940,7 +4008,7 @@ var require_manifest = __commonJSMin((exports, module) => {
 			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 (0, import_clone.default)(desc$1);
-			if (options.assign === "regex") return internals$22.regex(desc$1);
+			if (options.assign === "regex") return internals$21.regex(desc$1);
 			if (options.assign === "ref") return Ref$10.build(desc$1);
 			if (typeof desc$1 !== "object") return desc$1;
 			if (Object.keys(desc$1).length === 1) {
@@ -3954,7 +4022,7 @@ var require_manifest = __commonJSMin((exports, module) => {
 				};
 				if (desc$1.override) return Common$20.symbols.override;
 				if (desc$1.ref) return Ref$10.build(desc$1.ref);
-				if (desc$1.regex) return internals$22.regex(desc$1.regex);
+				if (desc$1.regex) return internals$21.regex(desc$1.regex);
 				if (desc$1.special) {
 					(0, import_assert.default)(["deep"].includes(desc$1.special), "Unknown special value", desc$1.special);
 					return Common$20.symbols.deepDefault;
@@ -3968,17 +4036,16 @@ var require_manifest = __commonJSMin((exports, module) => {
 			return normalized;
 		}
 	};
-	internals$22.regex = function(string) {
+	internals$21.regex = function(string) {
 		const end = string.lastIndexOf("/");
 		const exp = string.slice(1, end);
 		const flags = string.slice(end + 1);
 		return new RegExp(exp, flags);
 	};
-	internals$22.validate = function(joi$1, desc$1) {
-		Schemas$4 = Schemas$4 || import_schemas$2.default;
-		joi$1.assert(desc$1, Schemas$4.description);
+	internals$21.validate = function(joi$1, desc$1) {
+		Schemas$3 = Schemas$3 || import_schemas$1.default;
+		joi$1.assert(desc$1, Schemas$3.description);
 	};
-	module.exports = exports$2;
 });
 var require_lib$2 = __commonJSMin((exports) => {
 	exports.location = function(depth = 0) {
@@ -3998,7 +4065,7 @@ var require_trace = __commonJSMin((exports) => {
 	const { deepEqual: deepEqual$3 } = require_lib$4();
 	const Pinpoint = require_lib$2();
 	const Errors$7 = require_errors$2();
-	const internals$21 = {
+	const internals$20 = {
 		codes: {
 			error: 1,
 			pass: 2,
@@ -4012,7 +4079,7 @@ var require_trace = __commonJSMin((exports) => {
 	};
 	exports.setup = function(root$11) {
 		const trace = function() {
-			root$11._tracer = root$11._tracer || new internals$21.Tracer();
+			root$11._tracer = root$11._tracer || new internals$20.Tracer();
 			return root$11._tracer;
 		};
 		root$11.trace = trace;
@@ -4024,7 +4091,7 @@ var require_trace = __commonJSMin((exports) => {
 	exports.location = function(schema$2) {
 		return schema$2.$_setFlag("_tracerLocation", Pinpoint.location(2));
 	};
-	internals$21.Tracer = class {
+	internals$20.Tracer = class {
 		constructor() {
 			this.name = "Joi";
 			this._schemas = new Map();
@@ -4032,7 +4099,7 @@ var require_trace = __commonJSMin((exports) => {
 		_register(schema$2) {
 			const existing = this._schemas.get(schema$2);
 			if (existing) return existing.store;
-			const store = new internals$21.Store(schema$2);
+			const store = new internals$20.Store(schema$2);
 			const { filename, line } = schema$2._flags._tracerLocation || Pinpoint.location(5);
 			this._schemas.set(schema$2, {
 				filename,
@@ -4051,7 +4118,7 @@ var require_trace = __commonJSMin((exports) => {
 				const missing = [];
 				const skipped = [];
 				for (const [schema$2, log$1] of store._sources.entries()) {
-					if (internals$21.sub(log$1.paths, skipped)) continue;
+					if (internals$20.sub(log$1.paths, skipped)) continue;
 					if (!log$1.entry) {
 						missing.push({
 							status: "never reached",
@@ -4077,7 +4144,7 @@ var require_trace = __commonJSMin((exports) => {
 					const rules = schema$2._rules.map((rule) => rule.name);
 					for (const type of ["default", "failover"]) if (schema$2._flags[type] !== void 0) rules.push(type);
 					for (const name$3 of rules) {
-						const status = internals$21.labels[log$1.rule[name$3] || 0];
+						const status = internals$20.labels[log$1.rule[name$3] || 0];
 						if (status) {
 							const report = {
 								rule: name$3,
@@ -4093,13 +4160,13 @@ var require_trace = __commonJSMin((exports) => {
 					line,
 					missing,
 					severity: "error",
-					message: `Schema missing tests for ${missing.map(internals$21.message).join(", ")}`
+					message: `Schema missing tests for ${missing.map(internals$20.message).join(", ")}`
 				});
 			}
 			return coverage.length ? coverage : null;
 		}
 	};
-	internals$21.Store = class {
+	internals$20.Store = class {
 		constructor(schema$2) {
 			this.active = true;
 			this._sources = new Map();
@@ -4115,13 +4182,13 @@ var require_trace = __commonJSMin((exports) => {
 			});
 		}
 		entry(schema$2, state) {
-			internals$21.debug(state, { type: "entry" });
+			internals$20.debug(state, { type: "entry" });
 			this._record(schema$2, (log$1) => {
 				log$1.entry = true;
 			});
 		}
 		filter(schema$2, state, source, value) {
-			internals$21.debug(state, {
+			internals$20.debug(state, {
 				type: source,
 				...value
 			});
@@ -4130,14 +4197,14 @@ var require_trace = __commonJSMin((exports) => {
 			});
 		}
 		log(schema$2, state, source, name$3, result) {
-			internals$21.debug(state, {
+			internals$20.debug(state, {
 				type: source,
 				name: name$3,
 				result: result === "full" ? "pass" : result
 			});
 			this._record(schema$2, (log$1) => {
 				log$1[source][name$3] = log$1[source][name$3] || 0;
-				log$1[source][name$3] |= internals$21.codes[result];
+				log$1[source][name$3] |= internals$20.codes[result];
 			});
 		}
 		resolve(state, ref, to) {
@@ -4186,7 +4253,7 @@ var require_trace = __commonJSMin((exports) => {
 			}
 			if (path.length) log$1.paths.add(path);
 			const each$5 = (sub, source) => {
-				const subId = internals$21.id(sub, source);
+				const subId = internals$20.id(sub, source);
 				this._scan(sub, path.concat(subId));
 			};
 			schema$2.$_modify({
@@ -4198,22 +4265,22 @@ var require_trace = __commonJSMin((exports) => {
 			this._combos.set(merged, sources);
 		}
 	};
-	internals$21.message = function(item) {
+	internals$20.message = function(item) {
 		const path = item.paths ? Errors$7.path(item.paths[0]) + (item.rule ? ":" : "") : "";
 		return `${path}${item.rule || ""} (${item.status})`;
 	};
-	internals$21.id = function(schema$2, { source, name: name$3, path, key }) {
+	internals$20.id = function(schema$2, { source, name: name$3, path, key }) {
 		if (schema$2._flags.id) return schema$2._flags.id;
 		if (key) return key;
 		name$3 = `@${name$3}`;
 		if (source === "terms") return [name$3, path[Math.min(path.length - 1, 1)]];
 		return name$3;
 	};
-	internals$21.sub = function(paths, skipped) {
+	internals$20.sub = function(paths, skipped) {
 		for (const path of paths) for (const skip of skipped) if (deepEqual$3(path.slice(0, skip.length), skip)) return true;
 		return false;
 	};
-	internals$21.debug = function(state, event) {
+	internals$20.debug = function(state, event) {
 		if (state.mainstay.debug) {
 			event.path = state.debug ? [...state.path, state.debug] : state.path;
 			state.mainstay.debug.push(event);
@@ -4224,15 +4291,15 @@ var require_modify = __commonJSMin((exports) => {
 	const { assert: assert$45 } = require_lib$4();
 	const Common$19 = require_common$3();
 	const Ref$9 = require_ref$2();
-	const internals$20 = {};
-	exports.Ids = internals$20.Ids = class {
+	const internals$19 = {};
+	exports.Ids = internals$19.Ids = class {
 		constructor() {
 			this._byId = new Map();
 			this._byKey = new Map();
 			this._schemaChain = false;
 		}
 		clone() {
-			const clone$20 = new internals$20.Ids();
+			const clone$20 = new internals$19.Ids();
 			clone$20._byId = new Map(this._byId);
 			clone$20._byKey = new Map(this._byKey);
 			clone$20._schemaChain = this._schemaChain;
@@ -4260,7 +4327,7 @@ var require_modify = __commonJSMin((exports) => {
 			assert$45(Common$19.isSchema(adjusted.schema), "adjuster function failed to return a joi schema type");
 			for (const node of chain) adjusted = {
 				id: node.id,
-				schema: internals$20.fork(node.schema, adjusted.id, adjusted.schema)
+				schema: internals$19.fork(node.schema, adjusted.id, adjusted.schema)
 			};
 			return adjusted.schema;
 		}
@@ -4321,7 +4388,7 @@ var require_modify = __commonJSMin((exports) => {
 			return this._byId.get(id) || this._byKey.get(id);
 		}
 	};
-	internals$20.fork = function(schema$2, id, replacement) {
+	internals$19.fork = function(schema$2, id, replacement) {
 		const each$5 = (item, { key }) => {
 			if (id === (item._flags.id || key)) return replacement;
 		};
@@ -4335,7 +4402,7 @@ var require_modify = __commonJSMin((exports) => {
 		let obj;
 		for (const name$3 in schema$2._flags) {
 			if (name$3[0] === "_") continue;
-			const result = internals$20.scan(schema$2._flags[name$3], {
+			const result = internals$19.scan(schema$2._flags[name$3], {
 				source: "flags",
 				name: name$3
 			}, options);
@@ -4346,7 +4413,7 @@ var require_modify = __commonJSMin((exports) => {
 		}
 		for (let i$1 = 0; i$1 < schema$2._rules.length; ++i$1) {
 			const rule = schema$2._rules[i$1];
-			const result = internals$20.scan(rule.args, {
+			const result = internals$19.scan(rule.args, {
 				source: "rules",
 				name: rule.name
 			}, options);
@@ -4361,7 +4428,7 @@ var require_modify = __commonJSMin((exports) => {
 		}
 		for (const name$3 in schema$2.$_terms) {
 			if (name$3[0] === "_") continue;
-			const result = internals$20.scan(schema$2.$_terms[name$3], {
+			const result = internals$19.scan(schema$2.$_terms[name$3], {
 				source: "terms",
 				name: name$3
 			}, options);
@@ -4372,14 +4439,14 @@ var require_modify = __commonJSMin((exports) => {
 		}
 		return obj;
 	};
-	internals$20.scan = function(item, source, options, _path, _key) {
+	internals$19.scan = function(item, source, options, _path, _key) {
 		const path = _path || [];
 		if (item === null || typeof item !== "object") return;
 		let clone$20;
 		if (Array.isArray(item)) {
 			for (let i$1 = 0; i$1 < item.length; ++i$1) {
 				const key = source.source === "terms" && source.name === "keys" && item[i$1].key;
-				const result = internals$20.scan(item[i$1], source, options, [i$1, ...path], key);
+				const result = internals$19.scan(item[i$1], source, options, [i$1, ...path], key);
 				if (result !== void 0) {
 					clone$20 = clone$20 || item.slice();
 					clone$20[i$1] = result;
@@ -4398,7 +4465,7 @@ var require_modify = __commonJSMin((exports) => {
 		}
 		for (const key in item) {
 			if (key[0] === "_") continue;
-			const result = internals$20.scan(item[key], source, options, [key, ...path], _key);
+			const result = internals$19.scan(item[key], source, options, [key, ...path], _key);
 			if (result !== void 0) {
 				clone$20 = clone$20 || Object.assign({}, item);
 				clone$20[key] = result;
@@ -4410,8 +4477,8 @@ var require_modify = __commonJSMin((exports) => {
 var require_state$1 = __commonJSMin((exports, module) => {
 	const { clone: clone$12, reach: reach$2 } = require_lib$4();
 	const Common$18 = require_common$3();
-	const internals$19 = { value: Symbol("value") };
-	module.exports = internals$19.State = class {
+	const internals$18 = { value: Symbol("value") };
+	module.exports = internals$18.State = class {
 		constructor(path, ancestors, state) {
 			this.path = path;
 			this.ancestors = ancestors;
@@ -4420,18 +4487,18 @@ var require_state$1 = __commonJSMin((exports, module) => {
 			this.debug = null;
 		}
 		localize(path, ancestors = null, schema$2 = null) {
-			const state = new internals$19.State(path, ancestors, this);
-			if (schema$2 && state.schemas) state.schemas = [internals$19.schemas(schema$2), ...state.schemas];
+			const state = new internals$18.State(path, ancestors, this);
+			if (schema$2 && state.schemas) state.schemas = [internals$18.schemas(schema$2), ...state.schemas];
 			return state;
 		}
 		nest(schema$2, debug$13) {
-			const state = new internals$19.State(this.path, this.ancestors, this);
-			state.schemas = state.schemas && [internals$19.schemas(schema$2), ...state.schemas];
+			const state = new internals$18.State(this.path, this.ancestors, this);
+			state.schemas = state.schemas && [internals$18.schemas(schema$2), ...state.schemas];
 			state.debug = debug$13;
 			return state;
 		}
 		shadow(value, reason) {
-			this.mainstay.shadow = this.mainstay.shadow || new internals$19.Shadow();
+			this.mainstay.shadow = this.mainstay.shadow || new internals$18.Shadow();
 			this.mainstay.shadow.set(this.path, value, reason);
 		}
 		snapshot() {
@@ -4453,11 +4520,11 @@ var require_state$1 = __commonJSMin((exports, module) => {
 			this.mainstay.commit();
 		}
 	};
-	internals$19.schemas = function(schema$2) {
+	internals$18.schemas = function(schema$2) {
 		if (Common$18.isSchema(schema$2)) return { schema: schema$2 };
 		return schema$2;
 	};
-	internals$19.Shadow = class {
+	internals$18.Shadow = class {
 		constructor() {
 			this._values = null;
 		}
@@ -4475,11 +4542,11 @@ var require_state$1 = __commonJSMin((exports, module) => {
 				}
 				node = next;
 			}
-			node[internals$19.value] = value;
+			node[internals$18.value] = value;
 		}
 		get(path) {
 			const node = this.node(path);
-			if (node) return node[internals$19.value];
+			if (node) return node[internals$18.value];
 		}
 		node(path) {
 			if (!this._values) return;
@@ -4503,7 +4570,7 @@ var require_validator = __commonJSMin((exports) => {
 	const Common$17 = require_common$3();
 	const Errors$6 = require_errors$2();
 	const State = require_state$1();
-	const internals$18 = { result: Symbol("result") };
+	const internals$17 = { result: Symbol("result") };
 	exports.entry = function(value, schema$2, prefs) {
 		let settings = Common$17.defaults;
 		if (prefs) {
@@ -4511,7 +4578,7 @@ var require_validator = __commonJSMin((exports) => {
 			assert$44(prefs.artifacts === void 0, "Cannot override artifacts preference in synchronous validation");
 			settings = Common$17.preferences(Common$17.defaults, prefs);
 		}
-		const result = internals$18.entry(value, schema$2, settings);
+		const result = internals$17.entry(value, schema$2, settings);
 		assert$44(!result.mainstay.externals.length, "Schema with external rules must use validateAsync()");
 		const outcome = { value: result.value };
 		if (result.error) outcome.error = result.error;
@@ -4523,7 +4590,7 @@ var require_validator = __commonJSMin((exports) => {
 	exports.entryAsync = async function(value, schema$2, prefs) {
 		let settings = Common$17.defaults;
 		if (prefs) settings = Common$17.preferences(Common$17.defaults, prefs);
-		const result = internals$18.entry(value, schema$2, settings);
+		const result = internals$17.entry(value, schema$2, settings);
 		const mainstay = result.mainstay;
 		if (result.error) {
 			if (mainstay.debug) result.error.debug = mainstay.debug;
@@ -4559,7 +4626,7 @@ var require_validator = __commonJSMin((exports) => {
 						prefs,
 						original,
 						error: createError,
-						errorsArray: internals$18.errorsArray,
+						errorsArray: internals$17.errorsArray,
 						warn: (code$1, local) => mainstay.warnings.push((linked || external.schema).$_createError(code$1, node, local, external.state, settings)),
 						message: (messages$3, local) => (linked || external.schema).$_createError("external", node, local, external.state, settings, { messages: messages$3 })
 					});
@@ -4606,7 +4673,7 @@ var require_validator = __commonJSMin((exports) => {
 		if (schema$2.isAsync()) return exports.entryAsync(value, schema$2);
 		return exports.entry(value, schema$2);
 	};
-	internals$18.Mainstay = class {
+	internals$17.Mainstay = class {
 		constructor(tracer, debug$13, links) {
 			this.externals = [];
 			this.warnings = [];
@@ -4632,11 +4699,11 @@ var require_validator = __commonJSMin((exports) => {
 			this._snapshots.pop();
 		}
 	};
-	internals$18.entry = function(value, schema$2, prefs) {
-		const { tracer, cleanup } = internals$18.tracer(schema$2, prefs);
+	internals$17.entry = function(value, schema$2, prefs) {
+		const { tracer, cleanup } = internals$17.tracer(schema$2, prefs);
 		const debug$13 = prefs.debug ? [] : null;
 		const links = schema$2._ids._schemaChain ? new Map() : null;
-		const mainstay = new internals$18.Mainstay(tracer, debug$13, links);
+		const mainstay = new internals$17.Mainstay(tracer, debug$13, links);
 		const schemas = schema$2._ids._schemaChain ? [{ schema: schema$2 }] : null;
 		const state = new State([], [], {
 			mainstay,
@@ -4651,7 +4718,7 @@ var require_validator = __commonJSMin((exports) => {
 			mainstay
 		};
 	};
-	internals$18.tracer = function(schema$2, prefs) {
+	internals$17.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");
@@ -4660,11 +4727,11 @@ var require_validator = __commonJSMin((exports) => {
 				cleanup: true
 			};
 		}
-		return { tracer: internals$18.ignore };
+		return { tracer: internals$17.ignore };
 	};
 	exports.validate = function(value, schema$2, state, prefs, overrides = {}) {
 		if (schema$2.$_terms.whens) schema$2 = schema$2._generate(value, state, prefs).schema;
-		if (schema$2._preferences) prefs = internals$18.prefs(schema$2, prefs);
+		if (schema$2._preferences) prefs = internals$17.prefs(schema$2, prefs);
 		if (schema$2._cache && prefs.cache) {
 			const result = schema$2._cache.get(value);
 			state.mainstay.tracer.debug(state, "validate", "cached", !!result);
@@ -4677,7 +4744,7 @@ var require_validator = __commonJSMin((exports) => {
 			schema: schema$2,
 			state,
 			error: createError,
-			errorsArray: internals$18.errorsArray,
+			errorsArray: internals$17.errorsArray,
 			warn: (code$1, local, localState) => state.mainstay.warnings.push(createError(code$1, local, localState)),
 			message: (messages$3, local) => schema$2.$_createError("custom", value, local, state, prefs, { messages: messages$3 })
 		};
@@ -4687,7 +4754,7 @@ var require_validator = __commonJSMin((exports) => {
 			const prepared = def.prepare(value, helpers$8);
 			if (prepared) {
 				state.mainstay.tracer.value(state, "prepare", value, prepared.value);
-				if (prepared.errors) return internals$18.finalize(prepared.value, [].concat(prepared.errors), helpers$8);
+				if (prepared.errors) return internals$17.finalize(prepared.value, [].concat(prepared.errors), helpers$8);
 				value = prepared.value;
 			}
 		}
@@ -4695,25 +4762,25 @@ var require_validator = __commonJSMin((exports) => {
 			const coerced = def.coerce.method(value, helpers$8);
 			if (coerced) {
 				state.mainstay.tracer.value(state, "coerced", value, coerced.value);
-				if (coerced.errors) return internals$18.finalize(coerced.value, [].concat(coerced.errors), helpers$8);
+				if (coerced.errors) return internals$17.finalize(coerced.value, [].concat(coerced.errors), helpers$8);
 				value = coerced.value;
 			}
 		}
 		const empty$2 = schema$2._flags.empty;
-		if (empty$2 && empty$2.$_match(internals$18.trim(value, schema$2), state.nest(empty$2), Common$17.defaults)) {
+		if (empty$2 && empty$2.$_match(internals$17.trim(value, schema$2), state.nest(empty$2), Common$17.defaults)) {
 			state.mainstay.tracer.value(state, "empty", value, void 0);
 			value = void 0;
 		}
 		const presence = overrides.presence || schema$2._flags.presence || (schema$2._flags._endedSwitch ? null : prefs.presence);
 		if (value === void 0) {
-			if (presence === "forbidden") return internals$18.finalize(value, null, helpers$8);
-			if (presence === "required") return internals$18.finalize(value, [schema$2.$_createError("any.required", value, null, state, prefs)], helpers$8);
+			if (presence === "forbidden") return internals$17.finalize(value, null, helpers$8);
+			if (presence === "required") return internals$17.finalize(value, [schema$2.$_createError("any.required", value, null, state, prefs)], helpers$8);
 			if (presence === "optional") {
-				if (schema$2._flags.default !== Common$17.symbols.deepDefault) return internals$18.finalize(value, null, helpers$8);
+				if (schema$2._flags.default !== Common$17.symbols.deepDefault) return internals$17.finalize(value, null, helpers$8);
 				state.mainstay.tracer.value(state, "default", value, {});
 				value = {};
 			}
-		} else if (presence === "forbidden") return internals$18.finalize(value, [schema$2.$_createError("any.unknown", value, null, state, prefs)], helpers$8);
+		} else if (presence === "forbidden") return internals$17.finalize(value, [schema$2.$_createError("any.unknown", value, null, state, prefs)], helpers$8);
 		const errors = [];
 		if (schema$2._valids) {
 			const match$2 = schema$2._valids.get(value, state, prefs, schema$2._flags.insensitive);
@@ -4723,11 +4790,11 @@ var require_validator = __commonJSMin((exports) => {
 					value = match$2.value;
 				}
 				state.mainstay.tracer.filter(schema$2, state, "valid", match$2);
-				return internals$18.finalize(value, null, helpers$8);
+				return internals$17.finalize(value, null, helpers$8);
 			}
 			if (schema$2._flags.only) {
 				const report = schema$2.$_createError("any.only", value, { valids: schema$2._valids.values({ display: true }) }, state, prefs);
-				if (prefs.abortEarly) return internals$18.finalize(value, [report], helpers$8);
+				if (prefs.abortEarly) return internals$17.finalize(value, [report], helpers$8);
 				errors.push(report);
 			}
 		}
@@ -4736,7 +4803,7 @@ var require_validator = __commonJSMin((exports) => {
 			if (match$2) {
 				state.mainstay.tracer.filter(schema$2, state, "invalid", match$2);
 				const report = schema$2.$_createError("any.invalid", value, { invalids: schema$2._invalids.values({ display: true }) }, state, prefs);
-				if (prefs.abortEarly) return internals$18.finalize(value, [report], helpers$8);
+				if (prefs.abortEarly) return internals$17.finalize(value, [report], helpers$8);
 				errors.push(report);
 			}
 		}
@@ -4748,19 +4815,19 @@ var require_validator = __commonJSMin((exports) => {
 				if (base$3.errors) {
 					if (!Array.isArray(base$3.errors)) {
 						errors.push(base$3.errors);
-						return internals$18.finalize(value, errors, helpers$8);
+						return internals$17.finalize(value, errors, helpers$8);
 					}
 					if (base$3.errors.length) {
 						errors.push(...base$3.errors);
-						return internals$18.finalize(value, errors, helpers$8);
+						return internals$17.finalize(value, errors, helpers$8);
 					}
 				}
 			}
 		}
-		if (!schema$2._rules.length) return internals$18.finalize(value, errors, helpers$8);
-		return internals$18.rules(value, errors, helpers$8);
+		if (!schema$2._rules.length) return internals$17.finalize(value, errors, helpers$8);
+		return internals$17.rules(value, errors, helpers$8);
 	};
-	internals$18.rules = function(value, errors, helpers$8) {
+	internals$17.rules = function(value, errors, helpers$8) {
 		const { schema: schema$2, state, prefs } = helpers$8;
 		for (const rule of schema$2._rules) {
 			const definition = schema$2._definition.rules[rule.method];
@@ -4789,14 +4856,14 @@ var require_validator = __commonJSMin((exports) => {
 				}
 			}
 			ret = ret || definition.validate(value, helpers$8, args$1, rule);
-			const result = internals$18.rule(ret, rule);
+			const result = internals$17.rule(ret, rule);
 			if (result.errors) {
 				state.mainstay.tracer.log(schema$2, state, "rule", rule.name, "error");
 				if (rule.warn) {
 					state.mainstay.warnings.push(...result.errors);
 					continue;
 				}
-				if (prefs.abortEarly) return internals$18.finalize(value, result.errors, helpers$8);
+				if (prefs.abortEarly) return internals$17.finalize(value, result.errors, helpers$8);
 				errors.push(...result.errors);
 			} else {
 				state.mainstay.tracer.log(schema$2, state, "rule", rule.name, "pass");
@@ -4804,18 +4871,18 @@ var require_validator = __commonJSMin((exports) => {
 				value = result.value;
 			}
 		}
-		return internals$18.finalize(value, errors, helpers$8);
+		return internals$17.finalize(value, errors, helpers$8);
 	};
-	internals$18.rule = function(ret, rule) {
+	internals$17.rule = function(ret, rule) {
 		if (ret instanceof Errors$6.Report) {
-			internals$18.error(ret, rule);
+			internals$17.error(ret, rule);
 			return {
 				errors: [ret],
 				value: null
 			};
 		}
 		if (Array.isArray(ret) && ret[Common$17.symbols.errors]) {
-			ret.forEach((report) => internals$18.error(report, rule));
+			ret.forEach((report) => internals$17.error(report, rule));
 			return {
 				errors: ret,
 				value: null
@@ -4826,15 +4893,15 @@ var require_validator = __commonJSMin((exports) => {
 			value: ret
 		};
 	};
-	internals$18.error = function(report, rule) {
+	internals$17.error = function(report, rule) {
 		if (rule.message) report._setTemplate(rule.message);
 		return report;
 	};
-	internals$18.finalize = function(value, errors, helpers$8) {
+	internals$17.finalize = function(value, errors, helpers$8) {
 		errors = errors || [];
 		const { schema: schema$2, state, prefs } = helpers$8;
 		if (errors.length) {
-			const failover = internals$18.default("failover", void 0, errors, helpers$8);
+			const failover = internals$17.default("failover", void 0, errors, helpers$8);
 			if (failover !== void 0) {
 				state.mainstay.tracer.value(state, "failover", value, failover);
 				value = failover;
@@ -4847,7 +4914,7 @@ var require_validator = __commonJSMin((exports) => {
 			for (const error of errors) assert$44(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$18.default("default", value, errors, helpers$8);
+			const defaulted = internals$17.default("default", value, errors, helpers$8);
 			state.mainstay.tracer.value(state, "default", value, defaulted);
 			value = defaulted;
 		}
@@ -4882,14 +4949,14 @@ var require_validator = __commonJSMin((exports) => {
 		}
 		return result;
 	};
-	internals$18.prefs = function(schema$2, prefs) {
+	internals$17.prefs = function(schema$2, prefs) {
 		const isDefaultOptions = prefs === Common$17.defaults;
 		if (isDefaultOptions && schema$2._preferences[Common$17.symbols.prefs]) return schema$2._preferences[Common$17.symbols.prefs];
 		prefs = Common$17.preferences(prefs, schema$2._preferences);
 		if (isDefaultOptions) schema$2._preferences[Common$17.symbols.prefs] = prefs;
 		return prefs;
 	};
-	internals$18.default = function(flag, value, errors, helpers$8) {
+	internals$17.default = function(flag, value, errors, helpers$8) {
 		const { schema: schema$2, state, prefs } = helpers$8;
 		const source = schema$2._flags[flag];
 		if (prefs.noDefaults || source === void 0) return value;
@@ -4909,13 +4976,13 @@ var require_validator = __commonJSMin((exports) => {
 		if (Common$17.isResolvable(source)) return source.resolve(value, state, prefs);
 		return clone$11(source);
 	};
-	internals$18.trim = function(value, schema$2) {
+	internals$17.trim = function(value, schema$2) {
 		if (typeof value !== "string") return value;
 		const trim = schema$2.$_getRule("trim");
 		if (!trim || !trim.args.enabled) return value;
 		return value.trim();
 	};
-	internals$18.ignore = {
+	internals$17.ignore = {
 		active: false,
 		debug: ignore,
 		entry: ignore,
@@ -4924,7 +4991,7 @@ var require_validator = __commonJSMin((exports) => {
 		resolve: ignore,
 		value: ignore
 	};
-	internals$18.errorsArray = function() {
+	internals$17.errorsArray = function() {
 		const errors = [];
 		errors[Common$17.symbols.errors] = true;
 		return errors;
@@ -4933,12 +5000,12 @@ var require_validator = __commonJSMin((exports) => {
 var require_values$1 = __commonJSMin((exports, module) => {
 	const { assert: assert$43, deepEqual: deepEqual$2 } = require_lib$4();
 	const Common$16 = require_common$3();
-	const internals$17 = {};
-	module.exports = internals$17.Values = class {
+	const internals$16 = {};
+	module.exports = internals$16.Values = class {
 		constructor(values$3, refs) {
 			this._values = new Set(values$3);
 			this._refs = new Set(refs);
-			this._lowercase = internals$17.lowercases(values$3);
+			this._lowercase = internals$16.lowercases(values$3);
 			this._override = false;
 		}
 		get length() {
@@ -4958,7 +5025,7 @@ var require_values$1 = __commonJSMin((exports, module) => {
 			}
 		}
 		static merge(target, source, remove$1) {
-			target = target || new internals$17.Values();
+			target = target || new internals$16.Values();
 			if (source) {
 				if (source._override) return source.clone();
 				for (const item of [...source._values, ...source._refs]) target.add(item);
@@ -5019,13 +5086,13 @@ var require_values$1 = __commonJSMin((exports, module) => {
 			return Array.from([...this._values, ...this._refs]);
 		}
 		clone() {
-			const set = new internals$17.Values(this._values, this._refs);
+			const set = new internals$16.Values(this._values, this._refs);
 			set._override = this._override;
 			return set;
 		}
 		concat(source) {
 			assert$43(!source._override, "Cannot concat override set of values");
-			const set = new internals$17.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
+			const set = new internals$16.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
 			set._override = this._override;
 			return set;
 		}
@@ -5037,9 +5104,9 @@ var require_values$1 = __commonJSMin((exports, module) => {
 			return normalized;
 		}
 	};
-	internals$17.Values.prototype[Common$16.symbols.values] = true;
-	internals$17.Values.prototype.slice = internals$17.Values.prototype.clone;
-	internals$17.lowercases = function(from$2) {
+	internals$16.Values.prototype[Common$16.symbols.values] = true;
+	internals$16.Values.prototype.slice = internals$16.Values.prototype.clone;
+	internals$16.lowercases = function(from$2) {
 		const map$8 = new Map();
 		if (from$2) {
 			for (const value of from$2) if (typeof value === "string") map$8.set(value.toLowerCase(), value);
@@ -5051,18 +5118,18 @@ var require_base$2 = __commonJSMin((exports, module) => {
 	const { assert: assert$42, clone: clone$10, deepEqual: deepEqual$1, merge: merge$2 } = require_lib$4();
 	const Cache$2 = require_cache();
 	const Common$15 = require_common$3();
-	const Compile$5 = (init_compile(), __toCommonJS(compile_exports));
+	const Compile$6 = require_compile$1();
 	const Errors$5 = require_errors$2();
 	const Extend$2 = require_extend$1();
 	const Manifest$2 = require_manifest();
-	const Messages$5 = require_messages();
+	const Messages$4 = require_messages();
 	const Modify = require_modify();
 	const Ref$8 = require_ref$2();
 	const Trace$2 = require_trace();
 	const Validator = require_validator();
 	const Values$1 = require_values$1();
-	const internals$16 = {};
-	internals$16.Base = class {
+	const internals$15 = {};
+	internals$15.Base = class {
 		constructor(type) {
 			this.type = type;
 			this.$_root = null;
@@ -5248,7 +5315,7 @@ var require_base$2 = __commonJSMin((exports, module) => {
 		when(condition, options) {
 			const obj = this.clone();
 			if (!obj.$_terms.whens) obj.$_terms.whens = [];
-			const when = Compile$5.when(obj, condition, options);
+			const when = Compile$6.when(obj, condition, options);
 			if (!["any", "link"].includes(obj.type)) {
 				const conditions = when.is ? [when] : when.switch;
 				for (const item of conditions) {
@@ -5456,11 +5523,11 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			return obj;
 		}
 		$_compile(schema$2, options) {
-			return Compile$5.schema(this.$_root, schema$2, options);
+			return Compile$6.schema(this.$_root, schema$2, options);
 		}
 		$_createError(code$1, value, local, state, prefs, options = {}) {
 			const flags = options.flags !== false ? this._flags : {};
-			const messages$3 = options.messages ? Messages$5.merge(this._definition.messages, options.messages) : this._definition.messages;
+			const messages$3 = options.messages ? Messages$4.merge(this._definition.messages, options.messages) : this._definition.messages;
 			return new Errors$5.Report(code$1, value, local, flags, messages$3, state, prefs);
 		}
 		$_getFlag(name$3) {
@@ -5710,225 +5777,25 @@ var require_base$2 = __commonJSMin((exports, module) => {
 			};
 		}
 	};
-	internals$16.Base.prototype[Common$15.symbols.any] = {
+	internals$15.Base.prototype[Common$15.symbols.any] = {
 		version: Common$15.version,
-		compile: Compile$5.compile,
+		compile: Compile$6.compile,
 		root: "$_root"
 	};
-	internals$16.Base.prototype.isImmutable = true;
-	internals$16.Base.prototype.deny = internals$16.Base.prototype.invalid;
-	internals$16.Base.prototype.disallow = internals$16.Base.prototype.invalid;
-	internals$16.Base.prototype.equal = internals$16.Base.prototype.valid;
-	internals$16.Base.prototype.exist = internals$16.Base.prototype.required;
-	internals$16.Base.prototype.not = internals$16.Base.prototype.invalid;
-	internals$16.Base.prototype.options = internals$16.Base.prototype.prefs;
-	internals$16.Base.prototype.preferences = internals$16.Base.prototype.prefs;
-	module.exports = new internals$16.Base();
-});
-var package_exports$1 = {};
-__export(package_exports$1, {
-	browser: () => browser,
-	default: () => package_default$1,
-	dependencies: () => dependencies$1,
-	description: () => description$1,
-	devDependencies: () => devDependencies$1,
-	engines: () => engines,
-	files: () => files$1,
-	keywords: () => keywords$1,
-	license: () => license$1,
-	main: () => main$1,
-	name: () => name$2,
-	repository: () => repository$1,
-	scripts: () => scripts$1,
-	types: () => types,
-	version: () => version$3
-});
-var name$2, description$1, version$3, repository$1, engines, main$1, types, browser, files$1, keywords$1, dependencies$1, devDependencies$1, scripts$1, license$1, package_default$1;
-var init_package$1 = __esmMin(() => {
-	name$2 = "joi";
-	description$1 = "Object schema validation";
-	version$3 = "18.0.2";
-	repository$1 = {
-		"url": "git://github.com/hapijs/joi",
-		"type": "git"
-	};
-	engines = { "node": ">= 20" };
-	main$1 = "lib/index.js";
-	types = "lib/index.d.ts";
-	browser = "dist/joi-browser.min.js";
-	files$1 = ["lib/**/*", "dist/*"];
-	keywords$1 = ["schema", "validation"];
-	dependencies$1 = {
-		"@hapi/address": "^5.1.1",
-		"@hapi/formula": "^3.0.2",
-		"@hapi/hoek": "^11.0.7",
-		"@hapi/pinpoint": "^2.0.1",
-		"@hapi/tlds": "^1.1.1",
-		"@hapi/topo": "^6.0.2",
-		"@standard-schema/spec": "^1.0.0"
-	};
-	devDependencies$1 = {
-		"@hapi/bourne": "^3.0.0",
-		"@hapi/code": "^9.0.3",
-		"@hapi/eslint-plugin": "^7.0.0",
-		"@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x",
-		"@hapi/lab": "^26.0.0",
-		"@types/node": "^20.17.47",
-		"typescript": "^5.8.3"
-	};
-	scripts$1 = {
-		"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$1 = "BSD-3-Clause";
-	package_default$1 = {
-		name: name$2,
-		description: description$1,
-		version: version$3,
-		repository: repository$1,
-		engines,
-		main: main$1,
-		types,
-		browser,
-		files: files$1,
-		keywords: keywords$1,
-		dependencies: dependencies$1,
-		devDependencies: devDependencies$1,
-		scripts: scripts$1,
-		license: license$1
-	};
-});
-var require_common$4 = __commonJSMin((exports) => {
-	const { assert: Assert$1, AssertError: AssertError$1 } = require_lib$4();
-	const Pkg = (init_package$1(), __toCommonJS(package_exports$1).default);
-	let Messages$4;
-	let Schemas$3;
-	const internals$15 = { isoDate: /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/ };
-	exports.version = Pkg.version;
-	exports.defaults = {
-		abortEarly: true,
-		allowUnknown: false,
-		artifacts: false,
-		cache: true,
-		context: null,
-		convert: true,
-		dateFormat: "iso",
-		errors: {
-			escapeHtml: false,
-			label: "path",
-			language: null,
-			render: true,
-			stack: false,
-			wrap: {
-				label: "\"",
-				array: "[]"
-			}
-		},
-		externals: true,
-		messages: {},
-		nonEnumerables: false,
-		noDefaults: false,
-		presence: "optional",
-		skipFunctions: false,
-		stripUnknown: false,
-		warnings: false
-	};
-	exports.symbols = {
-		any: Symbol.for("@hapi/joi/schema"),
-		arraySingle: Symbol("arraySingle"),
-		deepDefault: Symbol("deepDefault"),
-		errors: Symbol("errors"),
-		literal: Symbol("literal"),
-		override: Symbol("override"),
-		parent: Symbol("parent"),
-		prefs: Symbol("prefs"),
-		ref: Symbol("ref"),
-		template: Symbol("template"),
-		values: Symbol("values")
-	};
-	exports.assertOptions = function(options, keys$10, name$3 = "Options") {
-		Assert$1(options && typeof options === "object" && !Array.isArray(options), "Options must be of type object");
-		const unknownKeys = Object.keys(options).filter((k) => !keys$10.includes(k));
-		Assert$1(unknownKeys.length === 0, `${name$3} contain unknown keys: ${unknownKeys}`);
-	};
-	exports.checkPreferences = function(prefs) {
-		Schemas$3 = Schemas$3 || require_schemas();
-		const result = Schemas$3.preferences.validate(prefs);
-		if (result.error) throw new AssertError$1([result.error.details[0].message]);
-	};
-	exports.compare = function(a$2, b, operator$1) {
-		switch (operator$1) {
-			case "=": return a$2 === b;
-			case ">": return a$2 > b;
-			case "<": return a$2 < b;
-			case ">=": return a$2 >= b;
-			case "<=": return a$2 <= b;
-		}
-	};
-	exports.default = function(value, defaultValue) {
-		return value === void 0 ? defaultValue : value;
-	};
-	exports.isIsoDate = function(date) {
-		return internals$15.isoDate.test(date);
-	};
-	exports.isNumber = function(value) {
-		return typeof value === "number" && !isNaN(value);
-	};
-	exports.isResolvable = function(obj) {
-		if (!obj) return false;
-		return obj[exports.symbols.ref] || obj[exports.symbols.template];
-	};
-	exports.isSchema = function(schema$2, options = {}) {
-		const any = schema$2 && schema$2[exports.symbols.any];
-		if (!any) return false;
-		Assert$1(options.legacy || any.version === exports.version, "Cannot mix different versions of joi schemas");
-		return true;
-	};
-	exports.isValues = function(obj) {
-		return obj[exports.symbols.values];
-	};
-	exports.limit = function(value) {
-		return Number.isSafeInteger(value) && value >= 0;
-	};
-	exports.preferences = function(target, source) {
-		Messages$4 = Messages$4 || require_messages();
-		target = target || {};
-		source = source || {};
-		const merged = Object.assign({}, target, source);
-		if (source.errors && target.errors) {
-			merged.errors = Object.assign({}, target.errors, source.errors);
-			merged.errors.wrap = Object.assign({}, target.errors.wrap, source.errors.wrap);
-		}
-		if (source.messages) merged.messages = Messages$4.compile(source.messages, target.messages);
-		delete merged[exports.symbols.prefs];
-		return merged;
-	};
-	exports.tryWithPath = function(fn$1, key, options = {}) {
-		try {
-			return fn$1();
-		} catch (err) {
-			if (err.path !== void 0) err.path = key + "." + err.path;
-			else err.path = key;
-			if (options.append) err.message = `${err.message} (${err.path})`;
-			throw err;
-		}
-	};
-	exports.validateArg = function(value, label, { assert: assert$55, message }) {
-		if (exports.isSchema(assert$55)) {
-			const result = assert$55.validate(value);
-			if (!result.error) return;
-			return result.error.message;
-		} else if (!assert$55(value)) return label ? `${label} ${message}` : message;
-	};
-	exports.verifyFlat = function(args$1, method$1) {
-		for (const arg of args$1) Assert$1(!Array.isArray(arg), "Method no longer accepts array arguments:", method$1);
-	};
+	internals$15.Base.prototype.isImmutable = true;
+	internals$15.Base.prototype.deny = internals$15.Base.prototype.invalid;
+	internals$15.Base.prototype.disallow = internals$15.Base.prototype.invalid;
+	internals$15.Base.prototype.equal = internals$15.Base.prototype.valid;
+	internals$15.Base.prototype.exist = internals$15.Base.prototype.required;
+	internals$15.Base.prototype.not = internals$15.Base.prototype.invalid;
+	internals$15.Base.prototype.options = internals$15.Base.prototype.prefs;
+	internals$15.Base.prototype.preferences = internals$15.Base.prototype.prefs;
+	module.exports = new internals$15.Base();
 });
 var require_any = __commonJSMin((exports, module) => {
 	const { assert: assert$41 } = require_lib$4();
 	const Base$3 = require_base$2();
-	const Common$14 = require_common$4();
+	const Common$14 = require_common$3();
 	const Messages$3 = require_messages();
 	module.exports = Base$3.extend({
 		type: "any",
@@ -6236,8 +6103,8 @@ var require_compile = __commonJSMin((exports) => {
 var require_alternatives = __commonJSMin((exports, module) => {
 	const { assert: assert$39, merge: merge$1 } = require_lib$4();
 	const Any$9 = require_any();
-	const Common$12 = require_common$4();
-	const Compile$4 = require_compile();
+	const Common$12 = require_common$3();
+	const Compile$5 = require_compile();
 	const Errors$4 = require_errors$2();
 	const Ref$6 = require_ref$2();
 	const internals$13 = {};
@@ -6325,7 +6192,7 @@ var require_alternatives = __commonJSMin((exports, module) => {
 				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$4.when(obj, condition, options);
+				const match$2 = Compile$5.when(obj, condition, options);
 				const conditions = match$2.is ? [match$2] : match$2.switch;
 				for (const item of conditions) if (item.then && item.otherwise) {
 					obj.$_setFlag("_endedSwitch", true, { clone: false });
@@ -6446,8 +6313,8 @@ var require_alternatives = __commonJSMin((exports, module) => {
 var require_array = __commonJSMin((exports, module) => {
 	const { assert: assert$38, deepEqual, reach } = require_lib$4();
 	const Any$8 = require_any();
-	const Common$11 = require_common$4();
-	const Compile$3 = require_compile();
+	const Common$11 = require_common$3();
+	const Compile$4 = require_compile();
 	const internals$12 = {};
 	module.exports = Any$8.extend({
 		type: "array",
@@ -6748,7 +6615,7 @@ var require_array = __commonJSMin((exports, module) => {
 					Common$11.assertOptions(options, ["by", "order"]);
 					const settings = { order: options.order || "ascending" };
 					if (options.by) {
-						settings.by = Compile$3.ref(options.by, { ancestor: 0 });
+						settings.by = Compile$4.ref(options.by, { ancestor: 0 });
 						assert$38(!settings.by.ancestor, "Cannot sort by ancestor");
 					}
 					return this.$_addRule({
@@ -6975,7 +6842,7 @@ var require_array = __commonJSMin((exports, module) => {
 var require_boolean = __commonJSMin((exports, module) => {
 	const { assert: assert$37 } = require_lib$4();
 	const Any$7 = require_any();
-	const Common$10 = require_common$4();
+	const Common$10 = require_common$3();
 	const Values = require_values$1();
 	const internals$11 = {};
 	internals$11.isBool = function(value) {
@@ -7062,7 +6929,7 @@ var require_boolean = __commonJSMin((exports, module) => {
 var require_date = __commonJSMin((exports, module) => {
 	const { assert: assert$36 } = require_lib$4();
 	const Any$6 = require_any();
-	const Common$9 = require_common$4();
+	const Common$9 = require_common$3();
 	const Template$4 = require_template();
 	const internals$10 = {};
 	internals$10.isDate = function(value) {
@@ -7333,8 +7200,8 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 	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$4();
-	const Compile$2 = require_compile();
+	const Common$8 = require_common$3();
+	const Compile$3 = require_compile();
 	const Errors$3 = require_errors$2();
 	const Ref$5 = require_ref$2();
 	const Template$3 = require_template();
@@ -7430,7 +7297,7 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 			} },
 			assert: {
 				method(subject, schema$2, message) {
-					if (!Template$3.isTemplate(subject)) subject = Compile$2.ref(subject);
+					if (!Template$3.isTemplate(subject)) subject = Compile$3.ref(subject);
 					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({
@@ -7725,13 +7592,13 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 		const paths = [];
 		for (const peer of peers) {
 			assert$34(typeof peer === "string", rel, "peers must be strings");
-			paths.push(Compile$2.ref(peer, {
+			paths.push(Compile$3.ref(peer, {
 				separator,
 				ancestor: 0,
 				prefix: false
 			}));
 		}
-		if (key !== null) key = Compile$2.ref(key, {
+		if (key !== null) key = Compile$3.ref(key, {
 			separator,
 			ancestor: 0,
 			prefix: false
@@ -8087,8 +7954,8 @@ var require_function = __commonJSMin((exports, module) => {
 var require_link = __commonJSMin((exports, module) => {
 	const { assert: assert$32 } = require_lib$4();
 	const Any$4 = require_any();
-	const Common$7 = require_common$4();
-	const Compile$1 = require_compile();
+	const Common$7 = require_common$3();
+	const Compile$2 = require_compile();
 	const Errors$2 = require_errors$2();
 	const internals$7 = {};
 	module.exports = Any$4.extend({
@@ -8114,7 +7981,7 @@ var require_link = __commonJSMin((exports, module) => {
 		rules: {
 			ref: { method(ref) {
 				assert$32(!this.$_terms.link, "Cannot reinitialize schema");
-				ref = Compile$1.ref(ref);
+				ref = Compile$2.ref(ref);
 				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();
@@ -8191,7 +8058,7 @@ var require_link = __commonJSMin((exports, module) => {
 var require_number = __commonJSMin((exports, module) => {
 	const { assert: assert$31 } = require_lib$4();
 	const Any$3 = require_any();
-	const Common$6 = require_common$4();
+	const Common$6 = require_common$3();
 	const internals$6 = {
 		numberRx: /^\s*[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:e([+-]?\d+))?\s*$/i,
 		precisionRx: /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/,
@@ -12478,7 +12345,7 @@ var require_string$1 = __commonJSMin((exports, module) => {
 	const { isDomainValid, isEmailValid, ipRegex, uriRegex } = (init_esm(), __toCommonJS(esm_exports));
 	const Tlds = require_commonjs();
 	const Any$2 = require_any();
-	const Common$5 = require_common$4();
+	const Common$5 = require_common$3();
 	const internals$5 = {
 		tlds: Tlds.tlds instanceof Set ? { tlds: {
 			allow: Tlds.tlds,
@@ -13195,7 +13062,7 @@ var require_binary = __commonJSMin((exports, module) => {
 	init_dist$1();
 	const { assert: assert$26 } = require_lib$4();
 	const Any = require_any();
-	const Common$4 = require_common$4();
+	const Common$4 = require_common$3();
 	module.exports = Any.extend({
 		type: "binary",
 		coerce: {
@@ -13276,7 +13143,7 @@ var require_lib = __commonJSMin((exports, module) => {
 	const { assert: assert$25, clone: clone$9 } = require_lib$4();
 	const Cache$1 = require_cache();
 	const Common$3 = require_common$3();
-	const Compile = (init_compile(), __toCommonJS(compile_exports));
+	const Compile$1 = require_compile$1();
 	const Errors$1 = require_errors$2();
 	const Extend$1 = require_extend$1();
 	const Manifest$1 = require_manifest();
@@ -13363,7 +13230,7 @@ var require_lib = __commonJSMin((exports, module) => {
 			Common$3.checkPreferences(prefs);
 		},
 		compile(schema$2, options) {
-			return Compile.compile(this, schema$2, options);
+			return Compile$1.compile(this, schema$2, options);
 		},
 		defaults(modifier) {
 			assert$25(typeof modifier === "function", "modifier must be a function");
@@ -13665,16 +13532,14 @@ var require_schemas = __commonJSMin((exports) => {
 		link: internals$2.desc.ref
 	}).pattern(/^[a-z]\w*$/, Joi$1.any());
 });
-var require_common$3 = __commonJSMin((exports, module) => {
-	var import_messages$2 = __toESM(require_messages());
-	var import_schemas$1 = __toESM(require_schemas());
-	init_lib();
+var require_common$3 = __commonJSMin((exports) => {
+	const { assert: Assert, AssertError } = require_lib$4();
+	const Pkg = (init_package$1(), __toCommonJS(package_exports$1).default);
 	let Messages$2;
 	let Schemas$1;
 	const internals$1 = { isoDate: /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/ };
-	const exports$1 = {};
-	exports$1.version = "2.20251203.0";
-	exports$1.defaults = {
+	exports.version = Pkg.version;
+	exports.defaults = {
 		abortEarly: true,
 		allowUnknown: false,
 		artifacts: false,
@@ -13702,7 +13567,7 @@ var require_common$3 = __commonJSMin((exports, module) => {
 		stripUnknown: false,
 		warnings: false
 	};
-	exports$1.symbols = {
+	exports.symbols = {
 		any: Symbol.for("@hapi/joi/schema"),
 		arraySingle: Symbol("arraySingle"),
 		deepDefault: Symbol("deepDefault"),
@@ -13713,20 +13578,19 @@ var require_common$3 = __commonJSMin((exports, module) => {
 		prefs: Symbol("prefs"),
 		ref: Symbol("ref"),
 		template: Symbol("template"),
-		values: Symbol("values"),
-		override: Symbol("override")
+		values: Symbol("values")
 	};
-	exports$1.assertOptions = function(options, keys$10, name$3 = "Options") {
-		(0, import_assert.default)(options && typeof options === "object" && !Array.isArray(options), "Options must be of type object");
+	exports.assertOptions = function(options, keys$10, name$3 = "Options") {
+		Assert(options && typeof options === "object" && !Array.isArray(options), "Options must be of type object");
 		const unknownKeys = Object.keys(options).filter((k) => !keys$10.includes(k));
-		(0, import_assert.default)(unknownKeys.length === 0, `${name$3} contain unknown keys: ${unknownKeys}`);
+		Assert(unknownKeys.length === 0, `${name$3} contain unknown keys: ${unknownKeys}`);
 	};
-	exports$1.checkPreferences = function(prefs) {
-		Schemas$1 = Schemas$1 || import_schemas$1.default;
+	exports.checkPreferences = function(prefs) {
+		Schemas$1 = Schemas$1 || require_schemas();
 		const result = Schemas$1.preferences.validate(prefs);
-		if (result.error) throw new import_assertError.default([result.error.details[0].message]);
+		if (result.error) throw new AssertError([result.error.details[0].message]);
 	};
-	exports$1.compare = function(a$2, b, operator$1) {
+	exports.compare = function(a$2, b, operator$1) {
 		switch (operator$1) {
 			case "=": return a$2 === b;
 			case ">": return a$2 > b;
@@ -13735,32 +13599,32 @@ var require_common$3 = __commonJSMin((exports, module) => {
 			case "<=": return a$2 <= b;
 		}
 	};
-	exports$1.default = function(value, defaultValue) {
+	exports.default = function(value, defaultValue) {
 		return value === void 0 ? defaultValue : value;
 	};
-	exports$1.isIsoDate = function(date) {
+	exports.isIsoDate = function(date) {
 		return internals$1.isoDate.test(date);
 	};
-	exports$1.isNumber = function(value) {
+	exports.isNumber = function(value) {
 		return typeof value === "number" && !isNaN(value);
 	};
-	exports$1.isResolvable = function(obj) {
+	exports.isResolvable = function(obj) {
 		if (!obj) return false;
-		return obj[exports$1.symbols.ref] || obj[exports$1.symbols.template];
+		return obj[exports.symbols.ref] || obj[exports.symbols.template];
 	};
-	exports$1.isSchema = function(schema$2, options = {}) {
-		const any = schema$2 && schema$2[exports$1.symbols.any];
+	exports.isSchema = function(schema$2, options = {}) {
+		const any = schema$2 && schema$2[exports.symbols.any];
 		if (!any) return false;
 		return true;
 	};
-	exports$1.isValues = function(obj) {
-		return obj[exports$1.symbols.values];
+	exports.isValues = function(obj) {
+		return obj[exports.symbols.values];
 	};
-	exports$1.limit = function(value) {
+	exports.limit = function(value) {
 		return Number.isSafeInteger(value) && value >= 0;
 	};
-	exports$1.preferences = function(target, source) {
-		Messages$2 = Messages$2 || import_messages$2.default;
+	exports.preferences = function(target, source) {
+		Messages$2 = Messages$2 || require_messages();
 		target = target || {};
 		source = source || {};
 		const merged = Object.assign({}, target, source);
@@ -13769,10 +13633,10 @@ var require_common$3 = __commonJSMin((exports, module) => {
 			merged.errors.wrap = Object.assign({}, target.errors.wrap, source.errors.wrap);
 		}
 		if (source.messages) merged.messages = Messages$2.compile(source.messages, target.messages);
-		delete merged[exports$1.symbols.prefs];
+		delete merged[exports.symbols.prefs];
 		return merged;
 	};
-	exports$1.tryWithPath = function(fn$1, key, options = {}) {
+	exports.tryWithPath = function(fn$1, key, options = {}) {
 		try {
 			return fn$1();
 		} catch (err) {
@@ -13782,17 +13646,16 @@ var require_common$3 = __commonJSMin((exports, module) => {
 			throw err;
 		}
 	};
-	exports$1.validateArg = function(value, label, { assert: assert$55, message }) {
-		if (exports$1.isSchema(assert$55)) {
+	exports.validateArg = function(value, label, { assert: assert$55, message }) {
+		if (exports.isSchema(assert$55)) {
 			const result = assert$55.validate(value);
 			if (!result.error) return;
 			return result.error.message;
 		} else if (!assert$55(value)) return label ? `${label} ${message}` : message;
 	};
-	exports$1.verifyFlat = function(args$1, method$1) {
-		for (const arg of args$1) (0, import_assert.default)(!Array.isArray(arg), "Method no longer accepts array arguments:", method$1);
+	exports.verifyFlat = function(args$1, method$1) {
+		for (const arg of args$1) Assert(!Array.isArray(arg), "Method no longer accepts array arguments:", method$1);
 	};
-	module.exports = exports$1;
 });
 var require_annotate = __commonJSMin((exports) => {
 	const { clone: clone$8 } = require_lib$4();
@@ -33089,7 +32952,7 @@ var init_package = __esmMin(() => {
 	};
 });
 var require_bn$1 = __commonJSMin((exports, module) => {
-	(function(module$1, exports$4) {
+	(function(module$1, exports$1) {
 		"use strict";
 		function assert$55(val, msg) {
 			if (!val) throw new Error(msg || "Assertion failed");
@@ -33116,7 +32979,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			}
 		}
 		if (typeof module$1 === "object") module$1.exports = BN$14;
-		else exports$4.BN = BN$14;
+		else exports$1.BN = BN$14;
 		BN$14.BN = BN$14;
 		BN$14.wordSize = 26;
 		var Buffer$27;
@@ -41229,7 +41092,7 @@ var require_withPublic = __commonJSMin((exports, module) => {
 	module.exports = withPublic$2;
 });
 var require_bn = __commonJSMin((exports, module) => {
-	(function(module$1, exports$4) {
+	(function(module$1, exports$1) {
 		"use strict";
 		function assert$55(val, msg) {
 			if (!val) throw new Error(msg || "Assertion failed");
@@ -41256,7 +41119,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			}
 		}
 		if (typeof module$1 === "object") module$1.exports = BN$14;
-		else exports$4.BN = BN$14;
+		else exports$1.BN = BN$14;
 		BN$14.BN = BN$14;
 		BN$14.wordSize = 26;
 		var Buffer$27;
@@ -45975,7 +45838,7 @@ var import_trace = __toESM(require_trace());
 var import_common = __toESM(require_common$3());
 var import_errors = __toESM(require_errors$2());
 var import_extend = __toESM(require_extend$1());
-init_compile();
+var import_compile = __toESM(require_compile$1());
 var import_schemas = __toESM(require_schemas());
 var import_manifest = __toESM(require_manifest());
 var import_template = __toESM(require_template());
@@ -46015,7 +45878,7 @@ var RootFactory = class RootFactory {
 	static assertValue(value, schema$2, annotate, args$1) {
 		const message = args$1[0] instanceof Error || typeof args$1[0] === "string" ? args$1[0] : null;
 		const options = message !== null ? args$1[1] : args$1[0];
-		const result = schema$2.validate(value, import_common.default.preferences({ errors: { stack: true } }, options || {}));
+		const result = schema$2.validate(value, import_common.preferences({ errors: { stack: true } }, options || {}));
 		let error = result.error;
 		if (!error) return result.value;
 		if (message instanceof Error) throw message;
@@ -46044,7 +45907,7 @@ var RootFactory = class RootFactory {
 	static getMethods() {
 		return {
 			ValidationError: import_errors.ValidationError,
-			version: import_common.default.version,
+			version: import_common.version,
 			cache: import_cache.provider,
 			assert(value, schema$2, ...args$1) {
 				RootFactory.assertValue(value, schema$2, true, args$1);
@@ -46053,21 +45916,21 @@ var RootFactory = class RootFactory {
 				return RootFactory.assertValue(value, schema$2, false, args$1);
 			},
 			build(desc$1) {
-				(0, import_assert.default)(typeof import_manifest.default.build === "function", "Manifest functionality disabled");
-				return import_manifest.default.build(this, desc$1);
+				(0, import_assert.default)(typeof import_manifest.build === "function", "Manifest functionality disabled");
+				return import_manifest.build(this, desc$1);
 			},
 			checkPreferences(prefs) {
-				import_common.default.checkPreferences(prefs);
+				import_common.checkPreferences(prefs);
 			},
 			compile(schema$2, options) {
-				return compile_default.compile(this, schema$2, options);
+				return import_compile.compile(this, schema$2, options);
 			},
 			defaults(modifier) {
 				(0, import_assert.default)(typeof modifier === "function", "modifier must be a function");
 				const joi$1 = { ...this };
 				for (const type of joi$1._types) {
 					const schema$2 = modifier(joi$1[type]());
-					(0, import_assert.default)(import_common.default.isSchema(schema$2), "modifier must return a valid schema object");
+					(0, import_assert.default)(import_common.isSchema(schema$2), "modifier must return a valid schema object");
 					joi$1[type] = function(...args$1) {
 						return RootFactory.generate(this, schema$2, args$1);
 					};
@@ -46078,7 +45941,7 @@ var RootFactory = class RootFactory {
 				return new import_template.default(...args$1);
 			},
 			extend(...extensions) {
-				import_common.default.verifyFlat(extensions, "extend");
+				import_common.verifyFlat(extensions, "extend");
 				(0, import_assert.default)(extensions.length, "You need to provide at least one extension");
 				this.assert(extensions, import_schemas.extensions);
 				const joi$1 = { ...this };
@@ -46102,11 +45965,11 @@ var RootFactory = class RootFactory {
 			isError: import_errors.ValidationError.isError,
 			isExpression: import_template.default.isTemplate,
 			isRef: import_ref.isRef,
-			isSchema: import_common.default.isSchema,
+			isSchema: import_common.isSchema,
 			in(...args$1) {
 				return import_ref.in(...args$1);
 			},
-			override: import_common.default.symbols.override,
+			override: import_common.symbols.override,
 			ref(...args$1) {
 				return import_ref.create(...args$1);
 			},
@@ -52503,7 +52366,7 @@ var libphonenumber = { exports: {} };
 libphonenumber.exports;
 var hasRequiredLibphonenumber;
 function requireLibphonenumber() {
-	return hasRequiredLibphonenumber || (hasRequiredLibphonenumber = 1, function(module$1, exports$1$1) {
+	return hasRequiredLibphonenumber || (hasRequiredLibphonenumber = 1, function(module$1, exports$1) {
 		(function(t$7) {
 			module$1.exports = t$7();
 		})(function() {
@@ -52530,7 +52393,7 @@ function requireLibphonenumber() {
 					return u;
 				}
 				return t$7;
-			}()({ 1: [function(require$1, module$2, exports$1$2) {
+			}()({ 1: [function(require$1, module$2, exports$1$1) {
 				(function(global) {
 					(function() {
 						var $jscomp = $jscomp || {};
@@ -134337,7 +134200,7 @@ function requireLibphonenumber() {
 								return t$7 = o$2.replace(this.DIGIT_PATTERN_, t$7), this.formattingTemplate_.clear(), this.formattingTemplate_.append(t$7), this.lastMatchPosition_ = r$2, t$7.substring(0, this.lastMatchPosition_ + 1);
 							}
 							return this.possibleFormats_.length == 1 && (this.ableToFormat_ = !1), this.currentFormattingPattern_ = "", this.accruedInput_.toString();
-						}, Object.defineProperty(exports$1$2, "__esModule", { value: !0 }), exports$1$2.default = i18n$1.phonenumbers, module$2.exports = exports$1$2.default;
+						}, Object.defineProperty(exports$1$1, "__esModule", { value: !0 }), exports$1$1.default = i18n$1.phonenumbers, module$2.exports = exports$1$1.default;
 					}).call(this);
 				}).call(this, typeof commonjsGlobal < "u" ? commonjsGlobal : typeof self < "u" ? self : typeof window < "u" ? window : {});
 			}, {}] }, {}, [1])(1);
@@ -145090,7 +144953,7 @@ const encode = (schema$2, options = {}) => {
 	});
 	const flattened = flattie(sanitized);
 	return encode$1({
-		version: "2.20251203.0",
+		version: "2.20251203.1",
 		schema: flattened
 	});
 };
@@ -145107,9 +144970,9 @@ const decode = (base64, options = {}) => {
 	}
 	if (!isPlainObject(decoded) || !("version" in decoded) || !("schema" in decoded) || typeof decoded.version !== "string" || !isPlainObject(decoded.schema)) throw new TypeError("Not a valid encoded schema");
 	const { version: schemaVersion, schema: schema$2 } = decoded;
-	if (import_semver.valid("2.20251203.0")) {
+	if (import_semver.valid("2.20251203.1")) {
 		if (!import_semver.valid(import_semver.coerce(schemaVersion))) throw new TypeError(`Invalid schema version: ${schemaVersion}`);
-		if (import_semver.gt(import_semver.coerce(schemaVersion), "2.20251203.0")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 2.20251203.0`);
+		if (import_semver.gt(import_semver.coerce(schemaVersion), "2.20251203.1")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 2.20251203.1`);
 		if (import_semver.lt(import_semver.coerce(schemaVersion), "1.20251201.3") && import_semver.gt(import_semver.coerce(schemaVersion), "1.0.0")) throw new TypeError(`Legacy schema version ${schemaVersion} is unsupported due to encoding format changes`);
 	}
 	const description$2 = nestie(schema$2);
@@ -146576,7 +146439,7 @@ const ValidationError = import_lib$2.default.ValidationError;
 init_esm();
 var import_lib = __toESM(require_lib$3());
 var import_lib$1 = __toESM(require_lib$2());
-const version = "2.20251203.0";
+const version = "2.20251203.1";
 var location = import_lib$1.location;
 export { ValidationError, esm_exports as address, decode, encode, import_lib as formula, location, tlds, validator, version };