z-schema 12.2.0 → 12.3.1

package/src/validation/combinators.ts

@@ -8,11 +8,11 @@ import { cacheValidationResult, deferOrRunSync } from './shared.js';
 // allOf
 // ---------------------------------------------------------------------------
 
-export function allOfValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function allOfValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.2
   for (let i = 0; i < schema.allOf!.length; i++) {
-    const validateResult = this._jsonValidate(report, schema.allOf![i], json);
-    if (this.options.breakOnFirstError && validateResult === false) {
+    const validateResult = ctx._jsonValidate(report, schema.allOf![i], json);
+    if (ctx.options.breakOnFirstError && !validateResult) {
       break;
     }
   }
@@ -22,14 +22,14 @@ export function allOfValidator(this: ZSchemaBase, report: Report, schema: JsonSc
 // anyOf
 // ---------------------------------------------------------------------------
 
-export function anyOfValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function anyOfValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.2
   const subReports: Report[] = [];
 
   for (let i = 0; i < schema.anyOf!.length; i++) {
     const subReport = new Report(report);
     subReports.push(subReport);
-    this._jsonValidate(subReport, schema.anyOf![i], json);
+    ctx._jsonValidate(subReport, schema.anyOf![i], json);
     cacheValidationResult(report, schema.anyOf![i], json, subReport.errors.length === 0);
   }
 
@@ -43,7 +43,7 @@ export function anyOfValidator(this: ZSchemaBase, report: Report, schema: JsonSc
       }
     }
 
-    if (passed === false) {
+    if (!passed) {
       report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
     }
   });
