z-schema 12.0.4 → 12.1.0

package/dist/schema-validator.mjs

@@ -0,0 +1,446 @@
+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";
+//#region src/schema-validator.ts
+const SchemaValidators = {
+	$ref: function(report, schema) {
+		if (typeof schema.$ref !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["$ref", "string"], void 0, schema, "$ref");
+	},
+	$schema: function(report, schema) {
+		if (typeof schema.$schema !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["$schema", "string"], void 0, schema, "$schema");
+	},
+	multipleOf: function(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) {
+		if (typeof schema.maximum !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["maximum", "number"], void 0, schema, "maximum");
+	},
+	exclusiveMaximum: function(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) {
+		if (typeof schema.minimum !== "number") report.addError("KEYWORD_TYPE_EXPECTED", ["minimum", "number"], void 0, schema, "minimum");
+	},
+	exclusiveMinimum: function(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) {
+		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) {
+		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");
+		}
+	},
+	additionalItems: function(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");
+			this.validateSchema(report, schema.additionalItems);
+			report.path.pop();
+		}
+	},
+	items: function(report, schema) {
+		if (Array.isArray(schema.items)) for (let idx = 0; idx < schema.items.length; idx++) {
+			report.path.push("items");
+			report.path.push(idx);
+			this.validateSchema(report, schema.items[idx]);
+			report.path.pop();
+			report.path.pop();
+		}
+		else if (isObject(schema.items) || report.options.version !== "draft-04" && typeof schema.items === "boolean") {
+			report.path.push("items");
+			this.validateSchema(report, schema.items);
+			report.path.pop();
+		} else report.addError("KEYWORD_TYPE_EXPECTED", ["items", report.options.version === "draft-04" ? ["array", "object"] : [
+			"array",
+			"object",
+			"boolean"
+		]], void 0, schema, "items");
+		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) {
+		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) {
+		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) {
+		if (typeof schema.uniqueItems !== "boolean") report.addError("KEYWORD_TYPE_EXPECTED", ["uniqueItems", "boolean"], void 0, schema, "uniqueItems");
+	},
+	maxProperties: function(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) {
+		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) {
+		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");
+		}
+	},
+	additionalProperties: function(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");
+			this.validateSchema(report, schema.additionalProperties);
+			report.path.pop();
+		}
+	},
+	properties: function(report, schema) {
+		if (!isObject(schema.properties)) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["properties", "object"], void 0, schema, "properties");
+			return;
+		}
+		const keys = Object.keys(schema.properties);
+		for (const key of keys) {
+			const val = schema.properties[key];
+			report.path.push("properties");
+			report.path.push(key);
+			this.validateSchema(report, val);
+			report.path.pop();
+			report.path.pop();
+		}
+		if (this.options.forceAdditional === true && schema.additionalProperties === void 0) report.addError("KEYWORD_UNDEFINED_STRICT", ["additionalProperties"], void 0, schema, "additionalProperties");
+		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) {
+		if (!isObject(schema.patternProperties)) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["patternProperties", "object"], void 0, schema, "patternProperties");
+			return;
+		}
+		const keys = Object.keys(schema.patternProperties);
+		for (const key of keys) {
+			const val = schema.patternProperties[key];
+			const result = compileSchemaRegex(key);
+			if (!result.ok) report.addError("KEYWORD_PATTERN", [
+				"patternProperties",
+				key,
+				result.error.message
+			], void 0, schema, "patternProperties");
+			report.path.push("patternProperties");
+			report.path.push(key);
+			this.validateSchema(report, val);
+			report.path.pop();
+			report.path.pop();
+		}
+		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");
+			}
+		}
+	},
+	enum: function(report, schema) {
+		if (Array.isArray(schema.enum) === false) 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");
+	},
+	type: function(report, schema) {
+		const primitiveTypes = [
+			"array",
+			"boolean",
+			"integer",
+			"number",
+			"null",
+			"object",
+			"string"
+		];
+		const primitiveTypeStr = primitiveTypes.join(",");
+		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");
+		} else if (typeof schema.type === "string") {
+			if (!primitiveTypes.includes(schema.type)) report.addError("KEYWORD_TYPE_EXPECTED", ["type", primitiveTypeStr], 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");
+		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");
+			report.path.push(idx);
+			this.validateSchema(report, schema.allOf[idx]);
+			report.path.pop();
+			report.path.pop();
+		}
+	},
+	anyOf: function(report, schema) {
+		if (Array.isArray(schema.anyOf) === false) 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");
+			report.path.push(idx);
+			this.validateSchema(report, schema.anyOf[idx]);
+			report.path.pop();
+			report.path.pop();
+		}
+	},
+	oneOf: function(report, schema) {
+		if (Array.isArray(schema.oneOf) === false) 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");
+			report.path.push(idx);
+			this.validateSchema(report, schema.oneOf[idx]);
+			report.path.pop();
+			report.path.pop();
+		}
+	},
+	not: function(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: function(report, schema) {
+		if (report.options.version !== "draft-07") return;
+		const ifSchema = schema.if;
+		if (!(typeof ifSchema === "boolean" || isObject(ifSchema))) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["if", ["boolean", "object"]], void 0, schema, "if");
+			return;
+		}
+		report.path.push("if");
+		this.validateSchema(report, ifSchema);
+		report.path.pop();
+	},
+	then: function(report, schema) {
+		if (report.options.version !== "draft-07") return;
+		const thenSchema = schema.then;
+		if (!(typeof thenSchema === "boolean" || isObject(thenSchema))) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["then", ["boolean", "object"]], void 0, schema, "then");
+			return;
+		}
+		report.path.push("then");
+		this.validateSchema(report, thenSchema);
+		report.path.pop();
+	},
+	else: function(report, schema) {
+		if (report.options.version !== "draft-07") return;
+		const elseSchema = schema.else;
+		if (!(typeof elseSchema === "boolean" || isObject(elseSchema))) {
+			report.addError("KEYWORD_TYPE_EXPECTED", ["else", ["boolean", "object"]], void 0, schema, "else");
+			return;
+		}
+		report.path.push("else");
+		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();
+			}
+		}
+	},
+	$defs: function(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");
+			return;
+		}
+		const keys = Object.keys(schema.$defs);
+		for (const key of keys) {
+			const val = schema.$defs[key];
+			report.path.push("$defs");
+			report.path.push(key);
+			this.validateSchema(report, val);
+			report.path.pop();
+			report.path.pop();
+		}
+	},
+	format: function(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");
+		}
+	},
+	contentEncoding: function(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) {
+		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) {
+		if (typeof schema.id !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["id", "string"], void 0, schema, "id");
+	},
+	title: function(report, schema) {
+		if (typeof schema.title !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["title", "string"], void 0, schema, "title");
+	},
+	description: function(report, schema) {
+		if (typeof schema.description !== "string") report.addError("KEYWORD_TYPE_EXPECTED", ["description", "string"], void 0, schema, "description");
+	},
+	default: function() {}
+};
+var SchemaValidator = class {
+	constructor(validator) {
+		this.validator = validator;
+	}
+	get options() {
+		return this.validator.options;
+	}
+	validateArrayOfSchemas(report, arr) {
+		for (const schema of arr) this.validateSchema(report, schema);
+		return report.isValid();
+	}
+	validateSchema(report, schema) {
+		report.commonErrorMessage = "SCHEMA_VALIDATION_FAILED";
+		if (Array.isArray(schema)) return this.validateArrayOfSchemas(report, schema);
+		if (typeof schema === "boolean") return true;
+		if (schema.__$validated) return true;
+		const hasParentSchema = schema.$schema && getId(schema) !== schema.$schema;
+		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");
+			} 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) {
+					if (!sch.type) sch.type = schema.type;
+				});
+			}
+			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");
+		}
+		const keys = Object.keys(schema);
+		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);
+			}
+		}
+		if (this.validator.options.pedanticCheck === true) {
+			if (schema.enum) {
+				const tmpSchema = shallowClone(schema);
+				delete tmpSchema.enum;
+				delete tmpSchema.default;
+				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]);
+					report.path.pop();
+				}
+				report.path.pop();
+			}
+			if (schema.default) {
+				report.path.push("default");
+				validate.call(this.validator, report, schema, schema.default);
+				report.path.pop();
+			}
+		}
+		const isValid = report.isValid();
+		if (isValid) schema.__$validated = true;
+		return isValid;
+	}
+};
+//#endregion
+export { SchemaValidator };

