@nhtio/validation 0.1.0-master-cb87a6f9 → 0.1.0-master-952eca46

package/index.mjs

@@ -52,13 +52,13 @@ var require_stringify = __commonJSMin((exports, module) => {
 var require_assert$1 = __commonJSMin((exports, module) => {
 	const AssertError$2 = require_assertError();
 	const Stringify = require_stringify();
-	const assert$53 = module.exports = function(condition, ...args$1) {
+	const assert$54 = module.exports = function(condition, ...args$1) {
 		if (condition) return;
 		if (args$1.length === 1 && args$1[0] instanceof Error) throw args$1[0];
 		const msgs = args$1.filter((arg) => arg !== "").map((arg) => {
 			return typeof arg === "string" ? arg : arg instanceof Error ? arg.message : Stringify(arg);
 		});
-		throw new AssertError$2(msgs.join(" "), assert$53);
+		throw new AssertError$2(msgs.join(" "), assert$54);
 	};
 });
 var dist_exports = {};
@@ -250,14 +250,14 @@ var init_dist$1 = __esmMin(() => {
 		const base64 = base64Js$1;
 		const ieee754$1$1 = ieee754$1;
 		const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
-		exports$1.Buffer = Buffer$27;
+		exports$1.Buffer = Buffer$29;
 		exports$1.SlowBuffer = SlowBuffer$1;
 		exports$1.INSPECT_MAX_BYTES = 50;
 		const K_MAX_LENGTH = 2147483647;
 		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.");
+		Buffer$29.TYPED_ARRAY_SUPPORT = typedArraySupport();
+		if (!Buffer$29.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.");
 		function typedArraySupport() {
 			try {
 				const arr = new GlobalUint8Array(1);
@@ -271,34 +271,34 @@ var init_dist$1 = __esmMin(() => {
 				return false;
 			}
 		}
-		Object.defineProperty(Buffer$27.prototype, "parent", {
+		Object.defineProperty(Buffer$29.prototype, "parent", {
 			enumerable: true,
 			get: function() {
-				if (!Buffer$27.isBuffer(this)) return void 0;
+				if (!Buffer$29.isBuffer(this)) return void 0;
 				return this.buffer;
 			}
 		});
-		Object.defineProperty(Buffer$27.prototype, "offset", {
+		Object.defineProperty(Buffer$29.prototype, "offset", {
 			enumerable: true,
 			get: function() {
-				if (!Buffer$27.isBuffer(this)) return void 0;
+				if (!Buffer$29.isBuffer(this)) return void 0;
 				return this.byteOffset;
 			}
 		});
 		function createBuffer(length) {
 			if (length > K_MAX_LENGTH) throw new RangeError("The value \"" + length + "\" is invalid for option \"size\"");
 			const buf = new GlobalUint8Array(length);
-			Object.setPrototypeOf(buf, Buffer$27.prototype);
+			Object.setPrototypeOf(buf, Buffer$29.prototype);
 			return buf;
 		}
-		function Buffer$27(arg, encodingOrOffset, length) {
+		function Buffer$29(arg, encodingOrOffset, length) {
 			if (typeof arg === "number") {
 				if (typeof encodingOrOffset === "string") throw new TypeError("The \"string\" argument must be of type string. Received type number");
 				return allocUnsafe$1(arg);
 			}
 			return from$2(arg, encodingOrOffset, length);
 		}
-		Buffer$27.poolSize = 8192;
+		Buffer$29.poolSize = 8192;
 		function from$2(value, encodingOrOffset, length) {
 			if (typeof value === "string") return fromString(value, encodingOrOffset);
 			if (GlobalArrayBuffer.isView(value)) return fromArrayView(value);
@@ -307,17 +307,17 @@ var init_dist$1 = __esmMin(() => {
 			if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) return fromArrayBuffer(value, encodingOrOffset, length);
 			if (typeof value === "number") throw new TypeError("The \"value\" argument must not be of type number. Received type number");
 			const valueOf = value.valueOf && value.valueOf();
-			if (valueOf != null && valueOf !== value) return Buffer$27.from(valueOf, encodingOrOffset, length);
+			if (valueOf != null && valueOf !== value) return Buffer$29.from(valueOf, encodingOrOffset, length);
 			const b = fromObject(value);
 			if (b) return b;
-			if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") return Buffer$27.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+			if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") return Buffer$29.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
 			throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
 		}
-		Buffer$27.from = function(value, encodingOrOffset, length) {
+		Buffer$29.from = function(value, encodingOrOffset, length) {
 			return from$2(value, encodingOrOffset, length);
 		};
-		Object.setPrototypeOf(Buffer$27.prototype, GlobalUint8Array.prototype);
-		Object.setPrototypeOf(Buffer$27, GlobalUint8Array);
+		Object.setPrototypeOf(Buffer$29.prototype, GlobalUint8Array.prototype);
+		Object.setPrototypeOf(Buffer$29, GlobalUint8Array);
 		function assertSize$1(size) {
 			if (typeof size !== "number") throw new TypeError("\"size\" argument must be of type number");
 			else if (size < 0) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
@@ -328,22 +328,22 @@ var init_dist$1 = __esmMin(() => {
 			if (fill !== void 0) return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
 			return createBuffer(size);
 		}
-		Buffer$27.alloc = function(size, fill, encoding) {
+		Buffer$29.alloc = function(size, fill, encoding) {
 			return alloc(size, fill, encoding);
 		};
 		function allocUnsafe$1(size) {
 			assertSize$1(size);
 			return createBuffer(size < 0 ? 0 : checked(size) | 0);
 		}
-		Buffer$27.allocUnsafe = function(size) {
+		Buffer$29.allocUnsafe = function(size) {
 			return allocUnsafe$1(size);
 		};
-		Buffer$27.allocUnsafeSlow = function(size) {
+		Buffer$29.allocUnsafeSlow = function(size) {
 			return allocUnsafe$1(size);
 		};
 		function fromString(string, encoding) {
 			if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
-			if (!Buffer$27.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
+			if (!Buffer$29.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
 			const length = byteLength$2(string, encoding) | 0;
 			let buf = createBuffer(length);
 			const actual = buf.write(string, encoding);
@@ -370,11 +370,11 @@ var init_dist$1 = __esmMin(() => {
 			if (byteOffset === void 0 && length === void 0) buf = new GlobalUint8Array(array);
 			else if (length === void 0) buf = new GlobalUint8Array(array, byteOffset);
 			else buf = new GlobalUint8Array(array, byteOffset, length);
-			Object.setPrototypeOf(buf, Buffer$27.prototype);
+			Object.setPrototypeOf(buf, Buffer$29.prototype);
 			return buf;
 		}
 		function fromObject(obj) {
-			if (Buffer$27.isBuffer(obj)) {
+			if (Buffer$29.isBuffer(obj)) {
 				const len$2 = checked(obj.length) | 0;
 				const buf = createBuffer(len$2);
 				if (buf.length === 0) return buf;
@@ -393,15 +393,15 @@ var init_dist$1 = __esmMin(() => {
 		}
 		function SlowBuffer$1(length) {
 			if (+length != length) length = 0;
-			return Buffer$27.alloc(+length);
+			return Buffer$29.alloc(+length);
 		}
-		Buffer$27.isBuffer = function isBuffer$6(b) {
-			return b != null && b._isBuffer === true && b !== Buffer$27.prototype;
+		Buffer$29.isBuffer = function isBuffer$6(b) {
+			return b != null && b._isBuffer === true && b !== Buffer$29.prototype;
 		};
-		Buffer$27.compare = function compare$16(a$2, b) {
-			if (isInstance(a$2, GlobalUint8Array)) a$2 = Buffer$27.from(a$2, a$2.offset, a$2.byteLength);
-			if (isInstance(b, GlobalUint8Array)) b = Buffer$27.from(b, b.offset, b.byteLength);
-			if (!Buffer$27.isBuffer(a$2) || !Buffer$27.isBuffer(b)) throw new TypeError("The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array");
+		Buffer$29.compare = function compare$16(a$2, b) {
+			if (isInstance(a$2, GlobalUint8Array)) a$2 = Buffer$29.from(a$2, a$2.offset, a$2.byteLength);
+			if (isInstance(b, GlobalUint8Array)) b = Buffer$29.from(b, b.offset, b.byteLength);
+			if (!Buffer$29.isBuffer(a$2) || !Buffer$29.isBuffer(b)) throw new TypeError("The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array");
 			if (a$2 === b) return 0;
 			let x$1 = a$2.length;
 			let y$1 = b.length;
@@ -414,7 +414,7 @@ var init_dist$1 = __esmMin(() => {
 			if (y$1 < x$1) return 1;
 			return 0;
 		};
-		Buffer$27.isEncoding = function isEncoding$1(encoding) {
+		Buffer$29.isEncoding = function isEncoding$1(encoding) {
 			switch (String(encoding).toLowerCase()) {
 				case "hex":
 				case "utf8":
@@ -430,30 +430,30 @@ var init_dist$1 = __esmMin(() => {
 				default: return false;
 			}
 		};
-		Buffer$27.concat = function concat$1(list, length) {
+		Buffer$29.concat = function concat$1(list, length) {
 			if (!Array.isArray(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
-			if (list.length === 0) return Buffer$27.alloc(0);
+			if (list.length === 0) return Buffer$29.alloc(0);
 			let i$4;
 			if (length === void 0) {
 				length = 0;
 				for (i$4 = 0; i$4 < list.length; ++i$4) length += list[i$4].length;
 			}
-			const buffer$3 = Buffer$27.allocUnsafe(length);
+			const buffer$3 = Buffer$29.allocUnsafe(length);
 			let pos = 0;
 			for (i$4 = 0; i$4 < list.length; ++i$4) {
 				let buf = list[i$4];
 				if (isInstance(buf, GlobalUint8Array)) if (pos + buf.length > buffer$3.length) {
-					if (!Buffer$27.isBuffer(buf)) buf = Buffer$27.from(buf);
+					if (!Buffer$29.isBuffer(buf)) buf = Buffer$29.from(buf);
 					buf.copy(buffer$3, pos);
 				} else GlobalUint8Array.prototype.set.call(buffer$3, buf, pos);
-				else if (!Buffer$27.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
+				else if (!Buffer$29.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
 				else buf.copy(buffer$3, pos);
 				pos += buf.length;
 			}
 			return buffer$3;
 		};
 		function byteLength$2(string, encoding) {
-			if (Buffer$27.isBuffer(string)) return string.length;
+			if (Buffer$29.isBuffer(string)) return string.length;
 			if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) return string.byteLength;
 			if (typeof string !== "string") throw new TypeError("The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type " + typeof string);
 			const len$2 = string.length;
@@ -478,7 +478,7 @@ var init_dist$1 = __esmMin(() => {
 					loweredCase = true;
 			}
 		}
-		Buffer$27.byteLength = byteLength$2;
+		Buffer$29.byteLength = byteLength$2;
 		function slowToString(encoding, start, end) {
 			let loweredCase = false;
 			if (start === void 0 || start < 0) start = 0;
@@ -507,19 +507,19 @@ var init_dist$1 = __esmMin(() => {
 					loweredCase = true;
 			}
 		}
-		Buffer$27.prototype._isBuffer = true;
+		Buffer$29.prototype._isBuffer = true;
 		function swap(b, n$4, m$3) {
 			const i$4 = b[n$4];
 			b[n$4] = b[m$3];
 			b[m$3] = i$4;
 		}
-		Buffer$27.prototype.swap16 = function swap16() {
+		Buffer$29.prototype.swap16 = function swap16() {
 			const len$2 = this.length;
 			if (len$2 % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
 			for (let i$4 = 0; i$4 < len$2; i$4 += 2) swap(this, i$4, i$4 + 1);
 			return this;
 		};
-		Buffer$27.prototype.swap32 = function swap32() {
+		Buffer$29.prototype.swap32 = function swap32() {
 			const len$2 = this.length;
 			if (len$2 % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
 			for (let i$4 = 0; i$4 < len$2; i$4 += 4) {
@@ -528,7 +528,7 @@ var init_dist$1 = __esmMin(() => {
 			}
 			return this;
 		};
-		Buffer$27.prototype.swap64 = function swap64() {
+		Buffer$29.prototype.swap64 = function swap64() {
 			const len$2 = this.length;
 			if (len$2 % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
 			for (let i$4 = 0; i$4 < len$2; i$4 += 8) {
@@ -539,29 +539,29 @@ var init_dist$1 = __esmMin(() => {
 			}
 			return this;
 		};
-		Buffer$27.prototype.toString = function toString$4() {
+		Buffer$29.prototype.toString = function toString$4() {
 			const length = this.length;
 			if (length === 0) return "";
 			if (arguments.length === 0) return utf8Slice(this, 0, length);
 			return slowToString.apply(this, arguments);
 		};
-		Buffer$27.prototype.toLocaleString = Buffer$27.prototype.toString;
-		Buffer$27.prototype.equals = function equals(b) {
-			if (!Buffer$27.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+		Buffer$29.prototype.toLocaleString = Buffer$29.prototype.toString;
+		Buffer$29.prototype.equals = function equals(b) {
+			if (!Buffer$29.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
 			if (this === b) return true;
-			return Buffer$27.compare(this, b) === 0;
+			return Buffer$29.compare(this, b) === 0;
 		};
-		Buffer$27.prototype.inspect = function inspect$4() {
+		Buffer$29.prototype.inspect = function inspect$4() {
 			let str = "";
 			const max$3 = exports$1.INSPECT_MAX_BYTES;
 			str = this.toString("hex", 0, max$3).replace(/(.{2})/g, "$1 ").trim();
 			if (this.length > max$3) str += " ... ";
 			return "<Buffer " + str + ">";
 		};
-		if (customInspectSymbol) Buffer$27.prototype[customInspectSymbol] = Buffer$27.prototype.inspect;
-		Buffer$27.prototype.compare = function compare$16(target, start, end, thisStart, thisEnd) {
-			if (isInstance(target, GlobalUint8Array)) target = Buffer$27.from(target, target.offset, target.byteLength);
-			if (!Buffer$27.isBuffer(target)) throw new TypeError("The \"target\" argument must be one of type Buffer or Uint8Array. Received type " + typeof target);
+		if (customInspectSymbol) Buffer$29.prototype[customInspectSymbol] = Buffer$29.prototype.inspect;
+		Buffer$29.prototype.compare = function compare$16(target, start, end, thisStart, thisEnd) {
+			if (isInstance(target, GlobalUint8Array)) target = Buffer$29.from(target, target.offset, target.byteLength);
+			if (!Buffer$29.isBuffer(target)) throw new TypeError("The \"target\" argument must be one of type Buffer or Uint8Array. Received type " + typeof target);
 			if (start === void 0) start = 0;
 			if (end === void 0) end = target ? target.length : 0;
 			if (thisStart === void 0) thisStart = 0;
@@ -603,8 +603,8 @@ var init_dist$1 = __esmMin(() => {
 			else byteOffset = buffer$3.length - 1;
 			else if (byteOffset < 0) if (dir) byteOffset = 0;
 			else return -1;
-			if (typeof val === "string") val = Buffer$27.from(val, encoding);
-			if (Buffer$27.isBuffer(val)) {
+			if (typeof val === "string") val = Buffer$29.from(val, encoding);
+			if (Buffer$29.isBuffer(val)) {
 				if (val.length === 0) return -1;
 				return arrayIndexOf(buffer$3, val, byteOffset, encoding, dir);
 			} else if (typeof val === "number") {
@@ -656,13 +656,13 @@ var init_dist$1 = __esmMin(() => {
 			}
 			return -1;
 		}
-		Buffer$27.prototype.includes = function includes$2(val, byteOffset, encoding) {
+		Buffer$29.prototype.includes = function includes$2(val, byteOffset, encoding) {
 			return this.indexOf(val, byteOffset, encoding) !== -1;
 		};
-		Buffer$27.prototype.indexOf = function indexOf$3(val, byteOffset, encoding) {
+		Buffer$29.prototype.indexOf = function indexOf$3(val, byteOffset, encoding) {
 			return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
 		};
-		Buffer$27.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+		Buffer$29.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
 			return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
 		};
 		function hexWrite(buf, string, offset$2, length) {
@@ -695,7 +695,7 @@ var init_dist$1 = __esmMin(() => {
 		function ucs2Write(buf, string, offset$2, length) {
 			return blitBuffer(utf16leToBytes(string, buf.length - offset$2), buf, offset$2, length);
 		}
-		Buffer$27.prototype.write = function write(string, offset$2, length, encoding) {
+		Buffer$29.prototype.write = function write(string, offset$2, length, encoding) {
 			if (offset$2 === void 0) {
 				encoding = "utf8";
 				length = this.length;
@@ -737,7 +737,7 @@ var init_dist$1 = __esmMin(() => {
 					loweredCase = true;
 			}
 		};
-		Buffer$27.prototype.toJSON = function toJSON() {
+		Buffer$29.prototype.toJSON = function toJSON() {
 			return {
 				type: "Buffer",
 				data: Array.prototype.slice.call(this._arr || this, 0)
@@ -834,7 +834,7 @@ var init_dist$1 = __esmMin(() => {
 			for (let i$4 = 0; i$4 < bytes.length - 1; i$4 += 2) res += String.fromCharCode(bytes[i$4] + bytes[i$4 + 1] * 256);
 			return res;
 		}
-		Buffer$27.prototype.slice = function slice$1(start, end) {
+		Buffer$29.prototype.slice = function slice$1(start, end) {
 			const len$2 = this.length;
 			start = ~~start;
 			end = end === void 0 ? len$2 : ~~end;
@@ -848,14 +848,14 @@ var init_dist$1 = __esmMin(() => {
 			} else if (end > len$2) end = len$2;
 			if (end < start) end = start;
 			const newBuf = this.subarray(start, end);
-			Object.setPrototypeOf(newBuf, Buffer$27.prototype);
+			Object.setPrototypeOf(newBuf, Buffer$29.prototype);
 			return newBuf;
 		};
 		function checkOffset(offset$2, ext, length) {
 			if (offset$2 % 1 !== 0 || offset$2 < 0) throw new RangeError("offset is not uint");
 			if (offset$2 + ext > length) throw new RangeError("Trying to access beyond buffer length");
 		}
-		Buffer$27.prototype.readUintLE = Buffer$27.prototype.readUIntLE = function readUIntLE(offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.readUintLE = Buffer$29.prototype.readUIntLE = function readUIntLE(offset$2, byteLength$3, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			byteLength$3 = byteLength$3 >>> 0;
 			if (!noAssert) checkOffset(offset$2, byteLength$3, this.length);
@@ -865,7 +865,7 @@ var init_dist$1 = __esmMin(() => {
 			while (++i$4 < byteLength$3 && (mul *= 256)) val += this[offset$2 + i$4] * mul;
 			return val;
 		};
-		Buffer$27.prototype.readUintBE = Buffer$27.prototype.readUIntBE = function readUIntBE(offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.readUintBE = Buffer$29.prototype.readUIntBE = function readUIntBE(offset$2, byteLength$3, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			byteLength$3 = byteLength$3 >>> 0;
 			if (!noAssert) checkOffset(offset$2, byteLength$3, this.length);
@@ -874,32 +874,32 @@ var init_dist$1 = __esmMin(() => {
 			while (byteLength$3 > 0 && (mul *= 256)) val += this[offset$2 + --byteLength$3] * mul;
 			return val;
 		};
-		Buffer$27.prototype.readUint8 = Buffer$27.prototype.readUInt8 = function readUInt8(offset$2, noAssert) {
+		Buffer$29.prototype.readUint8 = Buffer$29.prototype.readUInt8 = function readUInt8(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 1, this.length);
 			return this[offset$2];
 		};
-		Buffer$27.prototype.readUint16LE = Buffer$27.prototype.readUInt16LE = function readUInt16LE(offset$2, noAssert) {
+		Buffer$29.prototype.readUint16LE = Buffer$29.prototype.readUInt16LE = function readUInt16LE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 2, this.length);
 			return this[offset$2] | this[offset$2 + 1] << 8;
 		};
-		Buffer$27.prototype.readUint16BE = Buffer$27.prototype.readUInt16BE = function readUInt16BE(offset$2, noAssert) {
+		Buffer$29.prototype.readUint16BE = Buffer$29.prototype.readUInt16BE = function readUInt16BE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 2, this.length);
 			return this[offset$2] << 8 | this[offset$2 + 1];
 		};
-		Buffer$27.prototype.readUint32LE = Buffer$27.prototype.readUInt32LE = function readUInt32LE(offset$2, noAssert) {
+		Buffer$29.prototype.readUint32LE = Buffer$29.prototype.readUInt32LE = function readUInt32LE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 4, this.length);
 			return (this[offset$2] | this[offset$2 + 1] << 8 | this[offset$2 + 2] << 16) + this[offset$2 + 3] * 16777216;
 		};
-		Buffer$27.prototype.readUint32BE = Buffer$27.prototype.readUInt32BE = function readUInt32BE(offset$2, noAssert) {
+		Buffer$29.prototype.readUint32BE = Buffer$29.prototype.readUInt32BE = function readUInt32BE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 4, this.length);
 			return this[offset$2] * 16777216 + (this[offset$2 + 1] << 16 | this[offset$2 + 2] << 8 | this[offset$2 + 3]);
 		};
-		Buffer$27.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset$2) {
+		Buffer$29.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset$2) {
 			offset$2 = offset$2 >>> 0;
 			validateNumber(offset$2, "offset");
 			const first$1 = this[offset$2];
@@ -909,7 +909,7 @@ var init_dist$1 = __esmMin(() => {
 			const hi = this[++offset$2] + this[++offset$2] * 2 ** 8 + this[++offset$2] * 2 ** 16 + last$2 * 2 ** 24;
 			return BigInt(lo) + (BigInt(hi) << BigInt(32));
 		});
-		Buffer$27.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset$2) {
+		Buffer$29.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset$2) {
 			offset$2 = offset$2 >>> 0;
 			validateNumber(offset$2, "offset");
 			const first$1 = this[offset$2];
@@ -919,7 +919,7 @@ var init_dist$1 = __esmMin(() => {
 			const lo = this[++offset$2] * 2 ** 24 + this[++offset$2] * 2 ** 16 + this[++offset$2] * 2 ** 8 + last$2;
 			return (BigInt(hi) << BigInt(32)) + BigInt(lo);
 		});
-		Buffer$27.prototype.readIntLE = function readIntLE(offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.readIntLE = function readIntLE(offset$2, byteLength$3, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			byteLength$3 = byteLength$3 >>> 0;
 			if (!noAssert) checkOffset(offset$2, byteLength$3, this.length);
@@ -931,7 +931,7 @@ var init_dist$1 = __esmMin(() => {
 			if (val >= mul) val -= Math.pow(2, 8 * byteLength$3);
 			return val;
 		};
-		Buffer$27.prototype.readIntBE = function readIntBE(offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.readIntBE = function readIntBE(offset$2, byteLength$3, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			byteLength$3 = byteLength$3 >>> 0;
 			if (!noAssert) checkOffset(offset$2, byteLength$3, this.length);
@@ -943,35 +943,35 @@ var init_dist$1 = __esmMin(() => {
 			if (val >= mul) val -= Math.pow(2, 8 * byteLength$3);
 			return val;
 		};
-		Buffer$27.prototype.readInt8 = function readInt8(offset$2, noAssert) {
+		Buffer$29.prototype.readInt8 = function readInt8(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 1, this.length);
 			if (!(this[offset$2] & 128)) return this[offset$2];
 			return (255 - this[offset$2] + 1) * -1;
 		};
-		Buffer$27.prototype.readInt16LE = function readInt16LE(offset$2, noAssert) {
+		Buffer$29.prototype.readInt16LE = function readInt16LE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 2, this.length);
 			const val = this[offset$2] | this[offset$2 + 1] << 8;
 			return val & 32768 ? val | 4294901760 : val;
 		};
-		Buffer$27.prototype.readInt16BE = function readInt16BE(offset$2, noAssert) {
+		Buffer$29.prototype.readInt16BE = function readInt16BE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 2, this.length);
 			const val = this[offset$2 + 1] | this[offset$2] << 8;
 			return val & 32768 ? val | 4294901760 : val;
 		};
-		Buffer$27.prototype.readInt32LE = function readInt32LE(offset$2, noAssert) {
+		Buffer$29.prototype.readInt32LE = function readInt32LE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 4, this.length);
 			return this[offset$2] | this[offset$2 + 1] << 8 | this[offset$2 + 2] << 16 | this[offset$2 + 3] << 24;
 		};
-		Buffer$27.prototype.readInt32BE = function readInt32BE(offset$2, noAssert) {
+		Buffer$29.prototype.readInt32BE = function readInt32BE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 4, this.length);
 			return this[offset$2] << 24 | this[offset$2 + 1] << 16 | this[offset$2 + 2] << 8 | this[offset$2 + 3];
 		};
-		Buffer$27.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset$2) {
+		Buffer$29.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset$2) {
 			offset$2 = offset$2 >>> 0;
 			validateNumber(offset$2, "offset");
 			const first$1 = this[offset$2];
@@ -980,7 +980,7 @@ var init_dist$1 = __esmMin(() => {
 			const val = this[offset$2 + 4] + this[offset$2 + 5] * 2 ** 8 + this[offset$2 + 6] * 2 ** 16 + (last$2 << 24);
 			return (BigInt(val) << BigInt(32)) + BigInt(first$1 + this[++offset$2] * 2 ** 8 + this[++offset$2] * 2 ** 16 + this[++offset$2] * 2 ** 24);
 		});
-		Buffer$27.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset$2) {
+		Buffer$29.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset$2) {
 			offset$2 = offset$2 >>> 0;
 			validateNumber(offset$2, "offset");
 			const first$1 = this[offset$2];
@@ -989,32 +989,32 @@ var init_dist$1 = __esmMin(() => {
 			const val = (first$1 << 24) + this[++offset$2] * 2 ** 16 + this[++offset$2] * 2 ** 8 + this[++offset$2];
 			return (BigInt(val) << BigInt(32)) + BigInt(this[++offset$2] * 2 ** 24 + this[++offset$2] * 2 ** 16 + this[++offset$2] * 2 ** 8 + last$2);
 		});
-		Buffer$27.prototype.readFloatLE = function readFloatLE(offset$2, noAssert) {
+		Buffer$29.prototype.readFloatLE = function readFloatLE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 4, this.length);
 			return ieee754$1$1.read(this, offset$2, true, 23, 4);
 		};
-		Buffer$27.prototype.readFloatBE = function readFloatBE(offset$2, noAssert) {
+		Buffer$29.prototype.readFloatBE = function readFloatBE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 4, this.length);
 			return ieee754$1$1.read(this, offset$2, false, 23, 4);
 		};
-		Buffer$27.prototype.readDoubleLE = function readDoubleLE(offset$2, noAssert) {
+		Buffer$29.prototype.readDoubleLE = function readDoubleLE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 8, this.length);
 			return ieee754$1$1.read(this, offset$2, true, 52, 8);
 		};
-		Buffer$27.prototype.readDoubleBE = function readDoubleBE(offset$2, noAssert) {
+		Buffer$29.prototype.readDoubleBE = function readDoubleBE(offset$2, noAssert) {
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkOffset(offset$2, 8, this.length);
 			return ieee754$1$1.read(this, offset$2, false, 52, 8);
 		};
 		function checkInt(buf, value, offset$2, ext, max$3, min$1) {
-			if (!Buffer$27.isBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
+			if (!Buffer$29.isBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
 			if (value > max$3 || value < min$1) throw new RangeError("\"value\" argument is out of bounds");
 			if (offset$2 + ext > buf.length) throw new RangeError("Index out of range");
 		}
-		Buffer$27.prototype.writeUintLE = Buffer$27.prototype.writeUIntLE = function writeUIntLE(value, offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.writeUintLE = Buffer$29.prototype.writeUIntLE = function writeUIntLE(value, offset$2, byteLength$3, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			byteLength$3 = byteLength$3 >>> 0;
@@ -1028,7 +1028,7 @@ var init_dist$1 = __esmMin(() => {
 			while (++i$4 < byteLength$3 && (mul *= 256)) this[offset$2 + i$4] = value / mul & 255;
 			return offset$2 + byteLength$3;
 		};
-		Buffer$27.prototype.writeUintBE = Buffer$27.prototype.writeUIntBE = function writeUIntBE(value, offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.writeUintBE = Buffer$29.prototype.writeUIntBE = function writeUIntBE(value, offset$2, byteLength$3, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			byteLength$3 = byteLength$3 >>> 0;
@@ -1042,14 +1042,14 @@ var init_dist$1 = __esmMin(() => {
 			while (--i$4 >= 0 && (mul *= 256)) this[offset$2 + i$4] = value / mul & 255;
 			return offset$2 + byteLength$3;
 		};
-		Buffer$27.prototype.writeUint8 = Buffer$27.prototype.writeUInt8 = function writeUInt8(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeUint8 = Buffer$29.prototype.writeUInt8 = function writeUInt8(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 1, 255, 0);
 			this[offset$2] = value & 255;
 			return offset$2 + 1;
 		};
-		Buffer$27.prototype.writeUint16LE = Buffer$27.prototype.writeUInt16LE = function writeUInt16LE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeUint16LE = Buffer$29.prototype.writeUInt16LE = function writeUInt16LE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 2, 65535, 0);
@@ -1057,7 +1057,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2 + 1] = value >>> 8;
 			return offset$2 + 2;
 		};
-		Buffer$27.prototype.writeUint16BE = Buffer$27.prototype.writeUInt16BE = function writeUInt16BE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeUint16BE = Buffer$29.prototype.writeUInt16BE = function writeUInt16BE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 2, 65535, 0);
@@ -1065,7 +1065,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2 + 1] = value & 255;
 			return offset$2 + 2;
 		};
-		Buffer$27.prototype.writeUint32LE = Buffer$27.prototype.writeUInt32LE = function writeUInt32LE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeUint32LE = Buffer$29.prototype.writeUInt32LE = function writeUInt32LE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 4, 4294967295, 0);
@@ -1075,7 +1075,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2] = value & 255;
 			return offset$2 + 4;
 		};
-		Buffer$27.prototype.writeUint32BE = Buffer$27.prototype.writeUInt32BE = function writeUInt32BE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeUint32BE = Buffer$29.prototype.writeUInt32BE = function writeUInt32BE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 4, 4294967295, 0);
@@ -1125,13 +1125,13 @@ var init_dist$1 = __esmMin(() => {
 			buf[offset$2] = hi;
 			return offset$2 + 8;
 		}
-		Buffer$27.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset$2 = 0) {
+		Buffer$29.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset$2 = 0) {
 			return wrtBigUInt64LE(this, value, offset$2, BigInt(0), BigInt("0xffffffffffffffff"));
 		});
-		Buffer$27.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset$2 = 0) {
+		Buffer$29.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset$2 = 0) {
 			return wrtBigUInt64BE(this, value, offset$2, BigInt(0), BigInt("0xffffffffffffffff"));
 		});
-		Buffer$27.prototype.writeIntLE = function writeIntLE(value, offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.writeIntLE = function writeIntLE(value, offset$2, byteLength$3, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) {
@@ -1148,7 +1148,7 @@ var init_dist$1 = __esmMin(() => {
 			}
 			return offset$2 + byteLength$3;
 		};
-		Buffer$27.prototype.writeIntBE = function writeIntBE(value, offset$2, byteLength$3, noAssert) {
+		Buffer$29.prototype.writeIntBE = function writeIntBE(value, offset$2, byteLength$3, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) {
@@ -1165,7 +1165,7 @@ var init_dist$1 = __esmMin(() => {
 			}
 			return offset$2 + byteLength$3;
 		};
-		Buffer$27.prototype.writeInt8 = function writeInt8(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeInt8 = function writeInt8(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 1, 127, -128);
@@ -1173,7 +1173,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2] = value & 255;
 			return offset$2 + 1;
 		};
-		Buffer$27.prototype.writeInt16LE = function writeInt16LE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeInt16LE = function writeInt16LE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 2, 32767, -32768);
@@ -1181,7 +1181,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2 + 1] = value >>> 8;
 			return offset$2 + 2;
 		};
-		Buffer$27.prototype.writeInt16BE = function writeInt16BE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeInt16BE = function writeInt16BE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 2, 32767, -32768);
@@ -1189,7 +1189,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2 + 1] = value & 255;
 			return offset$2 + 2;
 		};
-		Buffer$27.prototype.writeInt32LE = function writeInt32LE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeInt32LE = function writeInt32LE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 4, 2147483647, -2147483648);
@@ -1199,7 +1199,7 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2 + 3] = value >>> 24;
 			return offset$2 + 4;
 		};
-		Buffer$27.prototype.writeInt32BE = function writeInt32BE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeInt32BE = function writeInt32BE(value, offset$2, noAssert) {
 			value = +value;
 			offset$2 = offset$2 >>> 0;
 			if (!noAssert) checkInt(this, value, offset$2, 4, 2147483647, -2147483648);
@@ -1210,10 +1210,10 @@ var init_dist$1 = __esmMin(() => {
 			this[offset$2 + 3] = value & 255;
 			return offset$2 + 4;
 		};
-		Buffer$27.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset$2 = 0) {
+		Buffer$29.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset$2 = 0) {
 			return wrtBigUInt64LE(this, value, offset$2, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
 		});
-		Buffer$27.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset$2 = 0) {
+		Buffer$29.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset$2 = 0) {
 			return wrtBigUInt64BE(this, value, offset$2, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
 		});
 		function checkIEEE754(buf, value, offset$2, ext, max$3, min$1) {
@@ -1227,10 +1227,10 @@ var init_dist$1 = __esmMin(() => {
 			ieee754$1$1.write(buf, value, offset$2, littleEndian, 23, 4);
 			return offset$2 + 4;
 		}
-		Buffer$27.prototype.writeFloatLE = function writeFloatLE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeFloatLE = function writeFloatLE(value, offset$2, noAssert) {
 			return writeFloat(this, value, offset$2, true, noAssert);
 		};
-		Buffer$27.prototype.writeFloatBE = function writeFloatBE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeFloatBE = function writeFloatBE(value, offset$2, noAssert) {
 			return writeFloat(this, value, offset$2, false, noAssert);
 		};
 		function writeDouble(buf, value, offset$2, littleEndian, noAssert) {
@@ -1240,14 +1240,14 @@ var init_dist$1 = __esmMin(() => {
 			ieee754$1$1.write(buf, value, offset$2, littleEndian, 52, 8);
 			return offset$2 + 8;
 		}
-		Buffer$27.prototype.writeDoubleLE = function writeDoubleLE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeDoubleLE = function writeDoubleLE(value, offset$2, noAssert) {
 			return writeDouble(this, value, offset$2, true, noAssert);
 		};
-		Buffer$27.prototype.writeDoubleBE = function writeDoubleBE(value, offset$2, noAssert) {
+		Buffer$29.prototype.writeDoubleBE = function writeDoubleBE(value, offset$2, noAssert) {
 			return writeDouble(this, value, offset$2, false, noAssert);
 		};
-		Buffer$27.prototype.copy = function copy(target, targetStart, start, end) {
-			if (!Buffer$27.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+		Buffer$29.prototype.copy = function copy(target, targetStart, start, end) {
+			if (!Buffer$29.isBuffer(target)) throw new TypeError("argument should be a Buffer");
 			if (!start) start = 0;
 			if (!end && end !== 0) end = this.length;
 			if (targetStart >= target.length) targetStart = target.length;
@@ -1265,7 +1265,7 @@ var init_dist$1 = __esmMin(() => {
 			else GlobalUint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
 			return len$2;
 		};
-		Buffer$27.prototype.fill = function fill(val, start, end, encoding) {
+		Buffer$29.prototype.fill = function fill(val, start, end, encoding) {
 			if (typeof val === "string") {
 				if (typeof start === "string") {
 					encoding = start;
@@ -1276,7 +1276,7 @@ var init_dist$1 = __esmMin(() => {
 					end = this.length;
 				}
 				if (encoding !== void 0 && typeof encoding !== "string") throw new TypeError("encoding must be a string");
-				if (typeof encoding === "string" && !Buffer$27.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
+				if (typeof encoding === "string" && !Buffer$29.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
 				if (val.length === 1) {
 					const code$2 = val.charCodeAt(0);
 					if (encoding === "utf8" && code$2 < 128 || encoding === "latin1") val = code$2;
@@ -1291,7 +1291,7 @@ var init_dist$1 = __esmMin(() => {
 			let i$4;
 			if (typeof val === "number") for (i$4 = start; i$4 < end; ++i$4) this[i$4] = val;
 			else {
-				const bytes = Buffer$27.isBuffer(val) ? val : Buffer$27.from(val, encoding);
+				const bytes = Buffer$29.isBuffer(val) ? val : Buffer$29.from(val, encoding);
 				const len$2 = bytes.length;
 				if (len$2 === 0) throw new TypeError("The value \"" + val + "\" is invalid for argument \"value\"");
 				for (i$4 = 0; i$4 < end - start; ++i$4) this[i$4 + start] = bytes[i$4 % len$2];
@@ -1506,7 +1506,7 @@ var init_dist$1 = __esmMin(() => {
 });
 var require_reach = __commonJSMin((exports, module) => {
 	const Assert$5 = require_assert$1();
-	const internals$40 = {};
+	const internals$41 = {};
 	module.exports = function(obj, chain, options) {
 		if (chain === false || chain === null || chain === void 0) return obj;
 		options = options || {};
@@ -1517,7 +1517,7 @@ var require_reach = __commonJSMin((exports, module) => {
 		let ref = obj;
 		for (let i$4 = 0; i$4 < path.length; ++i$4) {
 			let key = path[i$4];
-			const type = options.iterables && internals$40.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;
@@ -1534,14 +1534,14 @@ var require_reach = __commonJSMin((exports, module) => {
 		}
 		return ref;
 	};
-	internals$40.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$39 = {};
+	const internals$40 = {};
 	exports = module.exports = {
 		array: Array.prototype,
 		buffer: Buffer$1 && Buffer$1.prototype,
@@ -1556,7 +1556,7 @@ var require_types$1 = __commonJSMin((exports, module) => {
 		weakMap: WeakMap.prototype,
 		weakSet: WeakSet.prototype
 	};
-	internals$39.typeMap = new Map([
+	internals$40.typeMap = new Map([
 		["[object Error]", exports.error],
 		["[object Map]", exports.map],
 		["[object Promise]", exports.promise],
@@ -1572,7 +1572,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$39.typeMap.get(objName) || exports.generic;
+		return internals$40.typeMap.get(objName) || exports.generic;
 	};
 });
 var require_utils$7 = __commonJSMin((exports) => {
@@ -1585,7 +1585,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$38 = {
+	const internals$39 = {
 		needsProtoHack: new Set([
 			Types$1.set,
 			Types$1.map,
@@ -1594,13 +1594,13 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 		]),
 		structuredCloneExists: typeof structuredClone === "function"
 	};
-	module.exports = internals$38.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$38.clone;
+		let clone$21 = internals$39.clone;
 		let seen = _seen;
 		if (options.shallow) {
-			if (options.shallow !== true) return internals$38.cloneWithShallow(obj, options);
-			clone$20 = (value) => value;
+			if (options.shallow !== true) return internals$39.cloneWithShallow(obj, options);
+			clone$21 = (value) => value;
 		} else if (seen) {
 			const lookup$2 = seen.get(obj);
 			if (lookup$2) return lookup$2;
@@ -1612,11 +1612,11 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 			case Types$1.regex:
 			case Types$1.url: return new baseProto.constructor(obj);
 		}
-		const newObj = internals$38.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));
-		else if (baseProto === Types$1.map) for (const [key, value] of obj) newObj.set(key, clone$20(value, options, seen));
+		if (baseProto === Types$1.set) for (const value of obj) newObj.add(clone$21(value, options, seen));
+		else if (baseProto === Types$1.map) for (const [key, value] of obj) newObj.set(key, clone$21(value, options, seen));
 		const keys$10 = Utils$3.keys(obj, options);
 		for (const key of keys$10) {
 			if (key === "__proto__") continue;
@@ -1624,26 +1624,26 @@ var require_clone$1 = __commonJSMin((exports, module) => {
 				newObj.length = obj.length;
 				continue;
 			}
-			if (internals$38.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);
+			else if (descriptor.enumerable) newObj[key] = clone$21(obj[key], options, seen);
 			else Object.defineProperty(newObj, key, {
 				enumerable: false,
 				writable: true,
 				configurable: true,
-				value: clone$20(obj[key], options, seen)
+				value: clone$21(obj[key], options, seen)
 			});
 			else Object.defineProperty(newObj, key, {
 				enumerable: true,
 				writable: true,
 				configurable: true,
-				value: clone$20(obj[key], options, seen)
+				value: clone$21(obj[key], options, seen)
 			});
 		}
 		return newObj;
 	};
-	internals$38.cloneWithShallow = function(source, options) {
+	internals$39.cloneWithShallow = function(source, options) {
 		const keys$10 = options.shallow;
 		options = Object.assign({}, options);
 		options.shallow = false;
@@ -1652,11 +1652,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$38.clone(source, options, seen);
+		return internals$39.clone(source, options, seen);
 	};
-	internals$38.base = function(obj, baseProto, options) {
+	internals$39.base = function(obj, baseProto, options) {
 		if (options.prototype === false) {
-			if (internals$38.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);
@@ -1665,12 +1665,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$38.structuredCloneExists && (proto === baseProto || Error.isPrototypeOf(proto.constructor))) {
+		} else if (baseProto === Types$1.error && internals$39.structuredCloneExists && (proto === baseProto || Error.isPrototypeOf(proto.constructor))) {
 			const err$1 = structuredClone(obj);
 			if (Object.getPrototypeOf(err$1) !== proto) Object.setPrototypeOf(err$1, proto);
 			return err$1;
 		}
-		if (internals$38.needsProtoHack.has(baseProto)) {
+		if (internals$39.needsProtoHack.has(baseProto)) {
 			const newObj = new proto.constructor();
 			if (proto !== baseProto) Object.setPrototypeOf(newObj, proto);
 			return newObj;
@@ -1683,8 +1683,8 @@ var require_merge = __commonJSMin((exports, module) => {
 	const Assert$4 = require_assert$1();
 	const Clone$2 = require_clone$1();
 	const Utils$2 = require_utils$7();
-	const internals$37 = {};
-	module.exports = internals$37.merge = function(target, source, options) {
+	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;
@@ -1706,7 +1706,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$37.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;
 		}
@@ -1718,13 +1718,13 @@ var require_applyToDefaults = __commonJSMin((exports, module) => {
 	const Clone$1 = require_clone$1();
 	const Merge = require_merge();
 	const Reach$1 = require_reach();
-	const internals$36 = {};
+	const internals$37 = {};
 	module.exports = function(defaults$3, source, options = {}) {
 		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$36.applyToDefaultsWithShallow(defaults$3, source, options);
+		if (options.shallow) return internals$37.applyToDefaultsWithShallow(defaults$3, source, options);
 		const copy = Clone$1(defaults$3);
 		if (source === true) return copy;
 		const nullOverride = options.nullOverride !== void 0 ? options.nullOverride : false;
@@ -1733,7 +1733,7 @@ var require_applyToDefaults = __commonJSMin((exports, module) => {
 			mergeArrays: false
 		});
 	};
-	internals$36.applyToDefaultsWithShallow = function(defaults$3, source, options) {
+	internals$37.applyToDefaultsWithShallow = function(defaults$3, source, options) {
 		const keys$10 = options.shallow;
 		Assert$3(Array.isArray(keys$10), "Invalid keys");
 		const seen = new Map();
@@ -1746,14 +1746,14 @@ var require_applyToDefaults = __commonJSMin((exports, module) => {
 		}
 		const copy = Clone$1(defaults$3, {}, seen);
 		if (!merge$4) return copy;
-		for (const key of merge$4) internals$36.reachCopy(copy, source, key);
+		for (const key of merge$4) internals$37.reachCopy(copy, source, key);
 		const nullOverride = options.nullOverride !== void 0 ? options.nullOverride : false;
 		return Merge(copy, source, {
 			nullOverride,
 			mergeArrays: false
 		});
 	};
-	internals$36.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];
@@ -1904,17 +1904,17 @@ var init_dist = __esmMin(() => {
 });
 var require_bench = __commonJSMin((exports, module) => {
 	init_dist();
-	const internals$35 = {};
-	module.exports = internals$35.Bench = class {
+	const internals$36 = {};
+	module.exports = internals$36.Bench = class {
 		constructor() {
 			this.ts = 0;
 			this.reset();
 		}
 		reset() {
-			this.ts = internals$35.Bench.now();
+			this.ts = internals$36.Bench.now();
 		}
 		elapsed() {
-			return internals$35.Bench.now() - this.ts;
+			return internals$36.Bench.now() - this.ts;
 		}
 		static now() {
 			const ts = process$1.hrtime();
@@ -1934,12 +1934,12 @@ var require_block = __commonJSMin((exports, module) => {
 var require_deepEqual = __commonJSMin((exports, module) => {
 	init_dist$1();
 	const Types = require_types$1();
-	const internals$34 = { mismatched: null };
+	const internals$35 = { mismatched: null };
 	module.exports = function(obj, ref, options) {
 		options = Object.assign({ prototype: true }, options);
-		return !!internals$34.isDeepEqual(obj, ref, options, []);
+		return !!internals$35.isDeepEqual(obj, ref, options, []);
 	};
-	internals$34.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;
@@ -1947,32 +1947,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$34.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$34.mismatched: return false;
+			case internals$35.mismatched: return false;
 		}
 		for (let i$4 = seen.length - 1; i$4 >= 0; --i$4) if (seen[i$4].isSame(obj, ref)) return true;
-		seen.push(new internals$34.SeenEntry(obj, ref));
+		seen.push(new internals$35.SeenEntry(obj, ref));
 		try {
-			return !!internals$34.isDeepEqualObj(instanceType, obj, ref, options, seen);
+			return !!internals$35.isDeepEqualObj(instanceType, obj, ref, options, seen);
 		} finally {
 			seen.pop();
 		}
 	};
-	internals$34.getSharedType = function(obj, ref, checkPrototype) {
+	internals$35.getSharedType = function(obj, ref, checkPrototype) {
 		if (checkPrototype) {
-			if (Object.getPrototypeOf(obj) !== Object.getPrototypeOf(ref)) return internals$34.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$34.mismatched;
+		if (type !== Types.getInternalProto(ref)) return internals$35.mismatched;
 		return type;
 	};
-	internals$34.valueOf = function(obj) {
+	internals$35.valueOf = function(obj) {
 		const objValueOf = obj.valueOf;
 		if (objValueOf === void 0) return obj;
 		try {
@@ -1981,15 +1981,15 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 			return err$1;
 		}
 	};
-	internals$34.hasOwnEnumerableProperty = function(obj, key) {
+	internals$35.hasOwnEnumerableProperty = function(obj, key) {
 		return Object.prototype.propertyIsEnumerable.call(obj, key);
 	};
-	internals$34.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$34.isDeepEqualObj = function(instanceType, obj, ref, options, seen) {
-		const { isDeepEqual: isDeepEqual$2, valueOf, hasOwnEnumerableProperty } = internals$34;
+	internals$35.isDeepEqualObj = function(instanceType, obj, ref, options, seen) {
+		const { isDeepEqual: isDeepEqual$2, valueOf, hasOwnEnumerableProperty } = internals$35;
 		const { keys: keys$10, getOwnPropertySymbols } = 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;
@@ -2000,7 +2000,7 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 		}
 		else if (instanceType === Types.set) {
 			if (obj.size !== ref.size) return false;
-			if (!internals$34.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;
@@ -2053,7 +2053,7 @@ var require_deepEqual = __commonJSMin((exports, module) => {
 		}
 		return true;
 	};
-	internals$34.SeenEntry = class {
+	internals$35.SeenEntry = class {
 		constructor(obj, ref) {
 			this.obj = obj;
 			this.ref = ref;
@@ -2073,16 +2073,16 @@ var require_contain = __commonJSMin((exports, module) => {
 	const DeepEqual = require_deepEqual();
 	const EscapeRegex = require_escapeRegex();
 	const Utils$1 = require_utils$7();
-	const internals$33 = {};
+	const internals$34 = {};
 	module.exports = function(ref, values$3, options = {}) {
 		if (typeof values$3 !== "object") values$3 = [values$3];
 		Assert$2(!Array.isArray(values$3) || values$3.length, "Values array cannot be empty");
-		if (typeof ref === "string") return internals$33.string(ref, values$3, options);
-		if (Array.isArray(ref)) return internals$33.array(ref, values$3, options);
+		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$33.object(ref, values$3, options);
+		return internals$34.object(ref, values$3, options);
 	};
-	internals$33.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;
@@ -2096,7 +2096,7 @@ var require_contain = __commonJSMin((exports, module) => {
 				hits: 0
 			});
 		} else {
-			compare$16 = compare$16 ?? internals$33.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;
@@ -2113,7 +2113,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$33.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;
@@ -2132,14 +2132,14 @@ var require_contain = __commonJSMin((exports, module) => {
 		}
 		return !!hits;
 	};
-	internals$33.object = function(ref, values$3, options) {
+	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$33.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$33.compare(options);
+		const compare$16 = internals$34.compare(options);
 		const set = new Set(targets);
 		for (const key of keys$10) {
 			if (!set.has(key)) {
@@ -2152,7 +2152,7 @@ var require_contain = __commonJSMin((exports, module) => {
 		if (set.size) return options.part ? set.size < targets.length : false;
 		return true;
 	};
-	internals$33.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 = [];
@@ -2186,8 +2186,8 @@ var require_contain = __commonJSMin((exports, module) => {
 		}
 		return !!any;
 	};
-	internals$33.compare = function(options) {
-		if (!options.deep) return internals$33.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 = {
@@ -2196,7 +2196,7 @@ var require_contain = __commonJSMin((exports, module) => {
 		};
 		return (a$2, b) => DeepEqual(a$2, b, flags);
 	};
-	internals$33.shallow = function(a$2, b) {
+	internals$34.shallow = function(a$2, b) {
 		return a$2 === b;
 	};
 });
@@ -2208,28 +2208,28 @@ var require_escapeHeaderAttribute = __commonJSMin((exports, module) => {
 	};
 });
 var require_escapeHtml = __commonJSMin((exports, module) => {
-	const internals$32 = {};
+	const internals$33 = {};
 	module.exports = function(input) {
 		if (!input) return "";
 		let escaped = "";
 		for (let i$4 = 0; i$4 < input.length; ++i$4) {
 			const charCode = input.charCodeAt(i$4);
-			if (internals$32.isSafe(charCode)) escaped += input[i$4];
-			else escaped += internals$32.escapeHtmlChar(charCode);
+			if (internals$33.isSafe(charCode)) escaped += input[i$4];
+			else escaped += internals$33.escapeHtmlChar(charCode);
 		}
 		return escaped;
 	};
-	internals$32.escapeHtmlChar = function(charCode) {
-		const namedEscape = internals$32.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$32.isSafe = function(charCode) {
-		return internals$32.safeCharCodes.has(charCode);
+	internals$33.isSafe = function(charCode) {
+		return internals$33.safeCharCodes.has(charCode);
 	};
-	internals$32.namedHtml = new Map([
+	internals$33.namedHtml = new Map([
 		[38, "&amp;"],
 		[60, "&lt;"],
 		[62, "&gt;"],
@@ -2241,22 +2241,22 @@ var require_escapeHtml = __commonJSMin((exports, module) => {
 		[169, "&copy;"],
 		[174, "&reg;"]
 	]);
-	internals$32.safeCharCodes = function() {
+	internals$33.safeCharCodes = function() {
 		const safe = new Set();
 		for (let i$4 = 32; i$4 < 123; ++i$4) if (i$4 >= 97 || i$4 >= 65 && i$4 <= 90 || i$4 >= 48 && i$4 <= 57 || i$4 === 32 || i$4 === 46 || i$4 === 44 || i$4 === 45 || i$4 === 58 || i$4 === 95) safe.add(i$4);
 		return safe;
 	}();
 });
 var require_escapeJson = __commonJSMin((exports, module) => {
-	const internals$31 = {};
+	const internals$32 = {};
 	module.exports = function(input) {
 		if (!input) return "";
-		return input.replace(/[<>&\u2028\u2029]/g, internals$31.escape);
+		return input.replace(/[<>&\u2028\u2029]/g, internals$32.escape);
 	};
-	internals$31.escape = function(char) {
-		return internals$31.replacements.get(char);
+	internals$32.escape = function(char) {
+		return internals$32.replacements.get(char);
 	};
-	internals$31.replacements = new Map([
+	internals$32.replacements = new Map([
 		["<", "\\u003c"],
 		[">", "\\u003e"],
 		["&", "\\u0026"],
@@ -2265,29 +2265,29 @@ var require_escapeJson = __commonJSMin((exports, module) => {
 	]);
 });
 var require_flatten$1 = __commonJSMin((exports, module) => {
-	const internals$30 = {};
-	module.exports = internals$30.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$30.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$29 = {};
+	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$29.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$29.has = function(ref, key) {
+	internals$30.has = function(ref, key) {
 		if (typeof ref.has === "function") return ref.has(key);
 		return ref[key] !== void 0;
 	};
@@ -2298,9 +2298,9 @@ var require_isPromise = __commonJSMin((exports, module) => {
 	};
 });
 var require_once = __commonJSMin((exports, module) => {
-	const internals$28 = { wrapped: Symbol("wrapped") };
+	const internals$29 = { wrapped: Symbol("wrapped") };
 	module.exports = function(method$1) {
-		if (method$1[internals$28.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) {
@@ -2308,7 +2308,7 @@ var require_once = __commonJSMin((exports, module) => {
 				method$1(...args$1);
 			}
 		};
-		wrappedFn[internals$28.wrapped] = true;
+		wrappedFn[internals$29.wrapped] = true;
 		return wrappedFn;
 	};
 });
@@ -2322,7 +2322,7 @@ var require_reachTemplate = __commonJSMin((exports, module) => {
 	};
 });
 var require_wait = __commonJSMin((exports, module) => {
-	const internals$27 = { 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;
@@ -2330,7 +2330,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$27.maxTimer);
+				const time = Math.min(timeout$5, internals$28.maxTimer);
 				timeout$5 -= time;
 				_setTimeout(() => timeout$5 > 0 ? activate() : resolve(returnValue), time);
 			};
@@ -2437,9 +2437,9 @@ var init_package$1 = __esmMin(() => {
 	};
 });
 var require_cache = __commonJSMin((exports) => {
-	const { assert: assert$52, clone: clone$19 } = require_lib$4();
-	const Common$24 = require_common$3();
-	const internals$26 = {
+	const { assert: assert$53, clone: clone$20 } = require_lib$4();
+	const Common$25 = require_common$3();
+	const internals$27 = {
 		max: 1e3,
 		supported: new Set([
 			"undefined",
@@ -2449,21 +2449,21 @@ var require_cache = __commonJSMin((exports) => {
 		])
 	};
 	exports.provider = { provision(options) {
-		return new internals$26.Cache(options);
+		return new internals$27.Cache(options);
 	} };
-	internals$26.Cache = class {
+	internals$27.Cache = class {
 		constructor(options = {}) {
-			Common$24.assertOptions(options, ["max"]);
-			assert$52(options.max === void 0 || options.max && options.max > 0 && isFinite(options.max), "Invalid max cache size");
-			this._max = options.max || internals$26.max;
+			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$26.List();
+			this._list = new internals$27.List();
 		}
 		get length() {
 			return this._map.size;
 		}
 		set(key, value) {
-			if (key !== null && !internals$26.supported.has(typeof key)) return;
+			if (key !== null && !internals$27.supported.has(typeof key)) return;
 			let node = this._map.get(key);
 			if (node) {
 				node.value = value;
@@ -2481,7 +2481,7 @@ var require_cache = __commonJSMin((exports) => {
 			const node = this._map.get(key);
 			if (node) {
 				this._list.first(node);
-				return clone$19(node.value);
+				return clone$20(node.value);
 			}
 		}
 		_compact() {
@@ -2491,7 +2491,7 @@ var require_cache = __commonJSMin((exports) => {
 			}
 		}
 	};
-	internals$26.List = class {
+	internals$27.List = class {
 		constructor() {
 			this.tail = null;
 			this.head = null;
@@ -2524,7 +2524,7 @@ var require_cache = __commonJSMin((exports) => {
 	};
 });
 var require_lib$3 = __commonJSMin((exports) => {
-	const internals$25 = {
+	const internals$26 = {
 		operators: [
 			"!",
 			"^",
@@ -2590,7 +2590,7 @@ var require_lib$3 = __commonJSMin((exports) => {
 	};
 	exports.Parser = class {
 		constructor(string, options = {}) {
-			if (!options[internals$25.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",
@@ -2598,8 +2598,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$25.settings] ? options : Object.assign({
-				[internals$25.settings]: true,
+			this.settings = options[internals$26.settings] ? options : Object.assign({
+				[internals$26.settings]: true,
 				constants: {},
 				functions: {}
 			}, options);
@@ -2641,12 +2641,12 @@ var require_lib$3 = __commonJSMin((exports) => {
 						type: "literal",
 						value: current
 					});
-				} else if (internals$25.operatorCharacters.includes(current)) if (last$2 && last$2.type === "operator" && internals$25.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$25.numberRx)) parts.push({
+				else if (current.match(internals$26.numberRx)) parts.push({
 					type: "constant",
 					value: parseFloat(current)
 				});
@@ -2655,7 +2655,7 @@ var require_lib$3 = __commonJSMin((exports) => {
 					value: this.settings.constants[current]
 				});
 				else {
-					if (!current.match(internals$25.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
@@ -2675,11 +2675,11 @@ var require_lib$3 = __commonJSMin((exports) => {
 				if (!parenthesis) flush(c$1);
 				else current += c$1;
 			} else current += c$1;
-			else if (c$1 in internals$25.literals) literal = internals$25.literals[c$1];
+			else if (c$1 in internals$26.literals) literal = internals$26.literals[c$1];
 			else if (c$1 === "(") {
 				flush();
 				++parenthesis;
-			} else if (internals$25.operatorCharacters.includes(c$1)) {
+			} else if (internals$26.operatorCharacters.includes(c$1)) {
 				flush();
 				current = c$1;
 				flush();
@@ -2696,9 +2696,9 @@ var require_lib$3 = __commonJSMin((exports) => {
 			let operator$1 = false;
 			for (const part of parts) {
 				if (part.type === "operator") {
-					if (internals$25.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$25.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;
 			}
@@ -2712,11 +2712,11 @@ var require_lib$3 = __commonJSMin((exports) => {
 				value: parts[0].value
 			};
 			this._parts = parts.map((part) => {
-				if (part.type === "operator") return internals$25.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$25.reference(part.value);
+				return internals$26.reference(part.value);
 			});
 		}
 		_subFormula(string, name$2) {
@@ -2737,9 +2737,9 @@ var require_lib$3 = __commonJSMin((exports) => {
 					if (literal) {
 						current += c$1;
 						if (c$1 === literal) literal = false;
-					} else if (c$1 in internals$25.literals && !parenthesis) {
+					} else if (c$1 in internals$26.literals && !parenthesis) {
 						current += c$1;
-						literal = internals$25.literals[c$1];
+						literal = internals$26.literals[c$1];
 					} else if (c$1 === "," && !parenthesis) flush();
 					else {
 						current += c$1;
@@ -2763,47 +2763,47 @@ var require_lib$3 = __commonJSMin((exports) => {
 				if (part && part.type === "operator") {
 					const current = parts[i$4 + 1];
 					parts.splice(i$4 + 1, 1);
-					const value = internals$25.evaluate(current, context);
-					parts[i$4] = internals$25.single(part.value, value);
+					const value = internals$26.evaluate(current, context);
+					parts[i$4] = internals$26.single(part.value, value);
 				}
 			}
-			internals$25.operatorsOrder.forEach((set) => {
+			internals$26.operatorsOrder.forEach((set) => {
 				for (let i$4 = 1; i$4 < parts.length - 1;) if (set.includes(parts[i$4])) {
 					const operator$1 = parts[i$4];
-					const left = internals$25.evaluate(parts[i$4 - 1], context);
-					const right = internals$25.evaluate(parts[i$4 + 1], context);
+					const left = internals$26.evaluate(parts[i$4 - 1], context);
+					const right = internals$26.evaluate(parts[i$4 + 1], context);
 					parts.splice(i$4, 2);
-					const result = internals$25.calculate(operator$1, left, right);
+					const result = internals$26.calculate(operator$1, left, right);
 					parts[i$4 - 1] = result === 0 ? 0 : result;
 				} else i$4 += 2;
 			});
-			return internals$25.evaluate(parts[0], context);
+			return internals$26.evaluate(parts[0], context);
 		}
 	};
-	exports.Parser.prototype[internals$25.symbol] = true;
-	internals$25.reference = function(name$2) {
+	exports.Parser.prototype[internals$26.symbol] = true;
+	internals$26.reference = function(name$2) {
 		return function(context) {
 			return context && context[name$2] !== void 0 ? context[name$2] : null;
 		};
 	};
-	internals$25.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$25.symbol]) return part.evaluate(context);
+		if (part[internals$26.symbol]) return part.evaluate(context);
 		return part;
 	};
-	internals$25.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$25.calculate = function(operator$1, left, right) {
-		if (operator$1 === "??") return internals$25.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$25.exists(left) ? left : "";
-				right = internals$25.exists(right) ? right : "";
+				left = internals$26.exists(left) ? left : "";
+				right = internals$26.exists(right) ? right : "";
 				return left + right;
 			}
 		} else switch (operator$1) {
@@ -2826,17 +2826,17 @@ var require_lib$3 = __commonJSMin((exports) => {
 		}
 		return null;
 	};
-	internals$25.exists = function(value) {
+	internals$26.exists = function(value) {
 		return value !== null && value !== void 0;
 	};
 });
 var require_template = __commonJSMin((exports, module) => {
-	const { assert: assert$51, clone: clone$18, escapeHtml: escapeHtml$1 } = require_lib$4();
+	const { assert: assert$52, clone: clone$19, escapeHtml: escapeHtml$1 } = require_lib$4();
 	const Formula = require_lib$3();
-	const Common$23 = require_common$3();
+	const Common$24 = require_common$3();
 	const Errors$8 = require_errors$2();
-	const Ref$11 = require_ref$2();
-	const internals$24 = {
+	const Ref$12 = require_ref$2();
+	const internals$25 = {
 		symbol: Symbol("template"),
 		opens: new Array(1e3).join("\0"),
 		closes: new Array(1e3).join("
"),
@@ -2848,20 +2848,20 @@ var require_template = __commonJSMin((exports, module) => {
 			utc: Date.prototype.toUTCString
 		}
 	};
-	module.exports = exports = internals$24.Template = class {
+	module.exports = exports = internals$25.Template = class {
 		constructor(source, options) {
-			assert$51(typeof source === "string", "Template source must be a string");
-			assert$51(!source.includes("\0") && !source.includes("
"), "Template source cannot contain reserved control characters");
+			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");
 			this.source = source;
 			this.rendered = source;
 			this._template = null;
 			if (options) {
 				const { functions,...opts } = options;
-				this._settings = Object.keys(opts).length ? clone$18(opts) : void 0;
+				this._settings = Object.keys(opts).length ? clone$19(opts) : void 0;
 				this._functions = functions;
 				if (this._functions) {
-					assert$51(Object.keys(this._functions).every((key) => typeof key === "string"), "Functions keys must be strings");
-					assert$51(Object.values(this._functions).every((key) => typeof key === "function"), "Functions values must be functions");
+					assert$52(Object.keys(this._functions).every((key) => typeof key === "string"), "Functions keys must be strings");
+					assert$52(Object.values(this._functions).every((key) => typeof key === "function"), "Functions values must be functions");
 				}
 			} else {
 				this._settings = void 0;
@@ -2871,8 +2871,8 @@ var require_template = __commonJSMin((exports, module) => {
 		}
 		_parse() {
 			if (!this.source.includes("{")) return;
-			const encoded = internals$24.encode(this.source);
-			const parts = internals$24.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();
@@ -2882,20 +2882,20 @@ var require_template = __commonJSMin((exports, module) => {
 				const ender = raw ? "}" : "}}";
 				const end = part.indexOf(ender);
 				if (end === -1 || part[1] === "{") {
-					processed.push(`{${internals$24.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$24.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$24.decode(rest));
+				if (rest) processed.push(internals$25.decode(rest));
 			}
 			if (!refs) {
 				this.rendered = processed.join("");
@@ -2904,7 +2904,7 @@ var require_template = __commonJSMin((exports, module) => {
 			this._template = processed;
 		}
 		static date(date, prefs) {
-			return internals$24.dateFormat[prefs.dateFormat].call(date);
+			return internals$25.dateFormat[prefs.dateFormat].call(date);
 		}
 		describe(options = {}) {
 			if (!this._settings && options.compact) return this.source;
@@ -2914,7 +2914,7 @@ var require_template = __commonJSMin((exports, module) => {
 			return desc$1;
 		}
 		static build(desc$1) {
-			return new internals$24.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);
@@ -2923,7 +2923,7 @@ var require_template = __commonJSMin((exports, module) => {
 			return !!this._template;
 		}
 		static isTemplate(template) {
-			return template ? !!template[Common$23.symbols.template] : false;
+			return template ? !!template[Common$24.symbols.template] : false;
 		}
 		refs() {
 			if (!this._template) return;
@@ -2945,10 +2945,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$24.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$24.wrap(result, part.wrapped && prefs.errors.wrap.label));
+					parts.push(internals$25.wrap(result, part.wrapped && prefs.errors.wrap.label));
 				}
 			}
 			return parts.join("");
@@ -2956,7 +2956,7 @@ var require_template = __commonJSMin((exports, module) => {
 		_ref(content, { raw, wrapped }) {
 			const refs = [];
 			const reference = (variable) => {
-				const ref = Ref$11.create(variable, this._settings);
+				const ref = Ref$12.create(variable, this._settings);
 				refs.push(ref);
 				return (context) => {
 					const resolved = ref.resolve(...context);
@@ -2965,13 +2965,13 @@ var require_template = __commonJSMin((exports, module) => {
 			};
 			try {
 				const functions = this._functions ? {
-					...internals$24.functions,
+					...internals$25.functions,
 					...this._functions
-				} : internals$24.functions;
+				} : internals$25.functions;
 				var formula = new Formula.Parser(content, {
 					reference,
 					functions,
-					constants: internals$24.constants
+					constants: internals$25.constants
 				});
 			} catch (err$1) {
 				err$1.message = `Invalid template variable "${content}" fails due to: ${err$1.message}`;
@@ -2987,7 +2987,7 @@ var require_template = __commonJSMin((exports, module) => {
 						wrapped: wrapped || ref.type === "local" && ref.key === "label"
 					};
 				}
-				return internals$24.stringify(formula.single.value);
+				return internals$25.stringify(formula.single.value);
 			}
 			return {
 				formula,
@@ -2999,19 +2999,19 @@ var require_template = __commonJSMin((exports, module) => {
 			return this.source;
 		}
 	};
-	internals$24.Template.prototype[Common$23.symbols.template] = true;
-	internals$24.Template.prototype.isImmutable = true;
-	internals$24.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$24.opens.slice(0, $1.length);
+			return internals$25.opens.slice(0, $1.length);
 		}).replace(/\\(\}+)/g, ($0, $1) => {
-			return internals$24.closes.slice(0, $1.length);
+			return internals$25.closes.slice(0, $1.length);
 		});
 	};
-	internals$24.decode = function(string) {
+	internals$25.decode = function(string) {
 		return string.replace(/\u0000/g, "{").replace(/\u0001/g, "}");
 	};
-	internals$24.split = function(string) {
+	internals$25.split = function(string) {
 		const parts = [];
 		let current = "";
 		for (let i$4 = 0; i$4 < string.length; ++i$4) {
@@ -3029,16 +3029,16 @@ var require_template = __commonJSMin((exports, module) => {
 		parts.push(current);
 		return parts;
 	};
-	internals$24.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$24.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;
-		if (Ref$11.isRef(value) && value.render) {
+		if (Ref$12.isRef(value) && value.render) {
 			skipWrap = value.in;
 			value = value.resolve(original, state, prefs, local, {
 				in: value.in,
@@ -3046,10 +3046,10 @@ var require_template = __commonJSMin((exports, module) => {
 			});
 		}
 		if (value === null) return "null";
-		if (type === "string") return internals$24.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$24.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()}`);
@@ -3057,13 +3057,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$24.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$24.wrap(values$3.join(", "), !skipWrap && wrap$2.array);
+		return internals$25.wrap(values$3.join(", "), !skipWrap && wrap$2.array);
 	};
-	internals$24.constants = {
+	internals$25.constants = {
 		true: true,
 		false: false,
 		null: null,
@@ -3072,7 +3072,7 @@ var require_template = __commonJSMin((exports, module) => {
 		hour: 60 * 60 * 1e3,
 		day: 24 * 60 * 60 * 1e3
 	};
-	internals$24.functions = {
+	internals$25.functions = {
 		if(condition, then, otherwise) {
 			return condition ? then : otherwise;
 		},
@@ -3100,10 +3100,10 @@ var require_template = __commonJSMin((exports, module) => {
 	};
 });
 var require_ref$2 = __commonJSMin((exports) => {
-	const { assert: assert$50, clone: clone$17, reach: reach$4 } = require_lib$4();
-	const Common$22 = require_common$3();
-	let Template$7;
-	const internals$23 = {
+	const { assert: assert$51, clone: clone$18, reach: reach$4 } = require_lib$4();
+	const Common$23 = require_common$3();
+	let Template$8;
+	const internals$24 = {
 		symbol: Symbol("ref"),
 		defaults: {
 			adjust: null,
@@ -3115,8 +3115,8 @@ var require_ref$2 = __commonJSMin((exports) => {
 		}
 	};
 	exports.create = function(key, options = {}) {
-		assert$50(typeof key === "string", "Invalid reference key:", key);
-		Common$22.assertOptions(options, [
+		assert$51(typeof key === "string", "Invalid reference key:", key);
+		Common$23.assertOptions(options, [
 			"adjust",
 			"ancestor",
 			"in",
@@ -3126,25 +3126,25 @@ var require_ref$2 = __commonJSMin((exports) => {
 			"render",
 			"separator"
 		]);
-		assert$50(!options.prefix || typeof options.prefix === "object", "options.prefix must be of type object");
-		const ref = Object.assign({}, internals$23.defaults, options);
+		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$23.context(key, separator, options.prefix);
+		const context = internals$24.context(key, separator, options.prefix);
 		ref.type = context.type;
 		key = context.key;
 		if (ref.type === "value") {
 			if (context.root) {
-				assert$50(!separator || key[0] !== separator, "Cannot specify relative path with root prefix");
+				assert$51(!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$50(!separator || !key || key[0] !== separator, "Cannot combine prefix with ancestor option");
+			} 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$23.ancestor(key, separator);
+				const [ancestor, slice$1] = internals$24.ancestor(key, separator);
 				if (slice$1) {
 					key = key.slice(slice$1);
 					if (key === "") key = null;
@@ -3153,7 +3153,7 @@ var require_ref$2 = __commonJSMin((exports) => {
 			}
 		}
 		ref.path = separator ? key === null ? [] : key.split(separator) : [key];
-		return new internals$23.Ref(ref);
+		return new internals$24.Ref(ref);
 	};
 	exports.in = function(key, options = {}) {
 		return exports.create(key, {
@@ -3162,12 +3162,12 @@ var require_ref$2 = __commonJSMin((exports) => {
 		});
 	};
 	exports.isRef = function(ref) {
-		return ref ? !!ref[Common$22.symbols.ref] : false;
+		return ref ? !!ref[Common$23.symbols.ref] : false;
 	};
-	internals$23.Ref = class {
+	internals$24.Ref = class {
 		constructor(options) {
-			assert$50(typeof options === "object", "Invalid reference construction");
-			Common$22.assertOptions(options, [
+			assert$51(typeof options === "object", "Invalid reference construction");
+			Common$23.assertOptions(options, [
 				"adjust",
 				"ancestor",
 				"in",
@@ -3182,12 +3182,12 @@ var require_ref$2 = __commonJSMin((exports) => {
 				"root",
 				"display"
 			]);
-			assert$50([false, void 0].includes(options.separator) || typeof options.separator === "string" && options.separator.length === 1, "Invalid separator");
-			assert$50(!options.adjust || typeof options.adjust === "function", "options.adjust must be a function");
-			assert$50(!options.map || Array.isArray(options.map), "options.map must be an array");
-			assert$50(!options.map || !options.adjust, "Cannot set both map and adjust options");
-			Object.assign(this, internals$23.defaults, options);
-			assert$50(this.type === "value" || this.ancestor === void 0, "Non-value references cannot reference ancestors");
+			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;
@@ -3195,12 +3195,12 @@ var require_ref$2 = __commonJSMin((exports) => {
 			this.updateDisplay();
 		}
 		resolve(value, state, prefs, local, options = {}) {
-			assert$50(!this.in || options.in, "Invalid in() reference usage");
+			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$50(this.ancestor <= state.ancestors.length, "Invalid reference exceeds the schema root:", this.display);
+			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) {
@@ -3225,7 +3225,7 @@ var require_ref$2 = __commonJSMin((exports) => {
 			return [...state.path.slice(0, -this.ancestor), ...this.path];
 		}
 		clone() {
-			return new internals$23.Ref(this);
+			return new internals$24.Ref(this);
 		}
 		describe() {
 			const ref = { path: this.path };
@@ -3267,13 +3267,13 @@ var require_ref$2 = __commonJSMin((exports) => {
 			this.display = `ref:${lead}${key || ""}`;
 		}
 	};
-	internals$23.Ref.prototype[Common$22.symbols.ref] = true;
+	internals$24.Ref.prototype[Common$23.symbols.ref] = true;
 	exports.build = function(desc$1) {
-		desc$1 = Object.assign({}, internals$23.defaults, 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$23.Ref(desc$1);
+		return new internals$24.Ref(desc$1);
 	};
-	internals$23.context = function(key, separator, prefix = {}) {
+	internals$24.context = function(key, separator, prefix = {}) {
 		key = key.trim();
 		if (prefix) {
 			const globalp = prefix.global === void 0 ? "$" : prefix.global;
@@ -3298,7 +3298,7 @@ var require_ref$2 = __commonJSMin((exports) => {
 			type: "value"
 		};
 	};
-	internals$23.ancestor = function(key, separator) {
+	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];
@@ -3319,7 +3319,7 @@ var require_ref$2 = __commonJSMin((exports) => {
 				for (const ref of source) this.register(ref, target);
 				return;
 			}
-			if (Common$22.isSchema(source)) {
+			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
@@ -3330,15 +3330,15 @@ var require_ref$2 = __commonJSMin((exports) => {
 				ancestor: source.ancestor - target,
 				root: source.root
 			});
-			Template$7 = Template$7 || require_template();
-			if (Template$7.isTemplate(source)) this.register(source.refs(), target);
+			Template$8 = Template$8 || require_template();
+			if (Template$8.isTemplate(source)) this.register(source.refs(), target);
 		}
 		get length() {
 			return this.refs.length;
 		}
 		clone() {
 			const copy = new exports.Manager();
-			copy.refs = clone$17(this.refs);
+			copy.refs = clone$18(this.refs);
 			return copy;
 		}
 		reset() {
@@ -3350,80 +3350,80 @@ var require_ref$2 = __commonJSMin((exports) => {
 	};
 });
 var require_compile = __commonJSMin((exports) => {
-	const { assert: assert$49 } = require_lib$4();
-	const Common$21 = require_common$3();
-	const Ref$10 = require_ref$2();
-	const internals$22 = {};
+	const { assert: assert$50 } = require_lib$4();
+	const Common$22 = require_common$3();
+	const Ref$11 = require_ref$2();
+	const internals$23 = {};
 	exports.schema = function(Joi$2, config, options = {}) {
-		Common$21.assertOptions(options, ["appendPath", "override"]);
+		Common$22.assertOptions(options, ["appendPath", "override"]);
 		try {
-			return internals$22.schema(Joi$2, config, options);
+			return internals$23.schema(Joi$2, config, options);
 		} catch (err$1) {
 			if (options.appendPath && err$1.path !== void 0) err$1.message = `${err$1.message} (${err$1.path})`;
 			throw err$1;
 		}
 	};
-	internals$22.schema = function(Joi$2, config, options) {
-		assert$49(config !== void 0, "Invalid undefined schema");
+	internals$23.schema = function(Joi$2, config, options) {
+		assert$50(config !== void 0, "Invalid undefined schema");
 		if (Array.isArray(config)) {
-			assert$49(config.length, "Invalid empty array schema");
+			assert$50(config.length, "Invalid empty array schema");
 			if (config.length === 1) config = config[0];
 		}
 		const valid$2 = (base$3, ...values$3) => {
 			if (options.override !== false) return base$3.valid(Joi$2.override, ...values$3);
 			return base$3.valid(...values$3);
 		};
-		if (internals$22.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);
-		assert$49(typeof config === "object", "Invalid schema content:", typeof config);
-		if (Common$21.isResolvable(config)) return valid$2(Joi$2, config);
-		if (Common$21.isSchema(config)) return config;
+		assert$50(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$22.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);
 		if (config instanceof Date) return valid$2(Joi$2.date(), config);
-		assert$49(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), "Schema can only contain plain objects");
+		assert$50(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), "Schema can only contain plain objects");
 		return Joi$2.object().keys(config);
 	};
 	exports.ref = function(id, options) {
-		return Ref$10.isRef(id) ? id : Ref$10.create(id, options);
+		return Ref$11.isRef(id) ? id : Ref$11.create(id, options);
 	};
 	exports.compile = function(root$11, schema$2, options = {}) {
-		Common$21.assertOptions(options, ["legacy"]);
-		const any = schema$2 && schema$2[Common$21.symbols.any];
+		Common$22.assertOptions(options, ["legacy"]);
+		const any = schema$2 && schema$2[Common$22.symbols.any];
 		if (any) {
-			assert$49(options.legacy || any.version === Common$21.version, "Cannot mix different versions of joi schemas:", any.version, Common$21.version);
+			assert$50(options.legacy || any.version === Common$22.version, "Cannot mix different versions of joi schemas:", any.version, Common$22.version);
 			return schema$2;
 		}
 		if (typeof schema$2 !== "object" || !options.legacy) return exports.schema(root$11, schema$2, { appendPath: true });
-		const compiler = internals$22.walk(schema$2);
+		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$22.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$22.walk(item);
+				const compiler = internals$23.walk(item);
 				if (compiler) return compiler;
 			}
 			return null;
 		}
-		const any = schema$2[Common$21.symbols.any];
+		const any = schema$2[Common$22.symbols.any];
 		if (any) return {
 			root: schema$2[any.root],
 			compile: any.compile
 		};
-		assert$49(Object.getPrototypeOf(schema$2) === Object.getPrototypeOf({}), "Schema can only contain plain objects");
+		assert$50(Object.getPrototypeOf(schema$2) === Object.getPrototypeOf({}), "Schema can only contain plain objects");
 		for (const key in schema$2) {
-			const compiler = internals$22.walk(schema$2[key]);
+			const compiler = internals$23.walk(schema$2[key]);
 			if (compiler) return compiler;
 		}
 		return null;
 	};
-	internals$22.simple = function(value) {
+	internals$23.simple = function(value) {
 		return value === null || [
 			"boolean",
 			"string",
@@ -3432,12 +3432,12 @@ var require_compile = __commonJSMin((exports) => {
 	};
 	exports.when = function(schema$2, condition, options) {
 		if (options === void 0) {
-			assert$49(condition && typeof condition === "object", "Missing options");
+			assert$50(condition && typeof condition === "object", "Missing options");
 			options = condition;
-			condition = Ref$10.create(".");
+			condition = Ref$11.create(".");
 		}
 		if (Array.isArray(options)) options = { switch: options };
-		Common$21.assertOptions(options, [
+		Common$22.assertOptions(options, [
 			"is",
 			"not",
 			"then",
@@ -3445,19 +3445,19 @@ var require_compile = __commonJSMin((exports) => {
 			"switch",
 			"break"
 		]);
-		if (Common$21.isSchema(condition)) {
-			assert$49(options.is === void 0, "\"is\" can not be used with a schema condition");
-			assert$49(options.not === void 0, "\"not\" can not be used with a schema condition");
-			assert$49(options.switch === void 0, "\"switch\" can not be used with a schema condition");
-			return internals$22.condition(schema$2, {
+		if (Common$22.isSchema(condition)) {
+			assert$50(options.is === void 0, "\"is\" can not be used with a schema condition");
+			assert$50(options.not === void 0, "\"not\" can not be used with a schema condition");
+			assert$50(options.switch === void 0, "\"switch\" can not be used with a schema condition");
+			return internals$23.condition(schema$2, {
 				is: condition,
 				then: options.then,
 				otherwise: options.otherwise,
 				break: options.break
 			});
 		}
-		assert$49(Ref$10.isRef(condition) || typeof condition === "string", "Invalid condition:", condition);
-		assert$49(options.not === void 0 || options.is === void 0, "Cannot combine \"is\" with \"not\"");
+		assert$50(Ref$11.isRef(condition) || typeof condition === "string", "Invalid condition:", condition);
+		assert$50(options.not === void 0 || options.is === void 0, "Cannot combine \"is\" with \"not\"");
 		if (options.switch === void 0) {
 			let rule$1 = options;
 			if (options.not !== void 0) rule$1 = {
@@ -3467,10 +3467,10 @@ var require_compile = __commonJSMin((exports) => {
 				break: options.break
 			};
 			let is = rule$1.is !== void 0 ? schema$2.$_compile(rule$1.is) : schema$2.$_root.invalid(null, false, 0, "").required();
-			assert$49(rule$1.then !== void 0 || rule$1.otherwise !== void 0, "options must have at least one of \"then\", \"otherwise\", or \"switch\"");
-			assert$49(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$10.isRef(options.is) && !Common$21.isSchema(options.is)) is = is.required();
-			return internals$22.condition(schema$2, {
+			assert$50(rule$1.then !== void 0 || rule$1.otherwise !== void 0, "options must have at least one of \"then\", \"otherwise\", or \"switch\"");
+			assert$50(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$23.condition(schema$2, {
 				ref: exports.ref(condition),
 				is,
 				then: rule$1.then,
@@ -3478,10 +3478,10 @@ var require_compile = __commonJSMin((exports) => {
 				break: rule$1.break
 			});
 		}
-		assert$49(Array.isArray(options.switch), "\"switch\" must be an array");
-		assert$49(options.is === void 0, "Cannot combine \"switch\" with \"is\"");
-		assert$49(options.not === void 0, "Cannot combine \"switch\" with \"not\"");
-		assert$49(options.then === void 0, "Cannot combine \"switch\" with \"then\"");
+		assert$50(Array.isArray(options.switch), "\"switch\" must be an array");
+		assert$50(options.is === void 0, "Cannot combine \"switch\" with \"is\"");
+		assert$50(options.not === void 0, "Cannot combine \"switch\" with \"not\"");
+		assert$50(options.then === void 0, "Cannot combine \"switch\" with \"then\"");
 		const rule = {
 			ref: exports.ref(condition),
 			switch: [],
@@ -3490,23 +3490,23 @@ var require_compile = __commonJSMin((exports) => {
 		for (let i$4 = 0; i$4 < options.switch.length; ++i$4) {
 			const test = options.switch[i$4];
 			const last$2 = i$4 === options.switch.length - 1;
-			Common$21.assertOptions(test, last$2 ? [
+			Common$22.assertOptions(test, last$2 ? [
 				"is",
 				"then",
 				"otherwise"
 			] : ["is", "then"]);
-			assert$49(test.is !== void 0, "Switch statement missing \"is\"");
-			assert$49(test.then !== void 0, "Switch statement missing \"then\"");
+			assert$50(test.is !== void 0, "Switch statement missing \"is\"");
+			assert$50(test.then !== void 0, "Switch statement missing \"then\"");
 			const item = {
 				is: schema$2.$_compile(test.is),
 				then: schema$2.$_compile(test.then)
 			};
-			if (!Ref$10.isRef(test.is) && !Common$21.isSchema(test.is)) item.is = item.is.required();
+			if (!Ref$11.isRef(test.is) && !Common$22.isSchema(test.is)) item.is = item.is.required();
 			if (last$2) {
-				assert$49(options.otherwise === void 0 || test.otherwise === void 0, "Cannot specify \"otherwise\" inside and outside a \"switch\"");
+				assert$50(options.otherwise === void 0 || test.otherwise === void 0, "Cannot specify \"otherwise\" inside and outside a \"switch\"");
 				const otherwise = options.otherwise !== void 0 ? options.otherwise : test.otherwise;
 				if (otherwise !== void 0) {
-					assert$49(rule.break === void 0, "Cannot specify both otherwise and break");
+					assert$50(rule.break === void 0, "Cannot specify both otherwise and break");
 					item.otherwise = schema$2.$_compile(otherwise);
 				}
 			}
@@ -3514,47 +3514,47 @@ var require_compile = __commonJSMin((exports) => {
 		}
 		return rule;
 	};
-	internals$22.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;
 	};
 });
 var require_messages = __commonJSMin((exports) => {
-	const { assert: assert$48, clone: clone$16 } = require_lib$4();
-	const Template$6 = require_template();
+	const { assert: assert$49, clone: clone$17 } = require_lib$4();
+	const Template$7 = 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);
+			assert$49(!target, "Cannot set single message string");
+			return new Template$7(messages$3);
 		}
-		if (Template$6.isTemplate(messages$3)) {
-			assert$48(!target, "Cannot set single message template");
+		if (Template$7.isTemplate(messages$3)) {
+			assert$49(!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$16(target) : {};
+		assert$49(typeof messages$3 === "object" && !Array.isArray(messages$3), "Invalid message options");
+		target = target ? clone$17(target) : {};
 		for (let code$2 in messages$3) {
 			const message = messages$3[code$2];
-			if (code$2 === "root" || Template$6.isTemplate(message)) {
+			if (code$2 === "root" || Template$7.isTemplate(message)) {
 				target[code$2] = message;
 				continue;
 			}
 			if (typeof message === "string") {
-				target[code$2] = new Template$6(message);
+				target[code$2] = new Template$7(message);
 				continue;
 			}
-			assert$48(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$2);
+			assert$49(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$2);
 			const language = code$2;
 			target[language] = target[language] || {};
 			for (code$2 in message) {
 				const localized = message[code$2];
-				if (code$2 === "root" || Template$6.isTemplate(localized)) {
+				if (code$2 === "root" || Template$7.isTemplate(localized)) {
 					target[language][code$2] = localized;
 					continue;
 				}
-				assert$48(typeof localized === "string", "Invalid message for", code$2, "in", language);
-				target[language][code$2] = new Template$6(localized);
+				assert$49(typeof localized === "string", "Invalid message for", code$2, "in", language);
+				target[language][code$2] = new Template$7(localized);
 			}
 		}
 		return target;
@@ -3567,7 +3567,7 @@ var require_messages = __commonJSMin((exports) => {
 				target.root = message;
 				continue;
 			}
-			if (Template$6.isTemplate(message)) {
+			if (Template$7.isTemplate(message)) {
 				target[code$2] = message.describe({ compact: true });
 				continue;
 			}
@@ -3587,62 +3587,62 @@ var require_messages = __commonJSMin((exports) => {
 	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$16(base$3);
+		if (typeof extended === "string") return new Template$7(extended);
+		if (Template$7.isTemplate(extended)) return extended;
+		const target = clone$17(base$3);
 		for (let code$2 in extended) {
 			const message = extended[code$2];
-			if (code$2 === "root" || Template$6.isTemplate(message)) {
+			if (code$2 === "root" || Template$7.isTemplate(message)) {
 				target[code$2] = message;
 				continue;
 			}
 			if (typeof message === "string") {
-				target[code$2] = new Template$6(message);
+				target[code$2] = new Template$7(message);
 				continue;
 			}
-			assert$48(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$2);
+			assert$49(typeof message === "object" && !Array.isArray(message), "Invalid message for", code$2);
 			const language = code$2;
 			target[language] = target[language] || {};
 			for (code$2 in message) {
 				const localized = message[code$2];
-				if (code$2 === "root" || Template$6.isTemplate(localized)) {
+				if (code$2 === "root" || Template$7.isTemplate(localized)) {
 					target[language][code$2] = localized;
 					continue;
 				}
-				assert$48(typeof localized === "string", "Invalid message for", code$2, "in", language);
-				target[language][code$2] = new Template$6(localized);
+				assert$49(typeof localized === "string", "Invalid message for", code$2, "in", language);
+				target[language][code$2] = new Template$7(localized);
 			}
 		}
 		return target;
 	};
 });
 var require_extend$1 = __commonJSMin((exports) => {
-	const { assert: assert$47, clone: clone$15 } = require_lib$4();
-	const Common$20 = require_common$3();
-	const Messages$6 = require_messages();
-	const internals$21 = {};
+	const { assert: assert$48, clone: clone$16 } = require_lib$4();
+	const Common$21 = require_common$3();
+	const Messages$7 = require_messages();
+	const internals$22 = {};
 	exports.type = function(from$2, options) {
 		const base$3 = Object.getPrototypeOf(from$2);
-		const prototype = clone$15(base$3);
+		const prototype = clone$16(base$3);
 		const schema$2 = from$2._assign(Object.create(prototype));
 		const def = Object.assign({}, options);
 		delete def.base;
 		prototype._definition = def;
 		const parent = base$3._definition || {};
-		def.messages = Messages$6.merge(parent.messages, def.messages);
+		def.messages = Messages$7.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);
 		const terms = Object.assign({}, parent.terms);
 		if (def.terms) for (const name$2 in def.terms) {
 			const term = def.terms[name$2];
-			assert$47(schema$2.$_terms[name$2] === void 0, "Invalid term override for", def.type, name$2);
+			assert$48(schema$2.$_terms[name$2] === void 0, "Invalid term override for", def.type, name$2);
 			schema$2.$_terms[name$2] = term.init;
 			terms[name$2] = term;
 		}
 		def.terms = terms;
 		if (!def.args) def.args = parent.args;
-		def.prepare = internals$21.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 = {
@@ -3650,21 +3650,21 @@ var require_extend$1 = __commonJSMin((exports) => {
 				from: [].concat(def.coerce.from)
 			};
 		}
-		def.coerce = internals$21.coerce(def.coerce, parent.coerce);
-		def.validate = internals$21.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$2 in def.rules) {
 			const rule = def.rules[name$2];
-			assert$47(typeof rule === "object", "Invalid rule definition for", def.type, name$2);
+			assert$48(typeof rule === "object", "Invalid rule definition for", def.type, name$2);
 			let method$1 = rule.method;
 			if (method$1 === void 0) method$1 = function() {
 				return this.$_addRule(name$2);
 			};
 			if (method$1) {
-				assert$47(!prototype[name$2], "Rule conflict in", def.type, name$2);
+				assert$48(!prototype[name$2], "Rule conflict in", def.type, name$2);
 				prototype[name$2] = method$1;
 			}
-			assert$47(!rules[name$2], "Rule conflict in", def.type, name$2);
+			assert$48(!rules[name$2], "Rule conflict in", def.type, name$2);
 			rules[name$2] = rule;
 			if (rule.alias) {
 				const aliases$1 = [].concat(rule.alias);
@@ -3674,8 +3674,8 @@ var require_extend$1 = __commonJSMin((exports) => {
 				rule.argsByName = new Map();
 				rule.args = rule.args.map((arg) => {
 					if (typeof arg === "string") arg = { name: arg };
-					assert$47(!rule.argsByName.has(arg.name), "Duplicated argument name", arg.name);
-					if (Common$20.isSchema(arg.assert)) arg.assert = arg.assert.strict().label(arg.name);
+					assert$48(!rule.argsByName.has(arg.name), "Duplicated argument name", arg.name);
+					if (Common$21.isSchema(arg.assert)) arg.assert = arg.assert.strict().label(arg.name);
 					rule.argsByName.set(arg.name, arg);
 					return arg;
 				});
@@ -3684,9 +3684,9 @@ var require_extend$1 = __commonJSMin((exports) => {
 		def.rules = rules;
 		const modifiers$1 = Object.assign({}, parent.modifiers);
 		if (def.modifiers) for (const name$2 in def.modifiers) {
-			assert$47(!prototype[name$2], "Rule conflict in", def.type, name$2);
+			assert$48(!prototype[name$2], "Rule conflict in", def.type, name$2);
 			const modifier = def.modifiers[name$2];
-			assert$47(typeof modifier === "function", "Invalid modifier definition for", def.type, name$2);
+			assert$48(typeof modifier === "function", "Invalid modifier definition for", def.type, name$2);
 			const method$1 = function(arg) {
 				return this.rule({ [name$2]: arg });
 			};
@@ -3698,26 +3698,26 @@ var require_extend$1 = __commonJSMin((exports) => {
 			prototype._super = base$3;
 			schema$2.$_super = {};
 			for (const override in def.overrides) {
-				assert$47(base$3[override], "Cannot override missing", override);
-				def.overrides[override][Common$20.symbols.parent] = base$3[override];
+				assert$48(base$3[override], "Cannot override missing", override);
+				def.overrides[override][Common$21.symbols.parent] = base$3[override];
 				schema$2.$_super[override] = base$3[override].bind(schema$2);
 			}
 			Object.assign(prototype, def.overrides);
 		}
 		def.cast = Object.assign({}, parent.cast, def.cast);
 		const manifest = Object.assign({}, parent.manifest, def.manifest);
-		manifest.build = internals$21.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$21.rebuild(def.rebuild, parent.rebuild);
+		def.rebuild = internals$22.rebuild(def.rebuild, parent.rebuild);
 		return schema$2;
 	};
-	internals$21.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$21.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,
@@ -3738,7 +3738,7 @@ var require_extend$1 = __commonJSMin((exports) => {
 			}
 		};
 	};
-	internals$21.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);
@@ -3749,14 +3749,14 @@ var require_extend$1 = __commonJSMin((exports) => {
 			return parent(value, helpers$8) || prepared;
 		};
 	};
-	internals$21.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$21.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);
@@ -3768,13 +3768,268 @@ var require_extend$1 = __commonJSMin((exports) => {
 		};
 	};
 });
+var require_manifest$1 = __commonJSMin((exports) => {
+	var import_manifest$2 = __toESM(require_manifest$1());
+	var import_manifest$3 = __toESM(require_manifest$1());
+	var import_manifest$4 = __toESM(require_manifest$1());
+	var import_manifest$5 = __toESM(require_manifest$1());
+	var import_manifest$6 = __toESM(require_manifest$1());
+	var import_manifest$7 = __toESM(require_manifest$1());
+	var import_manifest$8 = __toESM(require_manifest$1());
+	const { assert: assert$47, clone: clone$15 } = import_manifest$8.default;
+	const Common$20 = import_manifest$7.default;
+	const Messages$6 = import_manifest$6.default;
+	const Ref$10 = import_manifest$5.default;
+	const Template$6 = import_manifest$4.default;
+	const ManifestDescriptionCache = new WeakMap();
+	var ManifestItemCacheClass = class {
+		#items = new WeakMap();
+		get(item, options = {}) {
+			const cached = this.#items.get(item);
+			if (cached) return cached.get(options);
+		}
+		set(item, options = {}, value) {
+			if (!this.#items.has(item)) this.#items.set(item, new WeakMap());
+			this.#items.get(item).set(options, value);
+		}
+		setAndReturn(item, options = {}, value) {
+			this.set(item, options, value);
+			return value;
+		}
+	};
+	const ManifestItemCache = new ManifestItemCacheClass();
+	let Schemas$4;
+	const internals$21 = {};
+	exports.describe = function(schema$2) {
+		const cached = ManifestDescriptionCache.get(schema$2);
+		if (cached) return cached;
+		const def = schema$2._definition;
+		const desc$1 = {
+			type: schema$2.type,
+			flags: {},
+			rules: []
+		};
+		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 = clone$15(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 (schema$2._valids) desc$1.allow = schema$2._valids.describe();
+		if (schema$2._invalids) desc$1.invalid = schema$2._invalids.describe();
+		for (const rule of schema$2._rules) {
+			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$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$21.describe(arg, { assign: key });
+				}
+				if (!Object.keys(item.args).length) delete item.args;
+			}
+			desc$1.rules.push(item);
+		}
+		if (!desc$1.rules.length) delete desc$1.rules;
+		for (const term in schema$2.$_terms) {
+			if (term[0] === "_") continue;
+			assert$47(!desc$1[term], "Cannot describe schema due to internal name conflict with", term);
+			const items = schema$2.$_terms[term];
+			if (!items) continue;
+			if (items instanceof Map) {
+				if (items.size) desc$1[term] = [...items.entries()];
+				continue;
+			}
+			if (Common$20.isValues(items)) {
+				desc$1[term] = items.describe();
+				continue;
+			}
+			assert$47(def.terms[term], "Term", term, "missing configuration");
+			const manifest = def.terms[term].manifest;
+			const mapped = typeof manifest === "object";
+			if (!items.length && !mapped) continue;
+			const normalized = [];
+			for (const item of items) normalized.push(internals$21.describe(item));
+			if (mapped) {
+				const { from: from$2, to } = manifest.mapped;
+				desc$1[term] = {};
+				for (const item of normalized) desc$1[term][item[to]] = item[from$2];
+				continue;
+			}
+			if (manifest === "single") {
+				assert$47(normalized.length === 1, "Term", term, "contains more than one item");
+				desc$1[term] = normalized[0];
+				continue;
+			}
+			desc$1[term] = normalized;
+		}
+		internals$21.validate(schema$2.$_root, desc$1);
+		ManifestDescriptionCache.set(schema$2, desc$1);
+		return desc$1;
+	};
+	internals$21.describe = function(item, options = {}) {
+		const cached = ManifestItemCache.get(item, options);
+		if (cached) return cached;
+		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, clone$15(item));
+		if (import_manifest$2.default && import_manifest$2.default.isBuffer(item)) return ManifestItemCache.setAndReturn(item, options, { buffer: item.toString("binary") });
+		if (item instanceof Date) return ManifestItemCache.setAndReturn(item, options, item.toISOString());
+		if (item instanceof Error) return ManifestItemCache.setAndReturn(item, options, item);
+		if (item instanceof RegExp) {
+			if (options.assign === "regex") return ManifestItemCache.setAndReturn(item, options, item.toString());
+			return ManifestItemCache.setAndReturn(item, options, { regex: item.toString() });
+		}
+		if (item[Common$20.symbols.literal]) return ManifestItemCache.setAndReturn(item, options, { function: item.literal });
+		if (typeof item.describe === "function") {
+			if (options.assign === "ref") return ManifestItemCache.setAndReturn(item, options, item.describe().ref);
+			return ManifestItemCache.setAndReturn(item, options, item.describe());
+		}
+		const normalized = {};
+		for (const key in item) {
+			const value = item[key];
+			if (value === void 0) continue;
+			normalized[key] = internals$21.describe(value, { assign: key });
+		}
+		return ManifestItemCache.setAndReturn(item, options, normalized);
+	};
+	exports.build = function(joi, desc$1) {
+		const builder = new internals$21.Builder(joi);
+		return builder.parse(desc$1);
+	};
+	internals$21.Builder = class {
+		constructor(joi) {
+			this.joi = joi;
+		}
+		parse(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) {
+				const setter = def.flags[flag] && def.flags[flag].setter || flag;
+				assert$47(typeof schema$2[setter] === "function", "Invalid flag", flag, "for type", desc$1.type);
+				schema$2 = schema$2[setter](this.build(desc$1.flags[flag]));
+			}
+			if (desc$1.preferences) schema$2 = schema$2.preferences(this.build(desc$1.preferences));
+			if (desc$1.allow) schema$2 = schema$2.allow(...this.build(desc$1.allow));
+			if (desc$1.invalid) schema$2 = schema$2.invalid(...this.build(desc$1.invalid));
+			if (desc$1.rules) for (const rule of desc$1.rules) {
+				assert$47(typeof schema$2[rule.name] === "function", "Invalid rule", rule.name, "for type", desc$1.type);
+				const args$1 = [];
+				if (rule.args) {
+					const built = {};
+					for (const key in rule.args) built[key] = this.build(rule.args[key], { assign: key });
+					const keys$10 = Object.keys(built);
+					const definition = def.rules[rule.name].args;
+					if (definition) {
+						assert$47(keys$10.length <= definition.length, "Invalid number of arguments for", desc$1.type, rule.name, "(expected up to", definition.length, ", found", keys$10.length, ")");
+						for (const { name: name$2 } of definition) args$1.push(built[name$2]);
+					} else {
+						assert$47(keys$10.length === 1, "Invalid number of arguments for", desc$1.type, rule.name, "(expected up to 1, found", keys$10.length, ")");
+						args$1.push(built[keys$10[0]]);
+					}
+				}
+				schema$2 = schema$2[rule.name](...args$1);
+				const options = {};
+				for (const custom$1 in def.modifiers) if (rule[custom$1] !== void 0) options[custom$1] = this.build(rule[custom$1]);
+				if (Object.keys(options).length) schema$2 = schema$2.rule(options);
+			}
+			const terms = {};
+			for (const key in desc$1) {
+				if ([
+					"allow",
+					"flags",
+					"invalid",
+					"whens",
+					"preferences",
+					"rules",
+					"type"
+				].includes(key)) continue;
+				assert$47(def.terms[key], "Term", key, "missing configuration");
+				const manifest = def.terms[key].manifest;
+				if (manifest === "schema") {
+					terms[key] = desc$1[key].map((item) => this.parse(item));
+					continue;
+				}
+				if (manifest === "values") {
+					terms[key] = desc$1[key].map((item) => this.build(item));
+					continue;
+				}
+				if (manifest === "single") {
+					terms[key] = this.build(desc$1[key]);
+					continue;
+				}
+				if (typeof manifest === "object") {
+					terms[key] = {};
+					for (const name$2 in desc$1[key]) {
+						const value = desc$1[key][name$2];
+						terms[key][name$2] = this.parse(value);
+					}
+					continue;
+				}
+				terms[key] = this.build(desc$1[key]);
+			}
+			if (desc$1.whens) terms.whens = desc$1.whens.map((when) => this.build(when));
+			schema$2 = def.manifest.build(schema$2, terms);
+			schema$2.$_temp.ruleset = false;
+			return schema$2;
+		}
+		build(desc$1, options = {}) {
+			if (desc$1 === null) return null;
+			if (Array.isArray(desc$1)) return desc$1.map((item) => this.build(item));
+			if (desc$1 instanceof Error) return desc$1;
+			if (options.assign === "options") return clone$15(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) {
+				if (desc$1.buffer) {
+					assert$47(import_manifest$2.default, "Buffers are not supported");
+					return import_manifest$2.default && import_manifest$2.default.from(desc$1.buffer, "binary");
+				}
+				if (desc$1.function) return {
+					[Common$20.symbols.literal]: true,
+					literal: desc$1.function
+				};
+				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$21.regex(desc$1.regex);
+				if (desc$1.special) {
+					assert$47(["deep"].includes(desc$1.special), "Unknown special value", desc$1.special);
+					return Common$20.symbols.deepDefault;
+				}
+				if (desc$1.value) return clone$15(desc$1.value);
+			}
+			if (desc$1.type) return this.parse(desc$1);
+			if (desc$1.template) return Template$6.build(desc$1);
+			const normalized = {};
+			for (const key in desc$1) normalized[key] = this.build(desc$1[key], { assign: key });
+			return normalized;
+		}
+	};
+	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$21.validate = function(joi, desc$1) {
+		Schemas$4 = Schemas$4 || import_manifest$3.default;
+		joi.assert(desc$1, Schemas$4.description);
+	};
+});
 var require_manifest = __commonJSMin((exports) => {
-	init_dist$1();
-	const { assert: assert$46, clone: clone$14 } = require_lib$4();
-	const Common$19 = require_common$3();
-	const Messages$5 = require_messages();
-	const Ref$9 = require_ref$2();
-	const Template$5 = require_template();
+	var import_manifest$1 = __toESM(require_manifest$1());
+	const { assert: assert$46, clone: clone$14 } = require_manifest$1();
+	const Common$19 = require_manifest$1();
+	const Messages$5 = require_manifest$1();
+	const Ref$9 = require_manifest$1();
+	const Template$5 = require_manifest$1();
 	let Schemas$3;
 	const internals$20 = {};
 	exports.describe = function(schema$2) {
@@ -3850,7 +4105,7 @@ var require_manifest = __commonJSMin((exports) => {
 		if (item === Common$19.symbols.deepDefault) return { special: "deep" };
 		if (typeof item !== "object" || item === null) return item;
 		if (options.assign === "options") return clone$14(item);
-		if (Buffer$1 && Buffer$1.isBuffer(item)) return { buffer: item.toString("binary") };
+		if (import_manifest$1.default && import_manifest$1.default.isBuffer(item)) return { buffer: item.toString("binary") };
 		if (item instanceof Date) return item.toISOString();
 		if (item instanceof Error) return item;
 		if (item instanceof RegExp) {
@@ -3961,8 +4216,8 @@ var require_manifest = __commonJSMin((exports) => {
 			if (typeof desc$1 !== "object") return desc$1;
 			if (Object.keys(desc$1).length === 1) {
 				if (desc$1.buffer) {
-					assert$46(Buffer$1, "Buffers are not supported");
-					return Buffer$1 && Buffer$1.from(desc$1.buffer, "binary");
+					assert$46(import_manifest$1.default, "Buffers are not supported");
+					return import_manifest$1.default && import_manifest$1.default.from(desc$1.buffer, "binary");
 				}
 				if (desc$1.function) return {
 					[Common$19.symbols.literal]: true,
@@ -3991,7 +4246,7 @@ var require_manifest = __commonJSMin((exports) => {
 		return new RegExp(exp, flags);
 	};
 	internals$20.validate = function(joi, desc$1) {
-		Schemas$3 = Schemas$3 || require_schemas();
+		Schemas$3 = Schemas$3 || require_manifest$1();
 		joi.assert(desc$1, Schemas$3.description);
 	};
 });
@@ -4247,11 +4502,11 @@ var require_modify = __commonJSMin((exports) => {
 			this._schemaChain = false;
 		}
 		clone() {
-			const clone$20 = new internals$18.Ids();
-			clone$20._byId = new Map(this._byId);
-			clone$20._byKey = new Map(this._byKey);
-			clone$20._schemaChain = this._schemaChain;
-			return clone$20;
+			const clone$21 = new internals$18.Ids();
+			clone$21._byId = new Map(this._byId);
+			clone$21._byKey = new Map(this._byKey);
+			clone$21._schemaChain = this._schemaChain;
+			return clone$21;
 		}
 		concat(source) {
 			if (source._schemaChain) this._schemaChain = true;
@@ -4367,11 +4622,11 @@ var require_modify = __commonJSMin((exports) => {
 			}, options);
 			if (result !== void 0) {
 				obj = obj || schema$2.clone();
-				const clone$20 = Object.assign({}, rule);
-				clone$20.args = result;
-				obj._rules[i$4] = clone$20;
+				const clone$21 = Object.assign({}, rule);
+				clone$21.args = result;
+				obj._rules[i$4] = clone$21;
 				const existingUnique = obj._singleRules.get(rule.name);
-				if (existingUnique === rule) obj._singleRules.set(rule.name, clone$20);
+				if (existingUnique === rule) obj._singleRules.set(rule.name, clone$21);
 			}
 		}
 		for (const name$2 in schema$2.$_terms) {
@@ -4390,17 +4645,17 @@ var require_modify = __commonJSMin((exports) => {
 	internals$18.scan = function(item, source, options, _path, _key) {
 		const path = _path || [];
 		if (item === null || typeof item !== "object") return;
-		let clone$20;
+		let clone$21;
 		if (Array.isArray(item)) {
 			for (let i$4 = 0; i$4 < item.length; ++i$4) {
 				const key = source.source === "terms" && source.name === "keys" && item[i$4].key;
 				const result = internals$18.scan(item[i$4], source, options, [i$4, ...path], key);
 				if (result !== void 0) {
-					clone$20 = clone$20 || item.slice();
-					clone$20[i$4] = result;
+					clone$21 = clone$21 || item.slice();
+					clone$21[i$4] = result;
 				}
 			}
-			return clone$20;
+			return clone$21;
 		}
 		if (options.schema !== false && Common$18.isSchema(item) || options.ref !== false && Ref$8.isRef(item)) {
 			const result = options.each(item, {
@@ -4415,11 +4670,11 @@ var require_modify = __commonJSMin((exports) => {
 			if (key[0] === "_") continue;
 			const result = internals$18.scan(item[key], source, options, [key, ...path], _key);
 			if (result !== void 0) {
-				clone$20 = clone$20 || Object.assign({}, item);
-				clone$20[key] = result;
+				clone$21 = clone$21 || Object.assign({}, item);
+				clone$21[key] = result;
 			}
 		}
-		return clone$20;
+		return clone$21;
 	};
 });
 var require_state$1 = __commonJSMin((exports, module) => {
@@ -7340,24 +7595,24 @@ var require_keys$1 = __commonJSMin((exports, module) => {
 	internals$8.clone = function(value, prefs) {
 		if (typeof value === "object") {
 			if (prefs.nonEnumerables) return Clone(value, { shallow: true });
-			const clone$21 = Object.create(Object.getPrototypeOf(value));
-			Object.assign(clone$21, value);
-			return clone$21;
+			const clone$22 = Object.create(Object.getPrototypeOf(value));
+			Object.assign(clone$22, value);
+			return clone$22;
 		}
-		const clone$20 = function(...args$1) {
+		const clone$21 = function(...args$1) {
 			return value.apply(this, args$1);
 		};
-		clone$20.prototype = Clone(value.prototype);
-		Object.defineProperty(clone$20, "name", {
+		clone$21.prototype = Clone(value.prototype);
+		Object.defineProperty(clone$21, "name", {
 			value: value.name,
 			writable: false
 		});
-		Object.defineProperty(clone$20, "length", {
+		Object.defineProperty(clone$21, "length", {
 			value: value.length,
 			writable: false
 		});
-		Object.assign(clone$20, value);
-		return clone$20;
+		Object.assign(clone$21, value);
+		return clone$21;
 	};
 	internals$8.dependency = function(schema$2, rel, key, peers, options) {
 		assert$35(key === null || typeof key === "string", rel, "key must be a strings");
@@ -13448,12 +13703,12 @@ var require_common$3 = __commonJSMin((exports) => {
 			throw err$1;
 		}
 	};
-	exports.validateArg = function(value, label, { assert: assert$54, message }) {
-		if (exports.isSchema(assert$54)) {
-			const result = assert$54.validate(value);
+	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$54(value)) return label ? `${label} ${message}` : 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(!Array.isArray(arg), "Method no longer accepts array arguments:", method$1);
@@ -13707,20 +13962,6 @@ Object.defineProperty(import_errors$1.default, "template", { value: function(val
 	if (!messages$3[code$2]) return messages$3["*"];
 	return messages$3[code$2];
 } });
-var import_manifest$1 = __toESM(require_manifest());
-const ManifestDescriptionCache = new WeakMap();
-const originalDescribe = import_manifest$1.default.describe;
-Object.defineProperty(import_manifest$1.default, "describe", {
-	value: function(schema$2) {
-		const cached = ManifestDescriptionCache.get(schema$2);
-		if (cached) return cached;
-		const result = originalDescribe.call(this, schema$2);
-		ManifestDescriptionCache.set(schema$2, result);
-		return result;
-	},
-	writable: true,
-	configurable: true
-});
 const json = (root$11) => {
 	return root$11;
 };
@@ -32770,7 +33011,7 @@ var init_package = __esmMin(() => {
 var require_bn$1 = __commonJSMin((exports, module) => {
 	(function(module$1, exports$1) {
 		"use strict";
-		function assert$54(val, msg) {
+		function assert$55(val, msg) {
 			if (!val) throw new Error(msg || "Assertion failed");
 		}
 		function inherits$14(ctor, superCtor) {
@@ -32798,10 +33039,10 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 		else exports$1.BN = BN$14;
 		BN$14.BN = BN$14;
 		BN$14.wordSize = 26;
-		var Buffer$27;
+		var Buffer$29;
 		try {
-			if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer$27 = window.Buffer;
-			else Buffer$27 = (init_dist$1(), __toCommonJS(dist_exports)).Buffer;
+			if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer$29 = window.Buffer;
+			else Buffer$29 = (init_dist$1(), __toCommonJS(dist_exports)).Buffer;
 		} catch (e$2) {}
 		BN$14.isBN = function isBN(num) {
 			if (num instanceof BN$14) return true;
@@ -32819,7 +33060,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			if (typeof number === "number") return this._initNumber(number, base$3, endian);
 			if (typeof number === "object") return this._initArray(number, base$3, endian);
 			if (base$3 === "hex") base$3 = 16;
-			assert$54(base$3 === (base$3 | 0) && base$3 >= 2 && base$3 <= 36);
+			assert$55(base$3 === (base$3 | 0) && base$3 >= 2 && base$3 <= 36);
 			number = number.toString().replace(/\s+/g, "");
 			var start = 0;
 			if (number[0] === "-") {
@@ -32844,7 +33085,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 				this.words = [number & 67108863, number / 67108864 & 67108863];
 				this.length = 2;
 			} else {
-				assert$54(number < 9007199254740992);
+				assert$55(number < 9007199254740992);
 				this.words = [
 					number & 67108863,
 					number / 67108864 & 67108863,
@@ -32856,7 +33097,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			this._initArray(this.toArray(), base$3, endian);
 		};
 		BN$14.prototype._initArray = function _initArray(number, base$3, endian) {
-			assert$54(typeof number.length === "number");
+			assert$55(typeof number.length === "number");
 			if (number.length <= 0) {
 				this.words = [0];
 				this.length = 1;
@@ -32975,7 +33216,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			dest.negative = this.negative;
 			dest.red = this.red;
 		};
-		BN$14.prototype.clone = function clone$20() {
+		BN$14.prototype.clone = function clone$21() {
 			var r$2 = new BN$14(null);
 			this.copy(r$2);
 			return r$2;
@@ -33143,21 +33384,21 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 				if (this.negative !== 0) out = "-" + out;
 				return out;
 			}
-			assert$54(false, "Base should be between 2 and 36");
+			assert$55(false, "Base should be between 2 and 36");
 		};
 		BN$14.prototype.toNumber = function toNumber$8() {
 			var ret = this.words[0];
 			if (this.length === 2) ret += this.words[1] * 67108864;
 			else if (this.length === 3 && this.words[2] === 1) ret += 4503599627370496 + this.words[1] * 67108864;
-			else if (this.length > 2) assert$54(false, "Number can only safely store up to 53 bits");
+			else if (this.length > 2) assert$55(false, "Number can only safely store up to 53 bits");
 			return this.negative !== 0 ? -ret : ret;
 		};
 		BN$14.prototype.toJSON = function toJSON() {
 			return this.toString(16);
 		};
 		BN$14.prototype.toBuffer = function toBuffer$5(endian, length) {
-			assert$54(typeof Buffer$27 !== "undefined");
-			return this.toArrayLike(Buffer$27, endian, length);
+			assert$55(typeof Buffer$29 !== "undefined");
+			return this.toArrayLike(Buffer$29, endian, length);
 		};
 		BN$14.prototype.toArray = function toArray$8(endian, length) {
 			return this.toArrayLike(Array, endian, length);
@@ -33165,8 +33406,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 		BN$14.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
 			var byteLength$2 = this.byteLength();
 			var reqLength = length || Math.max(1, byteLength$2);
-			assert$54(byteLength$2 <= reqLength, "byte array longer than desired length");
-			assert$54(reqLength > 0, "Requested array length <= 0");
+			assert$55(byteLength$2 <= reqLength, "byte array longer than desired length");
+			assert$55(reqLength > 0, "Requested array length <= 0");
 			this.strip();
 			var littleEndian = endian === "le";
 			var res = new ArrayType(reqLength);
@@ -33287,7 +33528,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.strip();
 		};
 		BN$14.prototype.ior = function ior(num) {
-			assert$54((this.negative | num.negative) === 0);
+			assert$55((this.negative | num.negative) === 0);
 			return this.iuor(num);
 		};
 		BN$14.prototype.or = function or(num) {
@@ -33307,7 +33548,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.strip();
 		};
 		BN$14.prototype.iand = function iand(num) {
-			assert$54((this.negative | num.negative) === 0);
+			assert$55((this.negative | num.negative) === 0);
 			return this.iuand(num);
 		};
 		BN$14.prototype.and = function and(num) {
@@ -33334,7 +33575,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.strip();
 		};
 		BN$14.prototype.ixor = function ixor(num) {
-			assert$54((this.negative | num.negative) === 0);
+			assert$55((this.negative | num.negative) === 0);
 			return this.iuxor(num);
 		};
 		BN$14.prototype.xor = function xor$2(num) {
@@ -33346,7 +33587,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return num.clone().iuxor(this);
 		};
 		BN$14.prototype.inotn = function inotn(width) {
-			assert$54(typeof width === "number" && width >= 0);
+			assert$55(typeof width === "number" && width >= 0);
 			var bytesNeeded = Math.ceil(width / 26) | 0;
 			var bitsLeft = width % 26;
 			this._expand(bytesNeeded);
@@ -33359,7 +33600,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.clone().inotn(width);
 		};
 		BN$14.prototype.setn = function setn(bit, val) {
-			assert$54(typeof bit === "number" && bit >= 0);
+			assert$55(typeof bit === "number" && bit >= 0);
 			var off = bit / 26 | 0;
 			var wbit = bit % 26;
 			this._expand(off + 1);
@@ -34188,8 +34429,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 				carry = carry >>> 13;
 			}
 			for (i$4 = 2 * len$2; i$4 < N; ++i$4) rws[i$4] = 0;
-			assert$54(carry === 0);
-			assert$54((carry & -8192) === 0);
+			assert$55(carry === 0);
+			assert$55((carry & -8192) === 0);
 		};
 		FFTM.prototype.stub = function stub(N) {
 			var ph = new Array(N);
@@ -34239,8 +34480,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.clone().mulTo(num, this);
 		};
 		BN$14.prototype.imuln = function imuln(num) {
-			assert$54(typeof num === "number");
-			assert$54(num < 67108864);
+			assert$55(typeof num === "number");
+			assert$55(num < 67108864);
 			var carry = 0;
 			for (var i$4 = 0; i$4 < this.length; i$4++) {
 				var w$1 = (this.words[i$4] | 0) * num;
@@ -34278,7 +34519,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return res;
 		};
 		BN$14.prototype.iushln = function iushln(bits$1) {
-			assert$54(typeof bits$1 === "number" && bits$1 >= 0);
+			assert$55(typeof bits$1 === "number" && bits$1 >= 0);
 			var r$2 = bits$1 % 26;
 			var s$6 = (bits$1 - r$2) / 26;
 			var carryMask = 67108863 >>> 26 - r$2 << 26 - r$2;
@@ -34304,11 +34545,11 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.strip();
 		};
 		BN$14.prototype.ishln = function ishln(bits$1) {
-			assert$54(this.negative === 0);
+			assert$55(this.negative === 0);
 			return this.iushln(bits$1);
 		};
 		BN$14.prototype.iushrn = function iushrn(bits$1, hint, extended) {
-			assert$54(typeof bits$1 === "number" && bits$1 >= 0);
+			assert$55(typeof bits$1 === "number" && bits$1 >= 0);
 			var h$1;
 			if (hint) h$1 = (hint - hint % 26) / 26;
 			else h$1 = 0;
@@ -34343,7 +34584,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.strip();
 		};
 		BN$14.prototype.ishrn = function ishrn(bits$1, hint, extended) {
-			assert$54(this.negative === 0);
+			assert$55(this.negative === 0);
 			return this.iushrn(bits$1, hint, extended);
 		};
 		BN$14.prototype.shln = function shln(bits$1) {
@@ -34359,7 +34600,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.clone().iushrn(bits$1);
 		};
 		BN$14.prototype.testn = function testn(bit) {
-			assert$54(typeof bit === "number" && bit >= 0);
+			assert$55(typeof bit === "number" && bit >= 0);
 			var r$2 = bit % 26;
 			var s$6 = (bit - r$2) / 26;
 			var q = 1 << r$2;
@@ -34368,10 +34609,10 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return !!(w$1 & q);
 		};
 		BN$14.prototype.imaskn = function imaskn(bits$1) {
-			assert$54(typeof bits$1 === "number" && bits$1 >= 0);
+			assert$55(typeof bits$1 === "number" && bits$1 >= 0);
 			var r$2 = bits$1 % 26;
 			var s$6 = (bits$1 - r$2) / 26;
-			assert$54(this.negative === 0, "imaskn works only with positive numbers");
+			assert$55(this.negative === 0, "imaskn works only with positive numbers");
 			if (this.length <= s$6) return this;
 			if (r$2 !== 0) s$6++;
 			this.length = Math.min(s$6, this.length);
@@ -34385,8 +34626,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.clone().imaskn(bits$1);
 		};
 		BN$14.prototype.iaddn = function iaddn(num) {
-			assert$54(typeof num === "number");
-			assert$54(num < 67108864);
+			assert$55(typeof num === "number");
+			assert$55(num < 67108864);
 			if (num < 0) return this.isubn(-num);
 			if (this.negative !== 0) {
 				if (this.length === 1 && (this.words[0] | 0) < num) {
@@ -34412,8 +34653,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this;
 		};
 		BN$14.prototype.isubn = function isubn(num) {
-			assert$54(typeof num === "number");
-			assert$54(num < 67108864);
+			assert$55(typeof num === "number");
+			assert$55(num < 67108864);
 			if (num < 0) return this.iaddn(-num);
 			if (this.negative !== 0) {
 				this.negative = 0;
@@ -34463,7 +34704,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 				this.words[i$4 + shift] = w$1 & 67108863;
 			}
 			if (carry === 0) return this.strip();
-			assert$54(carry === -1);
+			assert$55(carry === -1);
 			carry = 0;
 			for (i$4 = 0; i$4 < this.length; i$4++) {
 				w$1 = -(this.words[i$4] | 0) + carry;
@@ -34519,7 +34760,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			};
 		};
 		BN$14.prototype.divmod = function divmod(num, mode, positive) {
-			assert$54(!num.isZero());
+			assert$55(!num.isZero());
 			if (this.isZero()) return {
 				div: new BN$14(0),
 				mod: new BN$14(0)
@@ -34596,14 +34837,14 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
 		};
 		BN$14.prototype.modn = function modn(num) {
-			assert$54(num <= 67108863);
+			assert$55(num <= 67108863);
 			var p$1 = (1 << 26) % num;
 			var acc = 0;
 			for (var i$4 = this.length - 1; i$4 >= 0; i$4--) acc = (p$1 * acc + (this.words[i$4] | 0)) % num;
 			return acc;
 		};
 		BN$14.prototype.idivn = function idivn(num) {
-			assert$54(num <= 67108863);
+			assert$55(num <= 67108863);
 			var carry = 0;
 			for (var i$4 = this.length - 1; i$4 >= 0; i$4--) {
 				var w$1 = (this.words[i$4] | 0) + carry * 67108864;
@@ -34616,8 +34857,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.clone().idivn(num);
 		};
 		BN$14.prototype.egcd = function egcd(p$1) {
-			assert$54(p$1.negative === 0);
-			assert$54(!p$1.isZero());
+			assert$55(p$1.negative === 0);
+			assert$55(!p$1.isZero());
 			var x$1 = this;
 			var y$1 = p$1.clone();
 			if (x$1.negative !== 0) x$1 = x$1.umod(p$1);
@@ -34676,8 +34917,8 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			};
 		};
 		BN$14.prototype._invmp = function _invmp(p$1) {
-			assert$54(p$1.negative === 0);
-			assert$54(!p$1.isZero());
+			assert$55(p$1.negative === 0);
+			assert$55(!p$1.isZero());
 			var a$2 = this;
 			var b = p$1.clone();
 			if (a$2.negative !== 0) a$2 = a$2.umod(p$1);
@@ -34753,7 +34994,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this.words[0] & num;
 		};
 		BN$14.prototype.bincn = function bincn(bit) {
-			assert$54(typeof bit === "number");
+			assert$55(typeof bit === "number");
 			var r$2 = bit % 26;
 			var s$6 = (bit - r$2) / 26;
 			var q = 1 << r$2;
@@ -34788,7 +35029,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			if (this.length > 1) res = 1;
 			else {
 				if (negative) num = -num;
-				assert$54(num <= 67108863, "Number is too big");
+				assert$55(num <= 67108863, "Number is too big");
 				var w$1 = this.words[0] | 0;
 				res = w$1 === num ? 0 : w$1 < num ? -1 : 1;
 			}
@@ -34850,12 +35091,12 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return new Red(num);
 		};
 		BN$14.prototype.toRed = function toRed(ctx) {
-			assert$54(!this.red, "Already a number in reduction context");
-			assert$54(this.negative === 0, "red works only with positives");
+			assert$55(!this.red, "Already a number in reduction context");
+			assert$55(this.negative === 0, "red works only with positives");
 			return ctx.convertTo(this)._forceRed(ctx);
 		};
 		BN$14.prototype.fromRed = function fromRed() {
-			assert$54(this.red, "fromRed works only with numbers in reduction context");
+			assert$55(this.red, "fromRed works only with numbers in reduction context");
 			return this.red.convertFrom(this);
 		};
 		BN$14.prototype._forceRed = function _forceRed(ctx) {
@@ -34863,66 +35104,66 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			return this;
 		};
 		BN$14.prototype.forceRed = function forceRed(ctx) {
-			assert$54(!this.red, "Already a number in reduction context");
+			assert$55(!this.red, "Already a number in reduction context");
 			return this._forceRed(ctx);
 		};
 		BN$14.prototype.redAdd = function redAdd(num) {
-			assert$54(this.red, "redAdd works only with red numbers");
+			assert$55(this.red, "redAdd works only with red numbers");
 			return this.red.add(this, num);
 		};
 		BN$14.prototype.redIAdd = function redIAdd(num) {
-			assert$54(this.red, "redIAdd works only with red numbers");
+			assert$55(this.red, "redIAdd works only with red numbers");
 			return this.red.iadd(this, num);
 		};
 		BN$14.prototype.redSub = function redSub(num) {
-			assert$54(this.red, "redSub works only with red numbers");
+			assert$55(this.red, "redSub works only with red numbers");
 			return this.red.sub(this, num);
 		};
 		BN$14.prototype.redISub = function redISub(num) {
-			assert$54(this.red, "redISub works only with red numbers");
+			assert$55(this.red, "redISub works only with red numbers");
 			return this.red.isub(this, num);
 		};
 		BN$14.prototype.redShl = function redShl(num) {
-			assert$54(this.red, "redShl works only with red numbers");
+			assert$55(this.red, "redShl works only with red numbers");
 			return this.red.shl(this, num);
 		};
 		BN$14.prototype.redMul = function redMul(num) {
-			assert$54(this.red, "redMul works only with red numbers");
+			assert$55(this.red, "redMul works only with red numbers");
 			this.red._verify2(this, num);
 			return this.red.mul(this, num);
 		};
 		BN$14.prototype.redIMul = function redIMul(num) {
-			assert$54(this.red, "redMul works only with red numbers");
+			assert$55(this.red, "redMul works only with red numbers");
 			this.red._verify2(this, num);
 			return this.red.imul(this, num);
 		};
 		BN$14.prototype.redSqr = function redSqr() {
-			assert$54(this.red, "redSqr works only with red numbers");
+			assert$55(this.red, "redSqr works only with red numbers");
 			this.red._verify1(this);
 			return this.red.sqr(this);
 		};
 		BN$14.prototype.redISqr = function redISqr() {
-			assert$54(this.red, "redISqr works only with red numbers");
+			assert$55(this.red, "redISqr works only with red numbers");
 			this.red._verify1(this);
 			return this.red.isqr(this);
 		};
 		BN$14.prototype.redSqrt = function redSqrt() {
-			assert$54(this.red, "redSqrt works only with red numbers");
+			assert$55(this.red, "redSqrt works only with red numbers");
 			this.red._verify1(this);
 			return this.red.sqrt(this);
 		};
 		BN$14.prototype.redInvm = function redInvm() {
-			assert$54(this.red, "redInvm works only with red numbers");
+			assert$55(this.red, "redInvm works only with red numbers");
 			this.red._verify1(this);
 			return this.red.invm(this);
 		};
 		BN$14.prototype.redNeg = function redNeg() {
-			assert$54(this.red, "redNeg works only with red numbers");
+			assert$55(this.red, "redNeg works only with red numbers");
 			this.red._verify1(this);
 			return this.red.neg(this);
 		};
 		BN$14.prototype.redPow = function redPow(num) {
-			assert$54(this.red && !num.red, "redPow(normalNum)");
+			assert$55(this.red && !num.red, "redPow(normalNum)");
 			this.red._verify1(this);
 			return this.red.pow(this, num);
 		};
@@ -35052,18 +35293,18 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 				this.m = prime.p;
 				this.prime = prime;
 			} else {
-				assert$54(m$3.gtn(1), "modulus must be greater than 1");
+				assert$55(m$3.gtn(1), "modulus must be greater than 1");
 				this.m = m$3;
 				this.prime = null;
 			}
 		}
 		Red.prototype._verify1 = function _verify1(a$2) {
-			assert$54(a$2.negative === 0, "red works only with positives");
-			assert$54(a$2.red, "red works only with red numbers");
+			assert$55(a$2.negative === 0, "red works only with positives");
+			assert$55(a$2.red, "red works only with red numbers");
 		};
 		Red.prototype._verify2 = function _verify2(a$2, b) {
-			assert$54((a$2.negative | b.negative) === 0, "red works only with positives");
-			assert$54(a$2.red && a$2.red === b.red, "red works only with red numbers");
+			assert$55((a$2.negative | b.negative) === 0, "red works only with positives");
+			assert$55(a$2.red && a$2.red === b.red, "red works only with red numbers");
 		};
 		Red.prototype.imod = function imod(a$2) {
 			if (this.prime) return this.prime.ireduce(a$2)._forceRed(this);
@@ -35118,7 +35359,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 		Red.prototype.sqrt = function sqrt(a$2) {
 			if (a$2.isZero()) return a$2.clone();
 			var mod3 = this.m.andln(3);
-			assert$54(mod3 % 2 === 1);
+			assert$55(mod3 % 2 === 1);
 			if (mod3 === 3) {
 				var pow$1 = this.m.add(new BN$14(1)).iushrn(2);
 				return this.pow(a$2, pow$1);
@@ -35129,7 +35370,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 				s$6++;
 				q.iushrn(1);
 			}
-			assert$54(!q.isZero());
+			assert$55(!q.isZero());
 			var one = new BN$14(1).toRed(this);
 			var nOne = one.redNeg();
 			var lpow = this.m.subn(1).iushrn(1);
@@ -35143,7 +35384,7 @@ var require_bn$1 = __commonJSMin((exports, module) => {
 			while (t$7.cmp(one) !== 0) {
 				var tmp = t$7;
 				for (var i$4 = 0; tmp.cmp(one) !== 0; i$4++) tmp = tmp.redSqr();
-				assert$54(i$4 < m$3);
+				assert$55(i$4 < m$3);
 				var b = this.pow(c$1, new BN$14(1).iushln(m$3 - i$4 - 1));
 				r$2 = r$2.redMul(b);
 				c$1 = b.redSqr();
@@ -39540,7 +39781,7 @@ var require_node = __commonJSMin((exports, module) => {
 		"implicit",
 		"contains"
 	];
-	Node.prototype.clone = function clone$20() {
+	Node.prototype.clone = function clone$21() {
 		var state = this._baseState;
 		var cstate = {};
 		stateProps.forEach(function(prop) {
@@ -39554,9 +39795,9 @@ var require_node = __commonJSMin((exports, module) => {
 		var state = this._baseState;
 		methods.forEach(function(method$1) {
 			this[method$1] = function _wrappedMethod() {
-				var clone$20 = new this.constructor(this);
-				state.children.push(clone$20);
-				return clone$20[method$1].apply(clone$20, arguments);
+				var clone$21 = new this.constructor(this);
+				state.children.push(clone$21);
+				return clone$21[method$1].apply(clone$21, arguments);
 			};
 		}, this);
 	};
@@ -40910,7 +41151,7 @@ var require_withPublic = __commonJSMin((exports, module) => {
 var require_bn = __commonJSMin((exports, module) => {
 	(function(module$1, exports$1) {
 		"use strict";
-		function assert$54(val, msg) {
+		function assert$55(val, msg) {
 			if (!val) throw new Error(msg || "Assertion failed");
 		}
 		function inherits$14(ctor, superCtor) {
@@ -40938,10 +41179,10 @@ var require_bn = __commonJSMin((exports, module) => {
 		else exports$1.BN = BN$14;
 		BN$14.BN = BN$14;
 		BN$14.wordSize = 26;
-		var Buffer$27;
+		var Buffer$29;
 		try {
-			if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer$27 = window.Buffer;
-			else Buffer$27 = (init_dist$1(), __toCommonJS(dist_exports)).Buffer;
+			if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer$29 = window.Buffer;
+			else Buffer$29 = (init_dist$1(), __toCommonJS(dist_exports)).Buffer;
 		} catch (e$2) {}
 		BN$14.isBN = function isBN(num) {
 			if (num instanceof BN$14) return true;
@@ -40959,7 +41200,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			if (typeof number === "number") return this._initNumber(number, base$3, endian);
 			if (typeof number === "object") return this._initArray(number, base$3, endian);
 			if (base$3 === "hex") base$3 = 16;
-			assert$54(base$3 === (base$3 | 0) && base$3 >= 2 && base$3 <= 36);
+			assert$55(base$3 === (base$3 | 0) && base$3 >= 2 && base$3 <= 36);
 			number = number.toString().replace(/\s+/g, "");
 			var start = 0;
 			if (number[0] === "-") {
@@ -40984,7 +41225,7 @@ var require_bn = __commonJSMin((exports, module) => {
 				this.words = [number & 67108863, number / 67108864 & 67108863];
 				this.length = 2;
 			} else {
-				assert$54(number < 9007199254740992);
+				assert$55(number < 9007199254740992);
 				this.words = [
 					number & 67108863,
 					number / 67108864 & 67108863,
@@ -40996,7 +41237,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			this._initArray(this.toArray(), base$3, endian);
 		};
 		BN$14.prototype._initArray = function _initArray(number, base$3, endian) {
-			assert$54(typeof number.length === "number");
+			assert$55(typeof number.length === "number");
 			if (number.length <= 0) {
 				this.words = [0];
 				this.length = 1;
@@ -41034,7 +41275,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			if (c$1 >= 48 && c$1 <= 57) return c$1 - 48;
 			else if (c$1 >= 65 && c$1 <= 70) return c$1 - 55;
 			else if (c$1 >= 97 && c$1 <= 102) return c$1 - 87;
-			else assert$54(false, "Invalid character in " + string);
+			else assert$55(false, "Invalid character in " + string);
 		}
 		function parseHexByte(string, lowerBound, index$2) {
 			var r$2 = parseHex4Bits(string, index$2);
@@ -41081,7 +41322,7 @@ var require_bn = __commonJSMin((exports, module) => {
 				if (c$1 >= 49) b = c$1 - 49 + 10;
 				else if (c$1 >= 17) b = c$1 - 17 + 10;
 				else b = c$1;
-				assert$54(c$1 >= 0 && b < mul, "Invalid character");
+				assert$55(c$1 >= 0 && b < mul, "Invalid character");
 				r$2 += b;
 			}
 			return r$2;
@@ -41128,7 +41369,7 @@ var require_bn = __commonJSMin((exports, module) => {
 		BN$14.prototype._move = function _move(dest) {
 			move(dest, this);
 		};
-		BN$14.prototype.clone = function clone$20() {
+		BN$14.prototype.clone = function clone$21() {
 			var r$2 = new BN$14(null);
 			this.copy(r$2);
 			return r$2;
@@ -41302,20 +41543,20 @@ var require_bn = __commonJSMin((exports, module) => {
 				if (this.negative !== 0) out = "-" + out;
 				return out;
 			}
-			assert$54(false, "Base should be between 2 and 36");
+			assert$55(false, "Base should be between 2 and 36");
 		};
 		BN$14.prototype.toNumber = function toNumber$8() {
 			var ret = this.words[0];
 			if (this.length === 2) ret += this.words[1] * 67108864;
 			else if (this.length === 3 && this.words[2] === 1) ret += 4503599627370496 + this.words[1] * 67108864;
-			else if (this.length > 2) assert$54(false, "Number can only safely store up to 53 bits");
+			else if (this.length > 2) assert$55(false, "Number can only safely store up to 53 bits");
 			return this.negative !== 0 ? -ret : ret;
 		};
 		BN$14.prototype.toJSON = function toJSON() {
 			return this.toString(16, 2);
 		};
-		if (Buffer$27) BN$14.prototype.toBuffer = function toBuffer$5(endian, length) {
-			return this.toArrayLike(Buffer$27, endian, length);
+		if (Buffer$29) BN$14.prototype.toBuffer = function toBuffer$5(endian, length) {
+			return this.toArrayLike(Buffer$29, endian, length);
 		};
 		BN$14.prototype.toArray = function toArray$8(endian, length) {
 			return this.toArrayLike(Array, endian, length);
@@ -41328,8 +41569,8 @@ var require_bn = __commonJSMin((exports, module) => {
 			this._strip();
 			var byteLength$2 = this.byteLength();
 			var reqLength = length || Math.max(1, byteLength$2);
-			assert$54(byteLength$2 <= reqLength, "byte array longer than desired length");
-			assert$54(reqLength > 0, "Requested array length <= 0");
+			assert$55(byteLength$2 <= reqLength, "byte array longer than desired length");
+			assert$55(reqLength > 0, "Requested array length <= 0");
 			var res = allocate(ArrayType, reqLength);
 			var postfix = endian === "le" ? "LE" : "BE";
 			this["_toArrayLike" + postfix](res, byteLength$2);
@@ -41477,7 +41718,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this._strip();
 		};
 		BN$14.prototype.ior = function ior(num) {
-			assert$54((this.negative | num.negative) === 0);
+			assert$55((this.negative | num.negative) === 0);
 			return this.iuor(num);
 		};
 		BN$14.prototype.or = function or(num) {
@@ -41497,7 +41738,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this._strip();
 		};
 		BN$14.prototype.iand = function iand(num) {
-			assert$54((this.negative | num.negative) === 0);
+			assert$55((this.negative | num.negative) === 0);
 			return this.iuand(num);
 		};
 		BN$14.prototype.and = function and(num) {
@@ -41524,7 +41765,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this._strip();
 		};
 		BN$14.prototype.ixor = function ixor(num) {
-			assert$54((this.negative | num.negative) === 0);
+			assert$55((this.negative | num.negative) === 0);
 			return this.iuxor(num);
 		};
 		BN$14.prototype.xor = function xor$2(num) {
@@ -41536,7 +41777,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return num.clone().iuxor(this);
 		};
 		BN$14.prototype.inotn = function inotn(width) {
-			assert$54(typeof width === "number" && width >= 0);
+			assert$55(typeof width === "number" && width >= 0);
 			var bytesNeeded = Math.ceil(width / 26) | 0;
 			var bitsLeft = width % 26;
 			this._expand(bytesNeeded);
@@ -41549,7 +41790,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this.clone().inotn(width);
 		};
 		BN$14.prototype.setn = function setn(bit, val) {
-			assert$54(typeof bit === "number" && bit >= 0);
+			assert$55(typeof bit === "number" && bit >= 0);
 			var off = bit / 26 | 0;
 			var wbit = bit % 26;
 			this._expand(off + 1);
@@ -42377,8 +42618,8 @@ var require_bn = __commonJSMin((exports, module) => {
 				carry = carry >>> 13;
 			}
 			for (i$4 = 2 * len$2; i$4 < N; ++i$4) rws[i$4] = 0;
-			assert$54(carry === 0);
-			assert$54((carry & -8192) === 0);
+			assert$55(carry === 0);
+			assert$55((carry & -8192) === 0);
 		};
 		FFTM.prototype.stub = function stub(N) {
 			var ph = new Array(N);
@@ -42430,8 +42671,8 @@ var require_bn = __commonJSMin((exports, module) => {
 		BN$14.prototype.imuln = function imuln(num) {
 			var isNegNum = num < 0;
 			if (isNegNum) num = -num;
-			assert$54(typeof num === "number");
-			assert$54(num < 67108864);
+			assert$55(typeof num === "number");
+			assert$55(num < 67108864);
 			var carry = 0;
 			for (var i$4 = 0; i$4 < this.length; i$4++) {
 				var w$1 = (this.words[i$4] | 0) * num;
@@ -42469,7 +42710,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return res;
 		};
 		BN$14.prototype.iushln = function iushln(bits$1) {
-			assert$54(typeof bits$1 === "number" && bits$1 >= 0);
+			assert$55(typeof bits$1 === "number" && bits$1 >= 0);
 			var r$2 = bits$1 % 26;
 			var s$6 = (bits$1 - r$2) / 26;
 			var carryMask = 67108863 >>> 26 - r$2 << 26 - r$2;
@@ -42495,11 +42736,11 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this._strip();
 		};
 		BN$14.prototype.ishln = function ishln(bits$1) {
-			assert$54(this.negative === 0);
+			assert$55(this.negative === 0);
 			return this.iushln(bits$1);
 		};
 		BN$14.prototype.iushrn = function iushrn(bits$1, hint, extended) {
-			assert$54(typeof bits$1 === "number" && bits$1 >= 0);
+			assert$55(typeof bits$1 === "number" && bits$1 >= 0);
 			var h$1;
 			if (hint) h$1 = (hint - hint % 26) / 26;
 			else h$1 = 0;
@@ -42534,7 +42775,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this._strip();
 		};
 		BN$14.prototype.ishrn = function ishrn(bits$1, hint, extended) {
-			assert$54(this.negative === 0);
+			assert$55(this.negative === 0);
 			return this.iushrn(bits$1, hint, extended);
 		};
 		BN$14.prototype.shln = function shln(bits$1) {
@@ -42550,7 +42791,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this.clone().iushrn(bits$1);
 		};
 		BN$14.prototype.testn = function testn(bit) {
-			assert$54(typeof bit === "number" && bit >= 0);
+			assert$55(typeof bit === "number" && bit >= 0);
 			var r$2 = bit % 26;
 			var s$6 = (bit - r$2) / 26;
 			var q = 1 << r$2;
@@ -42559,10 +42800,10 @@ var require_bn = __commonJSMin((exports, module) => {
 			return !!(w$1 & q);
 		};
 		BN$14.prototype.imaskn = function imaskn(bits$1) {
-			assert$54(typeof bits$1 === "number" && bits$1 >= 0);
+			assert$55(typeof bits$1 === "number" && bits$1 >= 0);
 			var r$2 = bits$1 % 26;
 			var s$6 = (bits$1 - r$2) / 26;
-			assert$54(this.negative === 0, "imaskn works only with positive numbers");
+			assert$55(this.negative === 0, "imaskn works only with positive numbers");
 			if (this.length <= s$6) return this;
 			if (r$2 !== 0) s$6++;
 			this.length = Math.min(s$6, this.length);
@@ -42576,8 +42817,8 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this.clone().imaskn(bits$1);
 		};
 		BN$14.prototype.iaddn = function iaddn(num) {
-			assert$54(typeof num === "number");
-			assert$54(num < 67108864);
+			assert$55(typeof num === "number");
+			assert$55(num < 67108864);
 			if (num < 0) return this.isubn(-num);
 			if (this.negative !== 0) {
 				if (this.length === 1 && (this.words[0] | 0) <= num) {
@@ -42603,8 +42844,8 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this;
 		};
 		BN$14.prototype.isubn = function isubn(num) {
-			assert$54(typeof num === "number");
-			assert$54(num < 67108864);
+			assert$55(typeof num === "number");
+			assert$55(num < 67108864);
 			if (num < 0) return this.iaddn(-num);
 			if (this.negative !== 0) {
 				this.negative = 0;
@@ -42654,7 +42895,7 @@ var require_bn = __commonJSMin((exports, module) => {
 				this.words[i$4 + shift] = w$1 & 67108863;
 			}
 			if (carry === 0) return this._strip();
-			assert$54(carry === -1);
+			assert$55(carry === -1);
 			carry = 0;
 			for (i$4 = 0; i$4 < this.length; i$4++) {
 				w$1 = -(this.words[i$4] | 0) + carry;
@@ -42710,7 +42951,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			};
 		};
 		BN$14.prototype.divmod = function divmod(num, mode, positive) {
-			assert$54(!num.isZero());
+			assert$55(!num.isZero());
 			if (this.isZero()) return {
 				div: new BN$14(0),
 				mod: new BN$14(0)
@@ -42789,7 +43030,7 @@ var require_bn = __commonJSMin((exports, module) => {
 		BN$14.prototype.modrn = function modrn(num) {
 			var isNegNum = num < 0;
 			if (isNegNum) num = -num;
-			assert$54(num <= 67108863);
+			assert$55(num <= 67108863);
 			var p$1 = (1 << 26) % num;
 			var acc = 0;
 			for (var i$4 = this.length - 1; i$4 >= 0; i$4--) acc = (p$1 * acc + (this.words[i$4] | 0)) % num;
@@ -42801,7 +43042,7 @@ var require_bn = __commonJSMin((exports, module) => {
 		BN$14.prototype.idivn = function idivn(num) {
 			var isNegNum = num < 0;
 			if (isNegNum) num = -num;
-			assert$54(num <= 67108863);
+			assert$55(num <= 67108863);
 			var carry = 0;
 			for (var i$4 = this.length - 1; i$4 >= 0; i$4--) {
 				var w$1 = (this.words[i$4] | 0) + carry * 67108864;
@@ -42815,8 +43056,8 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this.clone().idivn(num);
 		};
 		BN$14.prototype.egcd = function egcd(p$1) {
-			assert$54(p$1.negative === 0);
-			assert$54(!p$1.isZero());
+			assert$55(p$1.negative === 0);
+			assert$55(!p$1.isZero());
 			var x$1 = this;
 			var y$1 = p$1.clone();
 			if (x$1.negative !== 0) x$1 = x$1.umod(p$1);
@@ -42875,8 +43116,8 @@ var require_bn = __commonJSMin((exports, module) => {
 			};
 		};
 		BN$14.prototype._invmp = function _invmp(p$1) {
-			assert$54(p$1.negative === 0);
-			assert$54(!p$1.isZero());
+			assert$55(p$1.negative === 0);
+			assert$55(!p$1.isZero());
 			var a$2 = this;
 			var b = p$1.clone();
 			if (a$2.negative !== 0) a$2 = a$2.umod(p$1);
@@ -42952,7 +43193,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this.words[0] & num;
 		};
 		BN$14.prototype.bincn = function bincn(bit) {
-			assert$54(typeof bit === "number");
+			assert$55(typeof bit === "number");
 			var r$2 = bit % 26;
 			var s$6 = (bit - r$2) / 26;
 			var q = 1 << r$2;
@@ -42987,7 +43228,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			if (this.length > 1) res = 1;
 			else {
 				if (negative) num = -num;
-				assert$54(num <= 67108863, "Number is too big");
+				assert$55(num <= 67108863, "Number is too big");
 				var w$1 = this.words[0] | 0;
 				res = w$1 === num ? 0 : w$1 < num ? -1 : 1;
 			}
@@ -43049,12 +43290,12 @@ var require_bn = __commonJSMin((exports, module) => {
 			return new Red(num);
 		};
 		BN$14.prototype.toRed = function toRed(ctx) {
-			assert$54(!this.red, "Already a number in reduction context");
-			assert$54(this.negative === 0, "red works only with positives");
+			assert$55(!this.red, "Already a number in reduction context");
+			assert$55(this.negative === 0, "red works only with positives");
 			return ctx.convertTo(this)._forceRed(ctx);
 		};
 		BN$14.prototype.fromRed = function fromRed() {
-			assert$54(this.red, "fromRed works only with numbers in reduction context");
+			assert$55(this.red, "fromRed works only with numbers in reduction context");
 			return this.red.convertFrom(this);
 		};
 		BN$14.prototype._forceRed = function _forceRed(ctx) {
@@ -43062,66 +43303,66 @@ var require_bn = __commonJSMin((exports, module) => {
 			return this;
 		};
 		BN$14.prototype.forceRed = function forceRed(ctx) {
-			assert$54(!this.red, "Already a number in reduction context");
+			assert$55(!this.red, "Already a number in reduction context");
 			return this._forceRed(ctx);
 		};
 		BN$14.prototype.redAdd = function redAdd(num) {
-			assert$54(this.red, "redAdd works only with red numbers");
+			assert$55(this.red, "redAdd works only with red numbers");
 			return this.red.add(this, num);
 		};
 		BN$14.prototype.redIAdd = function redIAdd(num) {
-			assert$54(this.red, "redIAdd works only with red numbers");
+			assert$55(this.red, "redIAdd works only with red numbers");
 			return this.red.iadd(this, num);
 		};
 		BN$14.prototype.redSub = function redSub(num) {
-			assert$54(this.red, "redSub works only with red numbers");
+			assert$55(this.red, "redSub works only with red numbers");
 			return this.red.sub(this, num);
 		};
 		BN$14.prototype.redISub = function redISub(num) {
-			assert$54(this.red, "redISub works only with red numbers");
+			assert$55(this.red, "redISub works only with red numbers");
 			return this.red.isub(this, num);
 		};
 		BN$14.prototype.redShl = function redShl(num) {
-			assert$54(this.red, "redShl works only with red numbers");
+			assert$55(this.red, "redShl works only with red numbers");
 			return this.red.shl(this, num);
 		};
 		BN$14.prototype.redMul = function redMul(num) {
-			assert$54(this.red, "redMul works only with red numbers");
+			assert$55(this.red, "redMul works only with red numbers");
 			this.red._verify2(this, num);
 			return this.red.mul(this, num);
 		};
 		BN$14.prototype.redIMul = function redIMul(num) {
-			assert$54(this.red, "redMul works only with red numbers");
+			assert$55(this.red, "redMul works only with red numbers");
 			this.red._verify2(this, num);
 			return this.red.imul(this, num);
 		};
 		BN$14.prototype.redSqr = function redSqr() {
-			assert$54(this.red, "redSqr works only with red numbers");
+			assert$55(this.red, "redSqr works only with red numbers");
 			this.red._verify1(this);
 			return this.red.sqr(this);
 		};
 		BN$14.prototype.redISqr = function redISqr() {
-			assert$54(this.red, "redISqr works only with red numbers");
+			assert$55(this.red, "redISqr works only with red numbers");
 			this.red._verify1(this);
 			return this.red.isqr(this);
 		};
 		BN$14.prototype.redSqrt = function redSqrt() {
-			assert$54(this.red, "redSqrt works only with red numbers");
+			assert$55(this.red, "redSqrt works only with red numbers");
 			this.red._verify1(this);
 			return this.red.sqrt(this);
 		};
 		BN$14.prototype.redInvm = function redInvm() {
-			assert$54(this.red, "redInvm works only with red numbers");
+			assert$55(this.red, "redInvm works only with red numbers");
 			this.red._verify1(this);
 			return this.red.invm(this);
 		};
 		BN$14.prototype.redNeg = function redNeg() {
-			assert$54(this.red, "redNeg works only with red numbers");
+			assert$55(this.red, "redNeg works only with red numbers");
 			this.red._verify1(this);
 			return this.red.neg(this);
 		};
 		BN$14.prototype.redPow = function redPow(num) {
-			assert$54(this.red && !num.red, "redPow(normalNum)");
+			assert$55(this.red && !num.red, "redPow(normalNum)");
 			this.red._verify1(this);
 			return this.red.pow(this, num);
 		};
@@ -43251,18 +43492,18 @@ var require_bn = __commonJSMin((exports, module) => {
 				this.m = prime.p;
 				this.prime = prime;
 			} else {
-				assert$54(m$3.gtn(1), "modulus must be greater than 1");
+				assert$55(m$3.gtn(1), "modulus must be greater than 1");
 				this.m = m$3;
 				this.prime = null;
 			}
 		}
 		Red.prototype._verify1 = function _verify1(a$2) {
-			assert$54(a$2.negative === 0, "red works only with positives");
-			assert$54(a$2.red, "red works only with red numbers");
+			assert$55(a$2.negative === 0, "red works only with positives");
+			assert$55(a$2.red, "red works only with red numbers");
 		};
 		Red.prototype._verify2 = function _verify2(a$2, b) {
-			assert$54((a$2.negative | b.negative) === 0, "red works only with positives");
-			assert$54(a$2.red && a$2.red === b.red, "red works only with red numbers");
+			assert$55((a$2.negative | b.negative) === 0, "red works only with positives");
+			assert$55(a$2.red && a$2.red === b.red, "red works only with red numbers");
 		};
 		Red.prototype.imod = function imod(a$2) {
 			if (this.prime) return this.prime.ireduce(a$2)._forceRed(this);
@@ -43318,7 +43559,7 @@ var require_bn = __commonJSMin((exports, module) => {
 		Red.prototype.sqrt = function sqrt(a$2) {
 			if (a$2.isZero()) return a$2.clone();
 			var mod3 = this.m.andln(3);
-			assert$54(mod3 % 2 === 1);
+			assert$55(mod3 % 2 === 1);
 			if (mod3 === 3) {
 				var pow$1 = this.m.add(new BN$14(1)).iushrn(2);
 				return this.pow(a$2, pow$1);
@@ -43329,7 +43570,7 @@ var require_bn = __commonJSMin((exports, module) => {
 				s$6++;
 				q.iushrn(1);
 			}
-			assert$54(!q.isZero());
+			assert$55(!q.isZero());
 			var one = new BN$14(1).toRed(this);
 			var nOne = one.redNeg();
 			var lpow = this.m.subn(1).iushrn(1);
@@ -43343,7 +43584,7 @@ var require_bn = __commonJSMin((exports, module) => {
 			while (t$7.cmp(one) !== 0) {
 				var tmp = t$7;
 				for (var i$4 = 0; tmp.cmp(one) !== 0; i$4++) tmp = tmp.redSqr();
-				assert$54(i$4 < m$3);
+				assert$55(i$4 < m$3);
 				var b = this.pow(c$1, new BN$14(1).iushln(m$3 - i$4 - 1));
 				r$2 = r$2.redMul(b);
 				c$1 = b.redSqr();
@@ -45706,11 +45947,11 @@ var RootFactory = class RootFactory {
 	static generate(root$11, schema$2, args$1) {
 		(0, import_assert.default)(root$11, "Must be invoked on a Joi instance.");
 		const cloned = schema$2.clone();
-		const originalDescribe$1 = cloned.describe.bind(cloned);
+		const originalDescribe = cloned.describe.bind(cloned);
 		cloned.describe = function() {
 			const cached = RootFactory.$_cachedDescriptions.get(this);
 			if (cached) return cached;
-			const result = originalDescribe$1();
+			const result = originalDescribe();
 			RootFactory.$_cachedDescriptions.set(this, result);
 			return result;
 		};
@@ -143180,7 +143421,7 @@ const encode = (schema$2, options = {}) => {
 		});
 	}
 	const json$1 = JSON.stringify({
-		version: "0.1.0-master-cb87a6f9",
+		version: "0.1.0-master-952eca46",
 		schema: description$2
 	}, (key, value) => {
 		if (typeof value === "bigint") return value.toString();
@@ -143228,9 +143469,9 @@ const decode = (base64, options = {}) => {
 	});
 	if (!isPlainObject(description$2) || !("version" in description$2) || !("schema" in description$2) || typeof description$2.version !== "string" || !isPlainObject(description$2.schema)) throw new TypeError("Not a valid encoded schema");
 	const { version: schemaVersion, schema: schema$2 } = description$2;
-	if (import_semver.valid("0.1.0-master-cb87a6f9")) {
+	if (import_semver.valid("0.1.0-master-952eca46")) {
 		if (!import_semver.valid(import_semver.coerce(schemaVersion))) throw new TypeError(`Invalid schema version: ${schemaVersion}`);
-		if (import_semver.gt(import_semver.coerce(schemaVersion), "0.1.0-master-cb87a6f9")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 0.1.0-master-cb87a6f9`);
+		if (import_semver.gt(import_semver.coerce(schemaVersion), "0.1.0-master-952eca46")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 0.1.0-master-952eca46`);
 	}
 	return validator.build(schema$2);
 };
@@ -144684,7 +144925,7 @@ init_esm();
 var import_lib = __toESM(require_lib$3());
 var import_lib$1 = __toESM(require_lib$2());
 var import_lib$2 = __toESM(require_lib());
-const version = "0.1.0-master-cb87a6f9";
+const version = "0.1.0-master-952eca46";
 var ValidationError = import_lib$2.ValidationError;
 var location = import_lib$1.location;
 export { ValidationError, esm_exports as address, decode, encode, import_lib as formula, location, tlds, validator, version };