@peripheries/renderer 0.27.0 → 0.28.1

package/dist/catalog.js

@@ -1,7 +1,1266 @@
-import { x as isEach } from "./chunks/query-DOXxGTO2.js";
-import { a as eachFormProblems, c as validatePage, i as componentsFor } from "./chunks/validate-y5_6ws0s.js";
+import { x as isEach } from "./chunks/query-D_f73wsU.js";
+import { a as eachFormProblems, c as validatePage, i as componentsFor } from "./chunks/validate-BfXuQLmV.js";
 import { KNOWLEDGE_BUDGETS, KNOWLEDGE_KEY } from "@peripheries/runtime";
-import Ajv2020 from "ajv/dist/2020.js";
+function deepCompareStrict(a, b) {
+	const typeofa = typeof a;
+	if (typeofa !== typeof b) return false;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b)) return false;
+		const length = a.length;
+		if (length !== b.length) return false;
+		for (let i = 0; i < length; i++) if (!deepCompareStrict(a[i], b[i])) return false;
+		return true;
+	}
+	if (typeofa === "object") {
+		if (!a || !b) return a === b;
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys.length !== bKeys.length) return false;
+		for (const k of aKeys) if (!deepCompareStrict(a[k], b[k])) return false;
+		return true;
+	}
+	return a === b;
+}
+function encodePointer(p) {
+	return encodeURI(escapePointer(p));
+}
+function escapePointer(p) {
+	return p.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+var schemaArrayKeyword = {
+	prefixItems: true,
+	items: true,
+	allOf: true,
+	anyOf: true,
+	oneOf: true
+};
+var schemaMapKeyword = {
+	$defs: true,
+	definitions: true,
+	properties: true,
+	patternProperties: true,
+	dependentSchemas: true
+};
+var ignoredKeyword = {
+	id: true,
+	$id: true,
+	$ref: true,
+	$schema: true,
+	$anchor: true,
+	$vocabulary: true,
+	$comment: true,
+	default: true,
+	enum: true,
+	const: true,
+	required: true,
+	type: true,
+	maximum: true,
+	minimum: true,
+	exclusiveMaximum: true,
+	exclusiveMinimum: true,
+	multipleOf: true,
+	maxLength: true,
+	minLength: true,
+	pattern: true,
+	format: true,
+	maxItems: true,
+	minItems: true,
+	uniqueItems: true,
+	maxProperties: true,
+	minProperties: true
+};
+var initialBaseURI = typeof self !== "undefined" && self.location && self.location.origin !== "null" ? new URL(self.location.origin + self.location.pathname + location.search) : new URL("https://github.com/cfworker");
+function dereference(schema, lookup = Object.create(null), baseURI = initialBaseURI, basePointer = "") {
+	if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+		const id = schema.$id || schema.id;
+		if (id) {
+			const url = new URL(id, baseURI.href);
+			if (url.hash.length > 1) lookup[url.href] = schema;
+			else {
+				url.hash = "";
+				if (basePointer === "") baseURI = url;
+				else dereference(schema, lookup, baseURI);
+			}
+		}
+	} else if (schema !== true && schema !== false) return lookup;
+	const schemaURI = baseURI.href + (basePointer ? "#" + basePointer : "");
+	if (lookup[schemaURI] !== void 0) throw new Error(`Duplicate schema URI "${schemaURI}".`);
+	lookup[schemaURI] = schema;
+	if (schema === true || schema === false) return lookup;
+	if (schema.__absolute_uri__ === void 0) Object.defineProperty(schema, "__absolute_uri__", {
+		enumerable: false,
+		value: schemaURI
+	});
+	if (schema.$ref && schema.__absolute_ref__ === void 0) {
+		const url = new URL(schema.$ref, baseURI.href);
+		url.hash = url.hash;
+		Object.defineProperty(schema, "__absolute_ref__", {
+			enumerable: false,
+			value: url.href
+		});
+	}
+	if (schema.$recursiveRef && schema.__absolute_recursive_ref__ === void 0) {
+		const url = new URL(schema.$recursiveRef, baseURI.href);
+		url.hash = url.hash;
+		Object.defineProperty(schema, "__absolute_recursive_ref__", {
+			enumerable: false,
+			value: url.href
+		});
+	}
+	if (schema.$anchor) {
+		const url = new URL("#" + schema.$anchor, baseURI.href);
+		lookup[url.href] = schema;
+	}
+	for (let key in schema) {
+		if (ignoredKeyword[key]) continue;
+		const keyBase = `${basePointer}/${encodePointer(key)}`;
+		const subSchema = schema[key];
+		if (Array.isArray(subSchema)) {
+			if (schemaArrayKeyword[key]) {
+				const length = subSchema.length;
+				for (let i = 0; i < length; i++) dereference(subSchema[i], lookup, baseURI, `${keyBase}/${i}`);
+			}
+		} else if (schemaMapKeyword[key]) for (let subKey in subSchema) dereference(subSchema[subKey], lookup, baseURI, `${keyBase}/${encodePointer(subKey)}`);
+		else dereference(subSchema, lookup, baseURI, keyBase);
+	}
+	return lookup;
+}
+var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+var DAYS = [
+	0,
+	31,
+	28,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
+var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
+var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
+var URL_ = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu;
+var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
+var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+var EMAIL = (input) => {
+	if (input[0] === "\"") return false;
+	const [name, host, ...rest] = input.split("@");
+	if (!name || !host || rest.length !== 0 || name.length > 64 || host.length > 253) return false;
+	if (name[0] === "." || name.endsWith(".") || name.includes("..")) return false;
+	if (!/^[a-z0-9.-]+$/i.test(host) || !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(name)) return false;
+	return host.split(".").every((part) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part));
+};
+var IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+var IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
+var DURATION = (input) => input.length > 1 && input.length < 80 && (/^P\d+([.,]\d+)?W$/.test(input) || /^P[\dYMDTHS]*(\d[.,]\d+)?[YMDHS]$/.test(input) && /^P([.,\d]+Y)?([.,\d]+M)?([.,\d]+D)?(T([.,\d]+H)?([.,\d]+M)?([.,\d]+S)?)?$/.test(input));
+function bind(r) {
+	return r.test.bind(r);
+}
+var format = {
+	date,
+	time: time.bind(void 0, false),
+	"date-time": date_time,
+	duration: DURATION,
+	uri,
+	"uri-reference": bind(URIREF),
+	"uri-template": bind(URITEMPLATE),
+	url: bind(URL_),
+	email: EMAIL,
+	hostname: bind(HOSTNAME),
+	ipv4: bind(IPV4),
+	ipv6: bind(IPV6),
+	regex,
+	uuid: bind(UUID),
+	"json-pointer": bind(JSON_POINTER),
+	"json-pointer-uri-fragment": bind(JSON_POINTER_URI_FRAGMENT),
+	"relative-json-pointer": bind(RELATIVE_JSON_POINTER)
+};
+function isLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function date(str) {
+	const matches = str.match(DATE);
+	if (!matches) return false;
+	const year = +matches[1];
+	const month = +matches[2];
+	const day = +matches[3];
+	return month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);
+}
+function time(full, str) {
+	const matches = str.match(TIME);
+	if (!matches) return false;
+	const hour = +matches[1];
+	const minute = +matches[2];
+	const second = +matches[3];
+	const timeZone = !!matches[5];
+	return (hour <= 23 && minute <= 59 && second <= 59 || hour == 23 && minute == 59 && second == 60) && (!full || timeZone);
+}
+var DATE_TIME_SEPARATOR = /t|\s/i;
+function date_time(str) {
+	const dateTime = str.split(DATE_TIME_SEPARATOR);
+	return dateTime.length == 2 && date(dateTime[0]) && time(true, dateTime[1]);
+}
+var NOT_URI_FRAGMENT = /\/|:/;
+var URI_PATTERN = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+function uri(str) {
+	return NOT_URI_FRAGMENT.test(str) && URI_PATTERN.test(str);
+}
+var Z_ANCHOR = /[^\\]\\Z/;
+function regex(str) {
+	if (Z_ANCHOR.test(str)) return false;
+	try {
+		new RegExp(str, "u");
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+function ucs2length(s) {
+	let result = 0;
+	let length = s.length;
+	let index = 0;
+	let charCode;
+	while (index < length) {
+		result++;
+		charCode = s.charCodeAt(index++);
+		if (charCode >= 55296 && charCode <= 56319 && index < length) {
+			charCode = s.charCodeAt(index);
+			if ((charCode & 64512) == 56320) index++;
+		}
+	}
+	return result;
+}
+function validate(instance, schema, draft = "2019-09", lookup = dereference(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = "#", schemaLocation = "#", evaluated = Object.create(null)) {
+	if (schema === true) return {
+		valid: true,
+		errors: []
+	};
+	if (schema === false) return {
+		valid: false,
+		errors: [{
+			instanceLocation,
+			keyword: "false",
+			keywordLocation: instanceLocation,
+			error: "False boolean schema."
+		}]
+	};
+	const rawInstanceType = typeof instance;
+	let instanceType;
+	switch (rawInstanceType) {
+		case "boolean":
+		case "number":
+		case "string":
+			instanceType = rawInstanceType;
+			break;
+		case "object":
+			if (instance === null) instanceType = "null";
+			else if (Array.isArray(instance)) instanceType = "array";
+			else instanceType = "object";
+			break;
+		default: throw new Error(`Instances of "${rawInstanceType}" type are not supported.`);
+	}
+	const { $ref, $recursiveRef, $recursiveAnchor, type: $type, const: $const, enum: $enum, required: $required, not: $not, anyOf: $anyOf, allOf: $allOf, oneOf: $oneOf, if: $if, then: $then, else: $else, format: $format, properties: $properties, patternProperties: $patternProperties, additionalProperties: $additionalProperties, unevaluatedProperties: $unevaluatedProperties, minProperties: $minProperties, maxProperties: $maxProperties, propertyNames: $propertyNames, dependentRequired: $dependentRequired, dependentSchemas: $dependentSchemas, dependencies: $dependencies, prefixItems: $prefixItems, items: $items, additionalItems: $additionalItems, unevaluatedItems: $unevaluatedItems, contains: $contains, minContains: $minContains, maxContains: $maxContains, minItems: $minItems, maxItems: $maxItems, uniqueItems: $uniqueItems, minimum: $minimum, maximum: $maximum, exclusiveMinimum: $exclusiveMinimum, exclusiveMaximum: $exclusiveMaximum, multipleOf: $multipleOf, minLength: $minLength, maxLength: $maxLength, pattern: $pattern, __absolute_ref__, __absolute_recursive_ref__ } = schema;
+	const errors = [];
+	if ($recursiveAnchor === true && recursiveAnchor === null) recursiveAnchor = schema;
+	if ($recursiveRef === "#") {
+		const refSchema = recursiveAnchor === null ? lookup[__absolute_recursive_ref__] : recursiveAnchor;
+		const keywordLocation = `${schemaLocation}/$recursiveRef`;
+		const result = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
+		if (!result.valid) errors.push({
+			instanceLocation,
+			keyword: "$recursiveRef",
+			keywordLocation,
+			error: "A subschema had errors."
+		}, ...result.errors);
+	}
+	if ($ref !== void 0) {
+		const refSchema = lookup[__absolute_ref__ || $ref];
+		if (refSchema === void 0) {
+			let message = `Unresolved $ref "${$ref}".`;
+			if (__absolute_ref__ && __absolute_ref__ !== $ref) message += `  Absolute URI "${__absolute_ref__}".`;
+			message += `\nKnown schemas:\n- ${Object.keys(lookup).join("\n- ")}`;
+			throw new Error(message);
+		}
+		const keywordLocation = `${schemaLocation}/$ref`;
+		const result = validate(instance, refSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated);
+		if (!result.valid) errors.push({
+			instanceLocation,
+			keyword: "$ref",
+			keywordLocation,
+			error: "A subschema had errors."
+		}, ...result.errors);
+		if (draft === "4" || draft === "7") return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	if (Array.isArray($type)) {
+		let length = $type.length;
+		let valid = false;
+		for (let i = 0; i < length; i++) if (instanceType === $type[i] || $type[i] === "integer" && instanceType === "number" && instance % 1 === 0 && instance === instance) {
+			valid = true;
+			break;
+		}
+		if (!valid) errors.push({
+			instanceLocation,
+			keyword: "type",
+			keywordLocation: `${schemaLocation}/type`,
+			error: `Instance type "${instanceType}" is invalid. Expected "${$type.join("\", \"")}".`
+		});
+	} else if ($type === "integer") {
+		if (instanceType !== "number" || instance % 1 || instance !== instance) errors.push({
+			instanceLocation,
+			keyword: "type",
+			keywordLocation: `${schemaLocation}/type`,
+			error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+		});
+	} else if ($type !== void 0 && instanceType !== $type) errors.push({
+		instanceLocation,
+		keyword: "type",
+		keywordLocation: `${schemaLocation}/type`,
+		error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+	});
+	if ($const !== void 0) {
+		if (instanceType === "object" || instanceType === "array") {
+			if (!deepCompareStrict(instance, $const)) errors.push({
+				instanceLocation,
+				keyword: "const",
+				keywordLocation: `${schemaLocation}/const`,
+				error: `Instance does not match ${JSON.stringify($const)}.`
+			});
+		} else if (instance !== $const) errors.push({
+			instanceLocation,
+			keyword: "const",
+			keywordLocation: `${schemaLocation}/const`,
+			error: `Instance does not match ${JSON.stringify($const)}.`
+		});
+	}
+	if ($enum !== void 0) {
+		if (instanceType === "object" || instanceType === "array") {
+			if (!$enum.some((value) => deepCompareStrict(instance, value))) errors.push({
+				instanceLocation,
+				keyword: "enum",
+				keywordLocation: `${schemaLocation}/enum`,
+				error: `Instance does not match any of ${JSON.stringify($enum)}.`
+			});
+		} else if (!$enum.some((value) => instance === value)) errors.push({
+			instanceLocation,
+			keyword: "enum",
+			keywordLocation: `${schemaLocation}/enum`,
+			error: `Instance does not match any of ${JSON.stringify($enum)}.`
+		});
+	}
+	if ($not !== void 0) {
+		const keywordLocation = `${schemaLocation}/not`;
+		if (validate(instance, $not, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation).valid) errors.push({
+			instanceLocation,
+			keyword: "not",
+			keywordLocation,
+			error: "Instance matched \"not\" schema."
+		});
+	}
+	let subEvaluateds = [];
+	if ($anyOf !== void 0) {
+		const keywordLocation = `${schemaLocation}/anyOf`;
+		const errorsLength = errors.length;
+		let anyValid = false;
+		for (let i = 0; i < $anyOf.length; i++) {
+			const subSchema = $anyOf[i];
+			const subEvaluated = Object.create(evaluated);
+			const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+			errors.push(...result.errors);
+			anyValid = anyValid || result.valid;
+			if (result.valid) subEvaluateds.push(subEvaluated);
+		}
+		if (anyValid) errors.length = errorsLength;
+		else errors.splice(errorsLength, 0, {
+			instanceLocation,
+			keyword: "anyOf",
+			keywordLocation,
+			error: "Instance does not match any subschemas."
+		});
+	}
+	if ($allOf !== void 0) {
+		const keywordLocation = `${schemaLocation}/allOf`;
+		const errorsLength = errors.length;
+		let allValid = true;
+		for (let i = 0; i < $allOf.length; i++) {
+			const subSchema = $allOf[i];
+			const subEvaluated = Object.create(evaluated);
+			const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+			errors.push(...result.errors);
+			allValid = allValid && result.valid;
+			if (result.valid) subEvaluateds.push(subEvaluated);
+		}
+		if (allValid) errors.length = errorsLength;
+		else errors.splice(errorsLength, 0, {
+			instanceLocation,
+			keyword: "allOf",
+			keywordLocation,
+			error: `Instance does not match every subschema.`
+		});
+	}
+	if ($oneOf !== void 0) {
+		const keywordLocation = `${schemaLocation}/oneOf`;
+		const errorsLength = errors.length;
+		const matches = $oneOf.filter((subSchema, i) => {
+			const subEvaluated = Object.create(evaluated);
+			const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+			errors.push(...result.errors);
+			if (result.valid) subEvaluateds.push(subEvaluated);
+			return result.valid;
+		}).length;
+		if (matches === 1) errors.length = errorsLength;
+		else errors.splice(errorsLength, 0, {
+			instanceLocation,
+			keyword: "oneOf",
+			keywordLocation,
+			error: `Instance does not match exactly one subschema (${matches} matches).`
+		});
+	}
+	if (instanceType === "object" || instanceType === "array") Object.assign(evaluated, ...subEvaluateds);
+	if ($if !== void 0) {
+		const keywordLocation = `${schemaLocation}/if`;
+		if (validate(instance, $if, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated).valid) {
+			if ($then !== void 0) {
+				const thenResult = validate(instance, $then, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/then`, evaluated);
+				if (!thenResult.valid) errors.push({
+					instanceLocation,
+					keyword: "if",
+					keywordLocation,
+					error: `Instance does not match "then" schema.`
+				}, ...thenResult.errors);
+			}
+		} else if ($else !== void 0) {
+			const elseResult = validate(instance, $else, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/else`, evaluated);
+			if (!elseResult.valid) errors.push({
+				instanceLocation,
+				keyword: "if",
+				keywordLocation,
+				error: `Instance does not match "else" schema.`
+			}, ...elseResult.errors);
+		}
+	}
+	if (instanceType === "object") {
+		if ($required !== void 0) {
+			for (const key of $required) if (!(key in instance)) errors.push({
+				instanceLocation,
+				keyword: "required",
+				keywordLocation: `${schemaLocation}/required`,
+				error: `Instance does not have required property "${key}".`
+			});
+		}
+		const keys = Object.keys(instance);
+		if ($minProperties !== void 0 && keys.length < $minProperties) errors.push({
+			instanceLocation,
+			keyword: "minProperties",
+			keywordLocation: `${schemaLocation}/minProperties`,
+			error: `Instance does not have at least ${$minProperties} properties.`
+		});
+		if ($maxProperties !== void 0 && keys.length > $maxProperties) errors.push({
+			instanceLocation,
+			keyword: "maxProperties",
+			keywordLocation: `${schemaLocation}/maxProperties`,
+			error: `Instance does not have at least ${$maxProperties} properties.`
+		});
+		if ($propertyNames !== void 0) {
+			const keywordLocation = `${schemaLocation}/propertyNames`;
+			for (const key in instance) {
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(key, $propertyNames, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+				if (!result.valid) errors.push({
+					instanceLocation,
+					keyword: "propertyNames",
+					keywordLocation,
+					error: `Property name "${key}" does not match schema.`
+				}, ...result.errors);
+			}
+		}
+		if ($dependentRequired !== void 0) {
+			const keywordLocation = `${schemaLocation}/dependantRequired`;
+			for (const key in $dependentRequired) if (key in instance) {
+				const required = $dependentRequired[key];
+				for (const dependantKey of required) if (!(dependantKey in instance)) errors.push({
+					instanceLocation,
+					keyword: "dependentRequired",
+					keywordLocation,
+					error: `Instance has "${key}" but does not have "${dependantKey}".`
+				});
+			}
+		}
+		if ($dependentSchemas !== void 0) for (const key in $dependentSchemas) {
+			const keywordLocation = `${schemaLocation}/dependentSchemas`;
+			if (key in instance) {
+				const result = validate(instance, $dependentSchemas[key], draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`, evaluated);
+				if (!result.valid) errors.push({
+					instanceLocation,
+					keyword: "dependentSchemas",
+					keywordLocation,
+					error: `Instance has "${key}" but does not match dependant schema.`
+				}, ...result.errors);
+			}
+		}
+		if ($dependencies !== void 0) {
+			const keywordLocation = `${schemaLocation}/dependencies`;
+			for (const key in $dependencies) if (key in instance) {
+				const propsOrSchema = $dependencies[key];
+				if (Array.isArray(propsOrSchema)) {
+					for (const dependantKey of propsOrSchema) if (!(dependantKey in instance)) errors.push({
+						instanceLocation,
+						keyword: "dependencies",
+						keywordLocation,
+						error: `Instance has "${key}" but does not have "${dependantKey}".`
+					});
+				} else {
+					const result = validate(instance, propsOrSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`);
+					if (!result.valid) errors.push({
+						instanceLocation,
+						keyword: "dependencies",
+						keywordLocation,
+						error: `Instance has "${key}" but does not match dependant schema.`
+					}, ...result.errors);
+				}
+			}
+		}
+		const thisEvaluated = Object.create(null);
+		let stop = false;
+		if ($properties !== void 0) {
+			const keywordLocation = `${schemaLocation}/properties`;
+			for (const key in $properties) {
+				if (!(key in instance)) continue;
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(instance[key], $properties[key], draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(key)}`);
+				if (result.valid) evaluated[key] = thisEvaluated[key] = true;
+				else {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "properties",
+						keywordLocation,
+						error: `Property "${key}" does not match schema.`
+					}, ...result.errors);
+					if (stop) break;
+				}
+			}
+		}
+		if (!stop && $patternProperties !== void 0) {
+			const keywordLocation = `${schemaLocation}/patternProperties`;
+			for (const pattern in $patternProperties) {
+				const regex = new RegExp(pattern, "u");
+				const subSchema = $patternProperties[pattern];
+				for (const key in instance) {
+					if (!regex.test(key)) continue;
+					const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+					const result = validate(instance[key], subSchema, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(pattern)}`);
+					if (result.valid) evaluated[key] = thisEvaluated[key] = true;
+					else {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "patternProperties",
+							keywordLocation,
+							error: `Property "${key}" matches pattern "${pattern}" but does not match associated schema.`
+						}, ...result.errors);
+					}
+				}
+			}
+		}
+		if (!stop && $additionalProperties !== void 0) {
+			const keywordLocation = `${schemaLocation}/additionalProperties`;
+			for (const key in instance) {
+				if (thisEvaluated[key]) continue;
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(instance[key], $additionalProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+				if (result.valid) evaluated[key] = true;
+				else {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "additionalProperties",
+						keywordLocation,
+						error: `Property "${key}" does not match additional properties schema.`
+					}, ...result.errors);
+				}
+			}
+		} else if (!stop && $unevaluatedProperties !== void 0) {
+			const keywordLocation = `${schemaLocation}/unevaluatedProperties`;
+			for (const key in instance) if (!evaluated[key]) {
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(instance[key], $unevaluatedProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+				if (result.valid) evaluated[key] = true;
+				else errors.push({
+					instanceLocation,
+					keyword: "unevaluatedProperties",
+					keywordLocation,
+					error: `Property "${key}" does not match unevaluated properties schema.`
+				}, ...result.errors);
+			}
+		}
+	} else if (instanceType === "array") {
+		if ($maxItems !== void 0 && instance.length > $maxItems) errors.push({
+			instanceLocation,
+			keyword: "maxItems",
+			keywordLocation: `${schemaLocation}/maxItems`,
+			error: `Array has too many items (${instance.length} > ${$maxItems}).`
+		});
+		if ($minItems !== void 0 && instance.length < $minItems) errors.push({
+			instanceLocation,
+			keyword: "minItems",
+			keywordLocation: `${schemaLocation}/minItems`,
+			error: `Array has too few items (${instance.length} < ${$minItems}).`
+		});
+		const length = instance.length;
+		let i = 0;
+		let stop = false;
+		if ($prefixItems !== void 0) {
+			const keywordLocation = `${schemaLocation}/prefixItems`;
+			const length2 = Math.min($prefixItems.length, length);
+			for (; i < length2; i++) {
+				const result = validate(instance[i], $prefixItems[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+				evaluated[i] = true;
+				if (!result.valid) {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "prefixItems",
+						keywordLocation,
+						error: `Items did not match schema.`
+					}, ...result.errors);
+					if (stop) break;
+				}
+			}
+		}
+		if ($items !== void 0) {
+			const keywordLocation = `${schemaLocation}/items`;
+			if (Array.isArray($items)) {
+				const length2 = Math.min($items.length, length);
+				for (; i < length2; i++) {
+					const result = validate(instance[i], $items[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+					evaluated[i] = true;
+					if (!result.valid) {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "items",
+							keywordLocation,
+							error: `Items did not match schema.`
+						}, ...result.errors);
+						if (stop) break;
+					}
+				}
+			} else for (; i < length; i++) {
+				const result = validate(instance[i], $items, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+				evaluated[i] = true;
+				if (!result.valid) {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "items",
+						keywordLocation,
+						error: `Items did not match schema.`
+					}, ...result.errors);
+					if (stop) break;
+				}
+			}
+			if (!stop && $additionalItems !== void 0) {
+				const keywordLocation = `${schemaLocation}/additionalItems`;
+				for (; i < length; i++) {
+					const result = validate(instance[i], $additionalItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+					evaluated[i] = true;
+					if (!result.valid) {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "additionalItems",
+							keywordLocation,
+							error: `Items did not match additional items schema.`
+						}, ...result.errors);
+					}
+				}
+			}
+		}
+		if ($contains !== void 0) {
+			if (length === 0 && $minContains === void 0) errors.push({
+				instanceLocation,
+				keyword: "contains",
+				keywordLocation: `${schemaLocation}/contains`,
+				error: `Array is empty. It must contain at least one item matching the schema.`
+			});
+			else if ($minContains !== void 0 && length < $minContains) errors.push({
+				instanceLocation,
+				keyword: "minContains",
+				keywordLocation: `${schemaLocation}/minContains`,
+				error: `Array has less items (${length}) than minContains (${$minContains}).`
+			});
+			else {
+				const keywordLocation = `${schemaLocation}/contains`;
+				const errorsLength = errors.length;
+				let contained = 0;
+				for (let j = 0; j < length; j++) {
+					const result = validate(instance[j], $contains, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${j}`, keywordLocation);
+					if (result.valid) {
+						evaluated[j] = true;
+						contained++;
+					} else errors.push(...result.errors);
+				}
+				if (contained >= ($minContains || 0)) errors.length = errorsLength;
+				if ($minContains === void 0 && $maxContains === void 0 && contained === 0) errors.splice(errorsLength, 0, {
+					instanceLocation,
+					keyword: "contains",
+					keywordLocation,
+					error: `Array does not contain item matching schema.`
+				});
+				else if ($minContains !== void 0 && contained < $minContains) errors.push({
+					instanceLocation,
+					keyword: "minContains",
+					keywordLocation: `${schemaLocation}/minContains`,
+					error: `Array must contain at least ${$minContains} items matching schema. Only ${contained} items were found.`
+				});
+				else if ($maxContains !== void 0 && contained > $maxContains) errors.push({
+					instanceLocation,
+					keyword: "maxContains",
+					keywordLocation: `${schemaLocation}/maxContains`,
+					error: `Array may contain at most ${$maxContains} items matching schema. ${contained} items were found.`
+				});
+			}
+		}
+		if (!stop && $unevaluatedItems !== void 0) {
+			const keywordLocation = `${schemaLocation}/unevaluatedItems`;
+			for (; i < length; i++) {
+				if (evaluated[i]) continue;
+				const result = validate(instance[i], $unevaluatedItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+				evaluated[i] = true;
+				if (!result.valid) errors.push({
+					instanceLocation,
+					keyword: "unevaluatedItems",
+					keywordLocation,
+					error: `Items did not match unevaluated items schema.`
+				}, ...result.errors);
+			}
+		}
+		if ($uniqueItems) for (let j = 0; j < length; j++) {
+			const a = instance[j];
+			const ao = typeof a === "object" && a !== null;
+			for (let k = 0; k < length; k++) {
+				if (j === k) continue;
+				const b = instance[k];
+				if (a === b || ao && typeof b === "object" && b !== null && deepCompareStrict(a, b)) {
+					errors.push({
+						instanceLocation,
+						keyword: "uniqueItems",
+						keywordLocation: `${schemaLocation}/uniqueItems`,
+						error: `Duplicate items at indexes ${j} and ${k}.`
+					});
+					j = Number.MAX_SAFE_INTEGER;
+					k = Number.MAX_SAFE_INTEGER;
+				}
+			}
+		}
+	} else if (instanceType === "number") {
+		if (draft === "4") {
+			if ($minimum !== void 0 && ($exclusiveMinimum === true && instance <= $minimum || instance < $minimum)) errors.push({
+				instanceLocation,
+				keyword: "minimum",
+				keywordLocation: `${schemaLocation}/minimum`,
+				error: `${instance} is less than ${$exclusiveMinimum ? "or equal to " : ""} ${$minimum}.`
+			});
+			if ($maximum !== void 0 && ($exclusiveMaximum === true && instance >= $maximum || instance > $maximum)) errors.push({
+				instanceLocation,
+				keyword: "maximum",
+				keywordLocation: `${schemaLocation}/maximum`,
+				error: `${instance} is greater than ${$exclusiveMaximum ? "or equal to " : ""} ${$maximum}.`
+			});
+		} else {
+			if ($minimum !== void 0 && instance < $minimum) errors.push({
+				instanceLocation,
+				keyword: "minimum",
+				keywordLocation: `${schemaLocation}/minimum`,
+				error: `${instance} is less than ${$minimum}.`
+			});
+			if ($maximum !== void 0 && instance > $maximum) errors.push({
+				instanceLocation,
+				keyword: "maximum",
+				keywordLocation: `${schemaLocation}/maximum`,
+				error: `${instance} is greater than ${$maximum}.`
+			});
+			if ($exclusiveMinimum !== void 0 && instance <= $exclusiveMinimum) errors.push({
+				instanceLocation,
+				keyword: "exclusiveMinimum",
+				keywordLocation: `${schemaLocation}/exclusiveMinimum`,
+				error: `${instance} is less than ${$exclusiveMinimum}.`
+			});
+			if ($exclusiveMaximum !== void 0 && instance >= $exclusiveMaximum) errors.push({
+				instanceLocation,
+				keyword: "exclusiveMaximum",
+				keywordLocation: `${schemaLocation}/exclusiveMaximum`,
+				error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
+			});
+		}
+		if ($multipleOf !== void 0) {
+			const remainder = instance % $multipleOf;
+			if (Math.abs(0 - remainder) >= 1.1920929e-7 && Math.abs($multipleOf - remainder) >= 1.1920929e-7) errors.push({
+				instanceLocation,
+				keyword: "multipleOf",
+				keywordLocation: `${schemaLocation}/multipleOf`,
+				error: `${instance} is not a multiple of ${$multipleOf}.`
+			});
+		}
+	} else if (instanceType === "string") {
+		const length = $minLength === void 0 && $maxLength === void 0 ? 0 : ucs2length(instance);
+		if ($minLength !== void 0 && length < $minLength) errors.push({
+			instanceLocation,
+			keyword: "minLength",
+			keywordLocation: `${schemaLocation}/minLength`,
+			error: `String is too short (${length} < ${$minLength}).`
+		});
+		if ($maxLength !== void 0 && length > $maxLength) errors.push({
+			instanceLocation,
+			keyword: "maxLength",
+			keywordLocation: `${schemaLocation}/maxLength`,
+			error: `String is too long (${length} > ${$maxLength}).`
+		});
+		if ($pattern !== void 0 && !new RegExp($pattern, "u").test(instance)) errors.push({
+			instanceLocation,
+			keyword: "pattern",
+			keywordLocation: `${schemaLocation}/pattern`,
+			error: `String does not match pattern.`
+		});
+		if ($format !== void 0 && format[$format] && !format[$format](instance)) errors.push({
+			instanceLocation,
+			keyword: "format",
+			keywordLocation: `${schemaLocation}/format`,
+			error: `String does not match format "${$format}".`
+		});
+	}
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+var Validator = class {
+	schema;
+	draft;
+	shortCircuit;
+	lookup;
+	constructor(schema, draft = "2019-09", shortCircuit = true) {
+		this.schema = schema;
+		this.draft = draft;
+		this.shortCircuit = shortCircuit;
+		this.lookup = dereference(schema);
+	}
+	validate(instance) {
+		return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);
+	}
+	addSchema(schema, id) {
+		if (id) schema = {
+			...schema,
+			$id: id
+		};
+		dereference(schema, this.lookup);
+	}
+};
+var META_ROOT = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/schema",
+	$vocabulary: {
+		"https://json-schema.org/draft/2020-12/vocab/core": true,
+		"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+		"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+		"https://json-schema.org/draft/2020-12/vocab/validation": true,
+		"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+		"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+		"https://json-schema.org/draft/2020-12/vocab/content": true
+	},
+	$dynamicAnchor: "meta",
+	title: "Core and Validation specifications meta-schema",
+	allOf: [
+		{ $ref: "meta/core" },
+		{ $ref: "meta/applicator" },
+		{ $ref: "meta/unevaluated" },
+		{ $ref: "meta/validation" },
+		{ $ref: "meta/meta-data" },
+		{ $ref: "meta/format-annotation" },
+		{ $ref: "meta/content" }
+	],
+	type: ["object", "boolean"],
+	$comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+	properties: {
+		definitions: {
+			$comment: "\"definitions\" has been replaced by \"$defs\".",
+			type: "object",
+			additionalProperties: { $dynamicRef: "#meta" },
+			deprecated: true,
+			default: {}
+		},
+		dependencies: {
+			$comment: "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+			type: "object",
+			additionalProperties: { anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }] },
+			deprecated: true,
+			default: {}
+		},
+		$recursiveAnchor: {
+			$comment: "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+			$ref: "meta/core#/$defs/anchorString",
+			deprecated: true
+		},
+		$recursiveRef: {
+			$comment: "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+			$ref: "meta/core#/$defs/uriReferenceString",
+			deprecated: true
+		}
+	}
+};
+var META_VOCABULARIES = [
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/applicator",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/applicator": true },
+		$dynamicAnchor: "meta",
+		title: "Applicator vocabulary meta-schema",
+		type: ["object", "boolean"],
+		properties: {
+			prefixItems: { $ref: "#/$defs/schemaArray" },
+			items: { $dynamicRef: "#meta" },
+			contains: { $dynamicRef: "#meta" },
+			additionalProperties: { $dynamicRef: "#meta" },
+			properties: {
+				type: "object",
+				additionalProperties: { $dynamicRef: "#meta" },
+				default: {}
+			},
+			patternProperties: {
+				type: "object",
+				additionalProperties: { $dynamicRef: "#meta" },
+				propertyNames: { format: "regex" },
+				default: {}
+			},
+			dependentSchemas: {
+				type: "object",
+				additionalProperties: { $dynamicRef: "#meta" },
+				default: {}
+			},
+			propertyNames: { $dynamicRef: "#meta" },
+			if: { $dynamicRef: "#meta" },
+			then: { $dynamicRef: "#meta" },
+			else: { $dynamicRef: "#meta" },
+			allOf: { $ref: "#/$defs/schemaArray" },
+			anyOf: { $ref: "#/$defs/schemaArray" },
+			oneOf: { $ref: "#/$defs/schemaArray" },
+			not: { $dynamicRef: "#meta" }
+		},
+		$defs: { schemaArray: {
+			type: "array",
+			minItems: 1,
+			items: { $dynamicRef: "#meta" }
+		} }
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/content",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/content": true },
+		$dynamicAnchor: "meta",
+		title: "Content vocabulary meta-schema",
+		type: ["object", "boolean"],
+		properties: {
+			contentEncoding: { type: "string" },
+			contentMediaType: { type: "string" },
+			contentSchema: { $dynamicRef: "#meta" }
+		}
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/core",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/core": true },
+		$dynamicAnchor: "meta",
+		title: "Core vocabulary meta-schema",
+		type: ["object", "boolean"],
+		properties: {
+			$id: {
+				$ref: "#/$defs/uriReferenceString",
+				$comment: "Non-empty fragments not allowed.",
+				pattern: "^[^#]*#?$"
+			},
+			$schema: { $ref: "#/$defs/uriString" },
+			$ref: { $ref: "#/$defs/uriReferenceString" },
+			$anchor: { $ref: "#/$defs/anchorString" },
+			$dynamicRef: { $ref: "#/$defs/uriReferenceString" },
+			$dynamicAnchor: { $ref: "#/$defs/anchorString" },
+			$vocabulary: {
+				type: "object",
+				propertyNames: { $ref: "#/$defs/uriString" },
+				additionalProperties: { type: "boolean" }
+			},
+			$comment: { type: "string" },
+			$defs: {
+				type: "object",
+				additionalProperties: { $dynamicRef: "#meta" }
+			}
+		},
+		$defs: {
+			anchorString: {
+				type: "string",
+				pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+			},
+			uriString: {
+				type: "string",
+				format: "uri"
+			},
+			uriReferenceString: {
+				type: "string",
+				format: "uri-reference"
+			}
+		}
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true },
+		$dynamicAnchor: "meta",
+		title: "Format vocabulary meta-schema for annotation results",
+		type: ["object", "boolean"],
+		properties: { format: { type: "string" } }
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/meta-data": true },
+		$dynamicAnchor: "meta",
+		title: "Meta-data vocabulary meta-schema",
+		type: ["object", "boolean"],
+		properties: {
+			title: { type: "string" },
+			description: { type: "string" },
+			default: true,
+			deprecated: {
+				type: "boolean",
+				default: false
+			},
+			readOnly: {
+				type: "boolean",
+				default: false
+			},
+			writeOnly: {
+				type: "boolean",
+				default: false
+			},
+			examples: {
+				type: "array",
+				items: true
+			}
+		}
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true },
+		$dynamicAnchor: "meta",
+		title: "Unevaluated applicator vocabulary meta-schema",
+		type: ["object", "boolean"],
+		properties: {
+			unevaluatedItems: { $dynamicRef: "#meta" },
+			unevaluatedProperties: { $dynamicRef: "#meta" }
+		}
+	},
+	{
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://json-schema.org/draft/2020-12/meta/validation",
+		$vocabulary: { "https://json-schema.org/draft/2020-12/vocab/validation": true },
+		$dynamicAnchor: "meta",
+		title: "Validation vocabulary meta-schema",
+		type: ["object", "boolean"],
+		properties: {
+			type: { anyOf: [{ $ref: "#/$defs/simpleTypes" }, {
+				type: "array",
+				items: { $ref: "#/$defs/simpleTypes" },
+				minItems: 1,
+				uniqueItems: true
+			}] },
+			const: true,
+			enum: {
+				type: "array",
+				items: true
+			},
+			multipleOf: {
+				type: "number",
+				exclusiveMinimum: 0
+			},
+			maximum: { type: "number" },
+			exclusiveMaximum: { type: "number" },
+			minimum: { type: "number" },
+			exclusiveMinimum: { type: "number" },
+			maxLength: { $ref: "#/$defs/nonNegativeInteger" },
+			minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+			pattern: {
+				type: "string",
+				format: "regex"
+			},
+			maxItems: { $ref: "#/$defs/nonNegativeInteger" },
+			minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+			uniqueItems: {
+				type: "boolean",
+				default: false
+			},
+			maxContains: { $ref: "#/$defs/nonNegativeInteger" },
+			minContains: {
+				$ref: "#/$defs/nonNegativeInteger",
+				default: 1
+			},
+			maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
+			minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+			required: { $ref: "#/$defs/stringArray" },
+			dependentRequired: {
+				type: "object",
+				additionalProperties: { $ref: "#/$defs/stringArray" }
+			}
+		},
+		$defs: {
+			nonNegativeInteger: {
+				type: "integer",
+				minimum: 0
+			},
+			nonNegativeIntegerDefault0: {
+				$ref: "#/$defs/nonNegativeInteger",
+				default: 0
+			},
+			simpleTypes: { enum: [
+				"array",
+				"boolean",
+				"integer",
+				"null",
+				"number",
+				"object",
+				"string"
+			] },
+			stringArray: {
+				type: "array",
+				items: { type: "string" },
+				uniqueItems: true,
+				default: []
+			}
+		}
+	}
+];
+var SchemaUnrunnable = class extends Error {
+	name = "SchemaUnrunnable";
+};
+var compiled = new WeakMap();
+var reported = new Set();
+var unrunnable = 0;
+var unrunnableSchemas = () => unrunnable;
+var resetUnrunnableSchemas = () => {
+	unrunnable = 0;
+	reported.clear();
+};
+function refuse(schema, cause) {
+	const error = new SchemaUnrunnable(cause instanceof Error ? cause.message.split("\n")[0] : String(cause));
+	const key = JSON.stringify(schema);
+	if (!reported.has(key)) {
+		reported.add(key);
+		unrunnable += 1;
+		console.error(`[json-schema] a props schema could not be run, so its props were not checked: ${error.message}`);
+	}
+	return error;
+}
+var CONTAINER = /^(properties|items|allOf|anyOf|oneOf|\$ref|additionalProperties|prefixItems|patternProperties)$/;
+function words(errors) {
+	const leaves = errors.filter((e) => !CONTAINER.test(e.keyword));
+	return (leaves.length ? leaves : errors).map((e) => `${e.instanceLocation.replace(/^#/, "")} ${e.error.replace(/^Instance /, "")}`.trim()).filter((line, i, all) => all.indexOf(line) === i).slice(0, 3).join("; ") || "does not fit its schema";
+}
+function judge(schema, value) {
+	let validator = compiled.get(schema);
+	if (!validator) {
+		try {
+			const problems = schemaProblems(schema);
+			if (problems.length) throw new Error(`not valid JSON Schema: ${problems.join("; ")}`);
+			validator = new Validator(schema, "2020-12", false);
+		} catch (cause) {
+			validator = refuse(schema, cause);
+		}
+		compiled.set(schema, validator);
+	}
+	if (validator instanceof SchemaUnrunnable) throw validator;
+	let result;
+	try {
+		result = validator.validate(value);
+	} catch (cause) {
+		const error = refuse(schema, cause);
+		compiled.set(schema, error);
+		throw error;
+	}
+	return result.valid ? { valid: true } : {
+		valid: false,
+		message: words(result.errors)
+	};
+}
+var meta;
+function metaValidator() {
+	if (!meta) {
+		meta = new Validator(META_ROOT, "2020-12", false);
+		for (const vocabulary of META_VOCABULARIES) meta.addSchema(vocabulary, vocabulary.$id);
+	}
+	return meta;
+}
+var SCHEMA_VALUED = [
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"contentSchema"
+];
+var SCHEMA_LISTS = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+var SCHEMA_MAPS = [
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function schemaProblems(schema, at = "") {
+	if (typeof schema === "boolean") return [];
+	if (!isObject(schema)) return [`${at} must be a schema (an object or a boolean)`.trim()];
+	const out = [];
+	const own = { ...schema };
+	for (const key of [
+		...SCHEMA_VALUED,
+		...SCHEMA_LISTS,
+		...SCHEMA_MAPS
+	]) delete own[key];
+	const verdict = metaValidator().validate(own);
+	if (!verdict.valid) out.push(...words(verdict.errors).split("; ").map((line) => `${at}${line}`.trim()));
+	for (const key of SCHEMA_VALUED) if (key in schema) out.push(...schemaProblems(schema[key], `${at}/${key}`));
+	for (const key of SCHEMA_LISTS) {
+		const list = schema[key];
+		if (Array.isArray(list)) list.forEach((sub, i) => out.push(...schemaProblems(sub, `${at}/${key}/${i}`)));
+		else if (key in schema) out.push(`${at}/${key} must be an array of schemas`);
+	}
+	for (const key of SCHEMA_MAPS) {
+		const map = schema[key];
+		if (isObject(map)) for (const [name, sub] of Object.entries(map)) out.push(...schemaProblems(sub, `${at}/${key}/${name}`));
+		else if (key in schema) out.push(`${at}/${key} must be an object of schemas`);
+	}
+	return out;
+}
 var ref = (kind, key) => `${kind}:${key}`;
 var size = (v) => JSON.stringify(v ?? null).length;
 var isReference = (v) => typeof v === "string" && (v.startsWith("@") || v.includes("${"));
@@ -21,10 +1280,6 @@ var exampleOf = (row) => row?.kind === "component" ? row.snippets?.[0] : void 0;
 function checkCatalog(input) {
 	const out = [];
 	const at = (row, field) => `${ref(row.kind, row.key)}${field ? `.${field}` : ""}`;
-	const ajv = new Ajv2020({
-		strict: false,
-		allErrors: true
-	});
 	const schemaOf = (name) => (input.registry[name] ?? input.scopeRegistry?.[name])?.props_schema;
 	const byRef = new Map();
 	for (const row of input.rows) {
@@ -71,12 +1326,15 @@ function checkCatalog(input) {
 			message: `${name} has no snippet`
 		});
 		const schema = entry.props_schema;
-		if (schema !== void 0 && schema !== null && !ajv.validateSchema(schema)) out.push({
-			severity: "error",
-			code: "KNOWLEDGE_SCHEMA_INVALID",
-			path: `component:${name}.props_schema`,
-			message: ajv.errorsText(ajv.errors, { dataVar: "props_schema" })
-		});
+		if (schema !== void 0 && schema !== null) {
+			const problems = schemaProblems(schema);
+			if (problems.length) out.push({
+				severity: "error",
+				code: "KNOWLEDGE_SCHEMA_INVALID",
+				path: `component:${name}.props_schema`,
+				message: `props_schema ${problems.join("; ")}`
+			});
+		}
 	}
 	for (const row of input.rows) if (row.kind === "component" && !input.registry[row.key]) out.push({
 		severity: "error",
@@ -125,7 +1383,7 @@ function checkCatalog(input) {
 		...input.registry
 	})) catalog.components[name] = { props_schema: entry.props_schema };
 	for (const row of input.rows) (row.snippets ?? []).forEach((snippet, i) => {
-		for (const problem of checkSnippet(snippet, catalog, ajv)) out.push({
+		for (const problem of checkSnippet(snippet, catalog)) out.push({
 			...problem,
 			code: "KNOWLEDGE_SNIPPET_INVALID",
 			path: `${at(row, `snippets[${i}]`)}${problem.path ? `.${problem.path}` : ""}`
@@ -183,7 +1441,7 @@ function checkCatalog(input) {
 	});
 	return out;
 }
-function checkSnippet(snippet, catalog, ajv) {
+function checkSnippet(snippet, catalog) {
 	if (!Array.isArray(snippet?.cells) || snippet.cells.length === 0) return [{
 		severity: "error",
 		message: "a snippet needs at least one cell"
@@ -199,7 +1457,7 @@ function checkSnippet(snippet, catalog, ajv) {
 		},
 		layout
 	};
-	return [...validatePage(page, catalog), ...propsAgainstSchemas(page, catalog, ajv)].filter((d) => d.severity !== "legacy").map((d) => ({
+	return [...validatePage(page, catalog), ...propsAgainstSchemas(page, catalog)].filter((d) => d.severity !== "legacy" && d.code !== "KNOWLEDGE_SCHEMA_INVALID").map((d) => ({
 		severity: d.severity,
 		cellId: d.cellId,
 		path: d.path?.replace(/^content\./, ""),
@@ -207,13 +1465,10 @@ function checkSnippet(snippet, catalog, ajv) {
 	}));
 }
 function validatePageProps(page, catalog) {
-	return propsAgainstSchemas(page, catalog, new Ajv2020({
-		strict: false,
-		allErrors: true
-	}));
+	return propsAgainstSchemas(page, catalog);
 }
 var asNode = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
-function propsAgainstSchemas(page, catalog, ajv) {
+function propsAgainstSchemas(page, catalog) {
 	const out = [];
 	(Array.isArray(page.content?.cells) ? page.content.cells : []).forEach((cell, i) => {
 		const properties = cell?.component ? componentsFor(catalog, cell)[cell.component]?.props_schema?.properties : void 0;
@@ -230,27 +1485,21 @@ function propsAgainstSchemas(page, catalog, ajv) {
 			});
 			if (!schema || typeof schema !== "object") continue;
 			if (isEach(value)) {
-				if (eachFormProblems(value).length === 0) checkMap(value.map, asNode(asNode(schema)?.items), `${path}.map`, push, ajv);
+				if (eachFormProblems(value).length === 0) checkMap(value.map, asNode(asNode(schema)?.items), `${path}.map`, push);
 				continue;
 			}
 			if (holdsReference(value)) continue;
-			let valid;
-			try {
-				valid = ajv.validate(schema, value);
-			} catch {
-				continue;
-			}
-			if (!valid) push("error", "PROP_INVALID", path, ajv.errorsText(ajv.errors, { dataVar: "" }).replace(/^\s+/, ""));
+			validateLiteral(schema, value, path, push);
 		}
 	});
 	return out;
 }
-function checkMap(map, items, path, push, ajv) {
+function checkMap(map, items, path, push) {
 	if (!items) return;
 	if (isEach(map)) return;
 	const fields = asNode(map);
 	if (!fields || !items.properties) {
-		if (map !== void 0 && !holdsReference(map)) validateLiteral(items, map, path, push, ajv);
+		if (map !== void 0 && !holdsReference(map)) validateLiteral(items, map, path, push);
 		return;
 	}
 	for (const key of Array.isArray(items.required) ? items.required : []) if (typeof key === "string" && !(key in fields)) push("error", "PROP_INVALID", path, `each element needs "${key}"; the map doesn't give it`);
@@ -262,13 +1511,17 @@ function checkMap(map, items, path, push, ajv) {
 			continue;
 		}
 		if (isEach(v)) {
-			if (eachFormProblems(v).length === 0) checkMap(v.map, asNode(sub.items), `${path}.${key}.map`, push, ajv);
-		} else if (!holdsReference(v)) validateLiteral(sub, v, `${path}.${key}`, push, ajv);
+			if (eachFormProblems(v).length === 0) checkMap(v.map, asNode(sub.items), `${path}.${key}.map`, push);
+		} else if (!holdsReference(v)) validateLiteral(sub, v, `${path}.${key}`, push);
 	}
 }
-function validateLiteral(schema, value, path, push, ajv) {
+function validateLiteral(schema, value, path, push) {
 	try {
-		if (!ajv.validate(schema, value)) push("error", "PROP_INVALID", path, ajv.errorsText(ajv.errors, { dataVar: "" }).replace(/^\s+/, ""));
-	} catch {}
+		const verdict = judge(schema, value);
+		if (!verdict.valid) push("error", "PROP_INVALID", path, verdict.message);
+	} catch (error) {
+		if (!(error instanceof SchemaUnrunnable)) throw error;
+		push("error", "KNOWLEDGE_SCHEMA_INVALID", path, `couldn’t be checked: its schema can’t be run (${error.message})`);
+	}
 }
-export { checkCatalog, validatePageProps };
+export { checkCatalog, resetUnrunnableSchemas, unrunnableSchemas, validatePageProps };