@rjsf/validator-ajv8 5.11.2 → 5.12.0

package/dist/compileSchemaValidators.esm.js

@@ -0,0 +1,68 @@
+// src/compileSchemaValidators.ts
+import fs from "fs";
+
+// src/compileSchemaValidatorsCode.ts
+import standaloneCode from "ajv/dist/standalone";
+import { schemaParser } from "@rjsf/utils";
+
+// src/createAjvInstance.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import isObject from "lodash/isObject";
+import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from "@rjsf/utils";
+var AJV_CONFIG = {
+  allErrors: true,
+  multipleOfPrecision: 8,
+  strict: false,
+  verbose: true
+};
+var COLOR_FORMAT_REGEX = /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/;
+var DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass = Ajv) {
+  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });
+  if (ajvFormatOptions) {
+    addFormats(ajv, ajvFormatOptions);
+  } else if (ajvFormatOptions !== false) {
+    addFormats(ajv);
+  }
+  ajv.addFormat("data-url", DATA_URL_FORMAT_REGEX);
+  ajv.addFormat("color", COLOR_FORMAT_REGEX);
+  ajv.addKeyword(ADDITIONAL_PROPERTY_FLAG);
+  ajv.addKeyword(RJSF_ADDITONAL_PROPERTIES_FLAG);
+  if (Array.isArray(additionalMetaSchemas)) {
+    ajv.addMetaSchema(additionalMetaSchemas);
+  }
+  if (isObject(customFormats)) {
+    Object.keys(customFormats).forEach((formatName) => {
+      ajv.addFormat(formatName, customFormats[formatName]);
+    });
+  }
+  return ajv;
+}
+
+// src/compileSchemaValidatorsCode.ts
+function compileSchemaValidatorsCode(schema, options = {}) {
+  const schemaMaps = schemaParser(schema);
+  const schemas = Object.values(schemaMaps);
+  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;
+  const compileOptions = {
+    ...ajvOptionsOverrides,
+    code: { lines: true, ...ajvOptionsOverrides.code, source: true },
+    schemas
+  };
+  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);
+  return standaloneCode(ajv);
+}
+
+// src/compileSchemaValidators.ts
+function compileSchemaValidators(schema, output, options = {}) {
+  console.log("parsing the schema");
+  const moduleCode = compileSchemaValidatorsCode(schema, options);
+  console.log(`writing ${output}`);
+  fs.writeFileSync(output, moduleCode);
+}
+export {
+  compileSchemaValidatorsCode,
+  compileSchemaValidators as default
+};
+//# sourceMappingURL=compileSchemaValidators.esm.js.map

