z-schema 12.1.1 → 12.3.1

package/dist/utils/{hostname.mjs → hostname.js}

@@ -1,13 +1,16 @@
 import isIPModule from "validator/lib/isIP.js";
 import punycode from "punycode/punycode.js";
 //#region src/utils/hostname.ts
-const IDN_SEPARATOR_REGEX = /[\u3002\uff0e\uff61]/g;
-const IDN_SEPARATOR_TEST_REGEX = /[\u3002\uff0e\uff61]/;
+const IDN_SEPARATOR_REGEX = /[\u3002\uFF0E\uFF61]/g;
+const IDN_SEPARATOR_TEST_REGEX = /[\u3002\uFF0E\uFF61]/;
 const splitHostnameLabels = (hostname) => {
 	if (hostname.length === 0 || hostname.length > 255) return null;
 	if (hostname.startsWith(".") || hostname.endsWith(".")) return null;
 	const labels = hostname.split(".");
-	if (labels.some((label) => label.length === 0 || label.length > 63)) return null;
+	for (let i = 0; i < labels.length; i++) {
+		const len = labels[i].length;
+		if (len === 0 || len > 63) return null;
+	}
 	return labels;
 };
 const isAsciiHostnameLabel = (label) => /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label);
@@ -18,7 +21,7 @@ const toUnicodeLabel = (label) => {
 	if (!/^xn--/i.test(label)) return label;
 	try {
 		return punycode.toUnicode(label.toLowerCase());
-	} catch (_e) {
+	} catch {
 		return null;
 	}
 };
