z-schema 12.2.0 → 12.3.1

package/dist/{json-validation.mjs → json-validation.js}

@@ -1,20 +1,20 @@
-import { isObject, whatIs } from "./utils/what-is.mjs";
-import { getId } from "./json-schema.mjs";
-import { Report } from "./report.mjs";
-import { compileSchemaRegex } from "./utils/schema-regex.mjs";
-import { VALIDATION_VOCAB_KEYWORDS, getCachedValidationResult, isValidationVocabularyEnabled } from "./validation/shared.mjs";
-import { additionalItemsValidator, containsValidator, itemsValidator, maxContainsValidator, maxItemsValidator, minContainsValidator, minItemsValidator, prefixItemsValidator, uniqueItemsValidator } from "./validation/array.mjs";
-import { allOfValidator, anyOfValidator, elseValidator, ifValidator, notValidator, oneOfValidator, thenValidator } from "./validation/combinators.mjs";
-import { exclusiveMaximumValidator, exclusiveMinimumValidator, maximumValidator, minimumValidator, multipleOfValidator } from "./validation/numeric.mjs";
-import { additionalPropertiesValidator, dependenciesValidator, dependentRequiredValidator, dependentSchemasValidator, maxPropertiesValidator, minPropertiesValidator, patternPropertiesValidator, propertiesValidator, propertyNamesValidator, requiredValidator } from "./validation/object.mjs";
-import { resolveDynamicRef, resolveRecursiveRef } from "./validation/ref.mjs";
-import { contentEncodingValidator, contentMediaTypeValidator, formatValidator, maxLengthValidator, minLengthValidator, patternValidator } from "./validation/string.mjs";
-import { constValidator, enumValidator, typeValidator } from "./validation/type.mjs";
+import { isObject, whatIs } from "./utils/what-is.js";
+import { getId } from "./json-schema.js";
+import { Report } from "./report.js";
+import { compileSchemaRegex } from "./utils/schema-regex.js";
+import { VALIDATION_VOCAB_KEYWORDS, getCachedValidationResult, isValidationVocabularyEnabled } from "./validation/shared.js";
+import { additionalItemsValidator, containsValidator, itemsValidator, maxContainsValidator, maxItemsValidator, minContainsValidator, minItemsValidator, prefixItemsValidator, uniqueItemsValidator } from "./validation/array.js";
+import { allOfValidator, anyOfValidator, elseValidator, ifValidator, notValidator, oneOfValidator, thenValidator } from "./validation/combinators.js";
+import { exclusiveMaximumValidator, exclusiveMinimumValidator, maximumValidator, minimumValidator, multipleOfValidator } from "./validation/numeric.js";
+import { additionalPropertiesValidator, dependenciesValidator, dependentRequiredValidator, dependentSchemasValidator, maxPropertiesValidator, minPropertiesValidator, patternPropertiesValidator, propertiesValidator, propertyNamesValidator, requiredValidator } from "./validation/object.js";
+import { resolveDynamicRef, resolveRecursiveRef } from "./validation/ref.js";
+import { contentEncodingValidator, contentMediaTypeValidator, formatValidator, maxLengthValidator, minLengthValidator, patternValidator } from "./validation/string.js";
+import { constValidator, enumValidator, typeValidator } from "./validation/type.js";
 //#region src/json-validation.ts