package/dist/compileSchemaValidators.esm.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/compileSchemaValidators.ts", "../src/compileSchemaValidatorsCode.ts", "../src/createAjvInstance.ts"],
+  "sourcesContent": ["import fs from 'fs';\nimport { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';\nimport { CustomValidatorOptionsType } from './types';\nimport { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';\n\nexport { compileSchemaValidatorsCode };\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n\n  const moduleCode = compileSchemaValidatorsCode(schema, options);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n", "import standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into javascript code in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport function compileSchemaValidatorsCode<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  options: CustomValidatorOptionsType = {}\n) {\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  return standaloneCode(ajv);\n}\n", "import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n} as const;\nexport const COLOR_FORMAT_REGEX =\n  /^(#?([0-9A-Fa-f]{3}){1,2}\\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\\(\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*\\))|(rgb\\(\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*\\)))$/;\nexport const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;\n\n/** Creates an Ajv version 8 implementation object with standard support for the 'color` and `data-url` custom formats.\n * If `additionalMetaSchemas` are provided then the Ajv instance is modified to add each of the meta schemas in the\n * list. If `customFormats` are provided then those additional formats are added to the list of supported formats. If\n * `ajvOptionsOverrides` are provided then they are spread on top of the default `AJV_CONFIG` options when constructing\n * the `Ajv` instance. With Ajv v8, the JSON Schema formats are not provided by default, but can be plugged in. By\n * default, all formats from the `ajv-formats` library are added. To disable this capability, set the `ajvFormatOptions`\n * parameter to `false`. Additionally, you can configure the `ajv-formats` by providing a custom set of\n * [format options](https://github.com/ajv-validator/ajv-formats) to the `ajvFormatOptions` parameter.\n *\n * @param [additionalMetaSchemas] - The list of additional meta schemas that the validator can access\n * @param [customFormats] - The set of additional custom formats that the validator will support\n * @param [ajvOptionsOverrides={}] - The set of validator config override options\n * @param [ajvFormatOptions] - The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it\n * @param [AjvClass] - The `Ajv` class to use when creating the validator instance\n */\nexport default function createAjvInstance(\n  additionalMetaSchemas?: CustomValidatorOptionsType['additionalMetaSchemas'],\n  customFormats?: CustomValidatorOptionsType['customFormats'],\n  ajvOptionsOverrides: CustomValidatorOptionsType['ajvOptionsOverrides'] = {},\n  ajvFormatOptions?: FormatsPluginOptions | false,\n  AjvClass: typeof Ajv = Ajv\n) {\n  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });\n  if (ajvFormatOptions) {\n    addFormats(ajv, ajvFormatOptions);\n  } else if (ajvFormatOptions !== false) {\n    addFormats(ajv);\n  }\n\n  // add custom formats\n  ajv.addFormat('data-url', DATA_URL_FORMAT_REGEX);\n  ajv.addFormat('color', COLOR_FORMAT_REGEX);\n\n  // Add RJSF-specific additional properties keywords so Ajv doesn't report errors if strict is enabled.\n  ajv.addKeyword(ADDITIONAL_PROPERTY_FLAG);\n  ajv.addKeyword(RJSF_ADDITONAL_PROPERTIES_FLAG);\n\n  // add more schemas to validate against\n  if (Array.isArray(additionalMetaSchemas)) {\n    ajv.addMetaSchema(additionalMetaSchemas);\n  }\n\n  // add more custom formats to validate against\n  if (isObject(customFormats)) {\n    Object.keys(customFormats).forEach((formatName) => {\n      ajv.addFormat(formatName, customFormats[formatName]);\n    });\n  }\n\n  return ajv;\n}\n"],
+  "mappings": ";AAAA,OAAO,QAAQ;;;ACAf,OAAO,oBAAoB;AAC3B,SAAuC,oBAAoB;;;ACD3D,OAAO,SAAsB;AAC7B,OAAO,gBAA0C;AACjD,OAAO,cAAc;AAGrB,SAAS,0BAA0B,sCAAsC;AAElE,IAAM,aAAsB;AAAA,EACjC,WAAW;AAAA,EACX,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,SAAS;AACX;AACO,IAAM,qBACX;AACK,IAAM,wBAAwB;AAiBtB,SAAR,kBACL,uBACA,eACA,sBAAyE,CAAC,GAC1E,kBACA,WAAuB,KACvB;AACA,QAAM,MAAM,IAAI,SAAS,EAAE,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAClE,MAAI,kBAAkB;AACpB,eAAW,KAAK,gBAAgB;AAAA,EAClC,WAAW,qBAAqB,OAAO;AACrC,eAAW,GAAG;AAAA,EAChB;AAGA,MAAI,UAAU,YAAY,qBAAqB;AAC/C,MAAI,UAAU,SAAS,kBAAkB;AAGzC,MAAI,WAAW,wBAAwB;AACvC,MAAI,WAAW,8BAA8B;AAG7C,MAAI,MAAM,QAAQ,qBAAqB,GAAG;AACxC,QAAI,cAAc,qBAAqB;AAAA,EACzC;AAGA,MAAI,SAAS,aAAa,GAAG;AAC3B,WAAO,KAAK,aAAa,EAAE,QAAQ,CAAC,eAAe;AACjD,UAAI,UAAU,YAAY,cAAc,UAAU,CAAC;AAAA,IACrD,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;ADnDO,SAAS,4BACd,QACA,UAAsC,CAAC,GACvC;AACA,QAAM,aAAa,aAAa,MAAM;AACtC,QAAM,UAAU,OAAO,OAAO,UAAU;AAExC,QAAM,EAAE,uBAAuB,eAAe,sBAAsB,CAAC,GAAG,kBAAkB,SAAS,IAAI;AAEvG,QAAM,iBAAiB;AAAA,IACrB,GAAG;AAAA,IACH,MAAM,EAAE,OAAO,MAAM,GAAG,oBAAoB,MAAM,QAAQ,KAAK;AAAA,IAC/D;AAAA,EACF;AACA,QAAM,MAAM,kBAAkB,uBAAuB,eAAe,gBAAgB,kBAAkB,QAAQ;AAE9G,SAAO,eAAe,GAAG;AAC3B;;;ADfe,SAAR,wBACL,QACA,QACA,UAAsC,CAAC,GACvC;AACA,UAAQ,IAAI,oBAAoB;AAEhC,QAAM,aAAa,4BAA4B,QAAQ,OAAO;AAC9D,UAAQ,IAAI,WAAW,MAAM,EAAE;AAC/B,KAAG,cAAc,QAAQ,UAAU;AACrC;",
+  "names": []
+}

