@jetio/validator 1.0.2 → 1.0.4

package/dist/index.esm.js

@@ -245,7 +245,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;
@@ -438,11 +437,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;
@@ -486,11 +484,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") {
@@ -606,10 +609,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(`}`);
@@ -635,10 +648,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(`}`);
@@ -657,12 +680,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);
     }
@@ -696,9 +719,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)
@@ -709,24 +735,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) {
@@ -761,27 +790,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}`;
@@ -790,20 +828,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) {
@@ -838,7 +878,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}`,
@@ -846,14 +886,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;
         }
     }
@@ -1441,7 +1490,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" &&
@@ -1563,24 +1612,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(`}`);
                 }
@@ -2248,9 +2312,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 || "/");
@@ -2258,11 +2320,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") {
@@ -2331,7 +2393,7 @@ class Compiler {
             result += `,${spreads}`;
         }
         result += "}";
-        if (this.options.allErrors) {
+        if (this.options.allErrors || this.noreturn) {
             result += ");";
         }
         else {
@@ -5078,7 +5140,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(", ")}"`);
@@ -5640,6 +5702,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);
@@ -5672,22 +5735,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) {
@@ -5720,6 +5767,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) {

package/dist/jet-validator.js

@@ -460,6 +460,7 @@ class JetValidator {
         const fconfig = {
             ...config,
         };
+        const has$Data = compileContext.uses$Data;
         if (typeof resolvedSchema === "boolean")
             fconfig.allErrors = false;
         const compiler = new compileSchema_1.Compiler(refables, mainSchema, fconfig, this, allKeywords, compileContext, false);
@@ -492,22 +493,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) {
@@ -540,6 +525,41 @@ 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;
+                        }
+                    }
+                }
+            }
+        }
+        const validatorKeys = Object.keys(formatValidators);
+        const validatorValues = Object.values(formatValidators);
         return new Function("formatValidators", "deepEqual", "canonicalStringify", "customKeywords", "len_of", ...regexParams, finalSource)(formatValidators, utilities_1.deepEqual, utilities_1.canonicalStringify, customKeywords, utilities_1.len_of, ...regexArgs);
     }
     compile(fschema, config) {