@rjsf/validator-ajv8 6.5.2 → 6.6.0

package/dist/compileSchemaValidators.cjs

@@ -37,14 +37,14 @@ module.exports = __toCommonJS(compileSchemaValidators_exports);
 var import_fs = __toESM(require("fs"), 1);
 
 // src/compileSchemaValidatorsCode.ts
-var import_standalone = __toESM(require("ajv/dist/standalone"), 1);
 var import_utils2 = require("@rjsf/utils");
+var import_standalone = __toESM(require("ajv/dist/standalone"), 1);
 
 // src/createAjvInstance.ts
+var import_utils = require("@rjsf/utils");
 var import_ajv = __toESM(require("ajv"), 1);
 var import_ajv_formats = __toESM(require("ajv-formats"), 1);
 var import_isObject = __toESM(require("lodash/isObject"), 1);
-var import_utils = require("@rjsf/utils");
 var AJV_CONFIG = {
   allErrors: true,
   multipleOfPrecision: 8,

package/dist/compileSchemaValidators.cjs.map

@@ -1,7 +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';\n\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 {\n    additionalMetaSchemas,\n    customFormats,\n    ajvOptionsOverrides = {},\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  } = 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(\n    additionalMetaSchemas,\n    customFormats,\n    compileOptions,\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  );\n\n  return standaloneCode(ajv);\n}\n", "import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITIONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nimport { CustomValidatorOptionsType } from './types';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n  discriminator: false, // TODO enable this in V6\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 * @param [extenderFn] - A function to call to extend AJV, such as `ajvErrors()`\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  extenderFn?: CustomValidatorOptionsType['extenderFn'],\n) {\n  let 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_ADDITIONAL_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  if (extenderFn) {\n    ajv = extenderFn(ajv);\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;AACrB,mBAA0E;AAInE,IAAM,aAAsB;AAAA,EACjC,WAAW;AAAA,EACX,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,eAAe;AAAA;AACjB;AACO,IAAM,qBACX;AACK,IAAM,wBAAwB;AAkBtB,SAAR,kBACL,uBACA,eACA,sBAAyE,CAAC,GAC1E,kBACA,WAAuB,WAAAC,SACvB,YACA;AACA,MAAI,MAAM,IAAI,SAAS,EAAE,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAChE,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,4CAA+B;AAG9C,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;AACA,MAAI,YAAY;AACd,UAAM,WAAW,GAAG;AAAA,EACtB;AAEA,SAAO;AACT;;;ADzDO,SAAS,4BACd,QACA,UAAsC,CAAC,GACvC;AACA,QAAM,iBAAa,4BAAa,MAAM;AACtC,QAAM,UAAU,OAAO,OAAO,UAAU;AAExC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,sBAAsB,CAAC;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,iBAAiB;AAAA,IACrB,GAAG;AAAA,IACH,MAAM,EAAE,OAAO,MAAM,GAAG,oBAAoB,MAAM,QAAQ,KAAK;AAAA,IAC/D;AAAA,EACF;AACA,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,aAAO,kBAAAC,SAAe,GAAG;AAC3B;;;AD5Be,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;",
+  "sourcesContent": ["import { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';\nimport fs from 'fs';\n\nimport { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';\nimport { CustomValidatorOptionsType } from './types';\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 { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\nimport standaloneCode from 'ajv/dist/standalone';\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 {\n    additionalMetaSchemas,\n    customFormats,\n    ajvOptionsOverrides = {},\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  } = 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(\n    additionalMetaSchemas,\n    customFormats,\n    compileOptions,\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  );\n\n  return standaloneCode(ajv);\n}\n", "import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITIONAL_PROPERTIES_FLAG } from '@rjsf/utils';\nimport Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n  discriminator: false, // TODO enable this in V6\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 * @param [extenderFn] - A function to call to extend AJV, such as `ajvErrors()`\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  extenderFn?: CustomValidatorOptionsType['extenderFn'],\n) {\n  let 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_ADDITIONAL_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  if (extenderFn) {\n    ajv = extenderFn(ajv);\n  }\n\n  return ajv;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,gBAAe;;;ACDf,IAAAA,gBAA2D;AAC3D,wBAA2B;;;ACD3B,mBAA0E;AAC1E,iBAA6B;AAC7B,yBAAiD;AACjD,sBAAqB;AAId,IAAM,aAAsB;AAAA,EACjC,WAAW;AAAA,EACX,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,eAAe;AAAA;AACjB;AACO,IAAM,qBACX;AACK,IAAM,wBAAwB;AAkBtB,SAAR,kBACL,uBACA,eACA,sBAAyE,CAAC,GAC1E,kBACA,WAAuB,WAAAC,SACvB,YACA;AACA,MAAI,MAAM,IAAI,SAAS,EAAE,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAChE,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,4CAA+B;AAG9C,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;AACA,MAAI,YAAY;AACd,UAAM,WAAW,GAAG;AAAA,EACtB;AAEA,SAAO;AACT;;;ADzDO,SAAS,4BACd,QACA,UAAsC,CAAC,GACvC;AACA,QAAM,iBAAa,4BAAa,MAAM;AACtC,QAAM,UAAU,OAAO,OAAO,UAAU;AAExC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,sBAAsB,CAAC;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,iBAAiB;AAAA,IACrB,GAAG;AAAA,IACH,MAAM,EAAE,OAAO,MAAM,GAAG,oBAAoB,MAAM,QAAQ,KAAK;AAAA,IAC/D;AAAA,EACF;AACA,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,aAAO,kBAAAC,SAAe,GAAG;AAC3B;;;AD5Be,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/compileSchemaValidators.esm.js

@@ -2,14 +2,14 @@
 import fs from "fs";
 
 // src/compileSchemaValidatorsCode.ts
-import standaloneCode from "ajv/dist/standalone";
 import { schemaParser } from "@rjsf/utils";
+import standaloneCode from "ajv/dist/standalone";
 
 // src/createAjvInstance.ts
+import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITIONAL_PROPERTIES_FLAG } from "@rjsf/utils";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import isObject from "lodash/isObject";
-import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITIONAL_PROPERTIES_FLAG } from "@rjsf/utils";
 var AJV_CONFIG = {
   allErrors: true,
   multipleOfPrecision: 8,

package/dist/compileSchemaValidators.esm.js.map

@@ -1,7 +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';\n\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 {\n    additionalMetaSchemas,\n    customFormats,\n    ajvOptionsOverrides = {},\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  } = 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(\n    additionalMetaSchemas,\n    customFormats,\n    compileOptions,\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  );\n\n  return standaloneCode(ajv);\n}\n", "import Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\nimport { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITIONAL_PROPERTIES_FLAG } from '@rjsf/utils';\n\nimport { CustomValidatorOptionsType } from './types';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n  discriminator: false, // TODO enable this in V6\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 * @param [extenderFn] - A function to call to extend AJV, such as `ajvErrors()`\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  extenderFn?: CustomValidatorOptionsType['extenderFn'],\n) {\n  let 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_ADDITIONAL_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  if (extenderFn) {\n    ajv = extenderFn(ajv);\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;AACrB,SAAS,0BAA0B,uCAAuC;AAInE,IAAM,aAAsB;AAAA,EACjC,WAAW;AAAA,EACX,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,eAAe;AAAA;AACjB;AACO,IAAM,qBACX;AACK,IAAM,wBAAwB;AAkBtB,SAAR,kBACL,uBACA,eACA,sBAAyE,CAAC,GAC1E,kBACA,WAAuB,KACvB,YACA;AACA,MAAI,MAAM,IAAI,SAAS,EAAE,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAChE,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,+BAA+B;AAG9C,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;AACA,MAAI,YAAY;AACd,UAAM,WAAW,GAAG;AAAA,EACtB;AAEA,SAAO;AACT;;;ADzDO,SAAS,4BACd,QACA,UAAsC,CAAC,GACvC;AACA,QAAM,aAAa,aAAa,MAAM;AACtC,QAAM,UAAU,OAAO,OAAO,UAAU;AAExC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,sBAAsB,CAAC;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,iBAAiB;AAAA,IACrB,GAAG;AAAA,IACH,MAAM,EAAE,OAAO,MAAM,GAAG,oBAAoB,MAAM,QAAQ,KAAK;AAAA,IAC/D;AAAA,EACF;AACA,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,eAAe,GAAG;AAC3B;;;AD5Be,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;",
+  "sourcesContent": ["import { RJSFSchema, StrictRJSFSchema } from '@rjsf/utils';\nimport fs from 'fs';\n\nimport { compileSchemaValidatorsCode } from './compileSchemaValidatorsCode';\nimport { CustomValidatorOptionsType } from './types';\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 { RJSFSchema, StrictRJSFSchema, schemaParser } from '@rjsf/utils';\nimport standaloneCode from 'ajv/dist/standalone';\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 {\n    additionalMetaSchemas,\n    customFormats,\n    ajvOptionsOverrides = {},\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  } = 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(\n    additionalMetaSchemas,\n    customFormats,\n    compileOptions,\n    ajvFormatOptions,\n    AjvClass,\n    extenderFn,\n  );\n\n  return standaloneCode(ajv);\n}\n", "import { ADDITIONAL_PROPERTY_FLAG, RJSF_ADDITIONAL_PROPERTIES_FLAG } from '@rjsf/utils';\nimport Ajv, { Options } from 'ajv';\nimport addFormats, { FormatsPluginOptions } from 'ajv-formats';\nimport isObject from 'lodash/isObject';\n\nimport { CustomValidatorOptionsType } from './types';\n\nexport const AJV_CONFIG: Options = {\n  allErrors: true,\n  multipleOfPrecision: 8,\n  strict: false,\n  verbose: true,\n  discriminator: false, // TODO enable this in V6\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 * @param [extenderFn] - A function to call to extend AJV, such as `ajvErrors()`\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  extenderFn?: CustomValidatorOptionsType['extenderFn'],\n) {\n  let 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_ADDITIONAL_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  if (extenderFn) {\n    ajv = extenderFn(ajv);\n  }\n\n  return ajv;\n}\n"],
+  "mappings": ";AACA,OAAO,QAAQ;;;ACDf,SAAuC,oBAAoB;AAC3D,OAAO,oBAAoB;;;ACD3B,SAAS,0BAA0B,uCAAuC;AAC1E,OAAO,SAAsB;AAC7B,OAAO,gBAA0C;AACjD,OAAO,cAAc;AAId,IAAM,aAAsB;AAAA,EACjC,WAAW;AAAA,EACX,qBAAqB;AAAA,EACrB,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,eAAe;AAAA;AACjB;AACO,IAAM,qBACX;AACK,IAAM,wBAAwB;AAkBtB,SAAR,kBACL,uBACA,eACA,sBAAyE,CAAC,GAC1E,kBACA,WAAuB,KACvB,YACA;AACA,MAAI,MAAM,IAAI,SAAS,EAAE,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAChE,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,+BAA+B;AAG9C,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;AACA,MAAI,YAAY;AACd,UAAM,WAAW,GAAG;AAAA,EACtB;AAEA,SAAO;AACT;;;ADzDO,SAAS,4BACd,QACA,UAAsC,CAAC,GACvC;AACA,QAAM,aAAa,aAAa,MAAM;AACtC,QAAM,UAAU,OAAO,OAAO,UAAU;AAExC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,sBAAsB,CAAC;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,iBAAiB;AAAA,IACrB,GAAG;AAAA,IACH,MAAM,EAAE,OAAO,MAAM,GAAG,oBAAoB,MAAM,QAAQ,KAAK;AAAA,IAC/D;AAAA,EACF;AACA,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,eAAe,GAAG;AAC3B;;;AD5Be,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/index.cjs

@@ -36,60 +36,21 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/validator.ts
-var import_utils3 = require("@rjsf/utils");
-
-// src/createAjvInstance.ts
-var import_ajv = __toESM(require("ajv"), 1);
-var import_ajv_formats = __toESM(require("ajv-formats"), 1);
-var import_isObject = __toESM(require("lodash/isObject"), 1);
-var import_utils = require("@rjsf/utils");
-var AJV_CONFIG = {
-  allErrors: true,
-  multipleOfPrecision: 8,
-  strict: false,
-  verbose: true,
-  discriminator: false
-  // TODO enable this in V6
-};
-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, extenderFn) {
-  let 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_ADDITIONAL_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]);
-    });
-  }
-  if (extenderFn) {
-    ajv = extenderFn(ajv);
-  }
-  return ajv;
-}
+// src/precompiledValidator.ts
+var import_utils2 = require("@rjsf/utils");
+var import_get2 = __toESM(require("lodash/get"), 1);
 
 // src/processRawValidationErrors.ts
