@jetio/validator 1.0.2 → 1.0.4

package/README.md

@@ -363,28 +363,14 @@ For transparency, here are the keywords jet-validator intentionally does not sup
 
 ### Summary
 
-- **Compilation:** 10-27x faster than AJV (1.33ms vs 13.20ms average)
-- **Valid data validation:** 7% faster overall (2.44M vs 2.28M ops/sec)
-- **Invalid data validation:** 24% faster overall (4.15M vs 3.36M ops/sec)
-- **Win rate:** 49.2% on valid data, 66.2% on invalid data
-- **Overall winner:** 71.8% of all benchmarks
+🚀 **Compilation:** 19x faster (1.47ms vs 28.29ms)
+✅ **Valid Data:** 58% win rate (36/62)
+🛡️ **Invalid Data:** 73% win rate (45/62)
+🏆 **Overall:** 72% win rate (89/124)
 
-**Key Wins:**
+[📊 Full Benchmark Report](https://github.com/official-jetio/validator/blob/main/benchmarks/results/COMPARISON.md) | [📈 Detailed Results](https://github.com/official-jetio/validator/tree/main/benchmarks/results/)
 
-- Composition operations: 240-284% faster
-- Pattern matching: Up to 88% faster
-- Integer validation: 48-120% faster
-- Object validation at scale: 28-51% faster
-
-**Where AJV leads:**
-
-- Deeply chained $refs: 88% faster
-- Deep allOf chains: 68% faster
-- Complex conditionals: 36% faster
-
-[📊 Full Benchmark Report](https://github.com/official-jetio/validator/blob/main/benchmark/results/COMPARISON.md) | [📈 Detailed Results](https://github.com/official-jetio/validator/tree/main/benchmark/results/)
-
-_Tested against AJV v8.17.1 using official benchmarks with 65 schemas, 1000 warmups, 10000 iterations, 5 runs per test_
+_Tested against AJV v8.17.1 using official benchmarks with 65 schemas, 1000 warmups, 10000 iterations, 30 runs per test_
 
 ---
 
@@ -888,7 +874,6 @@ len_of("café"); // 4
 
 **Use case:** Validating `minLength`/`maxLength` for strings with emoji or special Unicode characters.
 
-**→ [See Full Utilities API Reference](https://github.com/official-jetio/validator/blob/main/DOCUMENTATION.md#utilities-api)**
 
 ---
 
@@ -910,18 +895,16 @@ const validate = jetValidator.compile(schema);
 
 **Benefits of switching:**
 
-- ⚡ 10-27x faster compilation
+- ⚡ 19x faster compilation
 - 📦 Smaller bundle size
-- 🎯 Built-in formats (no separate packages)
+- 🎯 Built-in formats and error messages (no separate packages)
 - ✨ Enhanced features (`elseIf`, better `$data`)
 
 **What's different:**
 
-- Error object structure (but more detailed)
-- Custom keywords use different API (more powerful)
-- Meta-schema setup is easier
-
-**→ [See Migration Guide](https://github.com/official-jetio/validator/blob/main/DOCUMENTATION.md#migration-from-ajv)**
+- Error object structure
+- Custom keywords use different API
+- Meta-schema setup with cli
 
 ---
 
@@ -939,7 +922,7 @@ const validate = jetValidator.compile(schema);
 ### Consider Alternatives If:
 
 ⚠️ You need 100% JSON Schema spec compliance (we're at 99.5%)  
-⚠️ You're already heavily invested in AJV ecosystem with custom plugins (we offer the same custom keywords but contexts are simpler and different, although much more easy to use and better)
+⚠️ You're already heavily invested in AJV ecosystem with custom plugins (we offer the same custom keywords but contexts are simpler and different, although much more easy to use)
 ⚠️ You need streaming validation for extremely large documents
 
 ---
@@ -951,7 +934,7 @@ const validate = jetValidator.compile(schema);
 jet-validator eliminates infinite recursion through a unique resolution approach. Unlike other validators that resolve references during traversal (causing stack overflow), jet-validator:
 
 1. **Collects** all references and identifiers
-2. **Assigns** unique function names to each location
+2. **Assigns** unique function names to each location when inlining is impossible
 3. **Resolves** references by replacing them with function calls
 
 This architecture enables both lightning-fast compilation and bulletproof circular reference handling.
@@ -965,14 +948,14 @@ This architecture enables both lightning-fast compilation and bulletproof circul
 Traditional validators:
 
 ```typescript
-// Slow: 20ms per compilation
+// Slow: 10-20ms per compilation
 const validate = ajv.compile(schema); // Must cache!
 ```
 
 jet-validator:
 
 ```typescript
-// Fast: 1-2ms per compilation
+// Fast: 0.7ms per compilation
 const validate = jetValidator.compile(schema); // Can recompile!
 ```
 
@@ -1141,7 +1124,7 @@ We welcome contributions! jet-validator is a community project and we appreciate
 ```bash
 # Clone the repo
 git clone https://github.com/official-jetio/validator
-cd jet-validator
+cd validator
 
 # Install dependencies
 npm install
@@ -1159,8 +1142,7 @@ npm run test:draft6
 npm run test
 
 # Run benchmarks
-npm run benchmark
-npm run benchmark:compare
+node --expose-gc --max-old-space-size=4096 --max-semi-space-size=64 benchmarks/jet-validator-benchmark.js
 ```
 
 ### Testing Philosophy
@@ -1174,7 +1156,7 @@ jet-validator uses the official [JSON Schema Test Suite](https://github.com/json
 3. Run the official test suite: `npm run test:draft2020-12` (or appropriate draft)
 4. Check compliance rate - aim to maintain or improve current 99.5%+ compliance
 
-**The test runner** (`tests/test-runner.ts`) validates against:
+**The test runner** (`tests/test.ts`) validates against:
 
 - 1,261+ tests for Draft 2020-12
 - 1,227+ tests for Draft 2019-09
@@ -1294,23 +1276,10 @@ We track bugs and feature requests using GitHub Issues.
 ---
 
 ## ⚠️ Benchmark Methodology & Hardware Notes
-
-The benchmarks took hours to run due to laptop hardware and the billions of operations performed. The `array100KItems` benchmark alone—validating 100K array items with 1,000 warmups, 10,000 iterations, and 5 runs—was particularly intensive.
-
 **Performance on Better Hardware:**
 
 Results will vary significantly on better hardware. While absolute numbers will improve across the board, jet-validator is expected to maintain its performance advantages, especially in compilation speed.
 
-**Implementation Differences:**
-
-Unlike AJV, jet-validator doesn't inline `$ref`s by default. This design choice:
-
-- Reduces code bloat
-- Enables proper tracing for `unevaluatedItems`/`unevaluatedProperties`
-- Maintains cleaner stack traces for debugging
-
-Optional inlining is a feature we plan to add in the future for users who prefer maximum runtime performance over bundle size.
-
 ---
 
 ## 🏆 Conclusion
@@ -1318,11 +1287,10 @@ Optional inlining is a feature we plan to add in the future for users who prefer
 jet-validator has proven itself as a strong contender for JSON Schema validation in the Node.js ecosystem, offering:
 
 ✅ **99.5% JSON Schema compliance** - More spec-compliant than AJV in many areas  
-✅ **10-27x faster compilation** - Game-changer for serverless  
-✅ **7% faster valid data** - Better average throughput  
-✅ **24% faster invalid data** - Better security posture  
-✅ **49% valid win rate** - More common-case wins  
-✅ **66% invalid win rate** - Dominant error detection
+🚀 **Compilation:** 19x faster (1.47ms vs 28.29ms) on average - Game-changer for serverless
+✅ **Valid Data:** 58% win rate (36/62)
+🛡️ **Invalid Data:** 73% win rate (45/62)
+🏆 **Overall:** 72% win rate (89/124)
 
 **jet-validator is the clear choice for:**
 
@@ -1331,12 +1299,10 @@ jet-validator has proven itself as a strong contender for JSON Schema validation
 - Real-world schema validation
 - Applications requiring fast compilation
 - Security-focused applications (invalid data detection)
-
-**Consider AJV for:**
-
-- Extremely deep composition chains (>10 levels)
 - Heavy reliance on complex $ref graphs
 - Schemas with complex conditional logic
+- Extremely deep composition chains (>10 levels)
+
 
 ---
 
@@ -1355,7 +1321,7 @@ MIT © [Great Venerable](https://github.com/greatvenerable)
 - **[npm Package](https://www.npmjs.com/package/@jetio/validator)**
 - **[GitHub Repository](https://github.com/@jetio/validator)**
 - **[Complete Documentation (20k+ lines)](https://github.com/official-jetio/validator/blob/main/DOCUMENTATION.md)**
-- **[Benchmark Results](https://github.com/official-jetio/validator/blob/main/benchmark/results/COMPARISON.md)**
+- **[Benchmark Results](https://github.com/official-jetio/validator/blob/main/benchmarks/results/COMPARISON.md)**
 - **[Issue Tracker](https://github.com/official-jetio/validator/issues)**
 - **[GitHub Discussions](https://github.com/official-jetio/validator/discussions)**
 

package/dist/compileSchema.d.ts

@@ -66,7 +66,6 @@ export declare class Compiler {
     private jetValidator;
     private notLogic;
     private noreturn;
-    private neutralError;
     private compileContext;
     private standAlone;
     private hasCompileKeyword;

package/dist/compileSchema.js

@@ -113,7 +113,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;
@@ -306,11 +305,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;
@@ -354,11 +352,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") {
@@ -474,10 +477,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(`}`);
@@ -503,10 +516,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(`}`);
@@ -525,12 +548,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);
     }
@@ -564,9 +587,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)
@@ -577,24 +603,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) {
@@ -629,27 +658,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}`;
@@ -658,20 +696,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) {
@@ -706,7 +746,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}`,
@@ -714,14 +754,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;
         }
     }
@@ -1309,7 +1358,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" &&
@@ -1431,24 +1480,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}++) {`);
-                    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(`}`);
+                    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(`}`);
                 }
@@ -2116,9 +2180,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 = (0, utilities_1.escapeTemplateString)(error.dataPath || pathContext.data || "/");
@@ -2126,11 +2188,11 @@ class Compiler {
         result += `dataPath: \`${escapedDataPath}\`,`;
         result += `schemaPath: \`${escapedSchemaPath}\`,`;
         result += `keyword: "${error.keyword}",`;
+        if (error.expected) {
+            result += `expected: ${error.expected},`;
+        }
         if (this.options.verbose) {
             result += `value: ${error.value},`;
-            if (error.expected) {
-                result += `expected: ${error.expected},`;
-            }
         }
         let errorMessage;
         if (this.options.errorMessage && typeof this.schema !== "boolean") {
@@ -2199,7 +2261,7 @@ class Compiler {
             result += `,${spreads}`;
         }
         result += "}";
-        if (this.options.allErrors) {
+        if (this.options.allErrors || this.noreturn) {
             result += ");";
         }
         else {