z-schema 12.1.1 → 12.3.1

package/dist/{schema-validator.mjs → schema-validator.js}

@@ -1,61 +1,73 @@
-import { isInteger, isObject } from "./utils/what-is.mjs";
-import { getId } from "./json-schema.mjs";
-import { shallowClone } from "./utils/clone.mjs";
-import { Report } from "./report.mjs";
-import { isFormatSupported } from "./format-validators.mjs";
-import { compileSchemaRegex } from "./utils/schema-regex.mjs";
-import { isUniqueArray } from "./utils/array.mjs";
-import { validate } from "./json-validation.mjs";
+import { isInteger, isObject } from "./utils/what-is.js";
+import { getId } from "./json-schema.js";
+import { shallowClone } from "./utils/clone.js";
+import { Report } from "./report.js";
+import { isFormatSupported } from "./format-validators.js";
+import { compileSchemaRegex } from "./utils/schema-regex.js";
+import { isUniqueArray } from "./utils/array.js";
+import { validate } from "./json-validation.js";
 //#region src/schema-validator.ts
+const PRIMITIVE_TYPES = [
+	"array",
+	"boolean",
+	"integer",
+	"number",
+	"null",
+	"object",
+	"string"
+];
+const PRIMITIVE_TYPE_STR = PRIMITIVE_TYPES.join(",");
+const PRIMITIVE_TYPES_SET = new Set(PRIMITIVE_TYPES);
 const SchemaValidators = {
-	$ref: function(report, schema) {
+	$ref(report, schema) {
 		if (typeof schema.$ref !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["$ref", "string"], void 0, schema, "$ref");
 	},
-	$schema: function(report, schema) {
+	$schema(report, schema) {
 		if (typeof schema.$schema !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["$schema", "string"], void 0, schema, "$schema");
 	},
-	multipleOf: function(report, schema) {
+	multipleOf(report, schema) {
 		if (typeof schema.multipleOf !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["multipleOf", "number"], void 0, schema, "multipleOf");
 		else if (schema.multipleOf <= 0) report.addError("KEYWORD_MUST_BE", ["multipleOf", "strictly greater than 0"], void 0, schema, "multipleOf");
 	},
-	maximum: function(report, schema) {
+	maximum(report, schema) {
 		if (typeof schema.maximum !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["maximum", "number"], void 0, schema, "maximum");
 	},
-	exclusiveMaximum: function(report, schema) {
+	exclusiveMaximum(report, schema) {
 		if (report.options.version === "draft-04") {
 			if (typeof schema.exclusiveMaximum !== "boolean") report.addError("KEYWORD_TYPE_EXPECTED", ["exclusiveMaximum", "boolean"], void 0, schema, "exclusiveMaximum");
 			else if (schema.maximum === void 0) report.addError("KEYWORD_DEPENDENCY", ["exclusiveMaximum", "maximum"], void 0, schema, "exclusiveMaximum");
 		} else if (typeof schema.exclusiveMaximum !== "boolean" && typeof schema.exclusiveMaximum !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["exclusiveMaximum", ["boolean", "number"]], void 0, schema, "exclusiveMaximum");
 	},
-	minimum: function(report, schema) {
+	minimum(report, schema) {
 		if (typeof schema.minimum !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["minimum", "number"], void 0, schema, "minimum");
 	},
-	exclusiveMinimum: function(report, schema) {
+	exclusiveMinimum(report, schema) {
 		if (report.options.version === "draft-04") {
 			if (typeof schema.exclusiveMinimum !== "boolean") report.addError("KEYWORD_TYPE_EXPECTED", ["exclusiveMinimum", "boolean"], void 0, schema, "exclusiveMinimum");
 			else if (schema.minimum === void 0) report.addError("KEYWORD_DEPENDENCY", ["exclusiveMinimum", "minimum"], void 0, schema, "exclusiveMinimum");
 		} else if (typeof schema.exclusiveMinimum !== "boolean" && typeof schema.exclusiveMinimum !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["exclusiveMinimum", ["boolean", "number"]], void 0, schema, "exclusiveMinimum");
 	},
-	maxLength: function(report, schema) {
+	maxLength(report, schema) {
 		if (!isInteger(schema.maxLength)) report.addError("KEYWORD_TYPE_EXPECTED", ["maxLength", "integer"], void 0, schema, "maxLength");
 		else if (schema.maxLength < 0) report.addError("KEYWORD_MUST_BE", ["maxLength", "greater than, or equal to 0"], void 0, schema, "maxLength");
 	},
-	minLength: function(report, schema) {
+	minLength(report, schema) {
 		if (!isInteger(schema.minLength)) report.addError("KEYWORD_TYPE_EXPECTED", ["minLength", "integer"], void 0, schema, "minLength");
 		else if (schema.minLength < 0) report.addError("KEYWORD_MUST_BE", ["minLength", "greater than, or equal to 0"], void 0, schema, "minLength");
 	},
-	pattern: function(report, schema) {
-		if (typeof schema.pattern !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["pattern", "string"], void 0, schema, "pattern");
-		else {
-			const result = compileSchemaRegex(schema.pattern);
-			if (!result.ok) report.addError("KEYWORD_PATTERN", [
-				"pattern",
-				schema.pattern,
-				result.error.message
-			], void 0, schema, "pattern");
+	pattern(report, schema) {
+		if (typeof schema.pattern !== "string") {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["pattern", "string"], void 0, schema, "pattern");
+			return;
 		}
+		const result = compileSchemaRegex(schema.pattern);
+		if (!result.ok) report.addError("KEYWORD_PATTERN", [
+			"pattern",
+			schema.pattern,
+			result.error.message
+		], void 0, schema, "pattern");
 	},
-	additionalItems: function(report, schema) {
+	additionalItems(report, schema) {
 		if (typeof schema.additionalItems !== "boolean" && !isObject(schema.additionalItems)) report.addError("KEYWORD_TYPE_EXPECTED", ["additionalItems", ["boolean", "object"]], void 0, schema, "additionalItems");
 		else if (isObject(schema.additionalItems)) {
 			report.path.push("additionalItems");
@@ -63,7 +75,7 @@ const SchemaValidators = {
 			report.path.pop();
 		}
 	},
-	items: function(report, schema) {
+	items(report, schema) {
 		if (Array.isArray(schema.items)) for (let idx = 0; idx < schema.items.length; idx++) {
 			report.path.push("items");
 			report.path.push(idx);
@@ -83,34 +95,34 @@ const SchemaValidators = {
 		if (this.options.forceAdditional === true && schema.additionalItems === void 0 && Array.isArray(schema.items)) report.addError("KEYWORD_UNDEFINED_STRICT", ["additionalItems"], void 0, schema, "additionalItems");
 		if (this.options.assumeAdditional && schema.additionalItems === void 0 && Array.isArray(schema.items)) schema.additionalItems = false;
 	},
-	maxItems: function(report, schema) {
+	maxItems(report, schema) {
 		if (typeof schema.maxItems !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["maxItems", "integer"], void 0, schema, "maxItems");
 		else if (schema.maxItems < 0) report.addError("KEYWORD_MUST_BE", ["maxItems", "greater than, or equal to 0"], void 0, schema, "maxItems");
 	},
-	minItems: function(report, schema) {
+	minItems(report, schema) {
 		if (!isInteger(schema.minItems)) report.addError("KEYWORD_TYPE_EXPECTED", ["minItems", "integer"], void 0, schema, "minItems");
 		else if (schema.minItems < 0) report.addError("KEYWORD_MUST_BE", ["minItems", "greater than, or equal to 0"], void 0, schema, "minItems");
 	},
-	uniqueItems: function(report, schema) {
+	uniqueItems(report, schema) {
 		if (typeof schema.uniqueItems !== "boolean") report.addError("KEYWORD_TYPE_EXPECTED", ["uniqueItems", "boolean"], void 0, schema, "uniqueItems");
 	},
-	maxProperties: function(report, schema) {
+	maxProperties(report, schema) {
 		if (!isInteger(schema.maxProperties)) report.addError("KEYWORD_TYPE_EXPECTED", ["maxProperties", "integer"], void 0, schema, "maxProperties");
 		else if (schema.maxProperties < 0) report.addError("KEYWORD_MUST_BE", ["maxProperties", "greater than, or equal to 0"], void 0, schema, "maxProperties");
 	},
-	minProperties: function(report, schema) {
+	minProperties(report, schema) {
 		if (!isInteger(schema.minProperties)) report.addError("KEYWORD_TYPE_EXPECTED", ["minProperties", "integer"], void 0, schema, "minProperties");
 		else if (schema.minProperties < 0) report.addError("KEYWORD_MUST_BE", ["minProperties", "greater than, or equal to 0"], void 0, schema, "minProperties");
 	},
-	required: function(report, schema) {
+	required(report, schema) {
 		if (!Array.isArray(schema.required)) report.addError("KEYWORD_TYPE_EXPECTED", ["required", "array"], void 0, schema, "required");
 		else if (report.options.version === "draft-04" && schema.required.length === 0) report.addError("KEYWORD_MUST_BE", ["required", "an array with at least one element"], void 0, schema, "required");
 		else {
 			for (const item of schema.required) if (typeof item !== "string") report.addError("KEYWORD_VALUE_TYPE", ["required", "string"], void 0, schema, "required");
-			if (isUniqueArray(schema.required) === false) report.addError("KEYWORD_MUST_BE", ["required", "an array with unique items"], void 0, schema, "required");
+			if (!isUniqueArray(schema.required)) report.addError("KEYWORD_MUST_BE", ["required", "an array with unique items"], void 0, schema, "required");
 		}
 	},
-	additionalProperties: function(report, schema) {
+	additionalProperties(report, schema) {
 		if (typeof schema.additionalProperties !== "boolean" && !isObject(schema.additionalProperties)) report.addError("KEYWORD_TYPE_EXPECTED", ["additionalProperties", ["boolean", "object"]], void 0, schema, "additionalProperties");
 		else if (isObject(schema.additionalProperties)) {
 			report.path.push("additionalProperties");
@@ -118,7 +130,7 @@ const SchemaValidators = {
 			report.path.pop();
 		}
 	},
-	properties: function(report, schema) {
+	properties(report, schema) {
 		if (!isObject(schema.properties)) {
 			report.addError("KEYWORD_TYPE_EXPECTED", ["properties", "object"], void 0, schema, "properties");
 			return;
@@ -136,7 +148,7 @@ const SchemaValidators = {
 		if (this.options.assumeAdditional && schema.additionalProperties === void 0) schema.additionalProperties = false;
 		if (this.options.forceProperties === true && keys.length === 0) report.addError("CUSTOM_MODE_FORCE_PROPERTIES", ["properties"], void 0, schema, "properties");
 	},
-	patternProperties: function(report, schema) {
+	patternProperties(report, schema) {
 		if (!isObject(schema.patternProperties)) {
 			report.addError("KEYWORD_TYPE_EXPECTED", ["patternProperties", "object"], void 0, schema, "patternProperties");
 			return;
@@ -158,93 +170,52 @@ const SchemaValidators = {
 		}
 		if (this.options.forceProperties === true && keys.length === 0) report.addError("CUSTOM_MODE_FORCE_PROPERTIES", ["patternProperties"], void 0, schema, "patternProperties");
 	},
-	dependencies: function(report, schema) {
-		if (!isObject(schema.dependencies)) report.addError("KEYWORD_TYPE_EXPECTED", ["dependencies", "object"], void 0, schema, "dependencies");
-		else {
-			const keys = Object.keys(schema.dependencies);
-			for (const schemaKey of keys) {
-				const schemaDependency = schema.dependencies[schemaKey];
-				if (isObject(schemaDependency) || report.options.version !== "draft-04" && typeof schemaDependency === "boolean") {
-					report.path.push("dependencies");
-					report.path.push(schemaKey);
-					this.validateSchema(report, schemaDependency);
-					report.path.pop();
-					report.path.pop();
-				} else if (Array.isArray(schemaDependency)) {
-					const depArray = schemaDependency;
-					if (report.options.version === "draft-04" && depArray.length === 0) report.addError("KEYWORD_MUST_BE", ["dependencies", "not empty array"], void 0, schema, "dependencies");
-					for (const dep of depArray) if (typeof dep !== "string") report.addError("KEYWORD_VALUE_TYPE", ["dependencies", "string"], void 0, schema, "dependencies");
-					if (isUniqueArray(depArray) === false) report.addError("KEYWORD_MUST_BE", ["dependencies", "an array with unique items"], void 0, schema, "dependencies");
-				} else report.addError("KEYWORD_VALUE_TYPE", ["dependencies", report.options.version === "draft-04" ? "object or array" : "boolean, object or array"], void 0, schema, "dependencies");
-			}
+	dependencies(report, schema) {
+		if (!isObject(schema.dependencies)) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["dependencies", "object"], void 0, schema, "dependencies");
+			return;
+		}
+		const keys = Object.keys(schema.dependencies);
+		for (const schemaKey of keys) {
+			const schemaDependency = schema.dependencies[schemaKey];
+			if (isObject(schemaDependency) || report.options.version !== "draft-04" && typeof schemaDependency === "boolean") {
+				report.path.push("dependencies");
+				report.path.push(schemaKey);
+				this.validateSchema(report, schemaDependency);
+				report.path.pop();
+				report.path.pop();
+			} else if (Array.isArray(schemaDependency)) {
+				const depArray = schemaDependency;
+				if (report.options.version === "draft-04" && depArray.length === 0) report.addError("KEYWORD_MUST_BE", ["dependencies", "not empty array"], void 0, schema, "dependencies");
+				for (const dep of depArray) if (typeof dep !== "string") report.addError("KEYWORD_VALUE_TYPE", ["dependencies", "string"], void 0, schema, "dependencies");
+				if (!isUniqueArray(depArray)) report.addError("KEYWORD_MUST_BE", ["dependencies", "an array with unique items"], void 0, schema, "dependencies");
+			} else report.addError("KEYWORD_VALUE_TYPE", ["dependencies", report.options.version === "draft-04" ? "object or array" : "boolean, object or array"], void 0, schema, "dependencies");
 		}
 	},
-	enum: function(report, schema) {
-		if (Array.isArray(schema.enum) === false) report.addError("KEYWORD_TYPE_EXPECTED", ["enum", "array"], void 0, schema, "enum");
+	enum(report, schema) {
+		if (!Array.isArray(schema.enum)) report.addError("KEYWORD_TYPE_EXPECTED", ["enum", "array"], void 0, schema, "enum");
 		else if (schema.enum.length === 0) report.addError("KEYWORD_MUST_BE", ["enum", "an array with at least one element"], void 0, schema, "enum");
-		else if (isUniqueArray(schema.enum) === false) report.addError("KEYWORD_MUST_BE", ["enum", "an array with unique elements"], void 0, schema, "enum");
+		else if (!isUniqueArray(schema.enum)) report.addError("KEYWORD_MUST_BE", ["enum", "an array with unique elements"], void 0, schema, "enum");
 	},
-	type: function(report, schema) {
-		const primitiveTypes = [
-			"array",
-			"boolean",
-			"integer",
-			"number",
-			"null",
-			"object",
-			"string"
-		];
-		const primitiveTypeStr = primitiveTypes.join(",");
+	type(report, schema) {
 		const isArray = Array.isArray(schema.type);
 		if (Array.isArray(schema.type)) {
-			for (const typeItem of schema.type) if (!primitiveTypes.includes(typeItem)) report.addError("KEYWORD_TYPE_EXPECTED", ["type", primitiveTypeStr], void 0, schema, "type");
-			if (isUniqueArray(schema.type) === false) report.addError("KEYWORD_MUST_BE", ["type", "an object with unique properties"], void 0, schema, "type");
+			for (const typeItem of schema.type) if (!PRIMITIVE_TYPES_SET.has(typeItem)) report.addError("KEYWORD_TYPE_EXPECTED", ["type", PRIMITIVE_TYPE_STR], void 0, schema, "type");
+			if (!isUniqueArray(schema.type)) report.addError("KEYWORD_MUST_BE", ["type", "an object with unique properties"], void 0, schema, "type");
 		} else if (typeof schema.type === "string") {
-			if (!primitiveTypes.includes(schema.type)) report.addError("KEYWORD_TYPE_EXPECTED", ["type", primitiveTypeStr], void 0, schema, "type");
+			if (!PRIMITIVE_TYPES_SET.has(schema.type)) report.addError("KEYWORD_TYPE_EXPECTED", ["type", PRIMITIVE_TYPE_STR], void 0, schema, "type");
 		} else report.addError("KEYWORD_TYPE_EXPECTED", ["type", ["string", "array"]], void 0, schema, "type");
-		if (this.options.noEmptyStrings === true) {
-			if (schema.type === "string" || isArray && schema.type.includes("string")) {
-				if (schema.minLength === void 0 && schema.enum === void 0 && schema.format === void 0) schema.minLength = 1;
-			}
-		}
-		if (this.options.noEmptyArrays === true) {
-			if (schema.type === "array" || isArray && schema.type.includes("array")) {
-				if (schema.minItems === void 0) schema.minItems = 1;
-			}
-		}
-		if (this.options.forceProperties === true) {
-			if (schema.type === "object" || isArray && schema.type.includes("object")) {
-				if (schema.properties === void 0 && schema.patternProperties === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["properties"], void 0, schema, "properties");
-			}
-		}
-		if (this.options.forceItems === true) {
-			if (schema.type === "array" || isArray && schema.type.includes("array")) {
-				if (schema.items === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["items"], void 0, schema, "items");
-			}
-		}
-		if (this.options.forceMinItems === true) {
-			if (schema.type === "array" || isArray && schema.type.includes("array")) {
-				if (schema.minItems === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["minItems"], void 0, schema, "minItems");
-			}
-		}
-		if (this.options.forceMaxItems === true) {
-			if (schema.type === "array" || isArray && schema.type.includes("array")) {
-				if (schema.maxItems === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["maxItems"], void 0, schema, "maxItems");
-			}
-		}
-		if (this.options.forceMinLength === true) {
-			if (schema.type === "string" || isArray && schema.type.includes("string")) {
-				if (schema.minLength === void 0 && schema.format === void 0 && schema.enum === void 0 && schema.pattern === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["minLength"], void 0, schema, "minLength");
-			}
-		}
-		if (this.options.forceMaxLength === true) {
-			if (schema.type === "string" || isArray && schema.type.includes("string")) {
-				if (schema.maxLength === void 0 && schema.format === void 0 && schema.enum === void 0 && schema.pattern === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["maxLength"], void 0, schema, "maxLength");
-			}
-		}
-	},
-	allOf: function(report, schema) {
-		if (Array.isArray(schema.allOf) === false) report.addError("KEYWORD_TYPE_EXPECTED", ["allOf", "array"], void 0, schema, "allOf");
+		if (this.options.noEmptyStrings === true && (schema.type === "string" || isArray && schema.type.includes("string")) && schema.minLength === void 0 && schema.enum === void 0 && schema.format === void 0) schema.minLength = 1;
+		if (this.options.noEmptyArrays === true && (schema.type === "array" || isArray && schema.type.includes("array")) && schema.minItems === void 0) schema.minItems = 1;
+		if (this.options.forceProperties === true && (schema.type === "object" || isArray && schema.type.includes("object")) && schema.properties === void 0 && schema.patternProperties === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["properties"], void 0, schema, "properties");
+		if (this.options.forceItems === true && (schema.type === "array" || isArray && schema.type.includes("array")) && schema.items === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["items"], void 0, schema, "items");
+		if (this.options.forceMinItems === true && (schema.type === "array" || isArray && schema.type.includes("array")) && schema.minItems === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["minItems"], void 0, schema, "minItems");
+		if (this.options.forceMaxItems === true && (schema.type === "array" || isArray && schema.type.includes("array")) && schema.maxItems === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["maxItems"], void 0, schema, "maxItems");
+		if (this.options.forceMinLength === true && (schema.type === "string" || isArray && schema.type.includes("string")) && schema.minLength === void 0 && schema.format === void 0 && schema.enum === void 0 && schema.pattern === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["minLength"], void 0, schema, "minLength");
+		if (this.options.forceMaxLength === true && (schema.type === "string" || isArray && schema.type.includes("string")) && schema.maxLength === void 0 && schema.format === void 0 && schema.enum === void 0 && schema.pattern === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["maxLength"], void 0, schema, "maxLength");
+	},
+	allOf(report, schema) {
+		if (!Array.isArray(schema.allOf)) report.addError("KEYWORD_TYPE_EXPECTED", ["allOf", "array"], void 0, schema, "allOf");
 		else if (schema.allOf.length === 0) report.addError("KEYWORD_MUST_BE", ["allOf", "an array with at least one element"], void 0, schema, "allOf");
 		else for (let idx = 0; idx < schema.allOf.length; idx++) {
 			report.path.push("allOf");
@@ -254,8 +225,8 @@ const SchemaValidators = {
 			report.path.pop();
 		}
 	},
-	anyOf: function(report, schema) {
-		if (Array.isArray(schema.anyOf) === false) report.addError("KEYWORD_TYPE_EXPECTED", ["anyOf", "array"], void 0, schema, "anyOf");
+	anyOf(report, schema) {
+		if (!Array.isArray(schema.anyOf)) report.addError("KEYWORD_TYPE_EXPECTED", ["anyOf", "array"], void 0, schema, "anyOf");
 		else if (schema.anyOf.length === 0) report.addError("KEYWORD_MUST_BE", ["anyOf", "an array with at least one element"], void 0, schema, "anyOf");
 		else for (let idx = 0; idx < schema.anyOf.length; idx++) {
 			report.path.push("anyOf");
@@ -265,8 +236,8 @@ const SchemaValidators = {
 			report.path.pop();
 		}
 	},
-	oneOf: function(report, schema) {
-		if (Array.isArray(schema.oneOf) === false) report.addError("KEYWORD_TYPE_EXPECTED", ["oneOf", "array"], void 0, schema, "oneOf");
+	oneOf(report, schema) {
+		if (!Array.isArray(schema.oneOf)) report.addError("KEYWORD_TYPE_EXPECTED", ["oneOf", "array"], void 0, schema, "oneOf");
 		else if (schema.oneOf.length === 0) report.addError("KEYWORD_MUST_BE", ["oneOf", "an array with at least one element"], void 0, schema, "oneOf");
 		else for (let idx = 0; idx < schema.oneOf.length; idx++) {
 			report.path.push("oneOf");
@@ -276,16 +247,17 @@ const SchemaValidators = {
 			report.path.pop();
 		}
 	},
-	not: function(report, schema) {
+	not(report, schema) {
 		const notSchema = schema.not;
-		if (!(report.options.version === "draft-04" ? isObject(notSchema) : typeof notSchema === "boolean" || isObject(notSchema))) report.addError("KEYWORD_TYPE_EXPECTED", ["not", report.options.version === "draft-04" ? "object" : ["boolean", "object"]], void 0, schema, "not");
-		else {
-			report.path.push("not");
-			this.validateSchema(report, notSchema);
-			report.path.pop();
+		if (!(report.options.version === "draft-04" ? isObject(notSchema) : typeof notSchema === "boolean" || isObject(notSchema))) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["not", report.options.version === "draft-04" ? "object" : ["boolean", "object"]], void 0, schema, "not");
+			return;
 		}
+		report.path.push("not");
+		this.validateSchema(report, notSchema);
+		report.path.pop();
 	},
-	if: function(report, schema) {
+	if(report, schema) {
 		if (report.options.version !== "draft-07") return;
 		const ifSchema = schema.if;
 		if (!(typeof ifSchema === "boolean" || isObject(ifSchema))) {
@@ -296,7 +268,7 @@ const SchemaValidators = {
 		this.validateSchema(report, ifSchema);
 		report.path.pop();
 	},
-	then: function(report, schema) {
+	then(report, schema) {
 		if (report.options.version !== "draft-07") return;
 		const thenSchema = schema.then;
 		if (!(typeof thenSchema === "boolean" || isObject(thenSchema))) {
@@ -307,7 +279,7 @@ const SchemaValidators = {
 		this.validateSchema(report, thenSchema);
 		report.path.pop();
 	},
-	else: function(report, schema) {
+	else(report, schema) {
 		if (report.options.version !== "draft-07") return;
 		const elseSchema = schema.else;
 		if (!(typeof elseSchema === "boolean" || isObject(elseSchema))) {
@@ -318,21 +290,22 @@ const SchemaValidators = {
 		this.validateSchema(report, elseSchema);
 		report.path.pop();
 	},
-	definitions: function(report, schema) {
-		if (!isObject(schema.definitions)) report.addError("KEYWORD_TYPE_EXPECTED", ["definitions", "object"], void 0, schema, "definitions");
-		else {
-			const keys = Object.keys(schema.definitions);
-			for (const key of keys) {
-				const val = schema.definitions[key];
-				report.path.push("definitions");
-				report.path.push(key);
-				this.validateSchema(report, val);
-				report.path.pop();
-				report.path.pop();
-			}
+	definitions(report, schema) {
+		if (!isObject(schema.definitions)) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["definitions", "object"], void 0, schema, "definitions");
+			return;
+		}
+		const keys = Object.keys(schema.definitions);
+		for (const key of keys) {
+			const val = schema.definitions[key];
+			report.path.push("definitions");
+			report.path.push(key);
+			this.validateSchema(report, val);
+			report.path.pop();
+			report.path.pop();
 		}
 	},
-	$defs: function(report, schema) {
+	$defs(report, schema) {
 		if (report.options.version !== "draft2019-09" && report.options.version !== "draft2020-12") return;
 		if (!isObject(schema.$defs)) {
 			report.addError("KEYWORD_TYPE_EXPECTED", ["$defs", "object"], void 0, schema, "$defs");
@@ -348,34 +321,36 @@ const SchemaValidators = {
 			report.path.pop();
 		}
 	},
-	format: function(report, schema) {
+	format(report, schema) {
 		if (this.options.formatAssertions === false) return;
-		if (typeof schema.format !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["format", "string"], void 0, schema, "format");
-		else {
-			const isModernDraft = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
-			if (!isFormatSupported(schema.format, this.options.customFormats) && this.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
+		if (typeof schema.format !== "string") {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["format", "string"], void 0, schema, "format");
+			return;
 		}
+		const isModernDraft = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
+		if (!isFormatSupported(schema.format, this.options.customFormats) && this.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
 	},
-	contentEncoding: function(report, schema) {
+	contentEncoding(report, schema) {
 		if (report.options.version !== "draft-07") return;
 		if (typeof schema.contentEncoding !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["contentEncoding", "string"], void 0, schema, "contentEncoding");
 	},
-	contentMediaType: function(report, schema) {
+	contentMediaType(report, schema) {
 		if (report.options.version !== "draft-07") return;
 		if (typeof schema.contentMediaType !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["contentMediaType", "string"], void 0, schema, "contentMediaType");
 	},
-	id: function(report, schema) {
+	id(report, schema) {
 		if (typeof schema.id !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["id", "string"], void 0, schema, "id");
 	},
-	title: function(report, schema) {
+	title(report, schema) {
 		if (typeof schema.title !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["title", "string"], void 0, schema, "title");
 	},
-	description: function(report, schema) {
+	description(report, schema) {
 		if (typeof schema.description !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["description", "string"], void 0, schema, "description");
 	},
-	default: function() {}
+	default() {}
 };
 var SchemaValidator = class {
+	validator;
 	constructor(validator) {
 		this.validator = validator;
 	}
@@ -395,18 +370,17 @@ var SchemaValidator = class {
 		if (hasParentSchema) {
 			if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
 				const subReport = new Report(report);
-				if (validate.call(this.validator, subReport, schema.__$schemaResolved, schema) === false) report.addError("PARENT_SCHEMA_VALIDATION_FAILED", void 0, subReport, schema, "$schema");
+				if (!validate(this.validator, subReport, schema.__$schemaResolved, schema)) report.addError("PARENT_SCHEMA_VALIDATION_FAILED", void 0, subReport, schema, "$schema");
 			} else if (this.validator.options.ignoreUnresolvableReferences !== true) report.addError("REF_UNRESOLVED", [schema.$schema], void 0, schema, "$schema");
 		}
 		if (this.validator.options.noTypeless === true) {
 			if (schema.type !== void 0) {
-				let schemas = [];
-				if (Array.isArray(schema.anyOf)) schemas = schemas.concat(schema.anyOf);
-				if (Array.isArray(schema.oneOf)) schemas = schemas.concat(schema.oneOf);
-				if (Array.isArray(schema.allOf)) schemas = schemas.concat(schema.allOf);
-				schemas.forEach(function(sch) {
+				const inheritType = (sch) => {
 					if (!sch.type) sch.type = schema.type;
-				});
+				};
+				if (Array.isArray(schema.anyOf)) for (let i = 0; i < schema.anyOf.length; i++) inheritType(schema.anyOf[i]);
+				if (Array.isArray(schema.oneOf)) for (let i = 0; i < schema.oneOf.length; i++) inheritType(schema.oneOf[i]);
+				if (Array.isArray(schema.allOf)) for (let i = 0; i < schema.allOf.length; i++) inheritType(schema.allOf[i]);
 			}
 			if (schema.enum === void 0 && schema.type === void 0 && schema.anyOf === void 0 && schema.oneOf === void 0 && schema.not === void 0 && schema.$ref === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["type"], void 0, schema, "type");
 		}
@@ -414,9 +388,7 @@ var SchemaValidator = class {
 		for (const key of keys) {
 			if (key.startsWith("__")) continue;
 			if (Object.hasOwn(SchemaValidators, key)) SchemaValidators[key].call(this, report, schema);
-			else if (!hasParentSchema) {
-				if (this.validator.options.noExtraKeywords === true) report.addError("KEYWORD_UNEXPECTED", [key], void 0, schema, void 0);
-			}
+			else if (!hasParentSchema && this.validator.options.noExtraKeywords === true) report.addError("KEYWORD_UNEXPECTED", [key], void 0, schema);
 		}
 		if (this.validator.options.pedanticCheck === true) {
 			if (schema.enum) {
@@ -426,14 +398,14 @@ var SchemaValidator = class {
 				report.path.push("enum");
 				for (let idx = 0; idx < schema.enum.length; idx++) {
 					report.path.push(idx);
-					validate.call(this.validator, report, tmpSchema, schema.enum[idx]);
+					validate(this.validator, report, tmpSchema, schema.enum[idx]);
 					report.path.pop();
 				}
 				report.path.pop();
 			}
 			if (schema.default) {
 				report.path.push("default");
-				validate.call(this.validator, report, schema, schema.default);
+				validate(this.validator, report, schema, schema.default);
 				report.path.pop();
 			}
 		}

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

@@ -1,4 +1,4 @@
-import { areEqual } from "./json.mjs";
+import { areEqual } from "./json.js";
 //#region src/utils/array.ts
 /**
 * Check if all elements in an array are unique.
@@ -22,7 +22,7 @@ const isUniqueArray = (arr, indexes, maxDepth) => {
 		const seen = /* @__PURE__ */ new Set();
 		for (let i = 0; i < l; i++) {
 			const v = arr[i];
-			const key = typeof v + ":" + String(v);
+			const key = `${typeof v}:${String(v)}`;
 			if (seen.has(key)) {
 				if (indexes) for (let j = 0; j < i; j++) {
 					const prev = arr[j];
@@ -37,7 +37,8 @@ const isUniqueArray = (arr, indexes, maxDepth) => {
 		}
 		return true;
 	}
-	for (let i = 0; i < l; i++) for (let j = i + 1; j < l; j++) if (areEqual(arr[i], arr[j], { maxDepth })) {
+	const eqOpts = { maxDepth };
+	for (let i = 0; i < l; i++) for (let j = i + 1; j < l; j++) if (areEqual(arr[i], arr[j], eqOpts)) {
 		if (indexes) indexes.push(i, j);
 		return false;
 	}

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

@@ -11,8 +11,9 @@ const decodeBase64 = (value) => {
 	} catch {
 		return;
 	}
-	if (typeof Buffer !== "undefined") try {
-		return Buffer.from(value, "base64").toString("utf8");
+	const bufferCtor = globalThis.Buffer;
+	if (bufferCtor !== void 0) try {
+		return bufferCtor.from(value, "base64").toString("utf-8");
 	} catch {
 		return;
 	}

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

@@ -1,39 +1,37 @@
-import { copyProp } from "./properties.mjs";
+import { copyProp } from "./properties.js";
 //#region src/utils/clone.ts
 const shallowClone = (src) => {
 	if (src == null || typeof src !== "object") return src;
-	let res;
 	if (Array.isArray(src)) {
-		res = [];
+		const res = [];
 		for (let i = 0; i < src.length; i++) res[i] = src[i];
-	} else {
-		res = {};
-		const keys = Object.keys(src).sort();
-		for (const key of keys) copyProp(src, res, key);
+		return res;
 	}
+	const res = {};
+	const keys = Object.keys(src).sort();
+	for (let i = 0; i < keys.length; i++) copyProp(src, res, keys[i]);
 	return res;
 };
 const deepClone = (src, maxDepth = 100) => {
 	let vidx = 0;
 	const visited = /* @__PURE__ */ new Map();
 	const cloned = [];
-	const cloneDeepInner = (src, _depth) => {
-		if (typeof src !== "object" || src === null) return src;
+	const cloneDeepInner = (node, _depth) => {
+		if (typeof node !== "object" || node === null) return node;
 		if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in deepClone. If your schema or data is deeply nested and valid, increase the maxRecursionDepth option.`);
-		let res;
-		const cidx = visited.get(src);
+		const cidx = visited.get(node);
 		if (cidx !== void 0) return cloned[cidx];
-		visited.set(src, vidx++);
-		if (Array.isArray(src)) {
-			res = [];
-			cloned.push(res);
-			for (let i = 0; i < src.length; i++) res[i] = cloneDeepInner(src[i], _depth + 1);
-		} else {
-			res = {};
+		visited.set(node, vidx++);
+		if (Array.isArray(node)) {
+			const res = [];
 			cloned.push(res);
-			const keys = Object.keys(src).sort();
-			for (const key of keys) copyProp(src, res, key, (v) => cloneDeepInner(v, _depth + 1));
+			for (let i = 0; i < node.length; i++) res[i] = cloneDeepInner(node[i], _depth + 1);
+			return res;
 		}
+		const res = {};
+		cloned.push(res);
+		const keys = Object.keys(node).sort();
+		for (let i = 0; i < keys.length; i++) copyProp(node, res, keys[i], (v) => cloneDeepInner(v, _depth + 1));
 		return res;
 	};
 	return cloneDeepInner(src, 0);