z-schema 12.2.0 → 12.4.0

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++) {
@@ -46,4 +46,4 @@ const resolveDynamicRef = (schema, dynamicScopeStack) => {
 	return target;
 };
 //#endregion
-export { resolveDynamicRef, resolveRecursiveRef };
+export { findDynamicAnchorInScope, getDynamicRefAnchorName, resolveDynamicRef, resolveRecursiveRef };

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");
@@ -13,7 +9,7 @@ const VOCAB_VALIDATION_2019_09 = "https://json-schema.org/draft/2019-09/vocab/va
 const VOCAB_VALIDATION_2020_12 = "https://json-schema.org/draft/2020-12/vocab/validation";
 const VOCAB_FORMAT_2019_09 = "https://json-schema.org/draft/2019-09/vocab/format";
 const VOCAB_FORMAT_ASSERTION_2020_12 = "https://json-schema.org/draft/2020-12/vocab/format-assertion";
-const VALIDATION_VOCAB_KEYWORDS = new Set([
+const VALIDATION_VOCAB_KEYWORDS = /* @__PURE__ */ new Set([
 	"type",
 	"multipleOf",
 	"maximum",
@@ -44,7 +40,9 @@ 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;
+	const has2019 = Object.hasOwn(vocabulary, VOCAB_VALIDATION_2019_09);
+	const has2020 = Object.hasOwn(vocabulary, VOCAB_VALIDATION_2020_12);
+	if (has2019 || has2020) return vocabulary[VOCAB_VALIDATION_2019_09] || vocabulary[VOCAB_VALIDATION_2020_12];
 	return false;
 };
 /**
@@ -60,8 +58,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 +83,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();
 	});

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

@@ -1,22 +1,22 @@
-import { whatIs } from "../utils/what-is.mjs";
-import { getFormatValidators } from "../format-validators.mjs";
-import { compileSchemaRegex } from "../utils/schema-regex.mjs";
-import { isFormatAssertionVocabEnabled, shouldSkipValidate } from "./shared.mjs";
-import { decodeBase64, isValidBase64 } from "../utils/base64.mjs";
-import { unicodeLength } from "../utils/unicode.mjs";
+import { whatIs } from "../utils/what-is.js";
+import { resolveFormatValidator } from "../format-validators.js";
+import { compileSchemaRegex } from "../utils/schema-regex.js";
+import { isFormatAssertionVocabEnabled, shouldSkipValidate } from "./shared.js";
+import { decodeBase64, isValidBase64 } from "../utils/base64.js";
+import { unicodeLength } from "../utils/unicode.js";
 //#region src/validation/string.ts
-function minLengthValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MIN_LENGTH"])) return;
+function minLengthValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MIN_LENGTH"])) return;
 	if (typeof json !== "string") return;
 	if (unicodeLength(json) < schema.minLength) report.addError("MIN_LENGTH", [json.length, schema.minLength], void 0, schema, "minLength");
 }
-function maxLengthValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MAX_LENGTH"])) return;
+function maxLengthValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MAX_LENGTH"])) return;
 	if (typeof json !== "string") return;
 	if (unicodeLength(json) > schema.maxLength) report.addError("MAX_LENGTH", [json.length, schema.maxLength], void 0, schema, "maxLength");
 }
-function patternValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["PATTERN"])) return;
+function patternValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["PATTERN"])) return;
 	if (typeof json !== "string") return;
 	const result = compileSchemaRegex(schema.pattern);
 	if (!result.ok) {
@@ -29,46 +29,46 @@ function patternValidator(report, schema, json) {
 	}
 	if (!result.value.test(json)) report.addError("PATTERN", [schema.pattern, json], void 0, schema, "pattern");
 }
-function formatValidator(report, schema, json) {
-	if (this.options.formatAssertions === false) return;
-	if (this.options.formatAssertions === true) {
-		if (!isFormatAssertionVocabEnabled(schema, report, this.options.version)) return;
-	}
-	const isModernDraft = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
-	const formatValidatorFn = getFormatValidators(this.options)[schema.format];
+function formatValidator(ctx, report, schema, json) {
+	if (ctx.options.formatAssertions === false) return;
+	if (ctx.options.formatAssertions === true && !isFormatAssertionVocabEnabled(schema, report, ctx.options.version)) return;
+	const isModernDraft = ctx.options.version === "draft2019-09" || ctx.options.version === "draft2020-12";
+	const formatValidatorFn = resolveFormatValidator(schema.format, ctx.options);
 	if (typeof formatValidatorFn === "function") {
-		if (shouldSkipValidate(this.validateOptions, ["INVALID_FORMAT"])) return;
+		if (shouldSkipValidate(ctx.validateOptions, ["INVALID_FORMAT"])) return;
 		if (report.hasError("INVALID_TYPE", [schema.type, whatIs(json)])) return;
-		if (formatValidatorFn.length === 2) report.addAsyncTaskWithPath(formatValidatorFn, [json], function(result) {
+		if (formatValidatorFn.length === 2) report.addAsyncTaskWithPath(formatValidatorFn, [json], (result) => {
 			if (result !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
 		});
 		else {
-			const result = formatValidatorFn.call(this, json);
+			const result = formatValidatorFn.call(ctx, json);
 			if (result instanceof Promise) {
 				const promiseResult = result;
 				report.addAsyncTaskWithPath(async (callback) => {
+					let resolved = false;
 					try {
-						callback(await promiseResult);
-					} catch (_error) {
-						callback(false);
-					}
-				}, [], function(resolvedResult) {
+						resolved = await promiseResult;
+					} catch {}
+					callback(resolved);
+				}, [], (resolvedResult) => {
 					if (resolvedResult !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
 				});
-			} else if (result !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
+			} else if (!result) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
 		}
-	} else if (this.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
+	} else if (ctx.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
 }
-function contentEncodingValidator(report, schema, json) {
-	if (this.options.version !== "draft-07") return;
+function contentEncodingValidator(ctx, report, schema, json) {
+	if (ctx.options.version !== "draft-07") return;
 	if (typeof json !== "string") return;
-	if (schema.contentEncoding !== "base64") return;
+	const { contentEncoding } = schema;
+	if (contentEncoding !== "base64") return;
 	if (!isValidBase64(json)) report.addError("INVALID_FORMAT", ["contentEncoding:base64", JSON.stringify(json)], void 0, schema, "contentEncoding");
 }
-function contentMediaTypeValidator(report, schema, json) {
-	if (this.options.version !== "draft-07") return;
+function contentMediaTypeValidator(ctx, report, schema, json) {
+	if (ctx.options.version !== "draft-07") return;
 	if (typeof json !== "string") return;
-	if (schema.contentMediaType !== "application/json") return;
+	const { contentMediaType } = schema;
+	if (contentMediaType !== "application/json") return;
 	let payload = json;
 	if (schema.contentEncoding === "base64") {
 		const decoded = decodeBase64(json);

package/dist/validation/type.js

@@ -0,0 +1,34 @@
+import { whatIs } from "../utils/what-is.js";
+import { areEqual } from "../utils/json.js";
+import { shouldSkipValidate } from "./shared.js";
+//#region src/validation/type.ts
+function typeValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["INVALID_TYPE"])) return;
+	const jsonType = whatIs(json);
+	if (typeof schema.type === "string") {
+		if (jsonType !== schema.type && (jsonType !== "integer" || schema.type !== "number")) report.addError("INVALID_TYPE", [schema.type, jsonType], void 0, schema, "type");
+	} else if (!schema.type.includes(jsonType) && (jsonType !== "integer" || !schema.type.includes("number"))) report.addError("INVALID_TYPE", [JSON.stringify(schema.type), jsonType], void 0, schema, "type");
+}
+function enumValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["ENUM_CASE_MISMATCH", "ENUM_MISMATCH"])) return;
+	const eqOpts = { maxDepth: ctx.options.maxRecursionDepth };
+	const eqOptsCI = {
+		caseInsensitiveComparison: true,
+		maxDepth: ctx.options.maxRecursionDepth
+	};
+	let caseInsensitiveMatch = false, match = false;
+	for (const enumVal of schema.enum) if (areEqual(json, enumVal, eqOpts)) {
+		match = true;
+		break;
+	} else if (areEqual(json, enumVal, eqOptsCI)) caseInsensitiveMatch = true;
+	if (!match) {
+		const error = caseInsensitiveMatch && ctx.options.enumCaseInsensitiveComparison ? "ENUM_CASE_MISMATCH" : "ENUM_MISMATCH";
+		report.addError(error, [JSON.stringify(json)], void 0, schema, "enum");
+	}
+}
+function constValidator(ctx, report, schema, json) {
+	const constValue = schema.const;
+	if (!areEqual(json, constValue, { maxDepth: ctx.options.maxRecursionDepth })) report.addError("CONST", [JSON.stringify(constValue)], void 0, schema);
+}
+//#endregion
+export { constValidator, enumValidator, typeValidator };

package/dist/{z-schema-base.d.mts → z-schema-base.d.ts}

@@ -1,11 +1,11 @@
-import { FormatValidatorFn } from "./format-validators.mjs";
-import { ZSchemaOptions } from "./z-schema-options.mjs";
-import { Report } from "./report.mjs";
-import { Errors, ValidateError } from "./errors.mjs";
-import { SchemaCache } from "./schema-cache.mjs";
-import { SchemaValidator } from "./schema-validator.mjs";
-import { SchemaCompiler } from "./schema-compiler.mjs";
-import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.mjs";
+import { FormatValidatorFn } from "./format-validators.js";
+import { ZSchemaOptions } from "./z-schema-options.js";
+import { Report } from "./report.js";
+import { Errors, ValidateError } from "./errors.js";
+import { SchemaCache } from "./schema-cache.js";
+import { SchemaValidator } from "./schema-validator.js";
+import { SchemaCompiler } from "./schema-compiler.js";
+import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.js";
 
 //#region src/z-schema-base.d.ts
 interface ValidateOptions {
@@ -13,10 +13,10 @@ interface ValidateOptions {
   includeErrors?: Array<keyof typeof Errors>;
   excludeErrors?: Array<keyof typeof Errors>;
 }
-type ValidateResponse = {
+interface ValidateResponse {
   valid: boolean;
   err?: ValidateError;
-};
+}
 type ValidateCallback = (err: ValidateResponse['err'], valid: ValidateResponse['valid']) => void;
 declare class ZSchemaBase {
   scache: SchemaCache;
@@ -36,8 +36,7 @@ declare class ZSchemaBase {
   getDefaultSchemaId(): string;
   _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
   _validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
-  _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): true;
-  _validate(json: unknown, schema: JsonSchema | string): true;
+  _validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): true;
   _validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
   /**
    * Register a format validator on this instance only (does not affect other instances or the global registry).

package/dist/{z-schema-base.mjs → z-schema-base.js}

@@ -1,18 +1,18 @@
-import { getRemotePath } from "./utils/uri.mjs";
-import { isObject, whatIs } from "./utils/what-is.mjs";
-import { isInternalKey } from "./json-schema.mjs";
-import { getValidateError } from "./errors.mjs";
-import { copyProp } from "./utils/properties.mjs";
-import { deepClone } from "./utils/clone.mjs";
-import { get, sortedKeys } from "./utils/json.mjs";
-import { Report } from "./report.mjs";
-import { VERSION_SCHEMA_URL_MAPPING } from "./json-schema-versions.mjs";
-import { defaultOptions, normalizeOptions } from "./z-schema-options.mjs";
-import { SchemaCache, prepareRemoteSchema } from "./schema-cache.mjs";
-import { getSupportedFormats } from "./format-validators.mjs";
-import { validate } from "./json-validation.mjs";
-import { SchemaCompiler } from "./schema-compiler.mjs";
-import { SchemaValidator } from "./schema-validator.mjs";
+import { getRemotePath } from "./utils/uri.js";
+import { isObject, whatIs } from "./utils/what-is.js";
+import { isInternalKey } from "./json-schema.js";
+import { getValidateError } from "./errors.js";
+import { copyProp } from "./utils/properties.js";
+import { deepClone } from "./utils/clone.js";
+import { get, sortedKeys } from "./utils/json.js";
+import { Report } from "./report.js";
+import { VERSION_SCHEMA_URL_MAPPING } from "./json-schema-versions.js";
+import { defaultOptions, normalizeOptions } from "./z-schema-options.js";
+import { SchemaCache, prepareRemoteSchema } from "./schema-cache.js";
+import { getSupportedFormats } from "./format-validators.js";
+import { validate } from "./json-validation.js";
+import { SchemaCompiler } from "./schema-compiler.js";
+import { SchemaValidator } from "./schema-validator.js";
 //#region src/z-schema-base.ts
 /**
 * Module-private symbol used by `ZSchema.create()` to authorise construction.
@@ -40,7 +40,7 @@ var ZSchemaBase = class {
 	* create a circular dependency).
 	*/
 	_jsonValidate(report, schema, json) {
-		return validate.call(this, report, schema, json);
+		return validate(this, report, schema, json);
 	}
 	getDefaultSchemaId() {
 		return this.options.version && this.options.version !== "none" ? VERSION_SCHEMA_URL_MAPPING[this.options.version] : VERSION_SCHEMA_URL_MAPPING[defaultOptions.version];
@@ -53,9 +53,9 @@ var ZSchemaBase = class {
 		if (!options) options = {};
 		this.validateOptions = options;
 		if (typeof schema !== "string" && typeof schema !== "boolean" && !isObject(schema)) {
-			const e = /* @__PURE__ */ new Error("Invalid .validate call - schema must be a string or object but " + whatIs(schema) + " was passed!");
+			const e = /* @__PURE__ */ new Error(`Invalid .validate call - schema must be a string or object but ${whatIs(schema)} was passed!`);
 			if (callback) {
-				setTimeout(function() {
+				setTimeout(() => {
 					callback(e, false);
 				}, 0);
 				return;
@@ -70,9 +70,9 @@ var ZSchemaBase = class {
 			const schemaName = schema;
 			_schema = this.scache.getSchema(report, schemaName);
 			if (!_schema) {
-				const e = /* @__PURE__ */ new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
+				const e = /* @__PURE__ */ new Error(`Schema with id '${schemaName}' wasn't found in the validator cache!`);
 				if (callback) {
-					setTimeout(function() {
+					setTimeout(() => {
 						callback(e, false);
 					}, 0);
 					return;
@@ -90,9 +90,9 @@ var ZSchemaBase = class {
 			report.rootSchema = _schema;
 			_schema = get(_schema, options.schemaPath);
 			if (!_schema) {
-				const e = /* @__PURE__ */ new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
+				const e = /* @__PURE__ */ new Error(`Schema path '${options.schemaPath}' wasn't found in the schema!`);
 				if (callback) {
-					setTimeout(function() {
+					setTimeout(() => {
 						callback(e, false);
 					}, 0);
 					return;
@@ -100,7 +100,7 @@ var ZSchemaBase = class {
 				throw e;
 			}
 		}
-		if (!foundError) validate.call(this, report, _schema, json);
+		if (!foundError) validate(this, report, _schema, json);
 		if (callback) {
 			report.processAsyncTasks(this.options.asyncTimeout, callback);
 			return;
@@ -171,8 +171,8 @@ var ZSchemaBase = class {
 		if (!err) return [];
 		const details = err.details || [];
 		const missingRefs = [];
-		function collect(details) {
-			for (const detail of details) {
+		function collect(items) {
+			for (const detail of items) {
 				if (detail.code === "UNRESOLVABLE_REFERENCE" || detail.code === "SCHEMA_NOT_REACHABLE") missingRefs.push(detail.params[0]);
 				if (detail.inner) collect(detail.inner);
 			}
@@ -188,9 +188,13 @@ var ZSchemaBase = class {
 	getMissingRemoteReferences(err) {
 		const missingReferences = this.getMissingReferences(err);
 		const missingRemoteReferences = [];
+		const seen = /* @__PURE__ */ new Set();
 		for (const ref of missingReferences) {
 			const remoteReference = getRemotePath(ref);
-			if (remoteReference && !missingRemoteReferences.includes(remoteReference)) missingRemoteReferences.push(remoteReference);
+			if (remoteReference && !seen.has(remoteReference)) {
+				seen.add(remoteReference);
+				missingRemoteReferences.push(remoteReference);
+			}
 		}
 		return missingRemoteReferences;
 	}
@@ -203,24 +207,25 @@ var ZSchemaBase = class {
 	getResolvedSchema(schemaId) {
 		const report = new Report(this.options);
 		const schema = this.scache.getSchemaByUri(report, schemaId);
-		if (!schema) return void 0;
+		if (!schema) return;
 		const clonedSchema = deepClone(schema, this.options.maxRecursionDepth);
 		const visited = /* @__PURE__ */ new WeakSet();
-		const cleanup = function(schema) {
-			let key;
-			const typeOf = whatIs(schema);
+		const cleanup = (node) => {
+			const typeOf = whatIs(node);
 			if (typeOf !== "object" && typeOf !== "array") return;
-			if (visited.has(schema)) return;
-			visited.add(schema);
-			if (schema.$ref && schema.__$refResolved) {
-				const from = schema.__$refResolved;
-				const to = schema;
-				delete schema.$ref;
-				delete schema.__$refResolved;
-				for (key in from) copyProp(from, to, key);
+			if (visited.has(node)) return;
+			visited.add(node);
+			const schemaNode = node;
+			if (schemaNode.$ref && schemaNode.__$refResolved) {
+				const from = schemaNode.__$refResolved;
+				const to = schemaNode;
+				delete schemaNode.$ref;
+				delete schemaNode.__$refResolved;
+				for (const key in from) if (Object.hasOwn(from, key)) copyProp(from, to, key);
 			}
-			for (key in schema) if (Object.hasOwn(schema, key)) if (isInternalKey(key)) delete schema[key];
-			else cleanup(schema[key]);
+			const record = node;
+			for (const key in record) if (Object.hasOwn(record, key)) if (isInternalKey(key)) delete record[key];
+			else cleanup(record[key]);
 		};
 		cleanup(clonedSchema);
 		return clonedSchema;

package/dist/{z-schema-options.d.mts → z-schema-options.d.ts}

@@ -1,6 +1,6 @@
-import { FormatValidatorFn } from "./format-validators.mjs";
-import { Report } from "./report.mjs";
-import { JsonSchemaVersion } from "./json-schema-versions.mjs";
+import { FormatValidatorFn } from "./format-validators.js";
+import { Report } from "./report.js";
+import { JsonSchemaVersion } from "./json-schema-versions.js";
 
 //#region src/z-schema-options.d.ts
 interface ZSchemaOptions {

package/dist/{z-schema-options.mjs → z-schema-options.js}

@@ -1,6 +1,6 @@
-import { MAX_ASYNC_TIMEOUT } from "./utils/constants.mjs";
-import { shallowClone } from "./utils/clone.mjs";
-import { CURRENT_DEFAULT_SCHEMA_VERSION } from "./json-schema-versions.mjs";
+import { MAX_ASYNC_TIMEOUT } from "./utils/constants.js";
+import { shallowClone } from "./utils/clone.js";
+import { CURRENT_DEFAULT_SCHEMA_VERSION } from "./json-schema-versions.js";
 //#region src/z-schema-options.ts
 const defaultOptions = {
 	version: CURRENT_DEFAULT_SCHEMA_VERSION,
@@ -33,7 +33,7 @@ const normalizeOptions = (options) => {
 	let normalized;
 	if (typeof options === "object") {
 		let keys = Object.keys(options);
-		for (const key of keys) if (defaultOptions[key] === void 0) throw new Error("Unexpected option passed to constructor: " + key);
+		for (const key of keys) if (defaultOptions[key] === void 0) throw new Error(`Unexpected option passed to constructor: ${key}`);
 		keys = Object.keys(defaultOptions);
 		for (const key of keys) if (options[key] === void 0) options[key] = shallowClone(defaultOptions[key]);
 		normalized = options;
@@ -52,4 +52,4 @@ const normalizeOptions = (options) => {
 	return normalized;
 };
 //#endregion
-export { defaultOptions, normalizeOptions };
+export { MAX_ASYNC_TIMEOUT, defaultOptions, normalizeOptions };

package/dist/{z-schema-reader.d.mts → z-schema-reader.d.ts}

@@ -1,4 +1,4 @@
-import { JsonSchema } from "./json-schema-versions.mjs";
+import { JsonSchema } from "./json-schema-versions.js";
 
 //#region src/z-schema-reader.d.ts
 type SchemaReader = (uri: string) => JsonSchema;