package/dist/compileSchemaValidators.js

@@ -1,8 +1,99 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-'use strict'
+// src/compileSchemaValidators.ts
+var compileSchemaValidators_exports = {};
+__export(compileSchemaValidators_exports, {
+  compileSchemaValidatorsCode: () => compileSchemaValidatorsCode,
+  default: () => compileSchemaValidators
+});
+module.exports = __toCommonJS(compileSchemaValidators_exports);
+var import_fs = __toESM(require("fs"));
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./compileSchemaValidators.cjs.production.min.js')
-} else {
-  module.exports = require('./compileSchemaValidators.cjs.development.js')
+// src/compileSchemaValidatorsCode.ts
+var import_standalone = __toESM(require("ajv/dist/standalone"));
+var import_utils2 = require("@rjsf/utils");
+
+// src/createAjvInstance.ts
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
+var import_isObject = __toESM(require("lodash/isObject"));
+var import_utils = require("@rjsf/utils");
+var AJV_CONFIG = {
+  allErrors: true,
+  multipleOfPrecision: 8,
+  strict: false,
+  verbose: true
+};
+var COLOR_FORMAT_REGEX = /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/;
+var DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass = import_ajv.default) {
+  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });
+  if (ajvFormatOptions) {
+    (0, import_ajv_formats.default)(ajv, ajvFormatOptions);
+  } else if (ajvFormatOptions !== false) {
+    (0, import_ajv_formats.default)(ajv);
+  }
+  ajv.addFormat("data-url", DATA_URL_FORMAT_REGEX);
+  ajv.addFormat("color", COLOR_FORMAT_REGEX);
+  ajv.addKeyword(import_utils.ADDITIONAL_PROPERTY_FLAG);
+  ajv.addKeyword(import_utils.RJSF_ADDITONAL_PROPERTIES_FLAG);
+  if (Array.isArray(additionalMetaSchemas)) {
+    ajv.addMetaSchema(additionalMetaSchemas);
+  }
+  if ((0, import_isObject.default)(customFormats)) {
+    Object.keys(customFormats).forEach((formatName) => {
+      ajv.addFormat(formatName, customFormats[formatName]);
+    });
+  }
+  return ajv;
+}
+
+// src/compileSchemaValidatorsCode.ts
+function compileSchemaValidatorsCode(schema, options = {}) {
+  const schemaMaps = (0, import_utils2.schemaParser)(schema);
+  const schemas = Object.values(schemaMaps);
+  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;
+  const compileOptions = {
+    ...ajvOptionsOverrides,
+    code: { lines: true, ...ajvOptionsOverrides.code, source: true },
+    schemas
+  };
+  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);
+  return (0, import_standalone.default)(ajv);
+}
+
+// src/compileSchemaValidators.ts
+function compileSchemaValidators(schema, output, options = {}) {
+  console.log("parsing the schema");
+  const moduleCode = compileSchemaValidatorsCode(schema, options);
+  console.log(`writing ${output}`);
+  import_fs.default.writeFileSync(output, moduleCode);
 }
+//# sourceMappingURL=compileSchemaValidators.js.map