package/dist/schemas/draft-04-schema.mjs

@@ -0,0 +1,125 @@
+//#region src/schemas/draft-04-schema.json
+var draft_04_schema_default = {
+	id: "http://json-schema.org/draft-04/schema#",
+	$schema: "http://json-schema.org/draft-04/schema#",
+	description: "Core schema meta-schema",
+	definitions: {
+		"schemaArray": {
+			"type": "array",
+			"minItems": 1,
+			"items": { "$ref": "#" }
+		},
+		"positiveInteger": {
+			"type": "integer",
+			"minimum": 0
+		},
+		"positiveIntegerDefault0": { "allOf": [{ "$ref": "#/definitions/positiveInteger" }, { "default": 0 }] },
+		"simpleTypes": { "enum": [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		] },
+		"stringArray": {
+			"type": "array",
+			"items": { "type": "string" },
+			"minItems": 1,
+			"uniqueItems": true
+		}
+	},
+	type: "object",
+	properties: {
+		"id": { "type": "string" },
+		"$schema": { "type": "string" },
+		"title": { "type": "string" },
+		"description": { "type": "string" },
+		"default": {},
+		"multipleOf": {
+			"type": "number",
+			"minimum": 0,
+			"exclusiveMinimum": true
+		},
+		"maximum": { "type": "number" },
+		"exclusiveMaximum": {
+			"type": "boolean",
+			"default": false
+		},
+		"minimum": { "type": "number" },
+		"exclusiveMinimum": {
+			"type": "boolean",
+			"default": false
+		},
+		"maxLength": { "$ref": "#/definitions/positiveInteger" },
+		"minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+		"pattern": {
+			"type": "string",
+			"format": "regex"
+		},
+		"additionalItems": {
+			"anyOf": [{ "type": "boolean" }, { "$ref": "#" }],
+			"default": {}
+		},
+		"items": {
+			"anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/schemaArray" }],
+			"default": {}
+		},
+		"maxItems": { "$ref": "#/definitions/positiveInteger" },
+		"minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+		"uniqueItems": {
+			"type": "boolean",
+			"default": false
+		},
+		"maxProperties": { "$ref": "#/definitions/positiveInteger" },
+		"minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+		"required": { "$ref": "#/definitions/stringArray" },
+		"additionalProperties": {
+			"anyOf": [{ "type": "boolean" }, { "$ref": "#" }],
+			"default": {}
+		},
+		"definitions": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#" },
+			"default": {}
+		},
+		"properties": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#" },
+			"default": {}
+		},
+		"patternProperties": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#" },
+			"default": {}
+		},
+		"dependencies": {
+			"type": "object",
+			"additionalProperties": { "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/stringArray" }] }
+		},
+		"enum": {
+			"type": "array",
+			"minItems": 1,
+			"uniqueItems": true
+		},
+		"type": { "anyOf": [{ "$ref": "#/definitions/simpleTypes" }, {
+			"type": "array",
+			"items": { "$ref": "#/definitions/simpleTypes" },
+			"minItems": 1,
+			"uniqueItems": true
+		}] },
+		"format": { "type": "string" },
+		"allOf": { "$ref": "#/definitions/schemaArray" },
+		"anyOf": { "$ref": "#/definitions/schemaArray" },
+		"oneOf": { "$ref": "#/definitions/schemaArray" },
+		"not": { "$ref": "#" }
+	},
+	dependencies: {
+		"exclusiveMaximum": ["maximum"],
+		"exclusiveMinimum": ["minimum"]
+	},
+	"default": {}
+};
+//#endregion
+export { draft_04_schema_default as default };