@jetio/validator 1.0.1 → 1.0.3

package/dist/validator.umd.js

@@ -251,7 +251,6 @@
           this.validateKeywords = new Set();
           this.notLogic = false;
           this.noreturn = false;
-          this.neutralError = false;
           this.standAlone = false;
           this.hasCompileKeyword = false;
           this.needslen_of = false;
@@ -444,11 +443,10 @@
               return src.join("");
           }
           const schema = rootSchema;
-          const varName = (schema.default === undefined || !this.options.useDefaults) &&
-              !this.options.removeAdditional &&
-              !this.options.coerceTypes
+          const varName = accessPattern === "rootData" ||
+              (inlined && (schema.default === undefined || !this.options.useDefaults))
               ? accessPattern
-              : "var" + counter++;
+              : "jv" + counter++;
           this.initializeDefault(src, schema, varName, accessPattern, inlined);
           let shouldTrackProps;
           let shouldTrackItems;
@@ -492,11 +490,16 @@
           return src.join("");
       }
       initializeDefault(src, schema, varName, accessPattern, inlined) {
-          if (schema.default !== undefined && this.options.useDefaults) {
-              src.push(`let ${varName} = ${accessPattern};`, `if (${varName} === undefined || ${varName} === null) {`, `${varName} = ${JSON.stringify(schema.default)};`, "}");
-          }
-          else if (this.options.removeAdditional || this.options.coerceTypes) {
-              src.push(`let ${varName} = ${accessPattern};`);
+          if (accessPattern !== "rootData") {
+              if (schema.default !== undefined && this.options.useDefaults) {
+                  src.push(`let ${varName} = ${accessPattern};`, `if (${varName} === undefined || ${varName} === null) {`, `${varName} = ${JSON.stringify(schema.default)};`, "}");
+              }
+              else if (!inlined) {
+                  const keyword = this.options.removeAdditional || this.options.coerceTypes
+                      ? "let"
+                      : "const";
+                  src.push(`${keyword} ${varName} = ${accessPattern};`);
+              }
           }
           if (this.options.coerceTypes) {
               if (schema.type === "number" || schema.type === "integer") {
@@ -605,7 +608,6 @@
           }
       }
       initializeSchemaRefables(src, schema, varName, pathContext, trackingState, extra) {
-          var _a;
           const funcValidator = "func" + counter++;
           const callArgs = this.buildRefCallArgs(varName, pathContext, trackingState, "#");
           const awaitPrefix = this.options.async ? "await " : "";
@@ -613,16 +615,25 @@
               src.push(`if(${extra.before} true){`);
           src.push(`const ${funcValidator}Result = ${awaitPrefix}${schema.__functionName}${callArgs};`);
           if (this.options.allErrors) {
-              src.push(`if (!${funcValidator}Result) {${this.errorVariable} = ${this.errorVariable}.concat(${schema.__functionName}.errors);${extra.refAfter || extra.after}}`);
+              src.push(`if (!${funcValidator}Result){${extra.after}${this.notLogic ? "" : `${this.errorVariable} = ${this.errorVariable}.concat(${schema.__functionName}.errors);`}}`);
           }
           else {
-              src.push(`if (!${funcValidator}Result){${this.mainFunctionName}.errors = ${schema.__functionName}.errors;${(_a = extra.refAfter) !== null && _a !== void 0 ? _a : extra.after}${this.noreturn ? "" : "return false;"}}`);
+              if (this.noreturn) {
+                  src.push(`if (!${funcValidator}Result){${extra.after}${this.notLogic ? "" : `${schema.__functionName}.errors.length > 1 ? (${this.errorVariable} = ${this.errorVariable}.concat(${schema.__functionName}.errors)) : ${this.errorVariable}.push(${schema.__functionName}.errors[0]);`}}`);
+              }
+              else {
+                  if (this.mainFunctionName === schema.__functionName) {
+                      src.push(`if (!${funcValidator}Result){${this.notLogic ? extra.after : `return false;`}}`);
+                  }
+                  else {
+                      src.push(`if (!${funcValidator}Result){${this.notLogic ? extra.after : `${this.mainFunctionName}.errors = ${schema.__functionName}.errors;return false;`}}`);
+                  }
+              }
           }
           if (extra.before != "")
               src.push(`}`);
       }
       handleReference(src, schema, varName, pathContext, trackingState, extra) {
-          var _a;
           const refType = schema.$ref ? "$ref" : "$dynamicRef";
           const refValue = schema.$ref || schema.$dynamicRef;
           if (refValue === "*unavailable") {
@@ -643,10 +654,20 @@
               src.push(`if(${extra.before} true){`);
           src.push(`const ${refValidator}Result = ${awaitPrefix}${functionName}${callArgs};`);
           if (this.options.allErrors) {
-              src.push(`if (!${refValidator}Result) {${this.errorVariable} = ${this.errorVariable}.concat(${functionName}.errors);${extra.refAfter || extra.after}}`);
+              src.push(`if (!${refValidator}Result){${extra.after}${this.notLogic ? "" : `${this.errorVariable} = ${this.errorVariable}.concat(${functionName}.errors);`}}`);
           }
           else {
-              src.push(`if (!${refValidator}Result){${this.mainFunctionName}.errors = ${functionName}.errors;${(_a = extra.refAfter) !== null && _a !== void 0 ? _a : extra.after}${this.noreturn ? "" : "return false;"}}`);
+              if (this.noreturn) {
+                  src.push(`if (!${refValidator}Result){${extra.after}${this.notLogic ? "" : `${functionName}.errors.length > 1 ? (${this.errorVariable} = ${this.errorVariable}.concat(${functionName}.errors)) : ${this.errorVariable}.push(${functionName}.errors[0]);`}}`);
+              }
+              else {
+                  if (this.mainFunctionName === functionName) {
+                      src.push(`if (!${refValidator}Result){${this.notLogic ? extra.after : `return false;`}}`);
+                  }
+                  else {
+                      src.push(`if (!${refValidator}Result){${this.notLogic ? extra.after : `${this.mainFunctionName}.errors = ${functionName}.errors;return false;`}}`);
+                  }
+              }
           }
           if (extra.before != "")
               src.push(`}`);
@@ -665,12 +686,12 @@
           return `(${args.join(", ")})`;
       }
       handleLogicalOperators(src, schema, varName, pathContext, trackingState, extra) {
+          if (schema.allOf)
+              this.handleAllOfOperator(src, schema, varName, pathContext, trackingState, extra);
           if (schema.not)
               this.handleNotOperator(src, schema, varName, pathContext, extra);
           if (schema.anyOf)
               this.handleAnyOfOperator(src, schema, varName, pathContext, trackingState, extra);
-          if (schema.allOf)
-              this.handleAllOfOperator(src, schema, varName, pathContext, trackingState, extra);
           if (schema.oneOf)
               this.handleOneOfOperator(src, schema, varName, pathContext, trackingState, extra);
       }
@@ -699,15 +720,17 @@
         })}${extra.after}};`);
       }
       handleAnyOfOperator(src, schema, varName, pathContext, trackingState, extra) {
-          var _a;
           if (!schema.anyOf)
               return;
           let firstLength = "";
           const anyOfValid = "anyOfValid" + counter++;
           src.push(`let ${anyOfValid} = false;`);
-          const anyOfError = "anyOfErr" + counter++;
-          if (!this.options.allErrors && !this.notLogic)
+          const anyOfError = this.noreturn
+              ? this.errorVariable
+              : "anyOfErr" + counter++;
+          if (!this.options.allErrors && !this.noreturn)
               src.push(`let ${anyOfError} = [];`);
+          const error = this.errorVariable;
           schema.anyOf.forEach((subSchema, index) => {
               const branch = `branch${counter++}Valid`;
               if (!this.options.allErrors)
@@ -718,24 +741,27 @@
               const configs = this.createSubschemaOptions(trackingState, pathContext, `anyOf/${index}`, schema);
               configs.pathContext.alt = `${pathContext.schema}/anyOf/${index}`;
               configs.pathContext.alt2 = `${pathContext.schema}/anyOf`;
+              let errorCountVar = "anyErrCnt" + counter++;
               if (this.options.allErrors) {
                   validatorFn = this.compileSchema(subSchema, configs.pathContext, configs.trackingState, varName, extra, true);
               }
               else {
+                  this.errorVariable = anyOfError;
                   validatorFn = this.compileSchema(subSchema, configs.pathContext, configs.trackingState, varName, {
                       before: `${branch} && `,
-                      after: `${branch} = false;${this.notLogic ? "" : `${anyOfError}.push(${this.mainFunctionName}.errors[0]);`}`,
-                      refAfter: `${branch} = false;${this.notLogic ? "" : `${anyOfError} = ${anyOfError}.concat(${this.mainFunctionName}.errors);`}`,
+                      after: `${branch} = false;`,
                   }, true);
               }
-              this.noreturn = noreturn;
-              let errorCountVar;
               if (this.options.allErrors) {
-                  errorCountVar = "anyErrCnt" + counter++;
                   src.push(`const ${errorCountVar} = ${this.errorVariable}.length;`);
                   if (index === 0)
                       firstLength = errorCountVar;
               }
+              else if (index === 0) {
+                  src.push(`const ${errorCountVar} = ${this.errorVariable}.length;`);
+                  firstLength = errorCountVar;
+              }
+              this.noreturn = noreturn;
               if (index > 0 &&
                   !trackingState.shouldTrackEvaluatedProperties &&
                   !trackingState.shouldTrackEvaluatedItems) {
@@ -770,28 +796,36 @@
               }
           });
           if (this.options.allErrors) {
-              src.push(`if (${anyOfValid}) {${this.errorVariable}.length = ${firstLength};}${extra.after != "" ? `else{${extra.after}}` : ""}`);
+              src.push(`if (${anyOfValid} && ${this.errorVariable}.length != ${firstLength}) {${this.errorVariable}.length = ${firstLength};}${extra.after != "" ? `else if(!${anyOfValid}){${extra.after}}` : ""}`);
           }
           else {
-              src.push(`if (${anyOfValid}){${this.mainFunctionName}.errors = undefined}else {${this.notLogic ? "" : `${this.mainFunctionName}.errors = ${anyOfError};`}${(_a = extra.refAfter) !== null && _a !== void 0 ? _a : extra.after}${this.noreturn ? "" : "return false;"}}`);
+              if (this.noreturn) {
+                  src.push(`if (${anyOfValid} && ${this.errorVariable}.length != ${firstLength}){${this.errorVariable}.length = ${firstLength};}else if(!${anyOfValid}){${extra.after}}`);
+              }
+              else {
+                  src.push(`if (${anyOfValid} && ${this.errorVariable}.length != ${firstLength}){${this.errorVariable}.length = ${firstLength};}else if(!${anyOfValid}){${this.notLogic ? extra.after : `${this.mainFunctionName}.errors = ${this.errorVariable};return false;`}}`);
+              }
+              this.errorVariable = error;
           }
       }
       handleOneOfOperator(src, schema, varName, pathContext, trackingState, extra) {
-          var _a;
           if (!schema.oneOf)
               return;
           let firstLength = "";
-          const oneOfErrors = `oneOfErrors${counter++}`;
+          const oneOfErrors = this.noreturn
+              ? this.errorVariable
+              : `oneOfErrors${counter++}`;
           const validSchemaCount = "validSchemaCount" + counter++;
           src.push(`let ${validSchemaCount} = 0;`);
-          if (!this.options.allErrors)
+          if (!this.options.allErrors && !this.noreturn)
               src.push(`let ${oneOfErrors} = [];`);
+          const noreturn = this.noreturn;
+          const error = this.errorVariable;
           schema.oneOf.forEach((subSchema, index) => {
               const branch = `branch${counter++}Valid`;
-              if (!this.options.allErrors && !this.notLogic)
+              if (!this.options.allErrors)
                   src.push(`let ${branch} = true;`);
               let validatorFn;
-              const noreturn = this.noreturn;
               this.noreturn = true;
               const configs = this.createSubschemaOptions(trackingState, pathContext, `oneOf/${index}`, schema);
               configs.pathContext.alt = `${pathContext.schema}/oneOf/${index}`;
@@ -800,20 +834,22 @@
                   validatorFn = this.compileSchema(subSchema, configs.pathContext, configs.trackingState, varName, extra, true);
               }
               else {
+                  this.errorVariable = oneOfErrors;
                   validatorFn = this.compileSchema(subSchema, configs.pathContext, configs.trackingState, varName, {
                       before: `${branch} && `,
-                      after: `${branch} = false;${this.notLogic ? "" : `${oneOfErrors}.push(${this.mainFunctionName}.errors[0]);`}`,
-                      refAfter: `${branch} = false;${this.notLogic ? "" : `${oneOfErrors} = ${oneOfErrors}.concat(${this.mainFunctionName}.errors);`}`,
+                      after: `${branch} = false;`,
                   }, true);
               }
-              this.noreturn = noreturn;
-              let errorCountVar;
+              let errorCountVar = "oneErrCnt" + counter++;
               if (this.options.allErrors) {
-                  errorCountVar = "oneErrCnt" + counter;
                   src.push(`const ${errorCountVar} = ${this.errorVariable}.length;`);
                   if (index === 0)
                       firstLength = errorCountVar;
               }
+              else if (index === 0) {
+                  src.push(`const ${errorCountVar} = ${this.errorVariable}.length;`);
+                  firstLength = errorCountVar;
+              }
               if (index > 0 &&
                   !trackingState.shouldTrackEvaluatedProperties &&
                   !trackingState.shouldTrackEvaluatedItems) {
@@ -848,7 +884,7 @@
               }
           });
           if (this.options.allErrors) {
-              src.push(`if (${validSchemaCount} == 1) {${this.errorVariable}.length = ${firstLength};} else{${this.buildErrorReturn(pathContext, {
+              src.push(`if (${validSchemaCount} == 1 && ${this.errorVariable}.length != ${firstLength}) {${this.errorVariable}.length = ${firstLength};}else if(${validSchemaCount} != 1){${this.buildErrorReturn(pathContext, {
                 keyword: "oneOf",
                 value: varName,
                 message: `"Data must validate against exactly one schema, but matched "+ ${validSchemaCount}`,
@@ -856,14 +892,23 @@
             })}${extra.after}}`);
           }
           else {
-              const noreturn = this.noreturn;
-              this.noreturn = true;
-              src.push(`if (${validSchemaCount} == 1){${this.mainFunctionName}.errors = undefined}else {${this.buildErrorReturn(pathContext, {
-                keyword: "oneOf",
-                value: varName,
-                message: `"Data must validate against exactly one schema, but matched "+ ${validSchemaCount}`,
-                expected: '"exactly one schema"',
-            })}${this.notLogic ? "" : `${oneOfErrors}.push(${this.mainFunctionName}.errors[0]);${this.mainFunctionName}.errors = ${oneOfErrors};`}${(_a = extra.refAfter) !== null && _a !== void 0 ? _a : extra.after}${noreturn ? "" : "return false;"}}`);
+              if (noreturn) {
+                  src.push(`if (${validSchemaCount} == 1 && ${this.errorVariable}.length != ${firstLength}){${this.errorVariable}.length = ${firstLength};}else if(${validSchemaCount} != 1){${this.buildErrorReturn(pathContext, {
+                    keyword: "oneOf",
+                    value: varName,
+                    message: `"Data must validate against exactly one schema, but matched "+ ${validSchemaCount}`,
+                    expected: '"exactly one schema"',
+                })}${extra.after}}`);
+              }
+              else {
+                  src.push(`if (${validSchemaCount} == 1 && ${this.errorVariable}.length != ${firstLength}){${this.errorVariable}.length = ${firstLength};}else if(${validSchemaCount} != 1){${this.buildErrorReturn(pathContext, {
+                    keyword: "oneOf",
+                    value: varName,
+                    message: `"Data must validate against exactly one schema, but matched "+ ${validSchemaCount}`,
+                    expected: '"exactly one schema"',
+                })}${this.notLogic ? extra.after : `${this.mainFunctionName}.errors = ${this.errorVariable};return false;`}}`);
+              }
+              this.errorVariable = error;
               this.noreturn = noreturn;
           }
       }
@@ -1329,11 +1374,15 @@
           else {
               comparisonTarget = schema.multipleOf;
           }
-          src.push(`const multipleOf = ${comparisonTarget};
-      const quotient = ${varName} / multipleOf;
-      const rounded = Math.round(quotient);
-      const tolerance = Math.abs(quotient) * Number.EPSILON;
-      if (${extra.before}multipleOf === 0 || !isFinite(quotient) || Math.abs(quotient - rounded) > tolerance) {${this.buildErrorReturn(pathContext, {
+          const multipleOfVar = "multipleOf" + counter++;
+          const quotientVar = "quotient" + counter++;
+          const roundedVar = "rounded" + counter++;
+          const toleranceVar = "tolerance" + counter++;
+          src.push(`const ${multipleOfVar} = ${comparisonTarget};
+    const ${quotientVar} = ${varName} / ${multipleOfVar};
+    const ${roundedVar} = Math.round(${quotientVar});
+    const ${toleranceVar} = Math.abs(${quotientVar}) * Number.EPSILON;
+    if (${extra.before}${multipleOfVar} === 0 || !isFinite(${quotientVar}) || Math.abs(${quotientVar} - ${roundedVar}) > ${toleranceVar}) {${this.buildErrorReturn(pathContext, {
             keyword: "multipleOf",
             value: varName,
             message: `"Value must be a multiple of " + ${comparisonTarget}`,
@@ -1437,7 +1486,8 @@
               else {
                   src.push(`const formatValidator = formatValidators[${formatKeyVar}].validate ?? formatValidators[${formatKeyVar}];`);
               }
-              src.push(`if (${extra.before}formatValidator && typeof ${varName} === 'string') {`, `  const isValid = typeof formatValidator === 'function' ? ${this.options.async ? "async" : ""}formatValidator(${varName}) : formatValidator.test(${varName});`, `  if (!isValid) {${this.buildErrorReturn(pathContext, {
+              const isValid = "isValid" + counter++;
+              src.push(`if (${extra.before}formatValidator && typeof ${varName} === 'string') {`, `  const ${isValid} = typeof formatValidator === 'function' ? ${this.options.async ? "async" : ""}formatValidator(${varName}) : formatValidator.test(${varName});`, `  if (!${isValid}) {${this.buildErrorReturn(pathContext, {
                 keyword: "format",
                 value: varName,
                 message: `"Failed to validate value against format "+${formatKeyVar}`,
@@ -1447,7 +1497,7 @@
           else {
               const data = this.jetValidator.getFormat(schema.format);
               if (!data) {
-                  throw new Error(`Format '${schema.format}' not found`);
+                  console.warn(`Format '${schema.format}' not found will be ignored`);
               }
               const format = typeof data === "object" && "validate" in data ? data.validate : data;
               const formatType = typeof data === "object" &&
@@ -1546,14 +1596,16 @@
               const resolvedPath = resolveDataPointerAtCompileTime(pointer, pathContext.$data, this.refCall);
               const requiredArrayExpr = generateArrayDataRef(src, resolvedPath, extra);
               src.push(`if (${extra.before}${requiredArrayExpr}) {`);
-              src.push(`for (let i = 0; i < ${requiredArrayExpr}.length; i++) {`);
-              src.push(`const prop = ${requiredArrayExpr}[i];`);
-              addEvaluatedProperty(src, "prop", trackingState);
-              src.push(`if (${extra.before}${varName}[prop] === undefined) {${this.buildErrorReturn(pathContext, {
+              const i = "i" + counter++;
+              src.push(`for (let ${i} = 0; ${i} < ${requiredArrayExpr}.length; ${i}++) {`);
+              const prop = "prop" + counter++;
+              src.push(`const ${prop} = ${requiredArrayExpr}[${i}];`);
+              addEvaluatedProperty(src, prop, trackingState);
+              src.push(`if (${extra.before}${varName}[${prop}] === undefined) {${this.buildErrorReturn(pathContext, {
                 keyword: "required",
                 value: varName,
-                message: `"Missing required field: " + prop + " in data."`,
-                expected: "prop",
+                message: `"Missing required field: " + ${prop} + " in data."`,
+                expected: `${prop}`,
                 schemaPath: `${pathContext.schema}`,
             })}${extra.after}}`);
               src.push(`}`);
@@ -1567,23 +1619,39 @@
               if (Array.isArray(schema.required)) {
                   if (this.options.allErrors ||
                       schema.required.length > this.options.loopRequired) {
-                      const arr = JSON.stringify(schema.required);
-                      const arrVar = `arr${src.length}${counter++}`;
-                      const iVar = `i${src.length}${counter++}`;
-                      src.push(`const ${arrVar} = ${arr};`);
                       if (extra.before != "")
                           src.push(`if(${extra.before} true){`);
-                      src.push(`for (let ${iVar} = 0; ${iVar} < ${arrVar}.length; ${iVar}++) {`);
-                      src.push(`const prop = ${arrVar}[${iVar}];`);
-                      addEvaluatedProperty(src, "prop", trackingState);
-                      src.push(`if (${extra.before}${varName}[prop] === undefined) {${this.buildErrorReturn(pathContext, {
-                        keyword: "required",
-                        value: varName,
-                        message: `"Missing required field: " + prop + " in data."`,
-                        expected: "prop",
-                        schemaPath: `${pathContext.schema}`,
-                    })}${extra.after}}`);
-                      src.push(`}`);
+                      if (schema.required.length > this.options.loopRequired) {
+                          const arr = JSON.stringify(schema.required);
+                          const arrVar = `arr${src.length}${counter++}`;
+                          const iVar = `i${src.length}${counter++}`;
+                          src.push(`const ${arrVar} = ${arr};`);
+                          src.push(`for (let ${iVar} = 0; ${iVar} < ${arrVar}.length; ${iVar}++) {`);
+                          const prop = "prop" + counter++;
+                          src.push(`const ${prop} = ${arrVar}[${iVar}];`);
+                          addEvaluatedProperty(src, prop, trackingState);
+                          src.push(`if (${extra.before}${varName}[${prop}] === undefined) {${this.buildErrorReturn(pathContext, {
+                            keyword: "required",
+                            value: varName,
+                            message: `"Missing required field: " + ${prop} + " in data."`,
+                            expected: `${prop}`,
+                            schemaPath: `${pathContext.schema}`,
+                        })}${extra.after}}`);
+                          src.push(`}`);
+                      }
+                      else {
+                          for (const prop of schema.required) {
+                              const errorMessage = JSON.stringify(`Missing required field: ${prop} in data.`);
+                              const pstring = JSON.stringify(prop);
+                              src.push(`if (${extra.before}${varName}[${pstring}] === undefined) {${this.buildErrorReturn(pathContext, {
+                                keyword: "required",
+                                value: varName,
+                                message: errorMessage,
+                                expected: `${pstring}`,
+                                schemaPath: `${pathContext.schema}`,
+                            })}${extra.after}}`);
+                          }
+                      }
                       if (extra.before != "")
                           src.push(`}`);
                   }
@@ -1636,21 +1704,22 @@
       handlePatternProperties(src, schema, varName, pathContext, trackingState, extra) {
           if (extra.before != "")
               src.push(`if(${extra.before} true){`);
-          src.push(`for (const key in ${varName}) {`);
+          const key = "key" + counter++;
+          src.push(`for (const ${key} in ${varName}) {`);
           Object.getOwnPropertyNames(schema.patternProperties).forEach((pattern) => {
               let pname = this.regexCache.get(pattern);
               if (!pname) {
                   pname = "patternProp" + counter++;
                   this.regexCache.set(pattern, pname);
               }
-              src.push(`if (${pname}.test(key)) {`);
-              addEvaluatedProperty(src, "key", trackingState);
+              src.push(`if (${pname}.test(${key})) {`);
+              addEvaluatedProperty(src, key, trackingState);
               const parent = trackingState.parentHasUnevaluatedProperties ||
                   trackingState.hasOwnUnevaluatedProperties;
               const patternValidation = this.compileSchema(schema.patternProperties[pattern], {
                   schema: `${pathContext.schema}/patternProperties/${JSON.stringify(pattern)}`,
-                  data: `${pathContext.data}/\${key}`,
-                  $data: `${pathContext.$data}/\${key}`,
+                  data: `${pathContext.data}/\${${key}}`,
+                  $data: `${pathContext.$data}/\${${key}}`,
                   alt: pathContext.alt,
                   alt2: pathContext.alt2,
               }, {
@@ -1659,7 +1728,7 @@
                   parentUnevaluatedPropVar: parent
                       ? trackingState.unevaluatedPropVar
                       : undefined,
-              }, `${varName}[key]`, extra);
+              }, `${varName}[${key}]`, extra);
               src.push(patternValidation, "}");
           });
           src.push("}");
@@ -1671,12 +1740,13 @@
           const explicitProps = Array.from(allowedProperties);
           if (extra.before != "")
               src.push(`if(${extra.before} true){`);
-          src.push(`for (const key in ${varName}) {`);
-          addEvaluatedProperty(src, "key", trackingState);
+          const key = "key" + counter++;
+          src.push(`for (const ${key} in ${varName}) {`);
+          addEvaluatedProperty(src, key, trackingState);
           let checks = [];
           if (explicitProps.length > 0) {
               const allowedCheck = explicitProps
-                  .map((key) => `key === ${JSON.stringify(key)}`)
+                  .map((keyItem) => `${key} === ${JSON.stringify(keyItem)}`)
                   .join(" || ");
               checks.push(allowedCheck);
           }
@@ -1688,7 +1758,7 @@
                       pname = "patternProp" + counter++;
                       this.regexCache.set(pattern, pname);
                   }
-                  return `${pname}.test(key)`;
+                  return `${pname}.test(${key})`;
               })
                   .join(" || ");
               checks.push(patternCheck);
@@ -1699,17 +1769,18 @@
           }
           const additionalPropValidation = this.compileSchema(schema.additionalProperties, {
               schema: `${pathContext.schema}/additionalProperties`,
-              data: `${pathContext.data}/\${key}`,
-              $data: `${pathContext.$data}/\${key}`,
+              data: `${pathContext.data}/\${${key}}`,
+              $data: `${pathContext.$data}/\${${key}}`,
               alt: pathContext.alt,
               alt2: pathContext.alt2,
-          }, {}, `${varName}[key]`, extra);
+          }, {}, `${varName}[${key}]`, extra);
           src.push(additionalPropValidation, "}");
           if (extra.before != "")
               src.push(`}`);
       }
       handlePropertyConstraints(src, schema, varName, pathContext, extra) {
-          src.push(`const objKeys = Object.keys(${varName});`);
+          const objKeys = "objKeys" + counter++;
+          src.push(`const ${objKeys} = Object.keys(${varName});`);
           if (schema.minProperties !== undefined) {
               const isDataRef = this.options.$data && isDataReference(schema.minProperties);
               let comparisonTarget;
@@ -1721,9 +1792,9 @@
               else {
                   comparisonTarget = schema.minProperties;
               }
-              src.push(`if (${extra.before}objKeys.length < ${comparisonTarget}) {${this.buildErrorReturn(pathContext, {
+              src.push(`if (${extra.before}${objKeys}.length < ${comparisonTarget}) {${this.buildErrorReturn(pathContext, {
                 keyword: "minProperties",
-                value: "objKeys.length",
+                value: `${objKeys}.length`,
                 message: `"Object must have at least " + ${comparisonTarget} + " properties."`,
                 expected: comparisonTarget,
             })}${extra.after}}`);
@@ -1742,9 +1813,9 @@
               else {
                   comparisonTarget = schema.maxProperties;
               }
-              src.push(`if (${extra.before}objKeys.length > ${comparisonTarget}) {${this.buildErrorReturn(pathContext, {
+              src.push(`if (${extra.before}${objKeys}.length > ${comparisonTarget}) {${this.buildErrorReturn(pathContext, {
                 keyword: "maxProperties",
-                value: "objKeys.length",
+                value: `${objKeys}.length`,
                 message: `"Object must have at most " + ${comparisonTarget} + " properties."`,
                 expected: comparisonTarget,
             })}${extra.after}}`);
@@ -1756,14 +1827,15 @@
       handlePropertyNames(src, schema, varName, pathContext, extra) {
           if (extra.before != "")
               src.push(`if(${extra.before} true){`);
-          src.push(`for (const key in ${varName}) {`);
+          const key = "key" + counter++;
+          src.push(`for (const ${key} in ${varName}) {`);
           const propertyNameValidation = this.compileSchema(schema.propertyNames, {
               schema: `${pathContext.schema}/propertyNames`,
-              data: `${pathContext.data}/\${key}`,
-              $data: `${pathContext.$data}/\${key}`,
+              data: `${pathContext.data}/\${${key}}`,
+              $data: `${pathContext.$data}/\${${key}}`,
               alt: pathContext.alt,
               alt2: pathContext.alt2,
-          }, {}, `key`, extra);
+          }, {}, key, extra);
           src.push(propertyNameValidation, "}");
           if (extra.before != "")
               src.push(`}`);
@@ -1876,7 +1948,8 @@
           const evalSet = trackingState.unevaluatedPropVar;
           if (extra.before != "")
               src.push(`if(${extra.before} true){`);
-          src.push(`const ${unName} = [];`, `for (const key in ${varName}) {`, `if (!${evalSet}.has(key)) {`, `${unName}.push(key);`, `}`, `}`);
+          const key = "key" + counter++;
+          src.push(`const ${unName} = [];`, `for (const ${key} in ${varName}) {`, `if (!${evalSet}.has(${key})) {`, `${unName}.push(${key});`, `}`, `}`);
           if (schema.unevaluatedProperties === false) {
               src.push(`if (${unName}.length > 0) {${this.buildErrorReturn(pathContext, {
                 keyword: "unevaluatedProperties",
@@ -1889,7 +1962,8 @@
           }
           else if (schema.unevaluatedProperties === true) {
               if (trackingState.parentHasUnevaluatedProperties) {
-                  src.push(`for(const key in ${varName}){${trackingState.parentUnevaluatedPropVar}.add(key)}`);
+                  const key = "key" + counter++;
+                  src.push(`for(const ${key} in ${varName}){${trackingState.parentUnevaluatedPropVar}.add(${key})}`);
               }
           }
           else {
@@ -2207,7 +2281,8 @@
           const evalSet = trackingState.unevaluatedItemVar;
           if (extra.before != "")
               src.push(`if(${extra.before} true){`);
-          src.push(`const ${unName} = [];`, `for (let i = 0; i < ${varName}.length; i++) {`, `if (!${evalSet}.has(i)) {`, `${unName}.push(i);`, `}`, `}`);
+          const i = "i" + counter++;
+          src.push(`const ${unName} = [];`, `for (let ${i} = 0; ${i} < ${varName}.length; ${i}++) {`, `if (!${evalSet}.has(${i})) {`, `${unName}.push(${i});`, `}`, `}`);
           if (schema.unevaluatedItems === false) {
               src.push(`if (${extra.before}${unName}.length > 0) {${this.buildErrorReturn(pathContext, {
                 keyword: "unevaluatedItems",
@@ -2246,9 +2321,7 @@
           var _a;
           if (this.notLogic)
               return "";
-          if (this.neutralError)
-              return "return false;";
-          let result = this.options.allErrors
+          let result = this.options.allErrors || this.noreturn
               ? `${this.errorVariable}.push({`
               : `${this.mainFunctionName}.errors = [{`;
           const escapedDataPath = escapeTemplateString(error.dataPath || pathContext.data || "/");
@@ -2329,7 +2402,7 @@
               result += `,${spreads}`;
           }
           result += "}";
-          if (this.options.allErrors) {
+          if (this.options.allErrors || this.noreturn) {
               result += ");";
           }
           else {
@@ -5083,7 +5156,7 @@
                       throw Error(`[${mode}] Unknown type ${type}`);
                   }
               }
-              for (const keyword of allPossibleIncompatible) {
+              for (const keyword of Array.from(allPossibleIncompatible)) {
                   const incompatibleWithAll = types.every((type) => { var _a; return (_a = incompatibleKeywords[type]) === null || _a === void 0 ? void 0 : _a.includes(keyword); });
                   if (incompatibleWithAll && schema[keyword] !== undefined) {
                       throw Error(`[${mode}] Keyword "${keyword}" is incompatible with ${types.length > 1 ? "all types" : "type"} "${types.join(", ")}"`);
@@ -5651,6 +5724,7 @@
           const fconfig = {
               ...config,
           };
+          const has$Data = compileContext.uses$Data;
           if (typeof resolvedSchema === "boolean")
               fconfig.allErrors = false;
           const compiler = new Compiler(refables, mainSchema, fconfig, this, allKeywords, compileContext, false);
@@ -5683,22 +5757,6 @@
               if (validate)
                   customKeywords.set(keywordDef, validate);
           }
-          if (typeof resolvedSchema !== "boolean") {
-              if (allFormats.size > 0) {
-                  for (const validatorKey of allFormats) {
-                      const validator = this.formatValidators[validatorKey];
-                      if (validator) {
-                          if (typeof validator === "function" ||
-                              validator instanceof RegExp) {
-                              formatValidators[validatorKey] = validator;
-                          }
-                          else {
-                              formatValidators[validatorKey] = validator.validate;
-                          }
-                      }
-                  }
-              }
-          }
           const asyncPrefix = config.async ? "async " : "";
           let functionDeclaration = "validate(rootData";
           if (compileContext.hasRootReference) {
@@ -5731,6 +5789,40 @@
                   regexArgs.push(new RegExp(key));
               }
           }
+          if (typeof resolvedSchema !== "boolean") {
+              if (has$Data) {
+                  const formatKeys = Array.isArray(fconfig.formats) && fconfig.formats.length > 0
+                      ? fconfig.formats
+                      : Object.keys(this.formatValidators);
+                  for (const validatorKey of formatKeys) {
+                      const validator = this.formatValidators[validatorKey];
+                      if (validator) {
+                          if (typeof validator === "function" ||
+                              validator instanceof RegExp) {
+                              formatValidators[validatorKey] = validator;
+                          }
+                          else {
+                              formatValidators[validatorKey] = validator.validate;
+                          }
+                      }
+                  }
+              }
+              else if (allFormats.size > 0) {
+                  for (const validatorKey of allFormats) {
+                      const validator = this.formatValidators[validatorKey];
+                      if (validator) {
+                          if (typeof validator === "function" ||
+                              validator instanceof RegExp) {
+                              formatValidators[validatorKey] = validator;
+                          }
+                          else {
+                              formatValidators[validatorKey] = validator.validate;
+                          }
+                      }
+                  }
+              }
+          }
+          Object.values(formatValidators);
           return new Function("formatValidators", "deepEqual", "canonicalStringify", "customKeywords", "len_of", ...regexParams, finalSource)(formatValidators, deepEqual, canonicalStringify, customKeywords, len_of, ...regexArgs);
       }
       compile(fschema, config) {