package/dist/compileSchemaValidators.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/compileSchemaValidators.ts", "../src/compileSchemaValidatorsCode.ts", "../src/createAjvInstance.ts"],
+  "sourcesContent": ["import fs from 'fs';\nimport { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';\nimport { CustomValidatorOptionsType } from './types';\nimport { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';\n\nexport { compileSchemaValidatorsCode };\n\n/** The function used to compile a schema into an output file in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param output - The name of the file into which the precompiled validator functions will be generated\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport default function compileSchemaValidators<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  output: string,\n  options: CustomValidatorOptionsType = {}\n) {\n  console.log('parsing the schema');\n\n  const moduleCode = compileSchemaValidatorsCode(schema, options);\n  console.log(`writing ${output}`);\n  fs.writeFileSync(output, moduleCode);\n}\n", "import standaloneCode from 'ajv/dist/standalone';\nimport { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\n\nimport createAjvInstance from './createAjvInstance';\nimport { CustomValidatorOptionsType } from './types';\n\n/** The function used to compile a schema into javascript code in the form that allows it to be used as a precompiled\n * validator. The main reasons for using a precompiled validator is reducing code size, improving validation speed and,\n * most importantly, avoiding dynamic code compilation when prohibited by a browser's Content Security Policy. For more\n * information about AJV code compilation see: https://ajv.js.org/standalone.html\n *\n * @param schema - The schema to be compiled into a set of precompiled validators functions\n * @param [options={}] - The set of `CustomValidatorOptionsType` information used to alter the AJV validator used for\n *        compiling the schema. They are the same options that are passed to the `customizeValidator()` function in\n *        order to modify the behavior of the regular AJV-based validator.\n */\nexport function compileSchemaValidatorsCode<S extends StrictRJSFSchema = RJSFSchema>(\n  schema: S,\n  options: CustomValidatorOptionsType = {}\n) {\n  const schemaMaps = schemaParser(schema);\n  const schemas = Object.values(schemaMaps);\n\n  const { additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass } = options;\n  // Allow users to turn off the `lines: true` feature in their own overrides, but NOT the `source: true`\n  const compileOptions = {\n    ...ajvOptionsOverrides,\n    code: { lines: true, ...ajvOptionsOverrides.code, source: true },\n    schemas,\n  };\n  const ajv = createAjvInstance(additionalMetaSchemas, customFormats, compileOptions, ajvFormatOptions, AjvClass);\n\n  return standaloneCode(ajv);\n}\n", "import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n} as const;\nexport const COLOR_FORMAT_REGEX =\n  /^(#?([0-9A-Fa-f]{3}){1,2}\\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\\(\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*,\\s*\\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\b\\s*\\))|(rgb\\(\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*,\\s*(\\d?\\d%|100%)+\\s*\\)))$/;\nexport const DATA_URL_FORMAT_REGEX = /^data:([a-z]+\\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;\n\n/** Creates an Ajv version 8 implementation object with standard support for the 'color` and `data-url` custom formats.\n * If `additionalMetaSchemas` are provided then the Ajv instance is modified to add each of the meta schemas in the\n * list. If `customFormats` are provided then those additional formats are added to the list of supported formats. If\n * `ajvOptionsOverrides` are provided then they are spread on top of the default `AJV_CONFIG` options when constructing\n * the `Ajv` instance. With Ajv v8, the JSON Schema formats are not provided by default, but can be plugged in. By\n * default, all formats from the `ajv-formats` library are added. To disable this capability, set the `ajvFormatOptions`\n * parameter to `false`. Additionally, you can configure the `ajv-formats` by providing a custom set of\n * [format options](https://github.com/ajv-validator/ajv-formats) to the `ajvFormatOptions` parameter.\n *\n * @param [additionalMetaSchemas] - The list of additional meta schemas that the validator can access\n * @param [customFormats] - The set of additional custom formats that the validator will support\n * @param [ajvOptionsOverrides={}] - The set of validator config override options\n * @param [ajvFormatOptions] - The `ajv-format` options to use when adding formats to `ajv`; pass `false` to disable it\n * @param [AjvClass] - The `Ajv` class to use when creating the validator instance\n */\nexport default function createAjvInstance(\n  additionalMetaSchemas?: CustomValidatorOptionsType['additionalMetaSchemas'],\n  customFormats?: CustomValidatorOptionsType['customFormats'],\n  ajvOptionsOverrides: CustomValidatorOptionsType['ajvOptionsOverrides'] = {},\n  ajvFormatOptions?: FormatsPluginOptions | false,\n  AjvClass: typeof Ajv = Ajv\n) {\n  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });\n  if (ajvFormatOptions) {\n    addFormats(ajv, ajvFormatOptions);\n  } else if (ajvFormatOptions !== false) {\n    addFormats(ajv);\n  }\n\n  // add custom formats\n  ajv.addFormat('data-url', DATA_URL_FORMAT_REGEX);\n  ajv.addFormat('color', COLOR_FORMAT_REGEX);\n\n  // Add RJSF-specific additional properties keywords so Ajv doesn't report errors if strict is enabled.\n  ajv.addKeyword(ADDITIONAL_PROPERTY_FLAG);\n  ajv.addKeyword(RJSF_ADDITONAL_PROPERTIES_FLAG);\n\n  // add more schemas to validate against\n  if (Array.isArray(additionalMetaSchemas)) {\n    ajv.addMetaSchema(additionalMetaSchemas);\n  }\n\n  // add more custom formats to validate against\n  if (isObject(customFormats)) {\n    Object.keys(customFormats).forEach((formatName) => {\n      ajv.addFormat(formatName, customFormats[formatName]);\n    });\n  }\n\n  return ajv;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAe;;;ACAf,wBAA2B;AAC3B,IAAAA,gBAA2D;;;ACD3D,iBAA6B;AAC7B,yBAAiD;AACjD,sBAAqB;AAGrB,mBAAyE;AAElE,IAAM,aAAsB;AAAA,EACjC,WAAW;AAAA,EACX,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,SAAS;AACX;AACO,IAAM,qBACX;AACK,IAAM,wBAAwB;AAiBtB,SAAR,kBACL,uBACA,eACA,sBAAyE,CAAC,GAC1E,kBACA,WAAuB,WAAAC,SACvB;AACA,QAAM,MAAM,IAAI,SAAS,EAAE,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAClE,MAAI,kBAAkB;AACpB,2BAAAC,SAAW,KAAK,gBAAgB;AAAA,EAClC,WAAW,qBAAqB,OAAO;AACrC,2BAAAA,SAAW,GAAG;AAAA,EAChB;AAGA,MAAI,UAAU,YAAY,qBAAqB;AAC/C,MAAI,UAAU,SAAS,kBAAkB;AAGzC,MAAI,WAAW,qCAAwB;AACvC,MAAI,WAAW,2CAA8B;AAG7C,MAAI,MAAM,QAAQ,qBAAqB,GAAG;AACxC,QAAI,cAAc,qBAAqB;AAAA,EACzC;AAGA,UAAI,gBAAAC,SAAS,aAAa,GAAG;AAC3B,WAAO,KAAK,aAAa,EAAE,QAAQ,CAAC,eAAe;AACjD,UAAI,UAAU,YAAY,cAAc,UAAU,CAAC;AAAA,IACrD,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;ADnDO,SAAS,4BACd,QACA,UAAsC,CAAC,GACvC;AACA,QAAM,iBAAa,4BAAa,MAAM;AACtC,QAAM,UAAU,OAAO,OAAO,UAAU;AAExC,QAAM,EAAE,uBAAuB,eAAe,sBAAsB,CAAC,GAAG,kBAAkB,SAAS,IAAI;AAEvG,QAAM,iBAAiB;AAAA,IACrB,GAAG;AAAA,IACH,MAAM,EAAE,OAAO,MAAM,GAAG,oBAAoB,MAAM,QAAQ,KAAK;AAAA,IAC/D;AAAA,EACF;AACA,QAAM,MAAM,kBAAkB,uBAAuB,eAAe,gBAAgB,kBAAkB,QAAQ;AAE9G,aAAO,kBAAAC,SAAe,GAAG;AAC3B;;;ADfe,SAAR,wBACL,QACA,QACA,UAAsC,CAAC,GACvC;AACA,UAAQ,IAAI,oBAAoB;AAEhC,QAAM,aAAa,4BAA4B,QAAQ,OAAO;AAC9D,UAAQ,IAAI,WAAW,MAAM,EAAE;AAC/B,YAAAC,QAAG,cAAc,QAAQ,UAAU;AACrC;",
+  "names": ["import_utils", "Ajv", "addFormats", "isObject", "standaloneCode", "fs"]
+}

