z-schema 12.2.0 → 12.4.0

package/dist/utils/hostname.js

@@ -0,0 +1,176 @@
+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 XN_LABEL_REGEX = /^xn--/i;
+const DISALLOWED_CATEGORY_REGEX = /[\p{P}\p{S}\p{Z}\p{C}]/u;
+const DISALLOWED_CATEGORY_WHITELIST = /* @__PURE__ */ new Set([
+	"-",
+	"·",
+	"͵",
+	"׳",
+	"״",
+	"・",
+	"۽",
+	"۾",
+	"་",
+	"‌",
+	"‍"
+]);
+const isDisallowedCodePoint = (char) => DISALLOWED_CATEGORY_REGEX.test(char) && !DISALLOWED_CATEGORY_WHITELIST.has(char);
+const TRANSPARENT_MARK_REGEX = /\p{Mn}/u;
+const ARABIC_SCRIPT_REGEX = /\p{Script=Arabic}/u;
+const ARABIC_INDIC_DIGITS_REGEX = /[\u0660-\u0669\u06F0-\u06F9]/;
+const isArabicJoiningLetter = (char) => char !== void 0 && ARABIC_SCRIPT_REGEX.test(char) && !ARABIC_INDIC_DIGITS_REGEX.test(char);
+const hasZwnjJoiningContext = (label, idx) => {
+	let before = idx - 1;
+	while (before >= 0 && TRANSPARENT_MARK_REGEX.test(label[before])) before--;
+	let after = idx + 1;
+	while (after < label.length && TRANSPARENT_MARK_REGEX.test(label[after])) after++;
+	return isArabicJoiningLetter(label[before]) && isArabicJoiningLetter(label[after]);
+};
+const BIDI_NSM_REGEX = /[\p{Mn}\p{Me}]/u;
+const BIDI_ARABIC_INDIC_DIGIT_REGEX = /[\u0660-\u0669]/;
+const BIDI_EXTENDED_ARABIC_INDIC_DIGIT_REGEX = /[\u06F0-\u06F9]/;
+const BIDI_HEBREW_SCRIPT_REGEX = /\p{Script=Hebrew}/u;
+const BIDI_AL_SCRIPT_REGEX = /[\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}]/u;
+const BIDI_ASCII_DIGIT_REGEX = /[0-9]/;
+const BIDI_LETTER_REGEX = /\p{L}/u;
+const classifyBidi = (char) => {
+	if (BIDI_NSM_REGEX.test(char)) return "NSM";
+	if (BIDI_ARABIC_INDIC_DIGIT_REGEX.test(char)) return "AN";
+	if (BIDI_EXTENDED_ARABIC_INDIC_DIGIT_REGEX.test(char)) return "EN";
+	if (BIDI_HEBREW_SCRIPT_REGEX.test(char)) return "R";
+	if (BIDI_AL_SCRIPT_REGEX.test(char)) return "AL";
+	if (BIDI_ASCII_DIGIT_REGEX.test(char)) return "EN";
+	if (BIDI_LETTER_REGEX.test(char)) return "L";
+	return "ON";
+};
+const isLabelBidiTriggering = (label) => {
+	for (const char of label) {
+		const bidiClass = classifyBidi(char);
+		if (bidiClass === "R" || bidiClass === "AL" || bidiClass === "AN") return true;
+	}
+	return false;
+};
+const isLabelBidiRuleValid = (label) => {
+	const classes = [];
+	for (const char of label) classes.push(classifyBidi(char));
+	if (classes.length === 0) return false;
+	const first = classes[0];
+	if (first !== "L" && first !== "R" && first !== "AL") return false;
+	let lastIdx = classes.length - 1;
+	while (lastIdx > 0 && classes[lastIdx] === "NSM") lastIdx--;
+	const last = classes[lastIdx];
+	if (first === "R" || first === "AL") {
+		let hasEN = false;
+		let hasAN = false;
+		for (let i = 0; i < classes.length; i++) {
+			const c = classes[i];
+			if (c !== "R" && c !== "AL" && c !== "AN" && c !== "EN" && c !== "NSM" && c !== "ON") return false;
+			if (c === "EN") hasEN = true;
+			else if (c === "AN") hasAN = true;
+		}
+		if (hasEN && hasAN) return false;
+		return last === "R" || last === "AL" || last === "EN" || last === "AN";
+	}
+	for (let i = 0; i < classes.length; i++) {
+		const c = classes[i];
+		if (c !== "L" && c !== "EN" && c !== "NSM" && c !== "ON") return false;
+	}
+	return last === "L" || last === "EN";
+};
+const isDomainBidiValid = (unicodeLabels) => {
+	let isBidiDomain = false;
+	for (let i = 0; i < unicodeLabels.length; i++) if (isLabelBidiTriggering(unicodeLabels[i])) {
+		isBidiDomain = true;
+		break;
+	}
+	if (!isBidiDomain) return true;
+	for (let i = 0; i < unicodeLabels.length; i++) if (!isLabelBidiRuleValid(unicodeLabels[i])) return false;
+	return true;
+};
+const splitHostnameLabels = (hostname) => {
+	if (hostname.length === 0 || hostname.length > 255) return null;
+	if (hostname.startsWith(".") || hostname.endsWith(".")) return null;
+	const labels = hostname.split(".");
+	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);
+const isGreek = (char) => /\p{Script=Greek}/u.test(char);
+const isHebrew = (char) => /\p{Script=Hebrew}/u.test(char);
+const hasCjkKanaOrHan = (input) => /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/u.test(input);
+const toUnicodeLabel = (label) => {
+	if (!XN_LABEL_REGEX.test(label)) return label;
+	try {
+		return punycode.toUnicode(label.toLowerCase());
+	} catch {
+		return null;
+	}
+};
+const isValidIdnUnicodeLabel = (label) => {
+	if (label.startsWith("-") || label.endsWith("-")) return false;
+	if (label.length >= 4 && label[2] === "-" && label[3] === "-" && !XN_LABEL_REGEX.test(label)) return false;
+	if (/^\p{M}/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 === "·" && (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 (char === "‌" && (idx === 0 || label[idx - 1] !== "्" && !hasZwnjJoiningContext(label, idx))) return false;
+	}
+	for (const char of label) if (isDisallowedCodePoint(char)) return false;
+	if (label.includes("・") && !hasCjkKanaOrHan(label.replaceAll("・", ""))) return false;
+	const hasArabicIndic = /[\u0660-\u0669]/.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) || /[^\u0000-\u007F]/.test(hostname)) return false;
+	if (isIPModule.default(hostname, 4)) return false;
+	const labels = splitHostnameLabels(hostname);
+	if (labels === null) return false;
+	for (let i = 0; i < labels.length; i++) {
+		const label = labels[i];
+		if (!isAsciiHostnameLabel(label)) return false;
+		if (XN_LABEL_REGEX.test(label)) {
+			const unicodeLabel = toUnicodeLabel(label);
+			if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) return false;
+		}
+	}
+	return true;
+};
+const isValidIdnHostname = (hostname) => {
+	const normalizedHostname = hostname.replace(IDN_SEPARATOR_REGEX, ".");
+	const labels = splitHostnameLabels(normalizedHostname);
+	if (labels === null) return false;
+	const unicodeLabels = [];
+	let totalLength = labels.length - 1;
+	for (let i = 0; i < labels.length; i++) {
+		const label = labels[i];
+		const unicodeLabel = toUnicodeLabel(label);
+		if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) return false;
+		let aLabel;
+		try {
+			aLabel = punycode.toASCII(unicodeLabel);
+		} catch {
+			return false;
+		}
+		if (XN_LABEL_REGEX.test(label) && aLabel.toLowerCase() !== label.toLowerCase()) return false;
+		if (aLabel.length > 63) return false;
+		totalLength += aLabel.length;
+		unicodeLabels.push(unicodeLabel);
+	}
+	if (totalLength > 253) return false;
+	return isDomainBidiValid(unicodeLabels);
+};
+//#endregion
+export { isValidHostname, isValidIdnHostname };

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)) {
@@ -15,20 +16,24 @@ const areEqual = (json1, json2, options, _depth = 0) => {
 	}
 	if (isObject(json1) && isObject(json2)) {
 		const keys1 = sortedKeys(json1);
-		if (!areEqual(keys1, sortedKeys(json2), options, _depth + 1)) return false;
+		const keys2 = sortedKeys(json2);
+		if (!areEqual(keys1, keys2, options, _depth + 1)) return false;
 		len = keys1.length;
 		for (i = 0; i < len; i++) if (!areEqual(json1[keys1[i]], json2[keys1[i]], options, _depth + 1)) return false;
 		return true;
 	}
 	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}

@@ -8,22 +8,22 @@ const toUtcTime = (hour, minute, offsetSign, offsetHour, offsetMinute) => {
 		minute: normalizedUtcTotalMinutes % 60
 	};
 };
-const RFC3339_TIME_REGEX = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(\.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/i;
+const RFC3339_TIME_REGEX = /^(?<hour>[0-9]{2}):(?<minute>[0-9]{2}):(?<second>[0-9]{2})(?<fraction>\.[0-9]+)?(?<offset>z|(?<offsetValue>[+-][0-9]{2}:[0-9]{2}))$/i;
 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;
 	if (matches[5].toLowerCase() !== "z") {
-		const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(matches[5]);
+		const offsetMatches = /^(?<sign>[+-])(?<hour>[0-9]{2}):(?<minute>[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;
@@ -39,4 +39,4 @@ const parseRfc3339Time = (time) => {
 	};
 };
 //#endregion
-export { parseRfc3339Time };
+export { parseRfc3339Time, toUtcTime };

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");
 	}