-function collectEvaluated(args) {
+function collectEvaluated(ctx, args) {
 	const { report, currentSchema, json, mode, depth } = args;
 	if (!currentSchema || typeof currentSchema === "boolean") return /* @__PURE__ */ new Set();
-	if (depth > (this.options.maxRecursionDepth ?? 100)) {
+	if (depth > (ctx.options.maxRecursionDepth ?? 100)) {
 		report.addError("COLLECT_EVALUATED_DEPTH_EXCEEDED", [depth]);
 		return /* @__PURE__ */ new Set();
 	}
@@ -25,7 +25,7 @@ function collectEvaluated(args) {
 		return false;
 	};
 	const recurse = (subSchema) => {
-		if (mode === "items") return collectEvaluated.call(this, {
+		if (mode === "items") return collectEvaluated(ctx, {
 			report,
 			currentSchema: subSchema,
 			json,
@@ -33,7 +33,7 @@ function collectEvaluated(args) {
 			jsonArr: args.jsonArr,
 			depth: depth + 1
 		});
-		return collectEvaluated.call(this, {
+		return collectEvaluated(ctx, {
 			report,
 			currentSchema: subSchema,
 			json,
@@ -43,7 +43,7 @@ function collectEvaluated(args) {
 		});
 	};
 	if (mode === "items") {
-		const jsonArr = args.jsonArr;
+		const { jsonArr } = args;
 		if (Array.isArray(currentSchema.prefixItems)) {
 			const len = Math.min(currentSchema.prefixItems.length, jsonArr.length);
 			for (let i = 0; i < len; i++) evaluated.add(i);
@@ -59,104 +59,102 @@ function collectEvaluated(args) {
 			let passed = getCachedValidationResult(report, currentSchema.contains, jsonArr[i]);
 			if (passed === void 0) {
 				const subReport = new Report(report);
-				validate.call(this, subReport, currentSchema.contains, jsonArr[i]);
+				validate(ctx, subReport, currentSchema.contains, jsonArr[i]);
 				passed = subReport.errors.length === 0;
 			}
 			if (passed) evaluated.add(i);
 		}
 		if (currentSchema.unevaluatedItems === true) return "all";
 	} else {
-		const jsonData = args.jsonData;
+		const { jsonData } = args;
 		if (isObject(currentSchema.properties)) {
-			for (const key of Object.keys(currentSchema.properties)) if (Object.hasOwn(jsonData, key)) evaluated.add(key);
+			const propKeysCE = Object.keys(currentSchema.properties);
+			for (let i = 0; i < propKeysCE.length; i++) {
+				const key = propKeysCE[i];
+				if (Object.hasOwn(jsonData, key)) evaluated.add(key);
+			}
 		}
 		if (isObject(currentSchema.patternProperties)) for (const pattern of Object.keys(currentSchema.patternProperties)) {
 			const result = compileSchemaRegex(pattern);
 			if (result.ok) {
-				for (const key of Object.keys(jsonData)) if (result.value.test(key)) evaluated.add(key);
+				const jdKeys = Object.keys(jsonData);
+				for (let i = 0; i < jdKeys.length; i++) if (result.value.test(jdKeys[i])) evaluated.add(jdKeys[i]);
 			}
 		}
 		if (currentSchema.additionalProperties !== void 0) {
-			const propKeys = isObject(currentSchema.properties) ? Object.keys(currentSchema.properties) : [];
+			const propKeySet = new Set(isObject(currentSchema.properties) ? Object.keys(currentSchema.properties) : []);
 			const patternRegexes = [];
 			if (isObject(currentSchema.patternProperties)) for (const pattern of Object.keys(currentSchema.patternProperties)) {
 				const result = compileSchemaRegex(pattern);
 				if (result.ok) patternRegexes.push(result.value);
 			}
-			for (const key of Object.keys(jsonData)) {
-				if (propKeys.includes(key)) continue;
-				if (patternRegexes.some((re) => re.test(key))) continue;
+			const apKeys = Object.keys(jsonData);
+			for (let i = 0; i < apKeys.length; i++) {
+				const key = apKeys[i];
+				if (propKeySet.has(key)) continue;
+				let matchedPattern = false;
+				for (let pi = 0; pi < patternRegexes.length; pi++) if (patternRegexes[pi].test(key)) {
+					matchedPattern = true;
+					break;
+				}
+				if (matchedPattern) continue;
 				evaluated.add(key);
 			}
 		}
 		if (isObject(currentSchema.dependentSchemas)) {
-			for (const [depKey, depSchema] of Object.entries(currentSchema.dependentSchemas)) if (Object.hasOwn(jsonData, depKey)) {
-				if (merge(recurse(depSchema))) return "all";
-			}
+			for (const [depKey, depSchema] of Object.entries(currentSchema.dependentSchemas)) if (Object.hasOwn(jsonData, depKey) && merge(recurse(depSchema))) return "all";
 		}
 		if (currentSchema.unevaluatedProperties === true) return "all";
 	}
 	if (Array.isArray(currentSchema.allOf)) {
-		for (const subSchema of currentSchema.allOf) if (merge(recurse(subSchema))) return "all";
+		for (let i = 0; i < currentSchema.allOf.length; i++) if (merge(recurse(currentSchema.allOf[i]))) return "all";
 	}
-	if (Array.isArray(currentSchema.anyOf)) for (const subSchema of currentSchema.anyOf) {
+	if (Array.isArray(currentSchema.anyOf)) for (let i = 0; i < currentSchema.anyOf.length; i++) {
+		const subSchema = currentSchema.anyOf[i];
 		let passed = getCachedValidationResult(report, subSchema, json);
 		if (passed === void 0) {
 			const subReport = new Report(report);
-			validate.call(this, subReport, subSchema, json);
+			validate(ctx, subReport, subSchema, json);
 			passed = subReport.errors.length === 0;
 		}
-		if (passed) {
-			if (merge(recurse(subSchema))) return "all";
-		}
+		if (passed && merge(recurse(subSchema))) return "all";
 	}
-	if (Array.isArray(currentSchema.oneOf)) for (const subSchema of currentSchema.oneOf) {
+	if (Array.isArray(currentSchema.oneOf)) for (let i = 0; i < currentSchema.oneOf.length; i++) {
+		const subSchema = currentSchema.oneOf[i];
 		let passed = getCachedValidationResult(report, subSchema, json);
 		if (passed === void 0) {
 			const subReport = new Report(report);
-			validate.call(this, subReport, subSchema, json);
+			validate(ctx, subReport, subSchema, json);
 			passed = subReport.errors.length === 0;
 		}
-		if (passed) {
-			if (merge(recurse(subSchema))) return "all";
-		}
+		if (passed && merge(recurse(subSchema))) return "all";
 	}
 	if (currentSchema.if !== void 0) {
 		let condPassed = getCachedValidationResult(report, currentSchema.if, json);
 		if (condPassed === void 0) {
 			const condReport = new Report(report);
-			validate.call(this, condReport, currentSchema.if, json);
+			validate(ctx, condReport, currentSchema.if, json);
 			condPassed = condReport.errors.length === 0;
 		}
 		if (condPassed) {
 			if (merge(recurse(currentSchema.if))) return "all";
-			if (currentSchema.then !== void 0) {
-				if (merge(recurse(currentSchema.then))) return "all";
-			}
-		} else if (currentSchema.else !== void 0) {
-			if (merge(recurse(currentSchema.else))) return "all";
-		}
-	}
-	if (currentSchema.__$refResolved && currentSchema.__$refResolved !== currentSchema) {
-		if (merge(recurse(currentSchema.__$refResolved))) return "all";
+			if (currentSchema.then !== void 0 && merge(recurse(currentSchema.then))) return "all";
+		} else if (currentSchema.else !== void 0 && merge(recurse(currentSchema.else))) return "all";
 	}
+	if (currentSchema.__$refResolved && currentSchema.__$refResolved !== currentSchema && merge(recurse(currentSchema.__$refResolved))) return "all";
 	const recursiveTarget = resolveRecursiveRef(currentSchema, report.__$recursiveAnchorStack);
-	if (recursiveTarget && recursiveTarget !== currentSchema) {
-		if (merge(recurse(recursiveTarget))) return "all";
-	}
+	if (recursiveTarget && recursiveTarget !== currentSchema && merge(recurse(recursiveTarget))) return "all";
 	const dynamicTarget = resolveDynamicRef(currentSchema, report.__$dynamicScopeStack);
-	if (dynamicTarget && dynamicTarget !== currentSchema) {
-		if (merge(recurse(dynamicTarget))) return "all";
-	}
+	if (dynamicTarget && dynamicTarget !== currentSchema && merge(recurse(dynamicTarget))) return "all";
 	return evaluated;
 }
-function unevaluatedItemsValidator(report, schema, json) {
+function unevaluatedItemsValidator(ctx, report, schema, json) {
 	if (!Array.isArray(json)) return;
 	if (schema.unevaluatedItems === true) return;
 	const unevalSchema = schema.unevaluatedItems;
 	if (unevalSchema === void 0) return;
 	if (json.length === 0) return;
-	const evaluatedItems = collectEvaluated.call(this, {
+	const evaluatedItems = collectEvaluated(ctx, {
 		report,
 		currentSchema: schema,
 		json,
@@ -169,23 +167,24 @@ function unevaluatedItemsValidator(report, schema, json) {
 	for (let i = 0; i < json.length; i++) if (!evaluatedItems.has(i)) unevaluatedIndices.push(i);
 	if (unevaluatedIndices.length === 0) return;
 	if (unevalSchema === false) report.addError("ARRAY_UNEVALUATED_ITEMS", void 0, void 0, schema, "unevaluatedItems");
-	else for (const idx of unevaluatedIndices) {
+	else for (let i = 0; i < unevaluatedIndices.length; i++) {
+		const idx = unevaluatedIndices[i];
 		const subReport = new Report(report);
-		validate.call(this, subReport, unevalSchema, json[idx]);
+		validate(ctx, subReport, unevalSchema, json[idx]);
 		if (subReport.errors.length > 0) {
 			report.addError("ARRAY_UNEVALUATED_ITEMS", void 0, void 0, schema, "unevaluatedItems");
 			break;
 		}
 	}
 }
-function unevaluatedPropertiesValidator(report, schema, json) {
+function unevaluatedPropertiesValidator(ctx, report, schema, json) {
 	if (!isObject(json)) return;
 	if (schema.unevaluatedProperties === true) return;
 	const unevalSchema = schema.unevaluatedProperties;
 	if (unevalSchema === void 0) return;
 	const allKeys = Object.keys(json);
 	if (allKeys.length === 0) return;
-	const evaluatedProperties = collectEvaluated.call(this, {
+	const evaluatedProperties = collectEvaluated(ctx, {
 		report,
 		currentSchema: schema,
 		json,
@@ -194,32 +193,35 @@ function unevaluatedPropertiesValidator(report, schema, json) {
 		depth: 0
 	});
 	if (evaluatedProperties === "all") return;
-	const unevaluatedKeys = allKeys.filter((key) => !evaluatedProperties.has(key));
+	const unevaluatedKeys = [];
+	for (let i = 0; i < allKeys.length; i++) if (!evaluatedProperties.has(allKeys[i])) unevaluatedKeys.push(allKeys[i]);
 	if (unevaluatedKeys.length === 0) return;
 	if (unevalSchema === false) report.addError("OBJECT_UNEVALUATED_PROPERTIES", [unevaluatedKeys.join(", ")], void 0, schema, "unevaluatedProperties");
-	else for (const key of unevaluatedKeys) {
+	else for (let i = 0; i < unevaluatedKeys.length; i++) {
+		const key = unevaluatedKeys[i];
 		const subReport = new Report(report);
-		validate.call(this, subReport, unevalSchema, json[key]);
+		validate(ctx, subReport, unevalSchema, json[key]);
 		if (subReport.errors.length > 0) report.addError("OBJECT_UNEVALUATED_PROPERTIES", [key], void 0, schema, "unevaluatedProperties");
 	}
 }
 function definitionsValidator() {}
+const noopValidator = () => {};
 const JsonValidators = {
-	id: () => {},
-	$id: () => {},
-	$ref: () => {},
-	$schema: () => {},
-	$dynamicAnchor: () => {},
-	$dynamicRef: () => {},
-	$anchor: () => {},
-	$defs: () => {},
-	$vocabulary: () => {},
-	$recursiveAnchor: () => {},
-	$recursiveRef: () => {},
-	examples: () => {},
-	title: () => {},
-	description: () => {},
-	default: () => {},
+	id: noopValidator,
+	$id: noopValidator,
+	$ref: noopValidator,
+	$schema: noopValidator,
+	$dynamicAnchor: noopValidator,
+	$dynamicRef: noopValidator,
+	$anchor: noopValidator,
+	$defs: noopValidator,
+	$vocabulary: noopValidator,
+	$recursiveAnchor: noopValidator,
+	$recursiveRef: noopValidator,
+	examples: noopValidator,
+	title: noopValidator,
+	description: noopValidator,
+	default: noopValidator,
 	type: typeValidator,
 	enum: enumValidator,
 	const: constValidator,
@@ -264,18 +266,18 @@ const JsonValidators = {
 	else: elseValidator,
 	definitions: definitionsValidator
 };
-const recurseArray = function(report, schema, json) {
+function recurseArray(ctx, report, schema, json) {
 	const schemaUri = typeof schema.$schema === "string" ? schema.$schema : void 0;
-	const prefixItems = (schemaUri === "https://json-schema.org/draft/2020-12/schema" || !schemaUri && this.options.version === "draft2020-12") && Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+	const prefixItems = (schemaUri === "https://json-schema.org/draft/2020-12/schema" || !schemaUri && ctx.options.version === "draft2020-12") && Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
 	if (prefixItems) {
 		for (let idx = 0; idx < json.length; idx++) if (idx < prefixItems.length) {
 			report.path.push(idx);
-			validate.call(this, report, prefixItems[idx], json[idx]);
+			validate(ctx, report, prefixItems[idx], json[idx]);
 			report.path.pop();
 		} else if (schema.items !== void 0 && !Array.isArray(schema.items)) {
 			report.path.push(idx);
 			report.schemaPath.push("items");
-			validate.call(this, report, schema.items, json[idx]);
+			validate(ctx, report, schema.items, json[idx]);
 			report.schemaPath.pop();
 			report.path.pop();
 		}
@@ -284,50 +286,56 @@ const recurseArray = function(report, schema, json) {
 	if (Array.isArray(schema.items)) {
 		for (let idx = 0; idx < json.length; idx++) if (idx < schema.items.length) {
 			report.path.push(idx);
-			validate.call(this, report, schema.items[idx], json[idx]);
+			validate(ctx, report, schema.items[idx], json[idx]);
 			report.path.pop();
 		} else if (typeof schema.additionalItems === "object") {
 			report.path.push(idx);
-			validate.call(this, report, schema.additionalItems, json[idx]);
+			validate(ctx, report, schema.additionalItems, json[idx]);
 			report.path.pop();
 		}
 	} else if (typeof schema.items === "object" || typeof schema.items === "boolean") for (let idx = 0; idx < json.length; idx++) {
 		report.path.push(idx);
 		report.schemaPath.push("items");
-		validate.call(this, report, schema.items, json[idx]);
+		validate(ctx, report, schema.items, json[idx]);
 		report.schemaPath.pop();
 		report.path.pop();
 	}
-};
-const recurseObject = function(report, schema, json) {
-	let additionalProperties = schema.additionalProperties;
+}
+function recurseObject(ctx, report, schema, json) {
+	let { additionalProperties } = schema;
 	if (additionalProperties === true || additionalProperties === void 0) additionalProperties = {};
 	const p = schema.properties ? Object.keys(schema.properties) : [];
 	const pp = schema.patternProperties ? Object.keys(schema.patternProperties) : [];
 	const keys = Object.keys(json);
+	const ppCompiled = [];
+	for (let i = 0; i < pp.length; i++) {
+		const r = compileSchemaRegex(pp[i]);
+		if (r.ok) ppCompiled.push({
+			key: pp[i],
+			re: r.value
+		});
+	}
 	for (const m of keys) {
 		const propertyValue = json[m];
+		const isProp = p.includes(m);
 		const s = [];
-		if (p.includes(m)) s.push(schema.properties[m]);
-		for (const regexString of pp) {
-			const result = compileSchemaRegex(regexString);
-			if (result.ok && result.value.test(m) === true) s.push(schema.patternProperties[regexString]);
-		}
+		if (isProp) s.push(schema.properties[m]);
+		for (let i = 0; i < ppCompiled.length; i++) if (ppCompiled[i].re.test(m)) s.push(schema.patternProperties[ppCompiled[i].key]);
 		if (s.length === 0 && additionalProperties !== false) s.push(additionalProperties);
 		for (const schema_s of s) {
 			report.path.push(m);
-			if (p.includes(m)) {
+			if (isProp) {
 				report.schemaPath.push("properties");
 				report.schemaPath.push(m);
 			} else report.schemaPath.push("additionalProperties");
-			validate.call(this, report, schema_s, propertyValue);
+			validate(ctx, report, schema_s, propertyValue);
 			report.path.pop();
 			report.schemaPath.pop();
-			if (p.includes(m)) report.schemaPath.pop();
+			if (isProp) report.schemaPath.pop();
 		}
 	}
-};
-function validate(report, schema, json) {
+}
+function validate(ctx, report, schema, json) {
 	report.commonErrorMessage = "JSON_OBJECT_VALIDATION_FAILED";
 	if (schema === true) return true;
 	if (schema === false) {
@@ -351,7 +359,7 @@ function validate(report, schema, json) {
 	let pushedDynamicScope = false;
 	const schemaId = getId(schema);
 	const dynamicScopeEntry = schema.__$resourceRoot || (isRoot || typeof schemaId === "string" ? schema : void 0);
-	if (dynamicScopeEntry && dynamicScopeStack[dynamicScopeStack.length - 1] !== dynamicScopeEntry) {
+	if (dynamicScopeEntry && dynamicScopeStack.at(-1) !== dynamicScopeEntry) {
 		dynamicScopeStack.push(dynamicScopeEntry);
 		pushedDynamicScope = true;
 	}
@@ -359,10 +367,11 @@ function validate(report, schema, json) {
 		recursiveAnchorStack.push(schema);
 		pushedRecursiveAnchor = true;
 	}
-	if (schema.$ref !== void 0) if (this.options.version === "draft2019-09" || this.options.version === "draft2020-12") {
-		if (!schema.__$refResolved) report.addError("REF_UNRESOLVED", [schema.$ref], void 0, schema);
-		else validate.call(this, report, schema.__$refResolved, json);
-		keys = keys.filter((key) => key !== "$ref");
+	if (schema.$ref !== void 0) if (ctx.options.version === "draft2019-09" || ctx.options.version === "draft2020-12") {
+		if (schema.__$refResolved) validate(ctx, report, schema.__$refResolved, json);
+		else report.addError("REF_UNRESOLVED", [schema.$ref], void 0, schema);
+		const refIdx = keys.indexOf("$ref");
+		if (refIdx !== -1) keys.splice(refIdx, 1);
 	} else {
 		let maxRefs = 99;
 		while (schema.$ref && maxRefs > 0) {
@@ -380,58 +389,65 @@ function validate(report, schema, json) {
 		report.schemaPath = [];
 	}
 	if (schema.$recursiveRef !== void 0) {
-		if (this.options.version === "draft2019-09" || this.options.version === "draft2020-12") {
+		if (ctx.options.version === "draft2019-09" || ctx.options.version === "draft2020-12") {
 			const recursiveRefTarget = resolveRecursiveRef(schema, recursiveAnchorStack);
-			if (!recursiveRefTarget) report.addError("REF_UNRESOLVED", [schema.$recursiveRef], void 0, schema);
-			else validate.call(this, report, recursiveRefTarget, json);
-			keys = keys.filter((key) => key !== "$recursiveRef");
+			if (recursiveRefTarget) validate(ctx, report, recursiveRefTarget, json);
+			else report.addError("REF_UNRESOLVED", [schema.$recursiveRef], void 0, schema);
+			const recursiveRefIdx = keys.indexOf("$recursiveRef");
+			if (recursiveRefIdx !== -1) keys.splice(recursiveRefIdx, 1);
 		}
 	}
 	if (schema.$dynamicRef !== void 0) {
-		if (this.options.version === "draft2020-12") {
+		if (ctx.options.version === "draft2020-12") {
 			const dynamicRefTarget = resolveDynamicRef(schema, dynamicScopeStack);
-			if (typeof dynamicRefTarget === "undefined") report.addError("REF_UNRESOLVED", [schema.$dynamicRef], void 0, schema);
-			else validate.call(this, report, dynamicRefTarget, json);
-			keys = keys.filter((key) => key !== "$dynamicRef");
+			if (dynamicRefTarget === void 0) report.addError("REF_UNRESOLVED", [schema.$dynamicRef], void 0, schema);
+			else validate(ctx, report, dynamicRefTarget, json);
+			const dynamicRefIdx = keys.indexOf("$dynamicRef");
+			if (dynamicRefIdx !== -1) keys.splice(dynamicRefIdx, 1);
 		}
 	}
-	const validationVocabularyEnabled = isValidationVocabularyEnabled(schema, report, this.options.version);
-	if (!validationVocabularyEnabled) keys = keys.filter((key) => !VALIDATION_VOCAB_KEYWORDS.has(key));
+	const validationVocabularyEnabled = isValidationVocabularyEnabled(schema, report, ctx.options.version);
+	if (!validationVocabularyEnabled) {
+		let wi = 0;
+		for (let ri = 0; ri < keys.length; ri++) if (!VALIDATION_VOCAB_KEYWORDS.has(keys[ri])) keys[wi++] = keys[ri];
+		keys.length = wi;
+	}
 	if (validationVocabularyEnabled && schema.type) {
 		keys.splice(keys.indexOf("type"), 1);
 		report.schemaPath.push("type");
-		JsonValidators.type.call(this, report, schema, json);
+		JsonValidators.type(ctx, report, schema, json);
 		report.schemaPath.pop();
-		if (report.errors.length && this.options.breakOnFirstError) {
+		if (report.errors.length && ctx.options.breakOnFirstError) {
 			if (pushedRecursiveAnchor) recursiveAnchorStack.pop();
 			if (pushedDynamicScope) dynamicScopeStack.pop();
 			return false;
 		}
 	}
 	const deferredUnevaluatedKeys = [];
-	for (const key of keys) {
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
 		if (key === "unevaluatedItems" || key === "unevaluatedProperties") {
 			deferredUnevaluatedKeys.push(key);
 			continue;
 		}
 		const validator = JsonValidators[key];
 		if (validator) {
-			validator.call(this, report, schema, json);
-			if (report.errors.length && this.options.breakOnFirstError) break;
+			validator(ctx, report, schema, json);
+			if (report.errors.length && ctx.options.breakOnFirstError) break;
 		}
 	}
-	if (deferredUnevaluatedKeys.length > 0 && !(report.errors.length > 0 && this.options.breakOnFirstError)) for (const key of deferredUnevaluatedKeys) {
-		const validator = JsonValidators[key];
+	if (deferredUnevaluatedKeys.length > 0 && !(report.errors.length > 0 && ctx.options.breakOnFirstError)) for (let i = 0; i < deferredUnevaluatedKeys.length; i++) {
+		const validator = JsonValidators[deferredUnevaluatedKeys[i]];
 		if (validator) {
-			validator.call(this, report, schema, json);
-			if (report.errors.length && this.options.breakOnFirstError) break;
+			validator(ctx, report, schema, json);
+			if (report.errors.length && ctx.options.breakOnFirstError) break;
 		}
 	}
-	if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
-		if (Array.isArray(json)) recurseArray.call(this, report, schema, json);
-		else if (isObject(json)) recurseObject.call(this, report, schema, json);
+	if (report.errors.length === 0 || ctx.options.breakOnFirstError === false) {
+		if (Array.isArray(json)) recurseArray(ctx, report, schema, json);
+		else if (isObject(json)) recurseObject(ctx, report, schema, json);
 	}
-	if (typeof this.options.customValidator === "function") this.options.customValidator.call(this, report, schema, json);
+	if (typeof ctx.options.customValidator === "function") ctx.options.customValidator.call(ctx, report, schema, json);
 	if (pushedRecursiveAnchor) recursiveAnchorStack.pop();
 	if (pushedDynamicScope) dynamicScopeStack.pop();
 	if (isRoot) report.rootSchema = void 0;

package/dist/{report.d.mts → report.d.ts}

@@ -1,7 +1,7 @@
-import { ZSchemaOptions } from "./z-schema-options.mjs";
-import { ErrorCode, ErrorParam } from "./errors.mjs";
-import { ValidateCallback, ValidateOptions } from "./z-schema-base.mjs";
-import { JsonSchema, JsonSchemaAll, JsonSchemaInternal } from "./json-schema-versions.mjs";
+import { ZSchemaOptions } from "./z-schema-options.js";
+import { ErrorCode, ErrorParam } from "./errors.js";
+import { ValidateCallback, ValidateOptions } from "./z-schema-base.js";
+import { JsonSchema, JsonSchemaAll, JsonSchemaInternal } from "./json-schema-versions.js";
 
 //#region src/report.d.ts
 interface SchemaErrorDetail {
@@ -71,11 +71,10 @@ declare class Report {
   options: ZSchemaOptions;
   reportOptions: ReportOptions;
   validateOptions: ValidateOptions;
-  constructor(zschemaOptions: ZSchemaOptions, validateOptions?: ValidateOptions);
-  constructor(parentReport: Report, validateOptions?: ValidateOptions);
+  constructor(parentOrOptions: ZSchemaOptions | Report, validateOptions?: ValidateOptions);
   constructor(parentReport: Report, reportOptions: ReportOptions, validateOptions?: ValidateOptions);
   isValid(): boolean;
-  addAsyncTask<FV, FN extends (...args: any[]) => FV>(fn: FN, args: Parameters<FN>, asyncTaskResultProcessFn: (result: ReturnType<FN>) => void): void;
+  addAsyncTask<FN extends (...args: any[]) => any>(fn: FN, args: Parameters<FN>, asyncTaskResultProcessFn: (result: ReturnType<FN>) => void): void;
   /**
    * Like {@link addAsyncTask}, but automatically saves the current `path` and
    * restores it around `processFn`.  This eliminates the manual
@@ -88,7 +87,7 @@ declare class Report {
   getPath(returnPathAsString?: boolean): string | (string | number)[];
   getSchemaPath(): Array<string | number>;
   getSchemaId(): string | undefined;
-  hasError(errCode: string, errParams: Array<any>): boolean;
+  hasError(errCode: string, errParams: any[]): boolean;
   addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema | boolean, keyword?: keyof JsonSchemaAll): void;
   getJson(): unknown;
   addCustomError(errorCode: ErrorCode, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema | boolean, keyword?: keyof JsonSchemaAll): void;

package/dist/{report.mjs → report.js}

@@ -1,10 +1,10 @@
-import { isAbsoluteUri } from "./utils/uri.mjs";
-import { MAX_ASYNC_TIMEOUT } from "./utils/constants.mjs";
-import { isObject } from "./utils/what-is.mjs";
-import { Errors, getValidateError } from "./errors.mjs";
-import { shallowClone } from "./utils/clone.mjs";
-import { get } from "./utils/json.mjs";
-import { jsonSymbol, schemaSymbol } from "./utils/symbols.mjs";
+import { MAX_ASYNC_TIMEOUT } from "./utils/constants.js";
+import { isAbsoluteUri } from "./utils/uri.js";
+import { isObject } from "./utils/what-is.js";
+import { Errors, getValidateError } from "./errors.js";
+import { shallowClone } from "./utils/clone.js";
+import { get } from "./utils/json.js";
+import { jsonSymbol, schemaSymbol } from "./utils/symbols.js";
 //#region src/report.ts
 const ASYNC_TIMEOUT_POLL_MS = 10;
 var Report = class Report {
@@ -28,8 +28,8 @@ var Report = class Report {
 		if (parentOrOptions instanceof Report) {
 			this.reportOptions = reportOptionsOrValidate || {};
 			this.validateOptions = validateOptions || parentOrOptions.validateOptions;
-			this.__$recursiveAnchorStack = [...parentOrOptions.__$recursiveAnchorStack];
-			this.__$dynamicScopeStack = [...parentOrOptions.__$dynamicScopeStack];
+			this.__$recursiveAnchorStack = parentOrOptions.__$recursiveAnchorStack.slice();
+			this.__$dynamicScopeStack = parentOrOptions.__$dynamicScopeStack.slice();
 			this.__validationResultCache = parentOrOptions.__validationResultCache;
 		} else {
 			this.reportOptions = {};
@@ -112,30 +112,24 @@ var Report = class Report {
 		setTimeout(checkTimeout, ASYNC_TIMEOUT_POLL_MS);
 	}
 	getPath(returnPathAsString) {
-		let path = [];
-		if (this.parentReport) path = path.concat(this.parentReport.path);
-		path = path.concat(this.path);
-		if (returnPathAsString !== true) return "#/" + path.map(function(segment) {
+		const path = this.parentReport ? this.parentReport.path.concat(this.path) : this.path.slice();
+		if (returnPathAsString !== true) return `#/${path.map((segment) => {
 			segment = segment.toString();
-			if (isAbsoluteUri(segment)) return "uri(" + segment + ")";
-			return segment.replace(/~/g, "~0").replace(/\//g, "~1");
-		}).join("/");
+			if (isAbsoluteUri(segment)) return `uri(${segment})`;
+			return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+		}).join("/")}`;
 		return path;
 	}
 	getSchemaPath() {
-		let schemaPath = [];
-		if (this.parentReport) schemaPath = schemaPath.concat(this.parentReport.schemaPath);
-		schemaPath = schemaPath.concat(this.schemaPath);
-		return schemaPath;
+		if (this.parentReport) return this.parentReport.schemaPath.concat(this.schemaPath);
+		return this.schemaPath.slice();
 	}
 	getSchemaId() {
 		if (!this.rootSchema) return;
-		let path = [];
-		if (this.parentReport) path = path.concat(this.parentReport.path);
-		path = path.concat(this.path);
+		const path = this.parentReport ? this.parentReport.path.concat(this.path) : this.path.slice();
 		while (path.length > 0) {
 			const obj = get(this.rootSchema, path);
-			if (obj && obj.id) return obj.id;
+			if (isObject(obj) && typeof obj.id === "string") return obj.id;
 			path.pop();
 		}
 		return this.rootSchema.id;
@@ -158,11 +152,11 @@ var Report = class Report {
 	}
 	addCustomError(errorCode, errorMessage, params, subReports, schema, keyword) {
 		if (typeof this.reportOptions.maxErrors === "number" && this.errors.length >= this.reportOptions.maxErrors) return;
-		if (!errorMessage) throw new Error("No errorMessage known for code " + errorCode);
-		params = params || [];
+		if (!errorMessage) throw new Error(`No errorMessage known for code ${errorCode}`);
+		params ||= [];
 		for (let idx = 0; idx < params.length; idx++) {
 			const param = params[idx] === null || isObject(params[idx]) ? JSON.stringify(params[idx]) : params[idx];
-			errorMessage = errorMessage.replace("{" + idx + "}", param.toString());
+			errorMessage = errorMessage.replace(`{${idx}}`, param.toString());
 		}
 		const err = {
 			code: errorCode,
@@ -171,10 +165,10 @@ var Report = class Report {
 			path: this.getPath(this.options.reportPathAsArray),
 			schemaPath: this.getSchemaPath(),
 			schemaId: this.getSchemaId(),
-			keyword
+			keyword,
+			[schemaSymbol]: schema,
+			[jsonSymbol]: this.getJson()
 		};
-		err[schemaSymbol] = schema;
-		err[jsonSymbol] = this.getJson();
 		if (schema && typeof schema === "string") err.description = schema;
 		else if (schema && typeof schema === "object") {
 			if (schema.title) err.title = schema.title;
@@ -183,7 +177,10 @@ var Report = class Report {
 		if (subReports != null) {
 			if (!Array.isArray(subReports)) subReports = [subReports];
 			err.inner = [];
-			for (const subReport of subReports) for (const error of subReport.errors) err.inner.push(error);
+			for (let si = 0; si < subReports.length; si++) {
+				const errs = subReports[si].errors;
+				for (let ei = 0; ei < errs.length; ei++) err.inner.push(errs[ei]);
+			}
 			if (err.inner.length === 0) err.inner = void 0;
 		}
 		if (Array.isArray(this.validateOptions.excludeErrors) && this.validateOptions.excludeErrors.includes(errorCode)) return;