package/dist/index.js

@@ -1,8 +1,365 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-'use strict'
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createPrecompiledValidator: () => createPrecompiledValidator,
+  customizeValidator: () => customizeValidator,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./index.cjs.production.min.js')
-} else {
-  module.exports = require('./index.cjs.development.js')
+// src/validator.ts
+var import_utils3 = require("@rjsf/utils");
+
+// src/createAjvInstance.ts
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
+var import_isObject = __toESM(require("lodash/isObject"));
+var import_utils = require("@rjsf/utils");
+var AJV_CONFIG = {
+  allErrors: true,
+  multipleOfPrecision: 8,
+  strict: false,
+  verbose: true
+};
+var COLOR_FORMAT_REGEX = /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/;
+var DATA_URL_FORMAT_REGEX = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides = {}, ajvFormatOptions, AjvClass = import_ajv.default) {
+  const ajv = new AjvClass({ ...AJV_CONFIG, ...ajvOptionsOverrides });
+  if (ajvFormatOptions) {
+    (0, import_ajv_formats.default)(ajv, ajvFormatOptions);
+  } else if (ajvFormatOptions !== false) {
+    (0, import_ajv_formats.default)(ajv);
+  }
+  ajv.addFormat("data-url", DATA_URL_FORMAT_REGEX);
+  ajv.addFormat("color", COLOR_FORMAT_REGEX);
+  ajv.addKeyword(import_utils.ADDITIONAL_PROPERTY_FLAG);
+  ajv.addKeyword(import_utils.RJSF_ADDITONAL_PROPERTIES_FLAG);
+  if (Array.isArray(additionalMetaSchemas)) {
+    ajv.addMetaSchema(additionalMetaSchemas);
+  }
+  if ((0, import_isObject.default)(customFormats)) {
+    Object.keys(customFormats).forEach((formatName) => {
+      ajv.addFormat(formatName, customFormats[formatName]);
+    });
+  }
+  return ajv;
+}
+
+// src/processRawValidationErrors.ts
+var import_get = __toESM(require("lodash/get"));
+var import_utils2 = require("@rjsf/utils");
+function transformRJSFValidationErrors(errors = [], uiSchema) {
+  return errors.map((e) => {
+    const { instancePath, keyword, params, schemaPath, parentSchema, ...rest } = e;
+    let { message = "" } = rest;
+    let property = instancePath.replace(/\//g, ".");
+    let stack = `${property} ${message}`.trim();
+    if ("missingProperty" in params) {
+      property = property ? `${property}.${params.missingProperty}` : params.missingProperty;
+      const currentProperty = params.missingProperty;
+      const uiSchemaTitle = (0, import_utils2.getUiOptions)((0, import_get.default)(uiSchema, `${property.replace(/^\./, "")}`)).title;
+      if (uiSchemaTitle) {
+        message = message.replace(currentProperty, uiSchemaTitle);
+      } else {
+        const parentSchemaTitle = (0, import_get.default)(parentSchema, [import_utils2.PROPERTIES_KEY, currentProperty, "title"]);
+        if (parentSchemaTitle) {
+          message = message.replace(currentProperty, parentSchemaTitle);
+        }
+      }
+      stack = message;
+    } else {
+      const uiSchemaTitle = (0, import_utils2.getUiOptions)((0, import_get.default)(uiSchema, `${property.replace(/^\./, "")}`)).title;
+      if (uiSchemaTitle) {
+        stack = `'${uiSchemaTitle}' ${message}`.trim();
+      } else {
+        const parentSchemaTitle = parentSchema?.title;
+        if (parentSchemaTitle) {
+          stack = `'${parentSchemaTitle}' ${message}`.trim();
+        }
+      }
+    }
+    return {
+      name: keyword,
+      property,
+      message,
+      params,
+      // specific to ajv
+      stack,
+      schemaPath
+    };
+  });
 }
+function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema) {
+  const { validationError: invalidSchemaError } = rawErrors;
+  let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
+  if (invalidSchemaError) {
+    errors = [...errors, { stack: invalidSchemaError.message }];
+  }
+  if (typeof transformErrors === "function") {
+    errors = transformErrors(errors, uiSchema);
+  }
+  let errorSchema = (0, import_utils2.toErrorSchema)(errors);
+  if (invalidSchemaError) {
+    errorSchema = {
+      ...errorSchema,
+      $schema: {
+        __errors: [invalidSchemaError.message]
+      }
+    };
+  }
+  if (typeof customValidate !== "function") {
+    return { errors, errorSchema };
+  }
+  const newFormData = (0, import_utils2.getDefaultFormState)(validator, schema, formData, schema, true);
+  const errorHandler = customValidate(newFormData, (0, import_utils2.createErrorHandler)(newFormData), uiSchema);
+  const userErrorSchema = (0, import_utils2.unwrapErrorHandler)(errorHandler);
+  return (0, import_utils2.validationDataMerge)({ errors, errorSchema }, userErrorSchema);
+}
+
+// src/validator.ts
+var AJV8Validator = class {
+  /** Constructs an `AJV8Validator` instance using the `options`
+   *
+   * @param options - The `CustomValidatorOptionsType` options that are used to create the AJV instance
+   * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
+   */
+  constructor(options, localizer) {
+    const { additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass } = options;
+    this.ajv = createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass);
+    this.localizer = localizer;
+  }
+  /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+   *
+   * @param errorSchema - The `ErrorSchema` instance to convert
+   * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
+   * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
+   *        the next major release.
+   */
+  toErrorList(errorSchema, fieldPath = []) {
+    return (0, import_utils3.toErrorList)(errorSchema, fieldPath);
+  }
+  /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
+   * by the playground. Returns the `errors` from the validation
+   *
+   * @param schema - The schema against which to validate the form data   * @param schema
+   * @param formData - The form data to validate
+   */
+  rawValidation(schema, formData) {
+    let compilationError = void 0;
+    let compiledValidator;
+    if (schema[import_utils3.ID_KEY]) {
+      compiledValidator = this.ajv.getSchema(schema[import_utils3.ID_KEY]);
+    }
+    try {
+      if (compiledValidator === void 0) {
+        compiledValidator = this.ajv.compile(schema);
+      }
+      compiledValidator(formData);
+    } catch (err) {
+      compilationError = err;
+    }
+    let errors;
+    if (compiledValidator) {
+      if (typeof this.localizer === "function") {
+        this.localizer(compiledValidator.errors);
+      }
+      errors = compiledValidator.errors || void 0;
+      compiledValidator.errors = null;
+    }
+    return {
+      errors,
+      validationError: compilationError
+    };
+  }
+  /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
+   * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
+   * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
+   * transform them in what ever way it chooses.
+   *
+   * @param formData - The form data to validate
+   * @param schema - The schema against which to validate the form data
+   * @param [customValidate] - An optional function that is used to perform custom validation
+   * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
+   * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+   */
+  validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+    const rawErrors = this.rawValidation(schema, formData);
+    return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
+  }
+  /** Validates data against a schema, returning true if the data is valid, or
+   * false otherwise. If the schema is invalid, then this function will return
+   * false.
+   *
+   * @param schema - The schema against which to validate the form data
+   * @param formData - The form data to validate
+   * @param rootSchema - The root schema used to provide $ref resolutions
+   */
+  isValid(schema, formData, rootSchema) {
+    const rootSchemaId = rootSchema[import_utils3.ID_KEY] ?? import_utils3.ROOT_SCHEMA_PREFIX;
+    try {
+      if (this.ajv.getSchema(rootSchemaId) === void 0) {
+        this.ajv.addSchema(rootSchema, rootSchemaId);
+      }
+      const schemaWithIdRefPrefix = (0, import_utils3.withIdRefPrefix)(schema);
+      const schemaId = schemaWithIdRefPrefix[import_utils3.ID_KEY] ?? (0, import_utils3.hashForSchema)(schemaWithIdRefPrefix);
+      let compiledValidator;
+      compiledValidator = this.ajv.getSchema(schemaId);
+      if (compiledValidator === void 0) {
+        compiledValidator = this.ajv.addSchema(schemaWithIdRefPrefix, schemaId).getSchema(schemaId) || this.ajv.compile(schemaWithIdRefPrefix);
+      }
+      const result = compiledValidator(formData);
+      return result;
+    } catch (e) {
+      console.warn("Error encountered compiling schema:", e);
+      return false;
+    } finally {
+      this.ajv.removeSchema(rootSchemaId);
+    }
+  }
+};
+
+// src/customizeValidator.ts
+function customizeValidator(options = {}, localizer) {
+  return new AJV8Validator(options, localizer);
+}
+
+// src/precompiledValidator.ts
+var import_get2 = __toESM(require("lodash/get"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
+var import_utils4 = require("@rjsf/utils");
+var AJV8PrecompiledValidator = class {
+  /** Constructs an `AJV8PrecompiledValidator` instance using the `validateFns` and `rootSchema`
+   *
+   * @param validateFns - The map of the validation functions that are generated by the `schemaCompile()` function
+   * @param rootSchema - The root schema that was used with the `compileSchema()` function
+   * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
+   * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
+   */
+  constructor(validateFns, rootSchema, localizer) {
+    this.rootSchema = rootSchema;
+    this.validateFns = validateFns;
+    this.localizer = localizer;
+    this.mainValidator = this.getValidator(rootSchema);
+    this.resolvedRootSchema = (0, import_utils4.retrieveSchema)(this, rootSchema, rootSchema);
+  }
+  /** Returns the precompiled validator associated with the given `schema` from the map of precompiled validator
+   * functions.
+   *
+   * @param schema - The schema for which a precompiled validator function is desired
+   * @returns - The precompiled validator function associated with this schema
+   */
+  getValidator(schema) {
+    const key = (0, import_get2.default)(schema, import_utils4.ID_KEY) || (0, import_utils4.hashForSchema)(schema);
+    const validator = this.validateFns[key];
+    if (!validator) {
+      throw new Error(`No precompiled validator function was found for the given schema for "${key}"`);
+    }
+    return validator;
+  }
+  /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+   *
+   * @param errorSchema - The `ErrorSchema` instance to convert
+   * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
+   * @deprecated - Use the `toErrorList()` function provided by `@rjsf/utils` instead. This function will be removed in
+   *        the next major release.
+   */
+  toErrorList(errorSchema, fieldPath = []) {
+    return (0, import_utils4.toErrorList)(errorSchema, fieldPath);
+  }
+  /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
+   * by the playground. Returns the `errors` from the validation
+   *
+   * @param schema - The schema against which to validate the form data   * @param schema
+   * @param formData - The form data to validate
+   * @throws - Error when the schema provided does not match the base schema of the precompiled validator
+   */
+  rawValidation(schema, formData) {
+    if (!(0, import_isEqual.default)(schema, this.resolvedRootSchema)) {
+      throw new Error(
+        "The schema associated with the precompiled schema differs from the schema provided for validation"
+      );
+    }
+    this.mainValidator(formData);
+    if (typeof this.localizer === "function") {
+      this.localizer(this.mainValidator.errors);
+    }
+    const errors = this.mainValidator.errors || void 0;
+    this.mainValidator.errors = null;
+    return { errors };
+  }
+  /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
+   * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
+   * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
+   * transform them in what ever way it chooses.
+   *
+   * @param formData - The form data to validate
+   * @param schema - The schema against which to validate the form data
+   * @param [customValidate] - An optional function that is used to perform custom validation
+   * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
+   * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+   */
+  validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
+    const rawErrors = this.rawValidation(schema, formData);
+    return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
+  }
+  /** Validates data against a schema, returning true if the data is valid, or false otherwise. If the schema is
+   * invalid, then this function will return false.
+   *
+   * @param schema - The schema against which to validate the form data
+   * @param formData - The form data to validate
+   * @param rootSchema - The root schema used to provide $ref resolutions
+   * @returns - true if the formData validates against the schema, false otherwise
+   * @throws - Error when the schema provided does not match the base schema of the precompiled validator OR if there
+   *        isn't a precompiled validator function associated with the schema
+   */
+  isValid(schema, formData, rootSchema) {
+    if (!(0, import_isEqual.default)(rootSchema, this.rootSchema)) {
+      throw new Error(
+        "The schema associated with the precompiled validator differs from the rootSchema provided for validation"
+      );
+    }
+    if ((0, import_get2.default)(schema, import_utils4.ID_KEY) === import_utils4.JUNK_OPTION_ID) {
+      return false;
+    }
+    const validator = this.getValidator(schema);
+    return validator(formData);
+  }
+};
+
+// src/createPrecompiledValidator.ts
+function createPrecompiledValidator(validateFns, rootSchema, localizer) {
+  return new AJV8PrecompiledValidator(validateFns, rootSchema, localizer);
+}
+
+// src/index.ts
+var src_default = customizeValidator();
+//# sourceMappingURL=index.js.map