@@ -53,14 +53,14 @@ export function anyOfValidator(this: ZSchemaBase, report: Report, schema: JsonSc
 // oneOf
 // ---------------------------------------------------------------------------
 
-export function oneOfValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function oneOfValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.2
   const subReports: Report[] = [];
 
   for (let i = 0; i < schema.oneOf!.length; i++) {
     const subReport = new Report(report);
     subReports.push(subReport);
-    this._jsonValidate(subReport, schema.oneOf![i], json);
+    ctx._jsonValidate(subReport, schema.oneOf![i], json);
     cacheValidationResult(report, schema.oneOf![i], json, subReport.errors.length === 0);
   }
 
@@ -85,10 +85,10 @@ export function oneOfValidator(this: ZSchemaBase, report: Report, schema: JsonSc
 // not
 // ---------------------------------------------------------------------------
 
-export function notValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function notValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
   const subReport = new Report(report);
-  if (this._jsonValidate(subReport, schema.not!, json) === true) {
+  if (ctx._jsonValidate(subReport, schema.not!, json)) {
     report.addError('NOT_PASSED', undefined, undefined, schema, 'not');
   }
 }
@@ -97,8 +97,8 @@ export function notValidator(this: ZSchemaBase, report: Report, schema: JsonSche
 // if / then / else
 // ---------------------------------------------------------------------------
 
-export function ifValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
-  if (this.options.version === 'draft-04' || this.options.version === 'draft-06') {
+export function ifValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (ctx.options.version === 'draft-04' || ctx.options.version === 'draft-06') {
     return;
   }
 
@@ -111,7 +111,7 @@ export function ifValidator(this: ZSchemaBase, report: Report, schema: JsonSchem
   }
 
   const conditionReport = new Report(report);
-  this._jsonValidate(conditionReport, conditionSchema as any, json);
+  ctx._jsonValidate(conditionReport, conditionSchema, json);
   cacheValidationResult(report, conditionSchema, json, conditionReport.errors.length === 0);
 
   const branchSchema = conditionReport.errors.length === 0 ? thenSchema : elseSchema;
@@ -119,7 +119,7 @@ export function ifValidator(this: ZSchemaBase, report: Report, schema: JsonSchem
     return;
   }
 
-  this._jsonValidate(report, branchSchema as any, json);
+  ctx._jsonValidate(report, branchSchema, json);
 }
 
 export function thenValidator() {

package/src/validation/numeric.ts

@@ -8,9 +8,9 @@ import { shouldSkipValidate } from './shared.js';
 // multipleOf
 // ---------------------------------------------------------------------------
 
-export function multipleOfValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function multipleOfValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.2
-  if (shouldSkipValidate(this.validateOptions, ['MULTIPLE_OF'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MULTIPLE_OF'])) {
     return;
   }
   if (typeof json !== 'number') {
@@ -27,9 +27,9 @@ export function multipleOfValidator(this: ZSchemaBase, report: Report, schema: J
 // maximum
 // ---------------------------------------------------------------------------
 
-export function maximumValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function maximumValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.2
-  if (shouldSkipValidate(this.validateOptions, ['MAXIMUM', 'MAXIMUM_EXCLUSIVE'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MAXIMUM', 'MAXIMUM_EXCLUSIVE'])) {
     return;
   }
   if (typeof json !== 'number') {
@@ -39,10 +39,8 @@ export function maximumValidator(this: ZSchemaBase, report: Report, schema: Json
     if (json > schema.maximum!) {
       report.addError('MAXIMUM', [json, schema.maximum!], undefined, schema, 'maximum');
     }
-  } else {
-    if (json >= schema.maximum!) {
-      report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum!], undefined, schema, 'maximum');
-    }
+  } else if (json >= schema.maximum!) {
+    report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum!], undefined, schema, 'maximum');
   }
 }
 
@@ -50,15 +48,10 @@ export function maximumValidator(this: ZSchemaBase, report: Report, schema: Json
 // exclusiveMaximum
 // ---------------------------------------------------------------------------
 
-export function exclusiveMaximumValidator(
-  this: ZSchemaBase,
-  report: Report,
-  schema: JsonSchemaInternal,
-  json: unknown
-) {
+export function exclusiveMaximumValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // In draft-06+, exclusiveMaximum is a standalone number
   if (typeof schema.exclusiveMaximum === 'number') {
-    if (shouldSkipValidate(this.validateOptions, ['MAXIMUM_EXCLUSIVE'])) {
+    if (shouldSkipValidate(ctx.validateOptions, ['MAXIMUM_EXCLUSIVE'])) {
       return;
     }
     if (typeof json !== 'number') {
@@ -75,9 +68,9 @@ export function exclusiveMaximumValidator(
 // minimum
 // ---------------------------------------------------------------------------
 
-export function minimumValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function minimumValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.2
-  if (shouldSkipValidate(this.validateOptions, ['MINIMUM', 'MINIMUM_EXCLUSIVE'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MINIMUM', 'MINIMUM_EXCLUSIVE'])) {
     return;
   }
   if (typeof json !== 'number') {
@@ -87,10 +80,8 @@ export function minimumValidator(this: ZSchemaBase, report: Report, schema: Json
     if (json < schema.minimum!) {
       report.addError('MINIMUM', [json, schema.minimum!], undefined, schema, 'minimum');
     }
-  } else {
-    if (json <= schema.minimum!) {
-      report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum!], undefined, schema, 'minimum');
-    }
+  } else if (json <= schema.minimum!) {
+    report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum!], undefined, schema, 'minimum');
   }
 }
 
@@ -98,15 +89,10 @@ export function minimumValidator(this: ZSchemaBase, report: Report, schema: Json
 // exclusiveMinimum
 // ---------------------------------------------------------------------------
 
-export function exclusiveMinimumValidator(
-  this: ZSchemaBase,
-  report: Report,
-  schema: JsonSchemaInternal,
-  json: unknown
-) {
+export function exclusiveMinimumValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // In draft-06+, exclusiveMinimum is a standalone number
   if (typeof schema.exclusiveMinimum === 'number') {
-    if (shouldSkipValidate(this.validateOptions, ['MINIMUM_EXCLUSIVE'])) {
+    if (shouldSkipValidate(ctx.validateOptions, ['MINIMUM_EXCLUSIVE'])) {
       return;
     }
     if (typeof json !== 'number') {

package/src/validation/object.ts

@@ -11,9 +11,9 @@ import { deferOrRunSync, shouldSkipValidate, supportsDependentKeywords } from '.
 // maxProperties
 // ---------------------------------------------------------------------------
 
-export function maxPropertiesValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function maxPropertiesValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.2
-  if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MAXIMUM'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['OBJECT_PROPERTIES_MAXIMUM'])) {
     return;
   }
   if (!isObject(json)) {
@@ -35,9 +35,9 @@ export function maxPropertiesValidator(this: ZSchemaBase, report: Report, schema
 // minProperties
 // ---------------------------------------------------------------------------
 
-export function minPropertiesValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function minPropertiesValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.2
-  if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MINIMUM'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['OBJECT_PROPERTIES_MINIMUM'])) {
     return;
   }
   if (!isObject(json)) {
@@ -59,9 +59,9 @@ export function minPropertiesValidator(this: ZSchemaBase, report: Report, schema
 // required
 // ---------------------------------------------------------------------------
 
-export function requiredValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function requiredValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.2
-  if (shouldSkipValidate(this.validateOptions, ['OBJECT_MISSING_REQUIRED_PROPERTY'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['OBJECT_MISSING_REQUIRED_PROPERTY'])) {
     return;
   }
   if (!isObject(json)) {
@@ -81,14 +81,14 @@ export function requiredValidator(this: ZSchemaBase, report: Report, schema: Jso
 // ---------------------------------------------------------------------------
 
 export function additionalPropertiesValidator(
-  this: ZSchemaBase,
+  ctx: ZSchemaBase,
   report: Report,
   schema: JsonSchemaInternal,
   json: unknown
 ) {
   // covered in properties and patternProperties
   if (schema.properties === undefined && schema.patternProperties === undefined) {
-    return propertiesValidator.call(this, report, schema, json);
+    propertiesValidator(ctx, report, schema, json);
   }
 }
 
@@ -97,14 +97,14 @@ export function additionalPropertiesValidator(
 // ---------------------------------------------------------------------------
 
 export function patternPropertiesValidator(
-  this: ZSchemaBase,
+  ctx: ZSchemaBase,
   report: Report,
   schema: JsonSchemaInternal,
   json: unknown
 ) {
   // covered in properties
   if (schema.properties === undefined) {
-    return propertiesValidator.call(this, report, schema, json);
+    propertiesValidator(ctx, report, schema, json);
   }
 }
 
@@ -112,16 +112,16 @@ export function patternPropertiesValidator(
 // properties
 // ---------------------------------------------------------------------------
 
-export function propertiesValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function propertiesValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.2
-  if (shouldSkipValidate(this.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
     return;
   }
   if (!isObject(json)) {
     return;
   }
-  const properties = schema.properties !== undefined ? schema.properties : {};
-  const patternProperties = schema.patternProperties !== undefined ? schema.patternProperties : {};
+  const properties = schema.properties === undefined ? {} : schema.properties;
+  const patternProperties = schema.patternProperties === undefined ? {} : schema.patternProperties;
   if (schema.additionalProperties === false) {
     // The property set of the json to validate.
     let s = Object.keys(json);
@@ -132,14 +132,15 @@ export function propertiesValidator(this: ZSchemaBase, report: Report, schema: J
     // remove from "s" all elements of "p", if any;
     s = difference(s, p);
     // for each regex in "pp", remove all elements of "s" which this regex matches.
-    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) {
+        if (regExp.test(s[idx2])) {
           s.splice(idx2, 1);
         }
       }
@@ -147,8 +148,8 @@ export function propertiesValidator(this: ZSchemaBase, report: Report, schema: J
     // Validation of the json succeeds if, after these two steps, set "s" is empty.
     if (s.length > 0) {
       // assumeAdditional can be an array of allowed properties
-      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);
@@ -168,9 +169,9 @@ export function propertiesValidator(this: ZSchemaBase, report: Report, schema: J
 // dependencies
 // ---------------------------------------------------------------------------
 
-export function dependenciesValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function dependenciesValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.2
-  if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
     return;
   }
   if (!isObject(json)) {
@@ -199,7 +200,7 @@ export function dependenciesValidator(this: ZSchemaBase, report: Report, schema:
         }
       } else {
         // if dependency is a schema, validate against this schema
-        this._jsonValidate(report, dependencyDefinition, json);
+        ctx._jsonValidate(report, dependencyDefinition, json);
       }
     }
   }
@@ -209,13 +210,8 @@ export function dependenciesValidator(this: ZSchemaBase, report: Report, schema:
 // dependentSchemas
 // ---------------------------------------------------------------------------
 
-export function dependentSchemasValidator(
-  this: ZSchemaBase,
-  report: Report,
-  schema: JsonSchemaInternal,
-  json: unknown
-) {
-  if (!supportsDependentKeywords(schema, this.options.version)) {
+export function dependentSchemasValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (!supportsDependentKeywords(schema, ctx.options.version)) {
     return;
   }
   if (!isObject(json) || !isObject(schema.dependentSchemas)) {
@@ -227,7 +223,7 @@ export function dependentSchemasValidator(
   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);
     }
   }
 }
@@ -237,15 +233,15 @@ export function dependentSchemasValidator(
 // ---------------------------------------------------------------------------
 
 export function dependentRequiredValidator(
-  this: ZSchemaBase,
+  ctx: ZSchemaBase,
   report: Report,
   schema: JsonSchemaInternal,
   json: unknown
 ) {
-  if (!supportsDependentKeywords(schema, this.options.version)) {
+  if (!supportsDependentKeywords(schema, ctx.options.version)) {
     return;
   }
-  if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
     return;
   }
   if (!isObject(json) || !isObject(schema.dependentRequired)) {
@@ -282,8 +278,8 @@ export function dependentRequiredValidator(
 // propertyNames
 // ---------------------------------------------------------------------------
 
-export function propertyNamesValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
-  if (shouldSkipValidate(this.validateOptions, ['PROPERTY_NAMES'])) {
+export function propertyNamesValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (shouldSkipValidate(ctx.validateOptions, ['PROPERTY_NAMES'])) {
     return;
   }
 
@@ -302,13 +298,13 @@ export function propertyNamesValidator(this: ZSchemaBase, report: Report, schema
   for (const key of keys) {
     const subReport = new Report_(report);
     subReports.push(subReport);
-    this._jsonValidate(subReport, propertyNamesSchema as any, 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, undefined);
+        report.addError('PROPERTY_NAMES', [keys[idx]], subReports[idx], schema);
       }
     }
   };

package/src/validation/ref.ts

@@ -10,11 +10,11 @@ import { getRemotePath } from '../utils/uri.js';
 export const getDynamicRefAnchorName = (dynamicRef: string) => {
   const hashIdx = dynamicRef.indexOf('#');
   if (hashIdx === -1) {
-    return undefined;
+    return;
   }
   const fragment = dynamicRef.slice(hashIdx + 1);
-  if (!fragment || fragment[0] === '/') {
-    return undefined;
+  if (!fragment || fragment.startsWith('/')) {
+    return;
   }
   return fragment;
 };
@@ -26,7 +26,6 @@ export const findDynamicAnchorInScope = (scopeSchema: JsonSchemaInternal, anchor
   if (found && found.$dynamicAnchor === anchorName) {
     return found;
   }
-  return undefined;
 };
 
 // ---------------------------------------------------------------------------
@@ -40,7 +39,7 @@ export const resolveRecursiveRef = (
   schema: JsonSchemaInternal,
   recursiveAnchorStack: JsonSchemaInternal[]
 ): JsonSchemaInternal | undefined => {
-  const resolved = schema.__$recursiveRefResolved as JsonSchemaInternal | undefined;
+  const resolved = schema.__$recursiveRefResolved;
   if (!resolved) {
     return undefined;
   }
@@ -66,7 +65,7 @@ export const resolveDynamicRef = (
   dynamicScopeStack: JsonSchemaInternal[]
 ): JsonSchemaInternal | boolean | undefined => {
   const resolved = schema.__$dynamicRefResolved as JsonSchemaInternal | boolean | undefined;
-  if (typeof resolved === 'undefined' || !schema.$dynamicRef) {
+  if (resolved === undefined || !schema.$dynamicRef) {
     return resolved;
   }
   let target = resolved;

package/src/validation/shared.ts

@@ -1,3 +1,4 @@
+import type { ErrorCode } from '../errors.js';
 import type { JsonSchema, JsonSchemaAll, JsonSchemaInternal, JsonSchemaVersion } from '../json-schema-versions.js';
 // JsonSchemaAll is retained for the VALIDATION_VOCAB_KEYWORDS Set key type.
 import type { Report } from '../report.js';
@@ -9,22 +10,17 @@ import { isObject } from '../utils/what-is.js';
 // Shared types
 // ---------------------------------------------------------------------------
 
-export type JsonValidatorFn = (this: ZSchemaBase, report: Report, schema: JsonSchema, json: unknown) => void;
+export type JsonValidatorFn = (ctx: ZSchemaBase, report: Report, schema: JsonSchema, json: unknown) => void;
 
 // ---------------------------------------------------------------------------
 // Draft / vocabulary helpers
 // ---------------------------------------------------------------------------
 
-export const shouldSkipValidate = function (options: ValidateOptions, errors: any) {
-  return (
-    options &&
-    Array.isArray(options.includeErrors) &&
-    options.includeErrors.length > 0 &&
-    !errors.some(function (err: any) {
-      return options.includeErrors!.includes(err);
-    })
-  );
-};
+export const shouldSkipValidate = (options: ValidateOptions, errors: readonly ErrorCode[]) =>
+  options &&
+  Array.isArray(options.includeErrors) &&
+  options.includeErrors.length > 0 &&
+  !errors.some((err) => options.includeErrors!.includes(err));
 
 export const supportsDependentKeywords = (
   schema: JsonSchemaInternal,
@@ -89,12 +85,12 @@ export const isValidationVocabularyEnabled = (
     return true;
   }
 
-  const vocabulary = metaSchema.$vocabulary as Record<string, boolean>;
+  const vocabulary = metaSchema.$vocabulary;
   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] === true || vocabulary[VOCAB_VALIDATION_2020_12] === true;
+    return vocabulary[VOCAB_VALIDATION_2019_09] || vocabulary[VOCAB_VALIDATION_2020_12];
   }
 
   return false;
@@ -124,16 +120,16 @@ export const isFormatAssertionVocabEnabled = (
     return false; // no vocabulary info, default to annotation-only for modern drafts
   }
 
-  const vocabulary = metaSchema.$vocabulary as Record<string, boolean>;
+  const vocabulary = metaSchema.$vocabulary;
 
   // For draft 2020-12, only the format-assertion vocabulary enables format as assertion
   if (Object.hasOwn(vocabulary, VOCAB_FORMAT_ASSERTION_2020_12)) {
-    return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12] === true;
+    return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12];
   }
 
   // For draft 2019-09, check if the format vocabulary is enabled (true)
   if (Object.hasOwn(vocabulary, VOCAB_FORMAT_2019_09)) {
-    return vocabulary[VOCAB_FORMAT_2019_09] === true;
+    return vocabulary[VOCAB_FORMAT_2019_09];
   }
 
   return false; // default to annotation-only for modern drafts
@@ -170,17 +166,22 @@ export function getCachedValidationResult(report: Report, schema: unknown, json:
  */
 export function deferOrRunSync(report: Report, subReports: Report[], decisionFn: () => void): void {
   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]);
+    }
   }
   const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
 
   if (hasAsyncTasks) {
     report.addAsyncTaskWithPath(
-      (callback) => {
-        setTimeout(() => callback(null), 0);
+      (callback: (result: unknown) => void) => {
+        setTimeout(() => {
+          callback(null);
+        }, 0);
       },
-      [] as any,
+      [],
       () => {
         decisionFn();
       }