@@ -26,34 +29,27 @@ const isValidIdnUnicodeLabel = (label) => {
 	if (label.startsWith("-") || label.endsWith("-")) return false;
 	if (label.length >= 4 && label[2] === "-" && label[3] === "-" && !/^xn--/i.test(label)) return false;
 	if (/^\p{M}/u.test(label)) return false;
-	if (/[\u302e\u302f\u0640\u07fa]/u.test(label)) return false;
+	if (/[\u302E\u302F\u0640\u07FA]/u.test(label)) return false;
 	for (let idx = 0; idx < label.length; idx++) {
 		const char = label[idx];
-		if (char === "·") {
-			if (idx === 0 || idx === label.length - 1 || label[idx - 1] !== "l" || label[idx + 1] !== "l") return false;
-		}
-		if (char === "͵") {
-			if (idx === label.length - 1 || !isGreek(label[idx + 1])) return false;
-		}
-		if (char === "׳" || char === "״") {
-			if (idx === 0 || !isHebrew(label[idx - 1])) return false;
-		}
-		if (char === "‍") {
-			if (idx === 0 || label[idx - 1] !== "्") return false;
-		}
+		if (char === "·" && (idx === 0 || idx === label.length - 1 || label[idx - 1] !== "l" || label[idx + 1] !== "l")) return false;
+		if (char === "͵" && (idx === label.length - 1 || !isGreek(label[idx + 1]))) return false;
+		if ((char === "׳" || char === "״") && (idx === 0 || !isHebrew(label[idx - 1]))) return false;
+		if (char === "‍" && (idx === 0 || label[idx - 1] !== "्")) return false;
 	}
-	if (label.includes("・") && !hasCjkKanaOrHan(label.replace(/\u30fb/g, ""))) return false;
+	if (label.includes("・") && !hasCjkKanaOrHan(label.replaceAll("・", ""))) return false;
 	const hasArabicIndic = /[\u0660-\u0669]/.test(label);
-	const hasExtendedArabicIndic = /[\u06f0-\u06f9]/.test(label);
+	const hasExtendedArabicIndic = /[\u06F0-\u06F9]/.test(label);
 	if (hasArabicIndic && hasExtendedArabicIndic) return false;
 	return true;
 };
 const isValidHostname = (hostname) => {
-	if (IDN_SEPARATOR_TEST_REGEX.test(hostname) || /[^\x00-\x7F]/.test(hostname)) return false;
+	if (IDN_SEPARATOR_TEST_REGEX.test(hostname) || /[^\u0000-\u007F]/.test(hostname)) return false;
 	if (isIPModule.default(hostname, 4)) return false;
 	const labels = splitHostnameLabels(hostname);
 	if (labels === null) return false;
-	for (const label of labels) {
+	for (let i = 0; i < labels.length; i++) {
+		const label = labels[i];
 		if (!isAsciiHostnameLabel(label)) return false;
 		if (/^xn--/i.test(label)) {
 			const unicodeLabel = toUnicodeLabel(label);
@@ -65,7 +61,8 @@ const isValidHostname = (hostname) => {
 const isValidIdnHostname = (hostname) => {
 	const labels = splitHostnameLabels(hostname.replace(IDN_SEPARATOR_REGEX, "."));
 	if (labels === null) return false;
-	for (const label of labels) {
+	for (let i = 0; i < labels.length; i++) {
+		const label = labels[i];
 		const unicodeLabel = toUnicodeLabel(label);
 		if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) return false;
 	}

package/dist/utils/{json.mjs → json.js}

@@ -1,10 +1,11 @@
-import { isObject } from "./what-is.mjs";
+import { isObject } from "./what-is.js";
 //#region src/utils/json.ts
+const sortedKeys = (obj) => Object.keys(obj).sort();
 const areEqual = (json1, json2, options, _depth = 0) => {
 	const caseInsensitiveComparison = options?.caseInsensitiveComparison || false;
 	const maxDepth = options?.maxDepth ?? 100;
 	if (json1 === json2) return true;
-	if (caseInsensitiveComparison === true && typeof json1 === "string" && typeof json2 === "string" && json1.toUpperCase() === json2.toUpperCase()) return true;
+	if (caseInsensitiveComparison && typeof json1 === "string" && typeof json2 === "string" && json1.toUpperCase() === json2.toUpperCase()) return true;
 	if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in areEqual. If your data is deeply nested and valid, increase the maxRecursionDepth option.`);
 	let i, len;
 	if (Array.isArray(json1) && Array.isArray(json2)) {
@@ -22,13 +23,16 @@ const areEqual = (json1, json2, options, _depth = 0) => {
 	}
 	return false;
 };
-const decodeJSONPointer = (str) => {
-	return decodeURIComponent(str).replace(/~[0-1]/g, (x) => x === "~1" ? "/" : "~");
-};
-const sortedKeys = (obj) => Object.keys(obj).sort();
+const decodeJSONPointer = (str) => decodeURIComponent(str).replaceAll(/~[0-1]/g, (x) => x === "~1" ? "/" : "~");
 const get = (obj, path) => {
 	if (typeof path === "string") path = path.split(".");
-	return path.reduce((acc, key) => acc && acc[key] !== void 0 ? acc[key] : void 0, obj);
+	let acc = obj;
+	for (let i = 0; i < path.length; i++) {
+		const key = path[i];
+		if (acc && acc[key] !== void 0) acc = acc[key];
+		else return;
+	}
+	return acc;
 };
 //#endregion
 export { areEqual, decodeJSONPointer, get, sortedKeys };

package/dist/utils/{schema-regex.mjs → schema-regex.js}

@@ -1,4 +1,4 @@
-import { MAX_SCHEMA_REGEX_LENGTH } from "./constants.mjs";
+import { MAX_SCHEMA_REGEX_LENGTH } from "./constants.js";
 import isSafeRegex from "safe-regex2";
 //#region src/utils/schema-regex.ts
 function compileSchemaRegex(pattern) {
@@ -21,12 +21,12 @@ function compileSchemaRegex(pattern) {
 			ok: true,
 			value: new RegExp(pattern, "u")
 		};
-	} catch (e) {
+	} catch (error) {
 		return {
 			ok: false,
 			error: {
 				pattern,
-				message: e && e.message ? e.message : "Invalid regular expression"
+				message: error instanceof Error ? error.message : "Invalid regular expression"
 			}
 		};
 	}
@@ -35,12 +35,12 @@ function compileSchemaRegex(pattern) {
 			ok: true,
 			value: new RegExp(pattern)
 		};
-	} catch (e) {
+	} catch (error) {
 		return {
 			ok: false,
 			error: {
 				pattern,
-				message: e && e.message ? e.message : "Invalid regular expression"
+				message: error instanceof Error ? error.message : "Invalid regular expression"
 			}
 		};
 	}

package/dist/utils/{time.mjs → time.js}

@@ -12,9 +12,9 @@ const RFC3339_TIME_REGEX = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(\.[0-9]+)?(z|([+-]
 const parseRfc3339Time = (time) => {
 	const matches = RFC3339_TIME_REGEX.exec(time);
 	if (matches === null) return null;
-	const hour = parseInt(matches[1], 10);
-	const minute = parseInt(matches[2], 10);
-	const second = parseInt(matches[3], 10);
+	const hour = Number.parseInt(matches[1], 10);
+	const minute = Number.parseInt(matches[2], 10);
+	const second = Number.parseInt(matches[3], 10);
 	if (hour > 23 || minute > 59 || second > 60) return null;
 	let utcHour = hour;
 	let utcMinute = minute;
@@ -22,8 +22,8 @@ const parseRfc3339Time = (time) => {
 		const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(matches[5]);
 		if (offsetMatches === null) return null;
 		const offsetSign = offsetMatches[1];
-		const offsetHour = parseInt(offsetMatches[2], 10);
-		const offsetMinute = parseInt(offsetMatches[3], 10);
+		const offsetHour = Number.parseInt(offsetMatches[2], 10);
+		const offsetMinute = Number.parseInt(offsetMatches[3], 10);
 		if (offsetHour > 23 || offsetMinute > 59) return null;
 		const utc = toUtcTime(hour, minute, offsetSign, offsetHour, offsetMinute);
 		utcHour = utc.hour;

package/dist/utils/unicode.js

@@ -0,0 +1,22 @@
+//#region src/utils/unicode.ts
+/**
+* Returns the number of Unicode code points in the string.
+* Uses a surrogate-aware charCodeAt scan (equivalent to the string iterator)
+* that counts a surrogate pair as one code point and lone surrogates as one each.
+*/
+function unicodeLength(str) {
+	let count = str.length;
+	for (let i = 0; i < str.length - 1; i++) {
+		const hi = str.charCodeAt(i);
+		if (hi >= 55296 && hi <= 56319) {
+			const lo = str.charCodeAt(i + 1);
+			if (lo >= 56320 && lo <= 57343) {
+				count--;
+				i++;
+			}
+		}
+	}
+	return count;
+}
+//#endregion
+export { unicodeLength };

package/dist/utils/{what-is.mjs → what-is.js}

@@ -6,8 +6,7 @@ const whatIs = (what) => {
 		return "object";
 	}
 	if (typeof what === "number") {
-		if (Number.isFinite(what)) if (what % 1 === 0) return "integer";
-		else return "number";
+		if (Number.isFinite(what)) return what % 1 === 0 ? "integer" : "number";
 		if (Number.isNaN(what)) return "not-a-number";
 		return "unknown-number";
 	}

package/dist/validation/{array.mjs → array.js}

@@ -1,35 +1,33 @@
-import { isUniqueArray } from "../utils/array.mjs";
-import { cacheValidationResult, deferOrRunSync, shouldSkipValidate } from "./shared.mjs";
+import { isUniqueArray } from "../utils/array.js";
+import { cacheValidationResult, deferOrRunSync, shouldSkipValidate } from "./shared.js";
 //#region src/validation/array.ts
-function additionalItemsValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["ARRAY_ADDITIONAL_ITEMS"])) return;
+function additionalItemsValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["ARRAY_ADDITIONAL_ITEMS"])) return;
 	if (!Array.isArray(json)) return;
-	if (schema.additionalItems === false && Array.isArray(schema.items)) {
-		if (json.length > schema.items.length) report.addError("ARRAY_ADDITIONAL_ITEMS", void 0, void 0, schema, "additionalItems");
-	}
+	if (schema.additionalItems === false && Array.isArray(schema.items) && json.length > schema.items.length) report.addError("ARRAY_ADDITIONAL_ITEMS", void 0, void 0, schema, "additionalItems");
 }
 function itemsValidator() {}
 function prefixItemsValidator() {}
-function maxItemsValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["ARRAY_LENGTH_LONG"])) return;
+function maxItemsValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["ARRAY_LENGTH_LONG"])) return;
 	if (!Array.isArray(json)) return;
 	if (json.length > schema.maxItems) report.addError("ARRAY_LENGTH_LONG", [json.length, schema.maxItems], void 0, schema, "maxItems");
 }
-function minItemsValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["ARRAY_LENGTH_SHORT"])) return;
+function minItemsValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["ARRAY_LENGTH_SHORT"])) return;
 	if (!Array.isArray(json)) return;
 	if (json.length < schema.minItems) report.addError("ARRAY_LENGTH_SHORT", [json.length, schema.minItems], void 0, schema, "minItems");
 }
-function uniqueItemsValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["ARRAY_UNIQUE"])) return;
+function uniqueItemsValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["ARRAY_UNIQUE"])) return;
 	if (!Array.isArray(json)) return;
 	if (schema.uniqueItems === true) {
 		const matches = [];
-		if (isUniqueArray(json, matches, this.options.maxRecursionDepth) === false) report.addError("ARRAY_UNIQUE", matches, void 0, schema, "uniqueItems");
+		if (!isUniqueArray(json, matches, ctx.options.maxRecursionDepth)) report.addError("ARRAY_UNIQUE", matches, void 0, schema, "uniqueItems");
 	}
 }
-function containsValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["CONTAINS"])) return;
+function containsValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["CONTAINS"])) return;
 	if (!Array.isArray(json)) return;
 	const containsSchema = schema.contains;
 	if (containsSchema === void 0) return;
@@ -38,16 +36,16 @@ function containsValidator(report, schema, json) {
 	for (let idx = 0; idx < json.length; idx++) {
 		const subReport = new Report_(report);
 		subReports.push(subReport);
-		this._jsonValidate(subReport, containsSchema, json[idx]);
+		ctx._jsonValidate(subReport, containsSchema, json[idx]);
 		cacheValidationResult(report, containsSchema, json[idx], subReport.errors.length === 0);
 	}
 	const addContainsErrorIfNeeded = () => {
 		let matchingItems = 0;
-		for (const subReport of subReports) if (subReport.errors.length === 0) matchingItems += 1;
-		const supportsContainsBounds = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
+		for (let i = 0; i < subReports.length; i++) if (subReports[i].errors.length === 0) matchingItems += 1;
+		const supportsContainsBounds = ctx.options.version === "draft2019-09" || ctx.options.version === "draft2020-12";
 		const minContains = supportsContainsBounds && typeof schema.minContains === "number" ? schema.minContains ?? 1 : 1;
 		const maxContains = supportsContainsBounds && typeof schema.maxContains === "number" ? schema.maxContains : void 0;
-		if (!(matchingItems >= minContains) || !(maxContains === void 0 || matchingItems <= maxContains)) report.addError("CONTAINS", void 0, subReports, schema, void 0);
+		if (!(matchingItems >= minContains) || !(maxContains === void 0 || matchingItems <= maxContains)) report.addError("CONTAINS", void 0, subReports, schema);
 	};
 	deferOrRunSync(report, subReports, addContainsErrorIfNeeded);
 }

package/dist/validation/{combinators.mjs → combinators.js}

@@ -1,18 +1,18 @@
-import { Report } from "../report.mjs";
-import { cacheValidationResult, deferOrRunSync } from "./shared.mjs";
+import { Report } from "../report.js";
+import { cacheValidationResult, deferOrRunSync } from "./shared.js";
 //#region src/validation/combinators.ts
-function allOfValidator(report, schema, json) {
+function allOfValidator(ctx, report, schema, json) {
 	for (let i = 0; i < schema.allOf.length; i++) {
-		const validateResult = this._jsonValidate(report, schema.allOf[i], json);
-		if (this.options.breakOnFirstError && validateResult === false) break;
+		const validateResult = ctx._jsonValidate(report, schema.allOf[i], json);
+		if (ctx.options.breakOnFirstError && !validateResult) break;
 	}
 }
-function anyOfValidator(report, schema, json) {
+function anyOfValidator(ctx, report, schema, json) {
 	const subReports = [];
 	for (let i = 0; i < schema.anyOf.length; i++) {
 		const subReport = new Report(report);
 		subReports.push(subReport);
-		this._jsonValidate(subReport, schema.anyOf[i], json);
+		ctx._jsonValidate(subReport, schema.anyOf[i], json);
 		cacheValidationResult(report, schema.anyOf[i], json, subReport.errors.length === 0);
 	}
 	deferOrRunSync(report, subReports, () => {
@@ -21,15 +21,15 @@ function anyOfValidator(report, schema, json) {
 			passed = true;
 			break;
 		}
-		if (passed === false) report.addError("ANY_OF_MISSING", void 0, subReports, schema, "anyOf");
+		if (!passed) report.addError("ANY_OF_MISSING", void 0, subReports, schema, "anyOf");
 	});
 }
-function oneOfValidator(report, schema, json) {
+function oneOfValidator(ctx, report, schema, json) {
 	const subReports = [];
 	for (let i = 0; i < schema.oneOf.length; i++) {
 		const subReport = new Report(report);
 		subReports.push(subReport);
-		this._jsonValidate(subReport, schema.oneOf[i], json);
+		ctx._jsonValidate(subReport, schema.oneOf[i], json);
 		cacheValidationResult(report, schema.oneOf[i], json, subReport.errors.length === 0);
 	}
 	deferOrRunSync(report, subReports, () => {
@@ -39,22 +39,22 @@ function oneOfValidator(report, schema, json) {
 		else if (passes > 1) report.addError("ONE_OF_MULTIPLE", void 0, void 0, schema, "oneOf");
 	});
 }
-function notValidator(report, schema, json) {
+function notValidator(ctx, report, schema, json) {
 	const subReport = new Report(report);
-	if (this._jsonValidate(subReport, schema.not, json) === true) report.addError("NOT_PASSED", void 0, void 0, schema, "not");
+	if (ctx._jsonValidate(subReport, schema.not, json)) report.addError("NOT_PASSED", void 0, void 0, schema, "not");
 }
-function ifValidator(report, schema, json) {
-	if (this.options.version === "draft-04" || this.options.version === "draft-06") return;
+function ifValidator(ctx, report, schema, json) {
+	if (ctx.options.version === "draft-04" || ctx.options.version === "draft-06") return;
 	const conditionSchema = schema.if;
 	const thenSchema = schema.then;
 	const elseSchema = schema.else;
 	if (conditionSchema === void 0 || thenSchema === void 0 && elseSchema === void 0) return;
 	const conditionReport = new Report(report);
-	this._jsonValidate(conditionReport, conditionSchema, json);
+	ctx._jsonValidate(conditionReport, conditionSchema, json);
 	cacheValidationResult(report, conditionSchema, json, conditionReport.errors.length === 0);
 	const branchSchema = conditionReport.errors.length === 0 ? thenSchema : elseSchema;
 	if (branchSchema === void 0) return;
-	this._jsonValidate(report, branchSchema, json);
+	ctx._jsonValidate(report, branchSchema, json);
 }
 function thenValidator() {}
 function elseValidator() {}

package/dist/validation/{numeric.mjs → numeric.js}

@@ -1,35 +1,35 @@
-import { shouldSkipValidate } from "./shared.mjs";
+import { shouldSkipValidate } from "./shared.js";
 //#region src/validation/numeric.ts
-function multipleOfValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MULTIPLE_OF"])) return;
+function multipleOfValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MULTIPLE_OF"])) return;
 	if (typeof json !== "number") return;
 	const result = json / schema.multipleOf;
 	if (!Number.isFinite(result) || Math.abs(result - Math.round(result)) >= 1e-10) report.addError("MULTIPLE_OF", [json, schema.multipleOf], void 0, schema, "multipleOf");
 }
-function maximumValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MAXIMUM", "MAXIMUM_EXCLUSIVE"])) return;
+function maximumValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MAXIMUM", "MAXIMUM_EXCLUSIVE"])) return;
 	if (typeof json !== "number") return;
 	if (schema.exclusiveMaximum !== true) {
 		if (json > schema.maximum) report.addError("MAXIMUM", [json, schema.maximum], void 0, schema, "maximum");
 	} else if (json >= schema.maximum) report.addError("MAXIMUM_EXCLUSIVE", [json, schema.maximum], void 0, schema, "maximum");
 }
-function exclusiveMaximumValidator(report, schema, json) {
+function exclusiveMaximumValidator(ctx, report, schema, json) {
 	if (typeof schema.exclusiveMaximum === "number") {
-		if (shouldSkipValidate(this.validateOptions, ["MAXIMUM_EXCLUSIVE"])) return;
+		if (shouldSkipValidate(ctx.validateOptions, ["MAXIMUM_EXCLUSIVE"])) return;
 		if (typeof json !== "number") return;
 		if (json >= schema.exclusiveMaximum) report.addError("MAXIMUM_EXCLUSIVE", [json, schema.exclusiveMaximum], void 0, schema, "exclusiveMaximum");
 	}
 }
-function minimumValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MINIMUM", "MINIMUM_EXCLUSIVE"])) return;
+function minimumValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MINIMUM", "MINIMUM_EXCLUSIVE"])) return;
 	if (typeof json !== "number") return;
 	if (schema.exclusiveMinimum !== true) {
 		if (json < schema.minimum) report.addError("MINIMUM", [json, schema.minimum], void 0, schema, "minimum");
 	} else if (json <= schema.minimum) report.addError("MINIMUM_EXCLUSIVE", [json, schema.minimum], void 0, schema, "minimum");
 }
-function exclusiveMinimumValidator(report, schema, json) {
+function exclusiveMinimumValidator(ctx, report, schema, json) {
 	if (typeof schema.exclusiveMinimum === "number") {
-		if (shouldSkipValidate(this.validateOptions, ["MINIMUM_EXCLUSIVE"])) return;
+		if (shouldSkipValidate(ctx.validateOptions, ["MINIMUM_EXCLUSIVE"])) return;
 		if (typeof json !== "number") return;
 		if (json <= schema.exclusiveMinimum) report.addError("MINIMUM_EXCLUSIVE", [json, schema.exclusiveMinimum], void 0, schema, "exclusiveMinimum");
 	}

package/dist/validation/{object.mjs → object.js}

@@ -1,22 +1,22 @@
-import { isObject } from "../utils/what-is.mjs";
-import { compileSchemaRegex } from "../utils/schema-regex.mjs";
-import { difference } from "../utils/array.mjs";
-import { deferOrRunSync, shouldSkipValidate, supportsDependentKeywords } from "./shared.mjs";
+import { isObject } from "../utils/what-is.js";
+import { compileSchemaRegex } from "../utils/schema-regex.js";
+import { difference } from "../utils/array.js";
+import { deferOrRunSync, shouldSkipValidate, supportsDependentKeywords } from "./shared.js";
 //#region src/validation/object.ts
-function maxPropertiesValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["OBJECT_PROPERTIES_MAXIMUM"])) return;
+function maxPropertiesValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["OBJECT_PROPERTIES_MAXIMUM"])) return;
 	if (!isObject(json)) return;
 	const keysCount = Object.keys(json).length;
 	if (keysCount > schema.maxProperties) report.addError("OBJECT_PROPERTIES_MAXIMUM", [keysCount, schema.maxProperties], void 0, schema, "maxProperties");
 }
-function minPropertiesValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["OBJECT_PROPERTIES_MINIMUM"])) return;
+function minPropertiesValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["OBJECT_PROPERTIES_MINIMUM"])) return;
 	if (!isObject(json)) return;
 	const keysCount = Object.keys(json).length;
 	if (keysCount < schema.minProperties) report.addError("OBJECT_PROPERTIES_MINIMUM", [keysCount, schema.minProperties], void 0, schema, "minProperties");
 }
-function requiredValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["OBJECT_MISSING_REQUIRED_PROPERTY"])) return;
+function requiredValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["OBJECT_MISSING_REQUIRED_PROPERTY"])) return;
 	if (!isObject(json)) return;
 	const idx = schema.required.length;
 	for (let i = 0; i < idx; i++) {
@@ -24,30 +24,31 @@ function requiredValidator(report, schema, json) {
 		if (!Object.hasOwn(json, requiredPropertyName)) report.addError("OBJECT_MISSING_REQUIRED_PROPERTY", [requiredPropertyName], void 0, schema, "required");
 	}
 }
-function additionalPropertiesValidator(report, schema, json) {
-	if (schema.properties === void 0 && schema.patternProperties === void 0) return propertiesValidator.call(this, report, schema, json);
+function additionalPropertiesValidator(ctx, report, schema, json) {
+	if (schema.properties === void 0 && schema.patternProperties === void 0) propertiesValidator(ctx, report, schema, json);
 }
-function patternPropertiesValidator(report, schema, json) {
-	if (schema.properties === void 0) return propertiesValidator.call(this, report, schema, json);
+function patternPropertiesValidator(ctx, report, schema, json) {
+	if (schema.properties === void 0) propertiesValidator(ctx, report, schema, json);
 }
-function propertiesValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["OBJECT_ADDITIONAL_PROPERTIES"])) return;
+function propertiesValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["OBJECT_ADDITIONAL_PROPERTIES"])) return;
 	if (!isObject(json)) return;
-	const properties = schema.properties !== void 0 ? schema.properties : {};
-	const patternProperties = schema.patternProperties !== void 0 ? schema.patternProperties : {};
+	const properties = schema.properties === void 0 ? {} : schema.properties;
+	const patternProperties = schema.patternProperties === void 0 ? {} : schema.patternProperties;
 	if (schema.additionalProperties === false) {
 		let s = Object.keys(json);
 		const p = Object.keys(properties);
 		const pp = Object.keys(patternProperties);
 		s = difference(s, p);
-		for (const ppKey of pp) {
+		for (let i = 0; i < pp.length; i++) {
+			const ppKey = pp[i];
 			const result = compileSchemaRegex(ppKey);
 			if (!result.ok) continue;
 			const regExp = result.value;
-			for (let idx2 = s.length - 1; idx2 >= 0; idx2--) if (regExp.test(s[idx2]) === true) s.splice(idx2, 1);
+			for (let idx2 = s.length - 1; idx2 >= 0; idx2--) if (regExp.test(s[idx2])) s.splice(idx2, 1);
 		}
 		if (s.length > 0) {
-			if (Array.isArray(this.options.assumeAdditional)) for (const allowed of this.options.assumeAdditional) {
+			if (Array.isArray(ctx.options.assumeAdditional)) for (const allowed of ctx.options.assumeAdditional) {
 				const io = s.indexOf(allowed);
 				if (io !== -1) s.splice(io, 1);
 			}
@@ -55,29 +56,29 @@ function propertiesValidator(report, schema, json) {
 		}
 	}
 }
-function dependenciesValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) return;
+function dependenciesValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) return;
 	if (!isObject(json)) return;
 	const keys = Object.keys(schema.dependencies);
 	for (const dependencyName of keys) if (Object.hasOwn(json, dependencyName)) {
 		const dependencyDefinition = schema.dependencies[dependencyName];
 		if (Array.isArray(dependencyDefinition)) {
 			for (const requiredPropertyName of dependencyDefinition) if (!Object.hasOwn(json, requiredPropertyName)) report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], void 0, schema, "dependencies");
-		} else this._jsonValidate(report, dependencyDefinition, json);
+		} else ctx._jsonValidate(report, dependencyDefinition, json);
 	}
 }
-function dependentSchemasValidator(report, schema, json) {
-	if (!supportsDependentKeywords(schema, this.options.version)) return;
+function dependentSchemasValidator(ctx, report, schema, json) {
+	if (!supportsDependentKeywords(schema, ctx.options.version)) return;
 	if (!isObject(json) || !isObject(schema.dependentSchemas)) return;
 	const keys = Object.keys(schema.dependentSchemas);
 	for (const dependencyName of keys) if (Object.hasOwn(json, dependencyName)) {
 		const dependencySchema = schema.dependentSchemas[dependencyName];
-		this._jsonValidate(report, dependencySchema, json);
+		ctx._jsonValidate(report, dependencySchema, json);
 	}
 }
-function dependentRequiredValidator(report, schema, json) {
-	if (!supportsDependentKeywords(schema, this.options.version)) return;
-	if (shouldSkipValidate(this.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) return;
+function dependentRequiredValidator(ctx, report, schema, json) {
+	if (!supportsDependentKeywords(schema, ctx.options.version)) return;
+	if (shouldSkipValidate(ctx.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) return;
 	if (!isObject(json) || !isObject(schema.dependentRequired)) return;
 	const keys = Object.keys(schema.dependentRequired);
 	for (const dependencyName of keys) {
@@ -87,8 +88,8 @@ function dependentRequiredValidator(report, schema, json) {
 		for (const requiredPropertyName of requiredProperties) if (!Object.hasOwn(json, requiredPropertyName)) report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], void 0, schema, "dependentRequired");
 	}
 }
-function propertyNamesValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["PROPERTY_NAMES"])) return;
+function propertyNamesValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["PROPERTY_NAMES"])) return;
 	if (!isObject(json)) return;
 	const propertyNamesSchema = schema.propertyNames;
 	if (propertyNamesSchema === void 0) return;
@@ -98,10 +99,10 @@ function propertyNamesValidator(report, schema, json) {
 	for (const key of keys) {
 		const subReport = new Report_(report);
 		subReports.push(subReport);
-		this._jsonValidate(subReport, propertyNamesSchema, key);
+		ctx._jsonValidate(subReport, propertyNamesSchema, key);
 	}
 	const addPropertyNameErrors = () => {
-		for (let idx = 0; idx < keys.length; idx++) if (subReports[idx].errors.length > 0) report.addError("PROPERTY_NAMES", [keys[idx]], subReports[idx], schema, void 0);
+		for (let idx = 0; idx < keys.length; idx++) if (subReports[idx].errors.length > 0) report.addError("PROPERTY_NAMES", [keys[idx]], subReports[idx], schema);
 	};
 	deferOrRunSync(report, subReports, addPropertyNameErrors);
 }

package/dist/validation/{ref.mjs → ref.js}

@@ -1,11 +1,11 @@
-import { getRemotePath } from "../utils/uri.mjs";
-import { findId, getId } from "../json-schema.mjs";
+import { getRemotePath } from "../utils/uri.js";
+import { findId, getId } from "../json-schema.js";
 //#region src/validation/ref.ts
 const getDynamicRefAnchorName = (dynamicRef) => {
 	const hashIdx = dynamicRef.indexOf("#");
 	if (hashIdx === -1) return;
 	const fragment = dynamicRef.slice(hashIdx + 1);
-	if (!fragment || fragment[0] === "/") return;
+	if (!fragment || fragment.startsWith("/")) return;
 	return fragment;
 };
 const findDynamicAnchorInScope = (scopeSchema, anchorName) => {
@@ -32,7 +32,7 @@ const resolveRecursiveRef = (schema, recursiveAnchorStack) => {
 */
 const resolveDynamicRef = (schema, dynamicScopeStack) => {
 	const resolved = schema.__$dynamicRefResolved;
-	if (typeof resolved === "undefined" || !schema.$dynamicRef) return resolved;
+	if (resolved === void 0 || !schema.$dynamicRef) return resolved;
 	let target = resolved;
 	const anchorName = getDynamicRefAnchorName(schema.$dynamicRef);
 	if (anchorName && typeof target === "object" && target.$dynamicAnchor === anchorName) for (let scopeIdx = 0; scopeIdx < dynamicScopeStack.length; scopeIdx++) {

package/dist/validation/{shared.mjs → shared.js}

@@ -1,10 +1,6 @@
-import { isObject } from "../utils/what-is.mjs";
+import { isObject } from "../utils/what-is.js";
 //#region src/validation/shared.ts
-const shouldSkipValidate = function(options, errors) {
-	return options && Array.isArray(options.includeErrors) && options.includeErrors.length > 0 && !errors.some(function(err) {
-		return options.includeErrors.includes(err);
-	});
-};
+const shouldSkipValidate = (options, errors) => options && Array.isArray(options.includeErrors) && options.includeErrors.length > 0 && !errors.some((err) => options.includeErrors.includes(err));
 const supportsDependentKeywords = (schema, version) => {
 	if (typeof schema.$schema === "string") return !/draft-04|draft-06|draft-07/.test(schema.$schema);
 	return !(version === "draft-04" || version === "draft-06" || version === "draft-07");
@@ -44,7 +40,7 @@ const isValidationVocabularyEnabled = (schema, report, version) => {
 	const metaSchema = currentSchemaMeta || rootSchemaMeta;
 	if (!metaSchema || typeof metaSchema !== "object" || !isObject(metaSchema.$vocabulary)) return true;
 	const vocabulary = metaSchema.$vocabulary;
-	if (Object.hasOwn(vocabulary, VOCAB_VALIDATION_2019_09) || Object.hasOwn(vocabulary, VOCAB_VALIDATION_2020_12)) return vocabulary[VOCAB_VALIDATION_2019_09] === true || vocabulary[VOCAB_VALIDATION_2020_12] === true;
+	if (Object.hasOwn(vocabulary, VOCAB_VALIDATION_2019_09) || Object.hasOwn(vocabulary, VOCAB_VALIDATION_2020_12)) return vocabulary[VOCAB_VALIDATION_2019_09] || vocabulary[VOCAB_VALIDATION_2020_12];
 	return false;
 };
 /**
@@ -60,8 +56,8 @@ const isFormatAssertionVocabEnabled = (schema, report, version) => {
 	const metaSchema = currentSchemaMeta || rootSchemaMeta;
 	if (!metaSchema || typeof metaSchema !== "object" || !isObject(metaSchema.$vocabulary)) return false;
 	const vocabulary = metaSchema.$vocabulary;
-	if (Object.hasOwn(vocabulary, VOCAB_FORMAT_ASSERTION_2020_12)) return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12] === true;
-	if (Object.hasOwn(vocabulary, VOCAB_FORMAT_2019_09)) return vocabulary[VOCAB_FORMAT_2019_09] === true;
+	if (Object.hasOwn(vocabulary, VOCAB_FORMAT_ASSERTION_2020_12)) return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12];
+	if (Object.hasOwn(vocabulary, VOCAB_FORMAT_2019_09)) return vocabulary[VOCAB_FORMAT_2019_09];
 	return false;
 };
 function cacheValidationResult(report, schema, json, passed) {
@@ -85,9 +81,14 @@ function getCachedValidationResult(report, schema, json) {
 */
 function deferOrRunSync(report, subReports, decisionFn) {
 	const asyncTasksBefore = report.asyncTasks.length;
-	for (const subReport of subReports) report.asyncTasks.push(...subReport.asyncTasks);
+	for (let i = 0; i < subReports.length; i++) {
+		const tasks = subReports[i].asyncTasks;
+		for (let j = 0; j < tasks.length; j++) report.asyncTasks.push(tasks[j]);
+	}
 	if (report.asyncTasks.length > asyncTasksBefore) report.addAsyncTaskWithPath((callback) => {
-		setTimeout(() => callback(null), 0);
+		setTimeout(() => {
+			callback(null);
+		}, 0);
 	}, [], () => {
 		decisionFn();
 	});