@jetio/validator 1.0.1 → 1.0.3

package/dist/index.cjs.js

@@ -249,7 +249,6 @@ class Compiler {
         this.validateKeywords = new Set();
         this.notLogic = false;
         this.noreturn = false;
-        this.neutralError = false;
         this.standAlone = false;
         this.hasCompileKeyword = false;
         this.needslen_of = false;
@@ -442,11 +441,10 @@ class Compiler {
             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;
@@ -490,11 +488,16 @@ class Compiler {
         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") {
@@ -610,10 +613,20 @@ class Compiler {
             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;${extra.refAfter ?? 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(`}`);
@@ -639,10 +652,20 @@ class Compiler {
             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;${extra.refAfter ?? 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(`}`);
@@ -661,12 +684,12 @@ class Compiler {
         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);
     }
@@ -700,9 +723,12 @@ class Compiler {
         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)
@@ -713,24 +739,27 @@ class Compiler {
             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) {
@@ -765,27 +794,36 @@ class Compiler {
             }
         });
         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};`}${extra.refAfter ?? 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) {
         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}`;
@@ -794,20 +832,22 @@ class Compiler {
                 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) {
@@ -842,7 +882,7 @@ class Compiler {
             }
         });
         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}`,
@@ -850,14 +890,23 @@ class Compiler {
             })}${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};`}${extra.refAfter ?? 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;
         }
     }
@@ -1323,11 +1372,15 @@ class Compiler {
         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}`,
@@ -1430,7 +1483,8 @@ class Compiler {
             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}`,
@@ -1440,7 +1494,7 @@ class Compiler {
         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" &&
@@ -1539,14 +1593,16 @@ class Compiler {
             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(`}`);
@@ -1560,23 +1616,39 @@ class Compiler {
             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(`}`);
                 }
@@ -1629,21 +1701,22 @@ class Compiler {
     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,
             }, {
@@ -1652,7 +1725,7 @@ class Compiler {
                 parentUnevaluatedPropVar: parent
                     ? trackingState.unevaluatedPropVar
                     : undefined,
-            }, `${varName}[key]`, extra);
+            }, `${varName}[${key}]`, extra);
             src.push(patternValidation, "}");
         });
         src.push("}");
@@ -1664,12 +1737,13 @@ class Compiler {
         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);
         }
@@ -1681,7 +1755,7 @@ class Compiler {
                     pname = "patternProp" + counter++;
                     this.regexCache.set(pattern, pname);
                 }
-                return `${pname}.test(key)`;
+                return `${pname}.test(${key})`;
             })
                 .join(" || ");
             checks.push(patternCheck);
@@ -1692,17 +1766,18 @@ class Compiler {
         }
         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;
@@ -1714,9 +1789,9 @@ class Compiler {
             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}}`);
@@ -1735,9 +1810,9 @@ class Compiler {
             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}}`);
@@ -1749,14 +1824,15 @@ class Compiler {
     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(`}`);
@@ -1868,7 +1944,8 @@ class Compiler {
         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",
@@ -1881,7 +1958,8 @@ class Compiler {
         }
         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 {
@@ -2199,7 +2277,8 @@ class Compiler {
         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",
@@ -2237,9 +2316,7 @@ class Compiler {
     buildErrorReturn(pathContext, error, spreads) {
         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 || "/");
@@ -2320,7 +2397,7 @@ class Compiler {
             result += `,${spreads}`;
         }
         result += "}";
-        if (this.options.allErrors) {
+        if (this.options.allErrors || this.noreturn) {
             result += ");";
         }
         else {
@@ -5067,7 +5144,7 @@ class SchemaResolver {
                     throw Error(`[${mode}] Unknown type ${type}`);
                 }
             }
-            for (const keyword of allPossibleIncompatible) {
+            for (const keyword of Array.from(allPossibleIncompatible)) {
                 const incompatibleWithAll = types.every((type) => incompatibleKeywords[type]?.includes(keyword));
                 if (incompatibleWithAll && schema[keyword] !== undefined) {
                     throw Error(`[${mode}] Keyword "${keyword}" is incompatible with ${types.length > 1 ? "all types" : "type"} "${types.join(", ")}"`);
@@ -5629,6 +5706,7 @@ class JetValidator {
         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);
@@ -5661,22 +5739,6 @@ class JetValidator {
             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) {
@@ -5709,6 +5771,40 @@ class JetValidator {
                 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) {