+var import_utils = require("@rjsf/utils");
 var import_get = __toESM(require("lodash/get"), 1);
-var import_utils2 = require("@rjsf/utils");
 function filterDuplicateErrors(errorList, suppressDuplicateFiltering = "none") {
   if (suppressDuplicateFiltering === "all") {
     return errorList;
   }
   return errorList.reduce((acc, err) => {
     const { message, schemaPath } = err;
-    const anyOfIndex = suppressDuplicateFiltering !== "anyOf" ? schemaPath?.indexOf(`/${import_utils2.ANY_OF_KEY}/`) : void 0;
-    const oneOfIndex = suppressDuplicateFiltering !== "oneOf" ? schemaPath?.indexOf(`/${import_utils2.ONE_OF_KEY}/`) : void 0;
+    const anyOfIndex = suppressDuplicateFiltering !== "anyOf" ? schemaPath?.indexOf(`/${import_utils.ANY_OF_KEY}/`) : void 0;
+    const oneOfIndex = suppressDuplicateFiltering !== "oneOf" ? schemaPath?.indexOf(`/${import_utils.ONE_OF_KEY}/`) : void 0;
     let schemaPrefix;
     if (anyOfIndex && anyOfIndex >= 0) {
       schemaPrefix = schemaPath?.substring(0, anyOfIndex);
@@ -118,16 +79,16 @@ function transformRJSFValidationErrors(errors = [], uiSchema, suppressDuplicateF
     if (rawPropertyNames.length > 0) {
       rawPropertyNames.forEach((currentProperty) => {
         const path = property ? `${property}.${currentProperty}` : currentProperty;
-        let uiSchemaTitle = (0, import_utils2.getUiOptions)((0, import_get.default)(uiSchema, `${path.replace(/^\./, "")}`)).title;
+        let uiSchemaTitle = (0, import_utils.getUiOptions)((0, import_get.default)(uiSchema, `${path.replace(/^\./, "")}`)).title;
         if (uiSchemaTitle === void 0) {
           const uiSchemaPath = schemaPath.replace(/\/properties\//g, "/").split("/").slice(1, -1).concat([currentProperty]);
-          uiSchemaTitle = (0, import_utils2.getUiOptions)((0, import_get.default)(uiSchema, uiSchemaPath)).title;
+          uiSchemaTitle = (0, import_utils.getUiOptions)((0, import_get.default)(uiSchema, uiSchemaPath)).title;
         }
         if (uiSchemaTitle) {
           message = message.replace(`'${currentProperty}'`, `'${uiSchemaTitle}'`);
           uiTitle = uiSchemaTitle;
         } else {
-          const parentSchemaTitle = (0, import_get.default)(parentSchema, [import_utils2.PROPERTIES_KEY, currentProperty, "title"]);
+          const parentSchemaTitle = (0, import_get.default)(parentSchema, [import_utils.PROPERTIES_KEY, currentProperty, "title"]);
           if (parentSchemaTitle) {
             message = message.replace(`'${currentProperty}'`, `'${parentSchemaTitle}'`);
             uiTitle = parentSchemaTitle;
@@ -136,7 +97,7 @@ function transformRJSFValidationErrors(errors = [], uiSchema, suppressDuplicateF
       });
       stack = message;
     } else {
-      const uiSchemaTitle = (0, import_utils2.getUiOptions)((0, import_get.default)(uiSchema, `${property.replace(/^\./, "")}`)).title;
+      const uiSchemaTitle = (0, import_utils.getUiOptions)((0, import_get.default)(uiSchema, `${property.replace(/^\./, "")}`)).title;
       if (uiSchemaTitle) {
         stack = `'${uiSchemaTitle}' ${message}`.trim();
         uiTitle = uiSchemaTitle;
@@ -173,7 +134,7 @@ function processRawValidationErrors(validator, rawErrors, formData, schema, cust
   if (typeof transformErrors === "function") {
     errors = transformErrors(errors, uiSchema);
   }
-  let errorSchema = (0, import_utils2.toErrorSchema)(errors);
+  let errorSchema = (0, import_utils.toErrorSchema)(errors);
   if (invalidSchemaError) {
     errorSchema = {
       ...errorSchema,
@@ -185,10 +146,169 @@ function processRawValidationErrors(validator, rawErrors, formData, schema, cust
   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, errorSchema);
-  const userErrorSchema = (0, import_utils2.unwrapErrorHandler)(errorHandler);
-  return (0, import_utils2.validationDataMerge)({ errors, errorSchema }, userErrorSchema);
+  const newFormData = (0, import_utils.getDefaultFormState)(validator, schema, formData, schema, true);
+  const errorHandler = customValidate(newFormData, (0, import_utils.createErrorHandler)(newFormData), uiSchema, errorSchema);
+  const userErrorSchema = (0, import_utils.unwrapErrorHandler)(errorHandler);
+  return (0, import_utils.validationDataMerge)({ errors, errorSchema }, userErrorSchema);
+}
+
+// src/precompiledValidator.ts
+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
+   * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
+   * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
+   */
+  constructor(validateFns, rootSchema, localizer, suppressDuplicateFiltering) {
+    this.rootSchema = rootSchema;
+    this.validateFns = validateFns;
+    this.localizer = localizer;
+    this.suppressDuplicateFiltering = suppressDuplicateFiltering;
+    this.mainValidator = this.getValidator(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_utils2.ID_KEY) || (0, import_utils2.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;
+  }
+  /** Ensures that the validator is using the same schema as the root schema used to construct the precompiled
+   * validator. It first compares the given `schema` against the root schema and if they aren't the same, then it
+   * checks against the resolved root schema, on the chance that a resolved version of the root schema was passed in
+   * instead of the raw root schema.
+   *
+   * @param schema - The schema against which to validate the form data
+   * @param [formData] - The form data to validate if any
+   */
+  ensureSameRootSchema(schema, formData) {
+    if (!(0, import_utils2.deepEquals)(schema, this.rootSchema)) {
+      const resolvedRootSchema = (0, import_utils2.retrieveSchema)(this, this.rootSchema, this.rootSchema, formData);
+      if (!(0, import_utils2.deepEquals)(schema, resolvedRootSchema)) {
+        throw new Error(
+          "The schema associated with the precompiled validator differs from the rootSchema provided for validation"
+        );
+      }
+    }
+    return true;
+  }
+  /** 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 [formData] - The form data to validate, if any
+   * @throws - Error when the schema provided does not match the base schema of the precompiled validator
+   */
+  rawValidation(schema, formData) {
+    this.ensureSameRootSchema(schema, formData);
+    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,
+      this.suppressDuplicateFiltering
+    );
+  }
+  /** 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) {
+    this.ensureSameRootSchema(rootSchema, formData);
+    if ((0, import_get2.default)(schema, import_utils2.ID_KEY) === import_utils2.JUNK_OPTION_ID) {
+      return false;
+    }
+    const validator = this.getValidator(schema);
+    return validator(formData);
+  }
+};
+
+// src/createPrecompiledValidator.ts
+function createPrecompiledValidator(validateFns, rootSchema, localizer, suppressDuplicateFiltering) {
+  return new AJV8PrecompiledValidator(validateFns, rootSchema, localizer, suppressDuplicateFiltering);
+}
+
+// src/validator.ts
+var import_utils4 = require("@rjsf/utils");
+
+// src/createAjvInstance.ts
+var import_utils3 = require("@rjsf/utils");
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import_isObject = __toESM(require("lodash/isObject"), 1);
+var AJV_CONFIG = {
+  allErrors: true,
+  multipleOfPrecision: 8,
+  strict: false,
+  verbose: true,
+  discriminator: false
+  // TODO enable this in V6
+};
+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, extenderFn) {
+  let 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_utils3.ADDITIONAL_PROPERTY_FLAG);
+  ajv.addKeyword(import_utils3.RJSF_ADDITIONAL_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]);
+    });
+  }
+  if (extenderFn) {
+    ajv = extenderFn(ajv);
+  }
+  return ajv;
 }
 
 // src/validator.ts
@@ -241,8 +361,8 @@ var AJV8Validator = class {
     let compilationError = void 0;
     let compiledValidator;
     try {
-      if (schema[import_utils3.ID_KEY]) {
-        compiledValidator = this.ajv.getSchema(schema[import_utils3.ID_KEY]);
+      if (schema[import_utils4.ID_KEY]) {
+        compiledValidator = this.ajv.getSchema(schema[import_utils4.ID_KEY]);
       }
       if (compiledValidator === void 0) {
         compiledValidator = this.ajv.compile(schema);
@@ -318,10 +438,10 @@ var AJV8Validator = class {
     if (this.lastSeenRootSchema === rootSchema && this.hasRegisteredRootSchema) {
       return;
     }
-    const rootSchemaId = rootSchema[import_utils3.ID_KEY] ?? import_utils3.ROOT_SCHEMA_PREFIX;
+    const rootSchemaId = rootSchema[import_utils4.ID_KEY] ?? import_utils4.ROOT_SCHEMA_PREFIX;
     if (this.ajv.getSchema(rootSchemaId) === void 0) {
       this.ajv.addSchema(rootSchema, rootSchemaId);
-    } else if (!(0, import_utils3.deepEquals)(rootSchema, this.ajv.getSchema(rootSchemaId)?.schema)) {
+    } else if (!(0, import_utils4.deepEquals)(rootSchema, this.ajv.getSchema(rootSchemaId)?.schema)) {
       this.ajv.removeSchema(rootSchemaId);
       this.ajv.addSchema(rootSchema, rootSchemaId);
     }
@@ -339,8 +459,8 @@ var AJV8Validator = class {
   isValid(schema, formData, rootSchema) {
     try {
       this.handleSchemaUpdate(rootSchema);
-      const schemaWithIdRefPrefix = (0, import_utils3.withIdRefPrefix)(schema);
-      const schemaId = schemaWithIdRefPrefix[import_utils3.ID_KEY] ?? (0, import_utils3.hashForSchema)(schemaWithIdRefPrefix);
+      const schemaWithIdRefPrefix = (0, import_utils4.withIdRefPrefix)(schema);
+      const schemaId = schemaWithIdRefPrefix[import_utils4.ID_KEY] ?? (0, import_utils4.hashForSchema)(schemaWithIdRefPrefix);
       let compiledValidator;
       compiledValidator = this.ajv.getSchema(schemaId);
       if (compiledValidator === void 0) {
@@ -360,124 +480,6 @@ function customizeValidator(options = {}, localizer) {
   return new AJV8Validator(options, localizer);
 }
 
-// src/precompiledValidator.ts
-var import_get2 = __toESM(require("lodash/get"), 1);
-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
-   * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
-   * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
-   */
-  constructor(validateFns, rootSchema, localizer, suppressDuplicateFiltering) {
-    this.rootSchema = rootSchema;
-    this.validateFns = validateFns;
-    this.localizer = localizer;
-    this.suppressDuplicateFiltering = suppressDuplicateFiltering;
-    this.mainValidator = this.getValidator(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;
-  }
-  /** Ensures that the validator is using the same schema as the root schema used to construct the precompiled
-   * validator. It first compares the given `schema` against the root schema and if they aren't the same, then it
-   * checks against the resolved root schema, on the chance that a resolved version of the root schema was passed in
-   * instead of the raw root schema.
-   *
-   * @param schema - The schema against which to validate the form data
-   * @param [formData] - The form data to validate if any
-   */
-  ensureSameRootSchema(schema, formData) {
-    if (!(0, import_utils4.deepEquals)(schema, this.rootSchema)) {
-      const resolvedRootSchema = (0, import_utils4.retrieveSchema)(this, this.rootSchema, this.rootSchema, formData);
-      if (!(0, import_utils4.deepEquals)(schema, resolvedRootSchema)) {
-        throw new Error(
-          "The schema associated with the precompiled validator differs from the rootSchema provided for validation"
-        );
-      }
-    }
-    return true;
-  }
-  /** 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 [formData] - The form data to validate, if any
-   * @throws - Error when the schema provided does not match the base schema of the precompiled validator
-   */
-  rawValidation(schema, formData) {
-    this.ensureSameRootSchema(schema, formData);
-    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,
-      this.suppressDuplicateFiltering
-    );
-  }
-  /** 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) {
-    this.ensureSameRootSchema(rootSchema, formData);
-    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, suppressDuplicateFiltering) {
-  return new AJV8PrecompiledValidator(validateFns, rootSchema, localizer, suppressDuplicateFiltering);
-}
-
 // src/index.ts
 var index_default = customizeValidator();
 //# sourceMappingURL=index.cjs.map