z-schema 12.2.0 → 12.4.0

package/src/utils/time.ts

@@ -24,7 +24,8 @@ export interface ParsedRfc3339Time {
   utcMinute: number;
 }
 
-const RFC3339_TIME_REGEX = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(\.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/i;
+const RFC3339_TIME_REGEX =
+  /^(?<hour>[0-9]{2}):(?<minute>[0-9]{2}):(?<second>[0-9]{2})(?<fraction>\.[0-9]+)?(?<offset>z|(?<offsetValue>[+-][0-9]{2}:[0-9]{2}))$/i;
 
 export const parseRfc3339Time = (time: string): ParsedRfc3339Time | null => {
   const matches = RFC3339_TIME_REGEX.exec(time);
@@ -32,9 +33,9 @@ export const parseRfc3339Time = (time: string): ParsedRfc3339Time | null => {
     return null;
   }
 
-  const hour = parseInt(matches[1], 10);
-  const minute = parseInt(matches[2], 10);
-  const second = parseInt(matches[3], 10);
+  const hour = Number.parseInt(matches[1], 10);
+  const minute = Number.parseInt(matches[2], 10);
+  const second = Number.parseInt(matches[3], 10);
   if (hour > 23 || minute > 59 || second > 60) {
     return null;
   }
@@ -42,14 +43,14 @@ export const parseRfc3339Time = (time: string): ParsedRfc3339Time | null => {
   let utcHour = hour;
   let utcMinute = minute;
   if (matches[5].toLowerCase() !== 'z') {
-    const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(matches[5]);
+    const offsetMatches = /^(?<sign>[+-])(?<hour>[0-9]{2}):(?<minute>[0-9]{2})$/.exec(matches[5]);
     if (offsetMatches === null) {
       return null;
     }
 
     const offsetSign = offsetMatches[1] as '+' | '-';
-    const offsetHour = parseInt(offsetMatches[2], 10);
-    const offsetMinute = parseInt(offsetMatches[3], 10);
+    const offsetHour = Number.parseInt(offsetMatches[2], 10);
+    const offsetMinute = Number.parseInt(offsetMatches[3], 10);
     if (offsetHour > 23 || offsetMinute > 59) {
       return null;
     }

package/src/utils/unicode.ts

@@ -1,12 +1,19 @@
 /**
  * Returns the number of Unicode code points in the string.
- * Uses the built-in string iterator which correctly handles surrogate pairs.
+ * Uses a surrogate-aware charCodeAt scan (equivalent to the string iterator)
+ * that counts a surrogate pair as one code point and lone surrogates as one each.
  */
 export function unicodeLength(str: string): number {
-  let count = 0;
-  for (const _cp of str) {
-    void _cp;
-    count++;
+  let count = str.length;
+  for (let i = 0; i < str.length - 1; i++) {
+    const hi = str.charCodeAt(i);
+    if (hi >= 0xd8_00 && hi <= 0xdb_ff) {
+      const lo = str.charCodeAt(i + 1);
+      if (lo >= 0xdc_00 && lo <= 0xdf_ff) {
+        count--;
+        i++;
+      }
+    }
   }
   return count;
 }

package/src/utils/what-is.ts

@@ -26,11 +26,7 @@ export const whatIs = (what: unknown): WHAT_IS => {
 
   if (typeof what === 'number') {
     if (Number.isFinite(what)) {
-      if (what % 1 === 0) {
-        return 'integer';
-      } else {
-        return 'number';
-      }
+      return what % 1 === 0 ? 'integer' : 'number';
     }
     if (Number.isNaN(what)) {
       return 'not-a-number';

package/src/validation/array.ts

@@ -9,9 +9,9 @@ import { cacheValidationResult, deferOrRunSync, shouldSkipValidate } from './sha
 // additionalItems
 // ---------------------------------------------------------------------------
 
-export function additionalItemsValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function additionalItemsValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.2
-  if (shouldSkipValidate(this.validateOptions, ['ARRAY_ADDITIONAL_ITEMS'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['ARRAY_ADDITIONAL_ITEMS'])) {
     return;
   }
   if (!Array.isArray(json)) {
@@ -19,10 +19,8 @@ export function additionalItemsValidator(this: ZSchemaBase, report: Report, sche
   }
   // if the value of "additionalItems" is boolean value false and the value of "items" is an array,
   // the json is valid if its size is less than, or equal to, the size of "items".
-  if (schema.additionalItems === false && Array.isArray(schema.items)) {
-    if (json.length > schema.items.length) {
-      report.addError('ARRAY_ADDITIONAL_ITEMS', undefined, undefined, schema, 'additionalItems');
-    }
+  if (schema.additionalItems === false && Array.isArray(schema.items) && json.length > schema.items.length) {
+    report.addError('ARRAY_ADDITIONAL_ITEMS', undefined, undefined, schema, 'additionalItems');
   }
 }
 
@@ -47,9 +45,9 @@ export function prefixItemsValidator() {
 // maxItems
 // ---------------------------------------------------------------------------
 
-export function maxItemsValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function maxItemsValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.2
-  if (shouldSkipValidate(this.validateOptions, ['ARRAY_LENGTH_LONG'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['ARRAY_LENGTH_LONG'])) {
     return;
   }
   if (!Array.isArray(json)) {
@@ -64,9 +62,9 @@ export function maxItemsValidator(this: ZSchemaBase, report: Report, schema: Jso
 // minItems
 // ---------------------------------------------------------------------------
 
-export function minItemsValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function minItemsValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.2
-  if (shouldSkipValidate(this.validateOptions, ['ARRAY_LENGTH_SHORT'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['ARRAY_LENGTH_SHORT'])) {
     return;
   }
   if (!Array.isArray(json)) {
@@ -81,9 +79,9 @@ export function minItemsValidator(this: ZSchemaBase, report: Report, schema: Jso
 // uniqueItems
 // ---------------------------------------------------------------------------
 
-export function uniqueItemsValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function uniqueItemsValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.2
-  if (shouldSkipValidate(this.validateOptions, ['ARRAY_UNIQUE'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['ARRAY_UNIQUE'])) {
     return;
   }
   if (!Array.isArray(json)) {
@@ -91,7 +89,7 @@ export function uniqueItemsValidator(this: ZSchemaBase, report: Report, schema:
   }
   if (schema.uniqueItems === true) {
     const matches: any[] = [];
-    if (isUniqueArray(json, matches, this.options.maxRecursionDepth) === false) {
+    if (!isUniqueArray(json, matches, ctx.options.maxRecursionDepth)) {
       report.addError('ARRAY_UNIQUE', matches, undefined, schema, 'uniqueItems');
     }
   }
@@ -101,8 +99,8 @@ export function uniqueItemsValidator(this: ZSchemaBase, report: Report, schema:
 // contains
 // ---------------------------------------------------------------------------
 
-export function containsValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
-  if (shouldSkipValidate(this.validateOptions, ['CONTAINS'])) {
+export function containsValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (shouldSkipValidate(ctx.validateOptions, ['CONTAINS'])) {
     return;
   }
 
@@ -120,19 +118,19 @@ export function containsValidator(this: ZSchemaBase, report: Report, schema: Jso
   for (let idx = 0; idx < json.length; idx++) {
     const subReport = new Report_(report);
     subReports.push(subReport);
-    this._jsonValidate(subReport, containsSchema as any, json[idx]);
+    ctx._jsonValidate(subReport, containsSchema, json[idx]);
     cacheValidationResult(report, containsSchema, json[idx], subReport.errors.length === 0);
   }
 
   const addContainsErrorIfNeeded = () => {
     let matchingItems = 0;
-    for (const subReport of subReports) {
-      if (subReport.errors.length === 0) {
+    for (let i = 0; i < subReports.length; i++) {
+      if (subReports[i].errors.length === 0) {
         matchingItems += 1;
       }
     }
 
-    const supportsContainsBounds = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+    const supportsContainsBounds = ctx.options.version === 'draft2019-09' || ctx.options.version === 'draft2020-12';
     const minContains: number =
       supportsContainsBounds && typeof schema.minContains === 'number' ? (schema.minContains ?? 1) : 1;
     const maxContains =
@@ -142,7 +140,7 @@ export function containsValidator(this: ZSchemaBase, report: Report, schema: Jso
     const notTooManyMatches = maxContains === undefined || matchingItems <= maxContains;
 
     if (!hasEnoughMatches || !notTooManyMatches) {
-      report.addError('CONTAINS', undefined, subReports, schema, undefined);
+      report.addError('CONTAINS', undefined, subReports, schema);
     }
   };
 
@@ -153,5 +151,9 @@ export function containsValidator(this: ZSchemaBase, report: Report, schema: Jso
 // maxContains / minContains  (no-op — handled inside contains)
 // ---------------------------------------------------------------------------
 
-export function maxContainsValidator() {}
-export function minContainsValidator() {}
+export function maxContainsValidator() {
+  // no-op: maxContains is evaluated inside the `contains` validator
+}
+export function minContainsValidator() {
+  // no-op: minContains is evaluated inside the `contains` validator
+}

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;