@rjsf/utils 6.0.0-alpha.0 → 6.0.0-beta.2

package/dist/utils.umd.js

@@ -1,18 +1,21 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/isEqualWith'), require('lodash/get'), require('lodash/isEmpty'), require('jsonpointer'), require('lodash/omit'), require('lodash/has'), require('lodash/isNumber'), require('lodash/isObject'), require('lodash/isString'), require('lodash/reduce'), require('lodash/times'), require('lodash/isEqual'), require('lodash/set'), require('lodash/transform'), require('lodash/merge'), require('lodash/flattenDeep'), require('lodash/uniq'), require('json-schema-merge-allof'), require('lodash/union'), require('lodash/isNil'), require('lodash/cloneDeep'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/isEqualWith', 'lodash/get', 'lodash/isEmpty', 'jsonpointer', 'lodash/omit', 'lodash/has', 'lodash/isNumber', 'lodash/isObject', 'lodash/isString', 'lodash/reduce', 'lodash/times', 'lodash/isEqual', 'lodash/set', 'lodash/transform', 'lodash/merge', 'lodash/flattenDeep', 'lodash/uniq', 'json-schema-merge-allof', 'lodash/union', 'lodash/isNil', 'lodash/cloneDeep', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject, global.isEqualWith, global.get8, global.isEmpty, global.jsonpointer, global.omit, global.has3, global.isNumber, global.isObject2, global.isString, global.reduce, global.times, global.isEqual4, global.set3, global.transform, global.merge, global.flattenDeep, global.uniq, global.mergeAllOf, global.union, global.isNil, global.cloneDeep, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
-})(this, (function (exports, isPlainObject, isEqualWith, get8, isEmpty, jsonpointer, omit, has3, isNumber, isObject2, isString, reduce, times, isEqual4, set3, transform, merge, flattenDeep, uniq, mergeAllOf, union, isNil, cloneDeep, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/isEqualWith'), require('lodash/get'), require('lodash/has'), require('lodash/isEqual'), require('lodash/set'), require('lodash/times'), require('lodash/transform'), require('lodash/merge'), require('lodash/flattenDeep'), require('lodash/uniq'), require('json-schema-merge-allof'), require('jsonpointer'), require('lodash/omit'), require('lodash/isObject'), require('lodash/isEmpty'), require('fast-uri'), require('lodash/isString'), require('lodash/union'), require('lodash/isNumber'), require('lodash/reduce'), require('lodash/isNil'), require('lodash/cloneDeep'), require('lodash/setWith'), require('nanoid'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/keys'), require('lodash/pickBy'), require('lodash/difference'), require('lodash/forEach')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/isEqualWith', 'lodash/get', 'lodash/has', 'lodash/isEqual', 'lodash/set', 'lodash/times', 'lodash/transform', 'lodash/merge', 'lodash/flattenDeep', 'lodash/uniq', 'json-schema-merge-allof', 'jsonpointer', 'lodash/omit', 'lodash/isObject', 'lodash/isEmpty', 'fast-uri', 'lodash/isString', 'lodash/union', 'lodash/isNumber', 'lodash/reduce', 'lodash/isNil', 'lodash/cloneDeep', 'lodash/setWith', 'nanoid', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/keys', 'lodash/pickBy', 'lodash/difference', 'lodash/forEach'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject4, global.isEqualWith, global.get12, global.has5, global.isEqual, global.set, global.times, global.transform, global.merge, global.flattenDeep, global.uniq, global.mergeAllOf, global.jsonpointer, global.omit, global.isObject3, global.isEmpty2, global.UriResolver, global.isString, global.union, global.isNumber, global.reduce, global.isNil, global.cloneDeep, global.setWith, global.nanoid, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.keys, global.pickBy, global.difference, global.forEach));
+})(this, (function (exports, isPlainObject4, isEqualWith, get12, has5, isEqual, set, times, transform, merge, flattenDeep, uniq, mergeAllOf, jsonpointer, omit, isObject3, isEmpty2, UriResolver, isString, union, isNumber, reduce, isNil, cloneDeep, setWith, nanoid, react, ReactIs, jsxRuntime, toPath, keys, pickBy, difference, forEach) { 'use strict';
 
   // src/isObject.ts
   function isObject(thing) {
-    if (typeof File !== "undefined" && thing instanceof File) {
+    if (typeof thing !== "object" || thing === null) {
       return false;
     }
-    if (typeof Date !== "undefined" && thing instanceof Date) {
+    if (typeof thing.lastModified === "number" && typeof File !== "undefined" && thing instanceof File) {
       return false;
     }
-    return typeof thing === "object" && thing !== null && !Array.isArray(thing);
+    if (typeof thing.getMonth === "function" && typeof Date !== "undefined" && thing instanceof Date) {
+      return false;
+    }
+    return !Array.isArray(thing);
   }
 
   // src/allowAdditionalItems.ts
@@ -62,17 +65,23 @@
   var JUNK_OPTION_ID = "_$junk_option_schema_id$_";
   var NAME_KEY = "$name";
   var ONE_OF_KEY = "oneOf";
+  var PATTERN_PROPERTIES_KEY = "patternProperties";
   var PROPERTIES_KEY = "properties";
+  var READONLY_KEY = "readonly";
   var REQUIRED_KEY = "required";
   var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
   var REF_KEY = "$ref";
-  var RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
+  var SCHEMA_KEY = "$schema";
+  var DISCRIMINATOR_PATH = ["discriminator", "propertyName"];
+  var FORM_CONTEXT_NAME = "formContext";
+  var LOOKUP_MAP_NAME = "layoutGridLookupMap";
   var RJSF_ADDITIONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
   var ROOT_SCHEMA_PREFIX = "__rjsf_rootSchema";
   var UI_FIELD_KEY = "ui:field";
   var UI_WIDGET_KEY = "ui:widget";
   var UI_OPTIONS_KEY = "ui:options";
   var UI_GLOBAL_OPTIONS_KEY = "ui:globalOptions";
+  var JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
 
   // src/getUiOptions.ts
   function getUiOptions(uiSchema = {}, globalOptions = {}) {
@@ -94,7 +103,7 @@
 
   // src/canExpand.ts
   function canExpand(schema, uiSchema = {}, formData) {
-    if (!schema.additionalProperties) {
+    if (!(schema.additionalProperties || schema.patternProperties)) {
       return false;
     }
     const { expandable = true } = getUiOptions(uiSchema);
@@ -121,7 +130,7 @@
         return { ...acc, [key]: createErrorHandler(value) };
       }, handler);
     }
-    if (isPlainObject(formData)) {
+    if (isPlainObject4(formData)) {
       const formObject = formData;
       return Object.keys(formObject).reduce((acc, key) => {
         return { ...acc, [key]: createErrorHandler(formObject[key]) };
@@ -137,20 +146,49 @@
       return void 0;
     });
   }
+  function findEmbeddedSchemaRecursive(schema, ref) {
+    if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY], ref)) {
+      return schema;
+    }
+    for (const subSchema of Object.values(schema)) {
+      if (isObject3(subSchema)) {
+        const result = findEmbeddedSchemaRecursive(subSchema, ref);
+        if (result !== void 0) {
+          return result;
+        }
+      }
+    }
+    return void 0;
+  }
   function splitKeyElementFromObject(key, object) {
     const value = object[key];
     const remaining = omit(object, [key]);
     return [remaining, value];
   }
-  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = []) {
+  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = ID_KEY in rootSchema ? rootSchema[ID_KEY] : void 0) {
     const ref = $ref || "";
-    let decodedRef;
+    let current = void 0;
     if (ref.startsWith("#")) {
-      decodedRef = decodeURIComponent(ref.substring(1));
-    } else {
-      throw new Error(`Could not find a definition for ${$ref}.`);
+      const decodedRef = decodeURIComponent(ref.substring(1));
+      if (baseURI === void 0 || ID_KEY in rootSchema && rootSchema[ID_KEY] === baseURI) {
+        current = jsonpointer.get(rootSchema, decodedRef);
+      } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+        current = findEmbeddedSchemaRecursive(rootSchema, baseURI.replace(/\/$/, ""));
+        if (current !== void 0) {
+          current = jsonpointer.get(current, decodedRef);
+        }
+      }
+    } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      const resolvedRef = baseURI ? UriResolver.resolve(baseURI, ref) : ref;
+      const [refId, ...refAnchor] = resolvedRef.replace(/#\/?$/, "").split("#");
+      current = findEmbeddedSchemaRecursive(rootSchema, refId.replace(/\/$/, ""));
+      if (current !== void 0) {
+        baseURI = current[ID_KEY];
+        if (!isEmpty2(refAnchor)) {
+          current = jsonpointer.get(current, decodeURIComponent(refAnchor.join("#")));
+        }
+      }
     }
-    const current = jsonpointer.get(rootSchema, decodedRef);
     if (current === void 0) {
       throw new Error(`Could not find a definition for ${$ref}.`);
     }
@@ -165,7 +203,7 @@
         throw new Error(`Definition for ${firstRef} contains a circular reference through ${circularPath}`);
       }
       const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
-      const subSchema = findSchemaDefinitionRecursive(theRef, rootSchema, [...recurseList, ref]);
+      const subSchema = findSchemaDefinitionRecursive(theRef, rootSchema, [...recurseList, ref], baseURI);
       if (Object.keys(remaining).length > 0) {
         return { ...remaining, ...subSchema };
       }
@@ -173,87 +211,13 @@
     }
     return current;
   }
-  function findSchemaDefinition($ref, rootSchema = {}) {
+  function findSchemaDefinition($ref, rootSchema = {}, baseURI = ID_KEY in rootSchema ? rootSchema[ID_KEY] : void 0) {
     const recurseList = [];
-    return findSchemaDefinitionRecursive($ref, rootSchema, recurseList);
-  }
-  function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
-    if (formData && discriminatorField) {
-      const value = get8(formData, discriminatorField);
-      if (value === void 0) {
-        return;
-      }
-      for (let i = 0; i < options.length; i++) {
-        const option = options[i];
-        const discriminator = get8(option, [PROPERTIES_KEY, discriminatorField], {});
-        if (discriminator.type === "object" || discriminator.type === "array") {
-          continue;
-        }
-        if (discriminator.const === value) {
-          return i;
-        }
-        if (discriminator.enum?.includes(value)) {
-          return i;
-        }
-      }
-    }
-    return;
-  }
-
-  // src/schema/getMatchingOption.ts
-  function getMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
-    if (formData === void 0) {
-      return 0;
-    }
-    const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-    if (isNumber(simpleDiscriminatorMatch)) {
-      return simpleDiscriminatorMatch;
-    }
-    for (let i = 0; i < options.length; i++) {
-      const option = options[i];
-      if (discriminatorField && has3(option, [PROPERTIES_KEY, discriminatorField])) {
-        const value = get8(formData, discriminatorField);
-        const discriminator = get8(option, [PROPERTIES_KEY, discriminatorField], {});
-        if (validator.isValid(discriminator, value, rootSchema)) {
-          return i;
-        }
-      } else if (option[PROPERTIES_KEY]) {
-        const requiresAnyOf = {
-          anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({
-            required: [key]
-          }))
-        };
-        let augmentedSchema;
-        if (option.anyOf) {
-          const { ...shallowClone } = option;
-          if (!shallowClone.allOf) {
-            shallowClone.allOf = [];
-          } else {
-            shallowClone.allOf = shallowClone.allOf.slice();
-          }
-          shallowClone.allOf.push(requiresAnyOf);
-          augmentedSchema = shallowClone;
-        } else {
-          augmentedSchema = Object.assign({}, option, requiresAnyOf);
-        }
-        delete augmentedSchema.required;
-        if (validator.isValid(augmentedSchema, formData, rootSchema)) {
-          return i;
-        }
-      } else if (validator.isValid(option, formData, rootSchema)) {
-        return i;
-      }
-    }
-    return 0;
-  }
-
-  // src/schema/getFirstMatchingOption.ts
-  function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
-    return getMatchingOption(validator, formData, options, rootSchema, discriminatorField);
+    return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
   }
   function getDiscriminatorFieldFromSchema(schema) {
     let discriminator;
-    const maybeString = get8(schema, "discriminator.propertyName", void 0);
+    const maybeString = get12(schema, DISCRIMINATOR_PATH);
     if (isString(maybeString)) {
       discriminator = maybeString;
     } else if (maybeString !== void 0) {
@@ -294,7 +258,7 @@
     if (!type && schema.enum) {
       return "string";
     }
-    if (!type && (schema.properties || schema.additionalProperties)) {
+    if (!type && (schema.properties || schema.additionalProperties || schema.patternProperties)) {
       return "object";
     }
     if (Array.isArray(type)) {
@@ -322,12 +286,87 @@
       return acc2;
     }, acc);
   }
+  function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
+    if (formData && discriminatorField) {
+      const value = get12(formData, discriminatorField);
+      if (value === void 0) {
+        return;
+      }
+      for (let i = 0; i < options.length; i++) {
+        const option = options[i];
+        const discriminator = get12(option, [PROPERTIES_KEY, discriminatorField], {});
+        if (discriminator.type === "object" || discriminator.type === "array") {
+          continue;
+        }
+        if (discriminator.const === value) {
+          return i;
+        }
+        if (discriminator.enum?.includes(value)) {
+          return i;
+        }
+      }
+    }
+    return;
+  }
 
-  // src/schema/retrieveSchema.ts
-  function retrieveSchema(validator, schema, rootSchema = {}, rawFormData) {
-    return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
+  // src/schema/getFirstMatchingOption.ts
+  function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
+    if (formData === void 0) {
+      return 0;
+    }
+    const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
+    if (isNumber(simpleDiscriminatorMatch)) {
+      return simpleDiscriminatorMatch;
+    }
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
+      if (discriminatorField && has5(option, [PROPERTIES_KEY, discriminatorField])) {
+        const value = get12(formData, discriminatorField);
+        const discriminator = get12(option, [PROPERTIES_KEY, discriminatorField], {});
+        if (validator.isValid(discriminator, value, rootSchema)) {
+          return i;
+        }
+      } else if (option[PROPERTIES_KEY]) {
+        const requiresAnyOf = {
+          anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({
+            required: [key]
+          }))
+        };
+        let augmentedSchema;
+        if (option.anyOf) {
+          const { ...shallowClone } = option;
+          if (!shallowClone.allOf) {
+            shallowClone.allOf = [];
+          } else {
+            shallowClone.allOf = shallowClone.allOf.slice();
+          }
+          shallowClone.allOf.push(requiresAnyOf);
+          augmentedSchema = shallowClone;
+        } else {
+          augmentedSchema = Object.assign({}, option, requiresAnyOf);
+        }
+        delete augmentedSchema.required;
+        if (validator.isValid(augmentedSchema, formData, rootSchema)) {
+          return i;
+        }
+      } else if (validator.isValid(option, formData, rootSchema)) {
+        return i;
+      }
+    }
+    return 0;
   }
-  function resolveCondition(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+  function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf) {
+    return retrieveSchemaInternal(
+      validator,
+      schema,
+      rootSchema,
+      rawFormData,
+      void 0,
+      void 0,
+      experimental_customMergeAllOf
+    )[0];
+  }
+  function resolveCondition(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = schema;
     const conditionValue = validator.isValid(expression, formData || {}, rootSchema);
     let resolvedSchemas = [resolvedSchemaLessConditional];
@@ -335,12 +374,28 @@
     if (expandAllBranches) {
       if (then && typeof then !== "boolean") {
         schemas = schemas.concat(
-          retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches, recurseList)
+          retrieveSchemaInternal(
+            validator,
+            then,
+            rootSchema,
+            formData,
+            expandAllBranches,
+            recurseList,
+            experimental_customMergeAllOf
+          )
         );
       }
       if (otherwise && typeof otherwise !== "boolean") {
         schemas = schemas.concat(
-          retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches, recurseList)
+          retrieveSchemaInternal(
+            validator,
+            otherwise,
+            rootSchema,
+            formData,
+            expandAllBranches,
+            recurseList,
+            experimental_customMergeAllOf
+          )
         );
       }
     } else {
@@ -353,7 +408,8 @@
             rootSchema,
             formData,
             expandAllBranches,
-            recurseList
+            recurseList,
+            experimental_customMergeAllOf
           )
         );
       }
@@ -362,7 +418,15 @@
       resolvedSchemas = schemas.map((s) => mergeSchemas(resolvedSchemaLessConditional, s));
     }
     return resolvedSchemas.flatMap(
-      (s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList)
+      (s) => retrieveSchemaInternal(
+        validator,
+        s,
+        rootSchema,
+        formData,
+        expandAllBranches,
+        recurseList,
+        experimental_customMergeAllOf
+      )
     );
   }
   function getAllPermutationsOfXxxOf(listOfLists) {
@@ -379,7 +443,16 @@
     );
     return allPermutations;
   }
-  function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+  function getMatchingPatternProperties(schema, key) {
+    return Object.keys(schema.patternProperties).filter((pattern) => RegExp(pattern).test(key)).reduce(
+      (obj, pattern) => {
+        set(obj, [pattern], schema.patternProperties[pattern]);
+        return obj;
+      },
+      {}
+    );
+  }
+  function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const updatedSchemas = resolveReference(
       validator,
       schema,
@@ -401,7 +474,15 @@
         formData
       );
       return resolvedSchemas.flatMap((s) => {
-        return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList);
+        return retrieveSchemaInternal(
+          validator,
+          s,
+          rootSchema,
+          formData,
+          expandAllBranches,
+          recurseList,
+          experimental_customMergeAllOf
+        );
       });
     }
     if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
@@ -412,15 +493,19 @@
           rootSchema,
           formData,
           expandAllBranches,
-          recurseList
+          recurseList,
+          experimental_customMergeAllOf
         )
       );
       const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
-      return allPermutations.map((permutation) => ({ ...schema, allOf: permutation }));
+      return allPermutations.map((permutation) => ({
+        ...schema,
+        allOf: permutation
+      }));
     }
     return [schema];
   }
-  function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+  function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const updatedSchema = resolveAllReferences(schema, rootSchema, recurseList);
     if (updatedSchema !== schema) {
       return retrieveSchemaInternal(
@@ -429,12 +514,13 @@
         rootSchema,
         formData,
         expandAllBranches,
-        recurseList
+        recurseList,
+        experimental_customMergeAllOf
       );
     }
     return [schema];
   }
-  function resolveAllReferences(schema, rootSchema, recurseList) {
+  function resolveAllReferences(schema, rootSchema, recurseList, baseURI) {
     if (!isObject(schema)) {
       return schema;
     }
@@ -445,8 +531,11 @@
         return resolvedSchema;
       }
       recurseList.push($ref);
-      const refSchema = findSchemaDefinition($ref, rootSchema);
+      const refSchema = findSchemaDefinition($ref, rootSchema, baseURI);
       resolvedSchema = { ...refSchema, ...localSchema };
+      if (ID_KEY in resolvedSchema) {
+        baseURI = resolvedSchema[ID_KEY];
+      }
     }
     if (PROPERTIES_KEY in resolvedSchema) {
       const childrenLists = [];
@@ -454,7 +543,7 @@
         resolvedSchema[PROPERTIES_KEY],
         (result, value, key) => {
           const childList = [...recurseList];
-          result[key] = resolveAllReferences(value, rootSchema, childList);
+          result[key] = resolveAllReferences(value, rootSchema, childList, baseURI);
           childrenLists.push(childList);
         },
         {}
@@ -465,12 +554,12 @@
     if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== "boolean") {
       resolvedSchema = {
         ...resolvedSchema,
-        items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
+        items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList, baseURI)
       };
     }
-    return isEqual4(schema, resolvedSchema) ? schema : resolvedSchema;
+    return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
   }
-  function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
+  function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData, experimental_customMergeAllOf) {
     const schema = {
       ...theSchema,
       properties: { ...theSchema.properties }
@@ -480,34 +569,54 @@
       if (key in schema.properties) {
         return;
       }
-      let additionalProperties = {};
-      if (typeof schema.additionalProperties !== "boolean") {
-        if (REF_KEY in schema.additionalProperties) {
-          additionalProperties = retrieveSchema(
+      if (PATTERN_PROPERTIES_KEY in schema) {
+        const matchingProperties = getMatchingPatternProperties(schema, key);
+        if (!isEmpty2(matchingProperties)) {
+          schema.properties[key] = retrieveSchema(
             validator,
-            { $ref: get8(schema.additionalProperties, [REF_KEY]) },
+            { allOf: Object.values(matchingProperties) },
             rootSchema,
-            formData
+            formData,
+            experimental_customMergeAllOf
           );
-        } else if ("type" in schema.additionalProperties) {
-          additionalProperties = { ...schema.additionalProperties };
-        } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
-          additionalProperties = {
-            type: "object",
-            ...schema.additionalProperties
-          };
+          set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+          return;
+        }
+      }
+      if (ADDITIONAL_PROPERTIES_KEY in schema && schema.additionalProperties !== false) {
+        let additionalProperties = {};
+        if (typeof schema.additionalProperties !== "boolean") {
+          if (REF_KEY in schema.additionalProperties) {
+            additionalProperties = retrieveSchema(
+              validator,
+              { $ref: get12(schema.additionalProperties, [REF_KEY]) },
+              rootSchema,
+              formData,
+              experimental_customMergeAllOf
+            );
+          } else if ("type" in schema.additionalProperties) {
+            additionalProperties = { ...schema.additionalProperties };
+          } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
+            additionalProperties = {
+              type: "object",
+              ...schema.additionalProperties
+            };
+          } else {
+            additionalProperties = { type: guessType(get12(formData, [key])) };
+          }
         } else {
-          additionalProperties = { type: guessType(get8(formData, [key])) };
+          additionalProperties = { type: guessType(get12(formData, [key])) };
         }
+        schema.properties[key] = additionalProperties;
+        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
       } else {
-        additionalProperties = { type: guessType(get8(formData, [key])) };
+        schema.properties[key] = { type: "null" };
+        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
       }
-      schema.properties[key] = additionalProperties;
-      set3(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     });
     return schema;
   }
-  function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = []) {
+  function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf) {
     if (!isObject(schema)) {
       return [{}];
     }
@@ -517,7 +626,8 @@
       rootSchema,
       expandAllBranches,
       recurseList,
-      rawFormData
+      rawFormData,
+      experimental_customMergeAllOf
     );
     return resolvedSchemas.flatMap((s) => {
       let resolvedSchema = s;
@@ -528,7 +638,8 @@
           rootSchema,
           expandAllBranches,
           recurseList,
-          rawFormData
+          rawFormData,
+          experimental_customMergeAllOf
         );
       }
       if (ALL_OF_KEY in resolvedSchema) {
@@ -537,18 +648,63 @@
           return [...allOf, restOfSchema];
         }
         try {
-          resolvedSchema = mergeAllOf(resolvedSchema, {
-            deep: false
+          const withContainsSchemas = [];
+          const withoutContainsSchemas = [];
+          resolvedSchema.allOf?.forEach((s2) => {
+            if (typeof s2 === "object" && s2.contains) {
+              withContainsSchemas.push(s2);
+            } else {
+              withoutContainsSchemas.push(s2);
+            }
           });
+          if (withContainsSchemas.length) {
+            resolvedSchema = { ...resolvedSchema, allOf: withoutContainsSchemas };
+          }
+          resolvedSchema = experimental_customMergeAllOf ? experimental_customMergeAllOf(resolvedSchema) : mergeAllOf(resolvedSchema, {
+            deep: false,
+            resolvers: {
+              $defs: mergeAllOf.options.resolvers.definitions
+            }
+          });
+          if (withContainsSchemas.length) {
+            resolvedSchema.allOf = withContainsSchemas;
+          }
         } catch (e) {
           console.warn("could not merge subschemas in allOf:\n", e);
           const { allOf, ...resolvedSchemaWithoutAllOf } = resolvedSchema;
           return resolvedSchemaWithoutAllOf;
         }
       }
-      const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+      if (PROPERTIES_KEY in resolvedSchema && PATTERN_PROPERTIES_KEY in resolvedSchema) {
+        resolvedSchema = Object.keys(resolvedSchema.properties).reduce(
+          (schema2, key) => {
+            const matchingProperties = getMatchingPatternProperties(schema2, key);
+            if (!isEmpty2(matchingProperties)) {
+              schema2.properties[key] = retrieveSchema(
+                validator,
+                { allOf: [schema2.properties[key], ...Object.values(matchingProperties)] },
+                rootSchema,
+                rawFormData,
+                experimental_customMergeAllOf
+              );
+            }
+            return schema2;
+          },
+          {
+            ...resolvedSchema,
+            properties: { ...resolvedSchema.properties }
+          }
+        );
+      }
+      const hasAdditionalProperties = PATTERN_PROPERTIES_KEY in resolvedSchema || ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
       if (hasAdditionalProperties) {
-        return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData);
+        return stubExistingAdditionalProperties(
+          validator,
+          resolvedSchema,
+          rootSchema,
+          rawFormData,
+          experimental_customMergeAllOf
+        );
       }
       return resolvedSchema;
     });
@@ -575,7 +731,7 @@
     }
     return [schema];
   }
-  function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData) {
+  function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const { dependencies, ...remainingSchema } = schema;
     const resolvedSchemas = resolveAnyOrOneOfSchemas(
       validator,
@@ -592,14 +748,15 @@
         rootSchema,
         expandAllBranches,
         recurseList,
-        formData
+        formData,
+        experimental_customMergeAllOf
       )
     );
   }
-  function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData) {
+  function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     let schemas = [resolvedSchema];
     for (const dependencyKey in dependencies) {
-      if (!expandAllBranches && get8(formData, [dependencyKey]) === void 0) {
+      if (!expandAllBranches && get12(formData, [dependencyKey]) === void 0) {
         continue;
       }
       if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
@@ -620,7 +777,8 @@
           dependencyValue,
           expandAllBranches,
           recurseList,
-          formData
+          formData,
+          experimental_customMergeAllOf
         );
       }
       return schemas.flatMap(
@@ -631,7 +789,8 @@
           rootSchema,
           expandAllBranches,
           recurseList,
-          formData
+          formData,
+          experimental_customMergeAllOf
         )
       );
     }
@@ -644,14 +803,15 @@
     const required = Array.isArray(schema.required) ? Array.from(/* @__PURE__ */ new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
     return { ...schema, required };
   }
-  function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData) {
+  function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const dependentSchemas = retrieveSchemaInternal(
       validator,
       dependencyValue,
       rootSchema,
       formData,
       expandAllBranches,
-      recurseList
+      recurseList,
+      experimental_customMergeAllOf
     );
     return dependentSchemas.flatMap((dependent) => {
       const { oneOf, ...dependentSchema } = dependent;
@@ -675,12 +835,13 @@
           resolvedOneOf,
           expandAllBranches,
           recurseList,
-          formData
+          formData,
+          experimental_customMergeAllOf
         )
       );
     });
   }
-  function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData) {
+  function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const validSubschemas = oneOf.filter((subschema) => {
       if (typeof subschema === "boolean" || !subschema || !subschema.properties) {
         return false;
@@ -711,13 +872,148 @@
         rootSchema,
         formData,
         expandAllBranches,
-        recurseList
+        recurseList,
+        experimental_customMergeAllOf
       );
       return schemas.map((s2) => mergeSchemas(schema, s2));
     });
   }
 
-  // src/schema/getClosestMatchingOption.ts
+  // src/schema/findSelectedOptionInXxxOf.ts
+  function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField, xxx, formData = {}, experimental_customMergeAllOf) {
+    if (Array.isArray(schema[xxx])) {
+      const discriminator = getDiscriminatorFieldFromSchema(schema);
+      const selectorField = discriminator || fallbackField;
+      const xxxOfs = schema[xxx].map(
+        (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
+      );
+      const data = get12(formData, selectorField);
+      if (data !== void 0) {
+        return xxxOfs.find((xxx2) => {
+          return isEqual(
+            get12(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get12(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+            data
+          );
+        });
+      }
+    }
+    return void 0;
+  }
+  function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
+    let fieldSchema = schema;
+    if (has5(schema, REF_KEY)) {
+      fieldSchema = retrieveSchema(validator, schema, rootSchema, void 0, experimental_customMergeAllOf);
+    }
+    if (isEmpty2(path)) {
+      return fieldSchema;
+    }
+    const pathList = Array.isArray(path) ? path : path.split(".");
+    const [part, ...nestedPath] = pathList;
+    if (part && has5(fieldSchema, part)) {
+      fieldSchema = get12(fieldSchema, part);
+      return getFromSchemaInternal(
+        validator,
+        rootSchema,
+        fieldSchema,
+        nestedPath,
+        experimental_customMergeAllOf
+      );
+    }
+    return void 0;
+  }
+  function getFromSchema(validator, rootSchema, schema, path, defaultValue, experimental_customMergeAllOf) {
+    const result = getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf);
+    if (result === void 0) {
+      return defaultValue;
+    }
+    return result;
+  }
+
+  // src/schema/findFieldInSchema.ts
+  var NOT_FOUND_SCHEMA = { title: "!@#$_UNKNOWN_$#@!" };
+  function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, experimental_customMergeAllOf) {
+    const pathList = Array.isArray(path) ? [...path] : path.split(".");
+    let parentField = schema;
+    const fieldName = pathList.pop();
+    if (pathList.length) {
+      pathList.forEach((subPath) => {
+        parentField = getFromSchema(
+          validator,
+          rootSchema,
+          parentField,
+          [PROPERTIES_KEY, subPath],
+          {},
+          experimental_customMergeAllOf
+        );
+        if (has5(parentField, ONE_OF_KEY)) {
+          parentField = findSelectedOptionInXxxOf(
+            validator,
+            rootSchema,
+            parentField,
+            fieldName,
+            ONE_OF_KEY,
+            get12(formData, subPath),
+            experimental_customMergeAllOf
+          );
+        } else if (has5(parentField, ANY_OF_KEY)) {
+          parentField = findSelectedOptionInXxxOf(
+            validator,
+            rootSchema,
+            parentField,
+            fieldName,
+            ANY_OF_KEY,
+            get12(formData, subPath),
+            experimental_customMergeAllOf
+          );
+        }
+      });
+    }
+    if (has5(parentField, ONE_OF_KEY)) {
+      parentField = findSelectedOptionInXxxOf(
+        validator,
+        rootSchema,
+        parentField,
+        fieldName,
+        ONE_OF_KEY,
+        formData,
+        experimental_customMergeAllOf
+      );
+    } else if (has5(parentField, ANY_OF_KEY)) {
+      parentField = findSelectedOptionInXxxOf(
+        validator,
+        rootSchema,
+        parentField,
+        fieldName,
+        ANY_OF_KEY,
+        formData,
+        experimental_customMergeAllOf
+      );
+    }
+    let field = getFromSchema(
+      validator,
+      rootSchema,
+      parentField,
+      [PROPERTIES_KEY, fieldName],
+      NOT_FOUND_SCHEMA,
+      experimental_customMergeAllOf
+    );
+    if (field === NOT_FOUND_SCHEMA) {
+      field = void 0;
+    }
+    const requiredArray = getFromSchema(
+      validator,
+      rootSchema,
+      parentField,
+      REQUIRED_KEY,
+      [],
+      experimental_customMergeAllOf
+    );
+    let isRequired;
+    if (field && Array.isArray(requiredArray)) {
+      isRequired = requiredArray.includes(fieldName);
+    }
+    return { field, isRequired };
+  }
   var JUNK_OPTION = {
     type: "object",
     $id: JUNK_OPTION_ID,
@@ -727,35 +1023,51 @@
       }
     }
   };
-  function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
+  function calculateIndexScore(validator, rootSchema, schema, formData, experimental_customMergeAllOf) {
     let totalScore = 0;
     if (schema) {
-      if (isObject2(schema.properties)) {
+      if (isObject3(schema.properties)) {
         totalScore += reduce(
           schema.properties,
           (score, value, key) => {
-            const formValue = get8(formData, key);
+            const formValue = get12(formData, key);
             if (typeof value === "boolean") {
               return score;
             }
-            if (has3(value, REF_KEY)) {
-              const newSchema = retrieveSchema(validator, value, rootSchema, formValue);
-              return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
+            if (has5(value, REF_KEY)) {
+              const newSchema = retrieveSchema(
+                validator,
+                value,
+                rootSchema,
+                formValue,
+                experimental_customMergeAllOf
+              );
+              return score + calculateIndexScore(
+                validator,
+                rootSchema,
+                newSchema,
+                formValue || {},
+                experimental_customMergeAllOf
+              );
             }
-            if ((has3(value, ONE_OF_KEY) || has3(value, ANY_OF_KEY)) && formValue) {
-              const key2 = has3(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            if ((has5(value, ONE_OF_KEY) || has5(value, ANY_OF_KEY)) && formValue) {
+              const key2 = has5(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
               const discriminator = getDiscriminatorFieldFromSchema(value);
               return score + getClosestMatchingOption(
                 validator,
                 rootSchema,
                 formValue,
-                get8(value, key2),
+                get12(value, key2),
                 -1,
-                discriminator
+                discriminator,
+                experimental_customMergeAllOf
               );
             }
             if (value.type === "object") {
-              return score + calculateIndexScore(validator, rootSchema, value, formValue || {});
+              if (isObject3(formValue)) {
+                score += 1;
+              }
+              return score + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
             }
             if (value.type === guessType(formValue)) {
               let newScore = score + 1;
@@ -776,7 +1088,7 @@
     }
     return totalScore;
   }
-  function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField) {
+  function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField, experimental_customMergeAllOf) {
     const resolvedOptions = options.map((option) => {
       return resolveAllReferences(option, rootSchema, []);
     });
@@ -803,7 +1115,7 @@
       (scoreData, index) => {
         const { bestScore } = scoreData;
         const option = resolvedOptions[index];
-        const score = calculateIndexScore(validator, rootSchema, option, formData);
+        const score = calculateIndexScore(validator, rootSchema, option, formData, experimental_customMergeAllOf);
         scoreCount.add(score);
         if (score > bestScore) {
           return { bestIndex: index, bestScore: score };
@@ -822,56 +1134,77 @@
   function isFixedItems(schema) {
     return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item));
   }
-  function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) {
+  function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
     if (Array.isArray(formData)) {
       const defaultsArray = Array.isArray(defaults) ? defaults : [];
-      const mapped = formData.map((value, idx) => {
-        if (defaultsArray[idx]) {
-          return mergeDefaultsWithFormData(defaultsArray[idx], value, mergeExtraArrayDefaults);
+      const overrideArray = overrideFormDataWithDefaults ? defaultsArray : formData;
+      const overrideOppositeArray = overrideFormDataWithDefaults ? formData : defaultsArray;
+      const mapped = overrideArray.map((value, idx) => {
+        if (overrideOppositeArray[idx] !== void 0) {
+          return mergeDefaultsWithFormData(
+            defaultsArray[idx],
+            formData[idx],
+            mergeExtraArrayDefaults,
+            defaultSupercedesUndefined,
+            overrideFormDataWithDefaults
+          );
         }
         return value;
       });
-      if (mergeExtraArrayDefaults && mapped.length < defaultsArray.length) {
-        mapped.push(...defaultsArray.slice(mapped.length));
+      if ((mergeExtraArrayDefaults || overrideFormDataWithDefaults) && mapped.length < overrideOppositeArray.length) {
+        mapped.push(...overrideOppositeArray.slice(mapped.length));
       }
       return mapped;
     }
     if (isObject(formData)) {
       const acc = Object.assign({}, defaults);
       return Object.keys(formData).reduce((acc2, key) => {
+        const keyValue = get12(formData, key);
+        const keyExistsInDefaults = isObject(defaults) && key in defaults;
+        const keyExistsInFormData = key in formData;
         acc2[key] = mergeDefaultsWithFormData(
-          defaults ? get8(defaults, key) : {},
-          get8(formData, key),
-          mergeExtraArrayDefaults
+          defaults ? get12(defaults, key) : {},
+          keyValue,
+          mergeExtraArrayDefaults,
+          defaultSupercedesUndefined,
+          // overrideFormDataWithDefaults can be true only when the key value exists in defaults
+          // Or if the key value doesn't exist in formData
+          overrideFormDataWithDefaults && (keyExistsInDefaults || !keyExistsInFormData)
         );
         return acc2;
       }, acc);
     }
+    if (defaultSupercedesUndefined && (!isNil(defaults) && isNil(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
+      return defaults;
+    }
     return formData;
   }
 
   // src/mergeObjects.ts
   function mergeObjects(obj1, obj2, concatArrays = false) {
-    return Object.keys(obj2).reduce((acc, key) => {
-      const left = obj1 ? obj1[key] : {}, right = obj2[key];
-      if (obj1 && key in obj1 && isObject(right)) {
-        acc[key] = mergeObjects(left, right, concatArrays);
-      } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
-        let toMerge = right;
-        if (concatArrays === "preventDuplicates") {
-          toMerge = right.reduce((result, value) => {
-            if (!left.includes(value)) {
-              result.push(value);
-            }
-            return result;
-          }, []);
+    return Object.keys(obj2).reduce(
+      (acc, key) => {
+        const left = obj1 ? obj1[key] : {}, right = obj2[key];
+        if (obj1 && key in obj1 && isObject(right)) {
+          acc[key] = mergeObjects(left, right, concatArrays);
+        } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
+          let toMerge = right;
+          if (concatArrays === "preventDuplicates") {
+            toMerge = right.reduce((result, value) => {
+              if (!left.includes(value)) {
+                result.push(value);
+              }
+              return result;
+            }, []);
+          }
+          acc[key] = left.concat(toMerge);
+        } else {
+          acc[key] = right;
         }
-        acc[key] = left.concat(toMerge);
-      } else {
-        acc[key] = right;
-      }
-      return acc;
-    }, Object.assign({}, obj1));
+        return acc;
+      },
+      Object.assign({}, obj1)
+    );
   }
 
   // src/isConstant.ts
@@ -880,8 +1213,8 @@
   }
 
   // src/schema/isSelect.ts
-  function isSelect(validator, theSchema, rootSchema = {}) {
-    const schema = retrieveSchema(validator, theSchema, rootSchema, void 0);
+  function isSelect(validator, theSchema, rootSchema = {}, experimental_customMergeAllOf) {
+    const schema = retrieveSchema(validator, theSchema, rootSchema, void 0, experimental_customMergeAllOf);
     const altSchemas = schema.oneOf || schema.anyOf;
     if (Array.isArray(schema.enum)) {
       return true;
@@ -893,14 +1226,79 @@
   }
 
   // src/schema/isMultiSelect.ts
-  function isMultiSelect(validator, schema, rootSchema) {
+  function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) {
     if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
       return false;
     }
-    return isSelect(validator, schema.items, rootSchema);
+    return isSelect(validator, schema.items, rootSchema, experimental_customMergeAllOf);
+  }
+  function constIsAjvDataReference(schema) {
+    const schemaConst = schema[CONST_KEY];
+    const schemaType = getSchemaType(schema);
+    return isObject(schemaConst) && isString(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+  }
+
+  // src/toConstant.ts
+  function toConstant(schema) {
+    if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
+      return schema.enum[0];
+    }
+    if (CONST_KEY in schema) {
+      return schema.const;
+    }
+    throw new Error("schema cannot be inferred as a constant");
+  }
+
+  // src/optionsList.ts
+  function optionsList(schema, uiSchema) {
+    if (schema.enum) {
+      let enumNames;
+      if (uiSchema) {
+        const { enumNames: uiEnumNames } = getUiOptions(uiSchema);
+        enumNames = uiEnumNames;
+      }
+      return schema.enum.map((value, i) => {
+        const label = enumNames?.[i] || String(value);
+        return { label, value };
+      });
+    }
+    let altSchemas = void 0;
+    let altUiSchemas = void 0;
+    if (schema.anyOf) {
+      altSchemas = schema.anyOf;
+      altUiSchemas = uiSchema?.anyOf;
+    } else if (schema.oneOf) {
+      altSchemas = schema.oneOf;
+      altUiSchemas = uiSchema?.oneOf;
+    }
+    let selectorField = getDiscriminatorFieldFromSchema(schema);
+    if (uiSchema) {
+      const { optionsSchemaSelector = selectorField } = getUiOptions(uiSchema);
+      selectorField = optionsSchemaSelector;
+    }
+    return altSchemas && altSchemas.map((aSchemaDef, index) => {
+      const { title } = getUiOptions(altUiSchemas?.[index]);
+      const aSchema = aSchemaDef;
+      let value;
+      let label = title;
+      if (selectorField) {
+        const innerSchema = get12(aSchema, [PROPERTIES_KEY, selectorField], {});
+        value = get12(innerSchema, DEFAULT_KEY, get12(innerSchema, CONST_KEY));
+        label = label || innerSchema?.title || aSchema.title || String(value);
+      } else {
+        value = toConstant(aSchema);
+        label = label || aSchema.title || String(value);
+      }
+      return {
+        schema: aSchema,
+        label,
+        value
+      };
+    });
   }
 
   // src/schema/getDefaultFormState.ts
+  var PRIMITIVE_TYPES = ["string", "number", "integer", "boolean", "null"];
   function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, idx = -1) {
     if (idx >= 0) {
       if (Array.isArray(schema.items) && idx < schema.items.length) {
@@ -917,47 +1315,54 @@
     }
     return {};
   }
-  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}) {
+  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}, isConst = false) {
     const { emptyObjectFields = "populateAllDefaults" } = experimental_defaultFormStateBehavior;
-    if (includeUndefinedValues) {
+    if (includeUndefinedValues || isConst) {
       obj[key] = computedDefault;
     } else if (emptyObjectFields !== "skipDefaults") {
+      const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
       if (isObject(computedDefault)) {
-        const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
         if (emptyObjectFields === "skipEmptyDefaults") {
-          if (!isEmpty(computedDefault)) {
+          if (!isEmpty2(computedDefault)) {
             obj[key] = computedDefault;
           }
-        } else if ((!isEmpty(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
+        } else if ((!isEmpty2(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
           obj[key] = computedDefault;
         }
       } else if (
         // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
         // Condition 1: computedDefault is not undefined
-        // Condition 2: If emptyObjectFields is 'populateAllDefaults' or 'skipEmptyDefaults) or if the key is a required field
-        computedDefault !== void 0 && (emptyObjectFields === "populateAllDefaults" || emptyObjectFields === "skipEmptyDefaults" || requiredFields.includes(key))
+        // Condition 2: If emptyObjectFields is 'populateAllDefaults' or 'skipEmptyDefaults)
+        // Or if isSelfOrParentRequired is 'true' and the key is a required field
+        computedDefault !== void 0 && (emptyObjectFields === "populateAllDefaults" || emptyObjectFields === "skipEmptyDefaults" || isSelfOrParentRequired && requiredFields.includes(key))
       ) {
         obj[key] = computedDefault;
       }
     }
   }
-  function computeDefaults(validator, rawSchema, {
-    parentDefaults,
-    rawFormData,
-    rootSchema = {},
-    includeUndefinedValues = false,
-    _recurseList = [],
-    experimental_defaultFormStateBehavior = void 0,
-    required
-  } = {}) {
+  function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
+    const {
+      parentDefaults,
+      rawFormData,
+      rootSchema = {},
+      includeUndefinedValues = false,
+      _recurseList = [],
+      experimental_defaultFormStateBehavior = void 0,
+      experimental_customMergeAllOf = void 0,
+      required,
+      shouldMergeDefaultsIntoFormData = false
+    } = computeDefaultsProps;
     const formData = isObject(rawFormData) ? rawFormData : {};
     const schema = isObject(rawSchema) ? rawSchema : {};
     let defaults = parentDefaults;
     let schemaToCompute = null;
+    let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
     let updatedRecurseList = _recurseList;
-    if (isObject(defaults) && isObject(schema.default)) {
+    if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
+      defaults = schema[CONST_KEY];
+    } else if (isObject(defaults) && isObject(schema.default)) {
       defaults = mergeObjects(defaults, schema.default);
-    } else if (DEFAULT_KEY in schema) {
+    } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
       defaults = schema.default;
     } else if (REF_KEY in schema) {
       const refName = schema[REF_KEY];
@@ -965,8 +1370,23 @@
         updatedRecurseList = _recurseList.concat(refName);
         schemaToCompute = findSchemaDefinition(refName, rootSchema);
       }
+      if (schemaToCompute && !defaults) {
+        defaults = schema.default;
+      }
     } else if (DEPENDENCIES_KEY in schema) {
-      const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], formData);
+      const defaultFormData = {
+        ...getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults),
+        ...formData
+      };
+      const resolvedSchema = resolveDependencies(
+        validator,
+        schema,
+        rootSchema,
+        false,
+        [],
+        defaultFormData,
+        experimental_customMergeAllOf
+      );
       schemaToCompute = resolvedSchema[0];
     } else if (isFixedItems(schema)) {
       defaults = schema.items.map(
@@ -975,9 +1395,11 @@
           includeUndefinedValues,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          experimental_customMergeAllOf,
           parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : void 0,
           rawFormData: formData,
-          required
+          required,
+          shouldMergeDefaultsIntoFormData
         })
       );
     } else if (ONE_OF_KEY in schema) {
@@ -986,13 +1408,21 @@
         return void 0;
       }
       const discriminator = getDiscriminatorFieldFromSchema(schema);
+      const { type = "null" } = remaining;
+      if (!Array.isArray(type) && PRIMITIVE_TYPES.includes(type) && experimental_dfsb_to_compute?.constAsDefaults === "skipOneOf") {
+        experimental_dfsb_to_compute = {
+          ...experimental_dfsb_to_compute,
+          constAsDefaults: "never"
+        };
+      }
       schemaToCompute = oneOf[getClosestMatchingOption(
         validator,
         rootSchema,
-        isEmpty(formData) ? void 0 : formData,
+        rawFormData ?? schema.default,
         oneOf,
         0,
-        discriminator
+        discriminator,
+        experimental_customMergeAllOf
       )];
       schemaToCompute = mergeSchemas(remaining, schemaToCompute);
     } else if (ANY_OF_KEY in schema) {
@@ -1004,171 +1434,270 @@
       schemaToCompute = anyOf[getClosestMatchingOption(
         validator,
         rootSchema,
-        isEmpty(formData) ? void 0 : formData,
+        rawFormData ?? schema.default,
         anyOf,
         0,
-        discriminator
+        discriminator,
+        experimental_customMergeAllOf
       )];
       schemaToCompute = mergeSchemas(remaining, schemaToCompute);
     }
-    if (schemaToCompute) {
-      return computeDefaults(validator, schemaToCompute, {
+    if (schemaToCompute) {
+      return computeDefaults(validator, schemaToCompute, {
+        rootSchema,
+        includeUndefinedValues,
+        _recurseList: updatedRecurseList,
+        experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
+        experimental_customMergeAllOf,
+        parentDefaults: defaults,
+        rawFormData: formData,
+        required,
+        shouldMergeDefaultsIntoFormData
+      });
+    }
+    if (defaults === void 0) {
+      defaults = schema.default;
+    }
+    const defaultBasedOnSchemaType = getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults);
+    let defaultsWithFormData = defaultBasedOnSchemaType ?? defaults;
+    if (shouldMergeDefaultsIntoFormData) {
+      const { arrayMinItems = {} } = experimental_defaultFormStateBehavior || {};
+      const { mergeExtraDefaults } = arrayMinItems;
+      const matchingFormData = ensureFormDataMatchingSchema(
+        validator,
+        schema,
+        rootSchema,
+        rawFormData,
+        experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf
+      );
+      if (!isObject(rawFormData) || ALL_OF_KEY in schema) {
+        defaultsWithFormData = mergeDefaultsWithFormData(
+          defaultsWithFormData,
+          matchingFormData,
+          mergeExtraDefaults,
+          true
+        );
+      }
+    }
+    return defaultsWithFormData;
+  }
+  function ensureFormDataMatchingSchema(validator, schema, rootSchema, formData, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
+    const isSelectField = !isConstant(schema) && isSelect(validator, schema, rootSchema, experimental_customMergeAllOf);
+    let validFormData = formData;
+    if (isSelectField) {
+      const getOptionsList = optionsList(schema);
+      const isValid = getOptionsList?.some((option) => deepEquals(option.value, formData));
+      validFormData = isValid ? formData : void 0;
+    }
+    const constTakesPrecedence = schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === "always";
+    if (constTakesPrecedence) {
+      validFormData = schema.const;
+    }
+    return validFormData;
+  }
+  function getObjectDefaults(validator, rawSchema, {
+    rawFormData,
+    rootSchema = {},
+    includeUndefinedValues = false,
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = void 0,
+    experimental_customMergeAllOf = void 0,
+    required,
+    shouldMergeDefaultsIntoFormData
+  } = {}, defaults) {
+    {
+      const formData = isObject(rawFormData) ? rawFormData : {};
+      const schema = rawSchema;
+      const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf) : schema;
+      const parentConst = retrievedSchema[CONST_KEY];
+      const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
+        (acc, key) => {
+          const propertySchema = get12(retrievedSchema, [PROPERTIES_KEY, key], {});
+          const hasParentConst = isObject(parentConst) && parentConst[key] !== void 0;
+          const hasConst = (isObject(propertySchema) && CONST_KEY in propertySchema || hasParentConst) && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(propertySchema);
+          const computedDefault = computeDefaults(validator, propertySchema, {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf,
+            includeUndefinedValues: includeUndefinedValues === true,
+            parentDefaults: get12(defaults, [key]),
+            rawFormData: get12(formData, [key]),
+            required: retrievedSchema.required?.includes(key),
+            shouldMergeDefaultsIntoFormData
+          });
+          maybeAddDefaultToObject(
+            acc,
+            key,
+            computedDefault,
+            includeUndefinedValues,
+            required,
+            retrievedSchema.required,
+            experimental_defaultFormStateBehavior,
+            hasConst
+          );
+          return acc;
+        },
+        {}
+      );
+      if (retrievedSchema.additionalProperties) {
+        const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
+        const keys2 = /* @__PURE__ */ new Set();
+        if (isObject(defaults)) {
+          Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys2.add(key));
+        }
+        const formDataRequired = [];
+        Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
+          keys2.add(key);
+          formDataRequired.push(key);
+        });
+        keys2.forEach((key) => {
+          const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf,
+            includeUndefinedValues: includeUndefinedValues === true,
+            parentDefaults: get12(defaults, [key]),
+            rawFormData: get12(formData, [key]),
+            required: retrievedSchema.required?.includes(key),
+            shouldMergeDefaultsIntoFormData
+          });
+          maybeAddDefaultToObject(
+            objectDefaults,
+            key,
+            computedDefault,
+            includeUndefinedValues,
+            required,
+            formDataRequired
+          );
+        });
+      }
+      return objectDefaults;
+    }
+  }
+  function getArrayDefaults(validator, rawSchema, {
+    rawFormData,
+    rootSchema = {},
+    _recurseList = [],
+    experimental_defaultFormStateBehavior = void 0,
+    experimental_customMergeAllOf = void 0,
+    required,
+    shouldMergeDefaultsIntoFormData
+  } = {}, defaults) {
+    const schema = rawSchema;
+    const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
+    const { populate: arrayMinItemsPopulate, mergeExtraDefaults: arrayMergeExtraDefaults } = arrayMinItemsStateBehavior;
+    const neverPopulate = arrayMinItemsPopulate === "never";
+    const ignoreMinItemsFlagSet = arrayMinItemsPopulate === "requiredOnly";
+    const isPopulateAll = arrayMinItemsPopulate === "all" || !neverPopulate && !ignoreMinItemsFlagSet;
+    const computeSkipPopulate = arrayMinItemsStateBehavior?.computeSkipPopulate ?? (() => false);
+    const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
+    const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
+    if (Array.isArray(defaults)) {
+      defaults = defaults.map((item, idx) => {
+        const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
+        return computeDefaults(validator, schemaItem, {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          experimental_customMergeAllOf,
+          parentDefaults: item,
+          required,
+          shouldMergeDefaultsIntoFormData
+        });
+      });
+    }
+    if (Array.isArray(rawFormData)) {
+      const schemaItem = getInnerSchemaForArrayItem(schema);
+      if (neverPopulate) {
+        defaults = rawFormData;
+      } else {
+        const itemDefaults = rawFormData.map((item, idx) => {
+          return computeDefaults(validator, schemaItem, {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf,
+            rawFormData: item,
+            parentDefaults: get12(defaults, [idx]),
+            required,
+            shouldMergeDefaultsIntoFormData
+          });
+        });
+        const mergeExtraDefaults = (ignoreMinItemsFlagSet && required || isPopulateAll) && arrayMergeExtraDefaults;
+        defaults = mergeDefaultsWithFormData(defaults, itemDefaults, mergeExtraDefaults);
+      }
+    }
+    const hasConst = isObject(schema) && CONST_KEY in schema && experimental_defaultFormStateBehavior?.constAsDefaults !== "never";
+    if (hasConst === false) {
+      if (neverPopulate) {
+        return defaults ?? emptyDefault;
+      }
+      if (ignoreMinItemsFlagSet && !required) {
+        return defaults ? defaults : void 0;
+      }
+    }
+    const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+    if (!schema.minItems || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
+      return defaults ? defaults : emptyDefault;
+    }
+    const defaultEntries = defaults || [];
+    const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
+    const fillerDefault = fillerSchema.default;
+    const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
+      computeDefaults(validator, fillerSchema, {
+        parentDefaults: fillerDefault,
         rootSchema,
-        includeUndefinedValues,
-        _recurseList: updatedRecurseList,
+        _recurseList,
         experimental_defaultFormStateBehavior,
-        parentDefaults: defaults,
-        rawFormData: formData,
-        required
-      });
-    }
-    if (defaults === void 0) {
-      defaults = schema.default;
-    }
-    switch (getSchemaType(schema)) {
+        experimental_customMergeAllOf,
+        required,
+        shouldMergeDefaultsIntoFormData
+      })
+    );
+    return defaultEntries.concat(fillerEntries);
+  }
+  function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps = {}, defaults) {
+    switch (getSchemaType(rawSchema)) {
+      // We need to recurse for object schema inner default values.
       case "object": {
-        const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData) : schema;
-        const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
-          (acc, key) => {
-            const computedDefault = computeDefaults(validator, get8(retrievedSchema, [PROPERTIES_KEY, key]), {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              includeUndefinedValues: includeUndefinedValues === true,
-              parentDefaults: get8(defaults, [key]),
-              rawFormData: get8(formData, [key]),
-              required: retrievedSchema.required?.includes(key)
-            });
-            maybeAddDefaultToObject(
-              acc,
-              key,
-              computedDefault,
-              includeUndefinedValues,
-              required,
-              retrievedSchema.required,
-              experimental_defaultFormStateBehavior
-            );
-            return acc;
-          },
-          {}
-        );
-        if (retrievedSchema.additionalProperties) {
-          const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
-          const keys = /* @__PURE__ */ new Set();
-          if (isObject(defaults)) {
-            Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
-          }
-          const formDataRequired = [];
-          Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
-            keys.add(key);
-            formDataRequired.push(key);
-          });
-          keys.forEach((key) => {
-            const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              includeUndefinedValues: includeUndefinedValues === true,
-              parentDefaults: get8(defaults, [key]),
-              rawFormData: get8(formData, [key]),
-              required: retrievedSchema.required?.includes(key)
-            });
-            maybeAddDefaultToObject(
-              objectDefaults,
-              key,
-              computedDefault,
-              includeUndefinedValues,
-              required,
-              formDataRequired
-            );
-          });
-        }
-        return objectDefaults;
+        return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
       }
       case "array": {
-        const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
-        const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
-        const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
-        const computeSkipPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
-        const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
-        if (Array.isArray(defaults)) {
-          defaults = defaults.map((item, idx) => {
-            const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
-            return computeDefaults(validator, schemaItem, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              parentDefaults: item,
-              required
-            });
-          });
-        }
-        if (Array.isArray(rawFormData)) {
-          const schemaItem = getInnerSchemaForArrayItem(schema);
-          if (neverPopulate) {
-            defaults = rawFormData;
-          } else {
-            defaults = rawFormData.map((item, idx) => {
-              return computeDefaults(validator, schemaItem, {
-                rootSchema,
-                _recurseList,
-                experimental_defaultFormStateBehavior,
-                rawFormData: item,
-                parentDefaults: get8(defaults, [idx]),
-                required
-              });
-            });
-          }
-        }
-        if (neverPopulate) {
-          return defaults ?? emptyDefault;
-        }
-        if (ignoreMinItemsFlagSet && !required) {
-          return defaults ? defaults : void 0;
-        }
-        const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-        if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
-          return defaults ? defaults : emptyDefault;
-        }
-        const defaultEntries = defaults || [];
-        const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
-        const fillerDefault = fillerSchema.default;
-        const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
-          computeDefaults(validator, fillerSchema, {
-            parentDefaults: fillerDefault,
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            required
-          })
-        );
-        return defaultEntries.concat(fillerEntries);
+        return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
       }
     }
-    return defaults;
   }
-  function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior) {
+  function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
     if (!isObject(theSchema)) {
       throw new Error("Invalid schema: " + theSchema);
     }
-    const schema = retrieveSchema(validator, theSchema, rootSchema, formData);
+    const schema = retrieveSchema(validator, theSchema, rootSchema, formData, experimental_customMergeAllOf);
     const defaults = computeDefaults(validator, schema, {
       rootSchema,
       includeUndefinedValues,
       experimental_defaultFormStateBehavior,
-      rawFormData: formData
+      experimental_customMergeAllOf,
+      rawFormData: formData,
+      shouldMergeDefaultsIntoFormData: true
     });
-    if (formData === void 0 || formData === null || typeof formData === "number" && isNaN(formData)) {
-      return defaults;
-    }
-    const { mergeExtraDefaults } = experimental_defaultFormStateBehavior?.arrayMinItems || {};
-    if (isObject(formData)) {
-      return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults);
-    }
-    if (Array.isArray(formData)) {
-      return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults);
+    if (isObject(formData) || Array.isArray(formData)) {
+      const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
+      const defaultSupercedesUndefined = mergeDefaultsIntoFormData === "useDefaultIfFormDataUndefined";
+      const result = mergeDefaultsWithFormData(
+        defaults,
+        formData,
+        true,
+        // set to true to add any additional default array entries.
+        defaultSupercedesUndefined,
+        true
+        // set to true to override formData with defaults if they exist.
+      );
+      return result;
     }
-    return formData;
+    return defaults;
   }
 
   // src/isCustomWidget.ts
@@ -1181,25 +1710,31 @@
   }
 
   // src/schema/isFilesArray.ts
-  function isFilesArray(validator, schema, uiSchema = {}, rootSchema) {
+  function isFilesArray(validator, schema, uiSchema = {}, rootSchema, experimental_customMergeAllOf) {
     if (uiSchema[UI_WIDGET_KEY] === "files") {
       return true;
     }
     if (schema.items) {
-      const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
+      const itemsSchema = retrieveSchema(
+        validator,
+        schema.items,
+        rootSchema,
+        void 0,
+        experimental_customMergeAllOf
+      );
       return itemsSchema.type === "string" && itemsSchema.format === "data-url";
     }
     return false;
   }
 
   // src/schema/getDisplayLabel.ts
-  function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions) {
+  function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions, experimental_customMergeAllOf) {
     const uiOptions = getUiOptions(uiSchema, globalOptions);
     const { label = true } = uiOptions;
     let displayLabel = !!label;
     const schemaType = getSchemaType(schema);
     if (schemaType === "array") {
-      displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema);
+      displayLabel = isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || isFilesArray(validator, schema, uiSchema, rootSchema, experimental_customMergeAllOf) || isCustomWidget(uiSchema);
     }
     if (schemaType === "object") {
       displayLabel = false;
@@ -1212,48 +1747,47 @@
     }
     return displayLabel;
   }
-  function mergeValidationData(validator, validationData, additionalErrorSchema) {
-    if (!additionalErrorSchema) {
-      return validationData;
-    }
-    const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
-    let errors = validator.toErrorList(additionalErrorSchema);
-    let errorSchema = additionalErrorSchema;
-    if (!isEmpty(oldErrorSchema)) {
-      errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-      errors = [...oldErrors].concat(errors);
-    }
-    return { errorSchema, errors };
-  }
   var NO_VALUE = Symbol("no Value");
-  function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) {
+  function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
     let newFormData;
-    if (has3(newSchema, PROPERTIES_KEY)) {
+    if (has5(newSchema, PROPERTIES_KEY)) {
       const removeOldSchemaData = {};
-      if (has3(oldSchema, PROPERTIES_KEY)) {
-        const properties = get8(oldSchema, PROPERTIES_KEY, {});
+      if (has5(oldSchema, PROPERTIES_KEY)) {
+        const properties = get12(oldSchema, PROPERTIES_KEY, {});
         Object.keys(properties).forEach((key) => {
-          if (has3(data, key)) {
+          if (has5(data, key)) {
             removeOldSchemaData[key] = void 0;
           }
         });
       }
-      const keys = Object.keys(get8(newSchema, PROPERTIES_KEY, {}));
+      const keys2 = Object.keys(get12(newSchema, PROPERTIES_KEY, {}));
       const nestedData = {};
-      keys.forEach((key) => {
-        const formValue = get8(data, key);
-        let oldKeyedSchema = get8(oldSchema, [PROPERTIES_KEY, key], {});
-        let newKeyedSchema = get8(newSchema, [PROPERTIES_KEY, key], {});
-        if (has3(oldKeyedSchema, REF_KEY)) {
-          oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
+      keys2.forEach((key) => {
+        const formValue = get12(data, key);
+        let oldKeyedSchema = get12(oldSchema, [PROPERTIES_KEY, key], {});
+        let newKeyedSchema = get12(newSchema, [PROPERTIES_KEY, key], {});
+        if (has5(oldKeyedSchema, REF_KEY)) {
+          oldKeyedSchema = retrieveSchema(
+            validator,
+            oldKeyedSchema,
+            rootSchema,
+            formValue,
+            experimental_customMergeAllOf
+          );
         }
-        if (has3(newKeyedSchema, REF_KEY)) {
-          newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
+        if (has5(newKeyedSchema, REF_KEY)) {
+          newKeyedSchema = retrieveSchema(
+            validator,
+            newKeyedSchema,
+            rootSchema,
+            formValue,
+            experimental_customMergeAllOf
+          );
         }
-        const oldSchemaTypeForKey = get8(oldKeyedSchema, "type");
-        const newSchemaTypeForKey = get8(newKeyedSchema, "type");
+        const oldSchemaTypeForKey = get12(oldKeyedSchema, "type");
+        const newSchemaTypeForKey = get12(newKeyedSchema, "type");
         if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-          if (has3(removeOldSchemaData, key)) {
+          if (has5(removeOldSchemaData, key)) {
             delete removeOldSchemaData[key];
           }
           if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
@@ -1262,23 +1796,24 @@
               rootSchema,
               newKeyedSchema,
               oldKeyedSchema,
-              formValue
+              formValue,
+              experimental_customMergeAllOf
             );
             if (itemData !== void 0 || newSchemaTypeForKey === "array") {
               nestedData[key] = itemData;
             }
           } else {
-            const newOptionDefault = get8(newKeyedSchema, "default", NO_VALUE);
-            const oldOptionDefault = get8(oldKeyedSchema, "default", NO_VALUE);
+            const newOptionDefault = get12(newKeyedSchema, "default", NO_VALUE);
+            const oldOptionDefault = get12(oldKeyedSchema, "default", NO_VALUE);
             if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
               if (oldOptionDefault === formValue) {
                 removeOldSchemaData[key] = newOptionDefault;
-              } else if (get8(newKeyedSchema, "readOnly") === true) {
+              } else if (get12(newKeyedSchema, "readOnly") === true) {
                 removeOldSchemaData[key] = void 0;
               }
             }
-            const newOptionConst = get8(newKeyedSchema, "const", NO_VALUE);
-            const oldOptionConst = get8(oldKeyedSchema, "const", NO_VALUE);
+            const newOptionConst = get12(newKeyedSchema, "const", NO_VALUE);
+            const oldOptionConst = get12(oldKeyedSchema, "const", NO_VALUE);
             if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
               removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
             }
@@ -1290,20 +1825,32 @@
         ...removeOldSchemaData,
         ...nestedData
       };
-    } else if (get8(oldSchema, "type") === "array" && get8(newSchema, "type") === "array" && Array.isArray(data)) {
-      let oldSchemaItems = get8(oldSchema, "items");
-      let newSchemaItems = get8(newSchema, "items");
+    } else if (get12(oldSchema, "type") === "array" && get12(newSchema, "type") === "array" && Array.isArray(data)) {
+      let oldSchemaItems = get12(oldSchema, "items");
+      let newSchemaItems = get12(newSchema, "items");
       if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
-        if (has3(oldSchemaItems, REF_KEY)) {
-          oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
+        if (has5(oldSchemaItems, REF_KEY)) {
+          oldSchemaItems = retrieveSchema(
+            validator,
+            oldSchemaItems,
+            rootSchema,
+            data,
+            experimental_customMergeAllOf
+          );
         }
-        if (has3(newSchemaItems, REF_KEY)) {
-          newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
+        if (has5(newSchemaItems, REF_KEY)) {
+          newSchemaItems = retrieveSchema(
+            validator,
+            newSchemaItems,
+            rootSchema,
+            data,
+            experimental_customMergeAllOf
+          );
         }
-        const oldSchemaType = get8(oldSchemaItems, "type");
-        const newSchemaType = get8(newSchemaItems, "type");
+        const oldSchemaType = get12(oldSchemaItems, "type");
+        const newSchemaType = get12(newSchemaItems, "type");
         if (!oldSchemaType || oldSchemaType === newSchemaType) {
-          const maxItems = get8(newSchema, "maxItems", -1);
+          const maxItems = get12(newSchema, "maxItems", -1);
           if (newSchemaType === "object") {
             newFormData = data.reduce((newValue, aValue) => {
               const itemValue = sanitizeDataForNewSchema(
@@ -1311,7 +1858,8 @@
                 rootSchema,
                 newSchemaItems,
                 oldSchemaItems,
-                aValue
+                aValue,
+                experimental_customMergeAllOf
               );
               if (itemValue !== void 0 && (maxItems < 0 || newValue.length < maxItems)) {
                 newValue.push(itemValue);
@@ -1328,64 +1876,79 @@
     }
     return newFormData;
   }
-  function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = []) {
-    if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-      const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-      const sameSchemaIndex = _recurseList.findIndex((item) => isEqual4(item, _schema));
-      if (sameSchemaIndex === -1) {
+  function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
+    const $id = id || idPrefix;
+    const idSchema = { $id };
+    if (typeof schema === "object") {
+      if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
+        const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+        const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
+        if (sameSchemaIndex === -1) {
+          return toIdSchemaInternal(
+            validator,
+            _schema,
+            idPrefix,
+            idSeparator,
+            id,
+            rootSchema,
+            formData,
+            _recurseList.concat(_schema),
+            experimental_customMergeAllOf
+          );
+        }
+      }
+      if (ITEMS_KEY in schema && !get12(schema, [ITEMS_KEY, REF_KEY])) {
         return toIdSchemaInternal(
           validator,
-          _schema,
+          get12(schema, ITEMS_KEY),
           idPrefix,
           idSeparator,
           id,
           rootSchema,
           formData,
-          _recurseList.concat(_schema)
+          _recurseList,
+          experimental_customMergeAllOf
         );
       }
-    }
-    if (ITEMS_KEY in schema && !get8(schema, [ITEMS_KEY, REF_KEY])) {
-      return toIdSchemaInternal(
-        validator,
-        get8(schema, ITEMS_KEY),
-        idPrefix,
-        idSeparator,
-        id,
-        rootSchema,
-        formData,
-        _recurseList
-      );
-    }
-    const $id = id || idPrefix;
-    const idSchema = { $id };
-    if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
-      for (const name in schema.properties) {
-        const field = get8(schema, [PROPERTIES_KEY, name]);
-        const fieldId = idSchema[ID_KEY] + idSeparator + name;
-        idSchema[name] = toIdSchemaInternal(
-          validator,
-          isObject(field) ? field : {},
-          idPrefix,
-          idSeparator,
-          fieldId,
-          rootSchema,
-          // It's possible that formData is not an object -- this can happen if an
-          // array item has just been added, but not populated with data yet
-          get8(formData, [name]),
-          _recurseList
-        );
+      if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
+        for (const name in schema.properties) {
+          const field = schema[PROPERTIES_KEY][name];
+          const fieldId = idSchema[ID_KEY] + idSeparator + name;
+          idSchema[name] = toIdSchemaInternal(
+            validator,
+            field,
+            idPrefix,
+            idSeparator,
+            fieldId,
+            rootSchema,
+            // It's possible that formData is not an object -- this can happen if an
+            // array item has just been added, but not populated with data yet
+            get12(formData, [name]),
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        }
       }
     }
     return idSchema;
   }
-  function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "root", idSeparator = "_") {
-    return toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData);
+  function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "root", idSeparator = "_", experimental_customMergeAllOf) {
+    return toIdSchemaInternal(
+      validator,
+      schema,
+      idPrefix,
+      idSeparator,
+      id,
+      rootSchema,
+      formData,
+      void 0,
+      experimental_customMergeAllOf
+    );
   }
-  function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
+  function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
     if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-      const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-      const sameSchemaIndex = _recurseList.findIndex((item) => isEqual4(item, _schema));
+      const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+      const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
       if (sameSchemaIndex === -1) {
         return toPathSchemaInternal(
           validator,
@@ -1393,7 +1956,8 @@
           name,
           rootSchema,
           formData,
-          _recurseList.concat(_schema)
+          _recurseList.concat(_schema),
+          experimental_customMergeAllOf
         );
       }
     }
@@ -1403,15 +1967,31 @@
     if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
       const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
       const discriminator = getDiscriminatorFieldFromSchema(schema);
-      const index = getClosestMatchingOption(validator, rootSchema, formData, xxxOf, 0, discriminator);
+      const index = getClosestMatchingOption(
+        validator,
+        rootSchema,
+        formData,
+        xxxOf,
+        0,
+        discriminator,
+        experimental_customMergeAllOf
+      );
       const _schema = xxxOf[index];
       pathSchema = {
         ...pathSchema,
-        ...toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList)
+        ...toPathSchemaInternal(
+          validator,
+          _schema,
+          name,
+          rootSchema,
+          formData,
+          _recurseList,
+          experimental_customMergeAllOf
+        )
       };
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-      set3(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+      set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
     }
     if (ITEMS_KEY in schema && Array.isArray(formData)) {
       const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
@@ -1424,7 +2004,8 @@
               `${name}.${i}`,
               rootSchema,
               element,
-              _recurseList
+              _recurseList,
+              experimental_customMergeAllOf
             );
           } else if (schemaAdditionalItems) {
             pathSchema[i] = toPathSchemaInternal(
@@ -1433,7 +2014,8 @@
               `${name}.${i}`,
               rootSchema,
               element,
-              _recurseList
+              _recurseList,
+              experimental_customMergeAllOf
             );
           } else {
             console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
@@ -1447,13 +2029,14 @@
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf
           );
         });
       }
     } else if (PROPERTIES_KEY in schema) {
       for (const property in schema.properties) {
-        const field = get8(schema, [PROPERTIES_KEY, property]);
+        const field = get12(schema, [PROPERTIES_KEY, property], {});
         pathSchema[property] = toPathSchemaInternal(
           validator,
           field,
@@ -1461,15 +2044,16 @@
           rootSchema,
           // It's possible that formData is not an object -- this can happen if an
           // array item has just been added, but not populated with data yet
-          get8(formData, [property]),
-          _recurseList
+          get12(formData, [property]),
+          _recurseList,
+          experimental_customMergeAllOf
         );
       }
     }
     return pathSchema;
   }
-  function toPathSchema(validator, schema, name = "", rootSchema, formData) {
-    return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
+  function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
+    return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
   }
 
   // src/createSchemaUtils.ts
@@ -1479,11 +2063,13 @@
      * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
      * @param rootSchema - The root schema that will be forwarded to all the APIs
      * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
+     * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
      */
-    constructor(validator, rootSchema, experimental_defaultFormStateBehavior) {
+    constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
       this.rootSchema = rootSchema;
       this.validator = validator;
       this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
+      this.experimental_customMergeAllOf = experimental_customMergeAllOf;
     }
     /** Returns the `ValidatorType` in the `SchemaUtilsType`
      *
@@ -1499,13 +2085,55 @@
      * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
      * @param rootSchema - The root schema that will be compared against the current one
      * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
+     * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
      * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
      */
-    doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
+    doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior = {}, experimental_customMergeAllOf) {
       if (!validator || !rootSchema) {
         return false;
       }
-      return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema) || !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior);
+      return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema) || !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior) || this.experimental_customMergeAllOf !== experimental_customMergeAllOf;
+    }
+    /** Finds the field specified by the `path` within the root or recursed `schema`. If there is no field for the specified
+     * `path`, then the default `{ field: undefined, isRequired: undefined }` is returned. It determines whether a leaf
+     * field is in the `required` list for its parent and if so, it is marked as required on return.
+     *
+     * @param schema - The current node within the JSON schema
+     * @param path - The remaining keys in the path to the desired field
+     * @param [formData] - The form data that is used to determine which oneOf option
+     * @returns - An object that contains the field and its required state. If no field can be found then
+     *            `{ field: undefined, isRequired: undefined }` is returned.
+     */
+    findFieldInSchema(schema, path, formData) {
+      return findFieldInSchema(
+        this.validator,
+        this.rootSchema,
+        schema,
+        path,
+        formData,
+        this.experimental_customMergeAllOf
+      );
+    }
+    /** Finds the oneOf option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` that
+     * matches the `formData[selectorField]` value. For the purposes of this function, `selectorField` is either
+     * `schema.discriminator.propertyName` or `fallbackField`.
+     *
+     * @param schema - The schema element in which to search for the selected oneOf option
+     * @param fallbackField - The field to use as a backup selector field if the schema does not have a required field
+     * @param xxx - Either `oneOf` or `anyOf`, defines which value is being sought
+     * @param [formData={}] - The form data that is used to determine which oneOf option
+     * @returns - The anyOf/oneOf option that matches the selector field in the schema or undefined if nothing is selected
+     */
+    findSelectedOptionInXxxOf(schema, fallbackField, xxx, formData) {
+      return findSelectedOptionInXxxOf(
+        this.validator,
+        this.rootSchema,
+        schema,
+        fallbackField,
+        xxx,
+        formData,
+        this.experimental_customMergeAllOf
+      );
     }
     /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
      * computed to have defaults provided in the `schema`.
@@ -1524,7 +2152,8 @@
         formData,
         this.rootSchema,
         includeUndefinedValues,
-        this.experimental_defaultFormStateBehavior
+        this.experimental_defaultFormStateBehavior,
+        this.experimental_customMergeAllOf
       );
     }
     /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
@@ -1536,7 +2165,14 @@
      * @returns - True if the label should be displayed or false if it should not
      */
     getDisplayLabel(schema, uiSchema, globalOptions) {
-      return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
+      return getDisplayLabel(
+        this.validator,
+        schema,
+        uiSchema,
+        this.rootSchema,
+        globalOptions,
+        this.experimental_customMergeAllOf
+      );
     }
     /** Determines which of the given `options` provided most closely matches the `formData`.
      * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
@@ -1558,7 +2194,8 @@
         formData,
         options,
         selectedOption,
-        discriminatorField
+        discriminatorField,
+        this.experimental_customMergeAllOf
       );
     }
     /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
@@ -1573,18 +2210,16 @@
     getFirstMatchingOption(formData, options, discriminatorField) {
       return getFirstMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
     }
-    /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
-     * Deprecated, use `getFirstMatchingOption()` instead.
-     *
-     * @param formData - The current formData, if any, onto which to provide any missing defaults
-     * @param options - The list of options to find a matching options from
-     * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
-     *          determine which option is selected
-     * @returns - The index of the matched option or 0 if none is available
-     * @deprecated
-     */
-    getMatchingOption(formData, options, discriminatorField) {
-      return getMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
+    getFromSchema(schema, path, defaultValue) {
+      return getFromSchema(
+        this.validator,
+        this.rootSchema,
+        schema,
+        path,
+        // @ts-expect-error TS2769: No overload matches this call
+        defaultValue,
+        this.experimental_customMergeAllOf
+      );
     }
     /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
      *
@@ -1593,7 +2228,7 @@
      * @returns - True if schema/uiSchema contains an array of files, otherwise false
      */
     isFilesArray(schema, uiSchema) {
-      return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
+      return isFilesArray(this.validator, schema, uiSchema, this.rootSchema, this.experimental_customMergeAllOf);
     }
     /** Checks to see if the `schema` combination represents a multi-select
      *
@@ -1601,7 +2236,7 @@
      * @returns - True if schema contains a multi-select, otherwise false
      */
     isMultiSelect(schema) {
-      return isMultiSelect(this.validator, schema, this.rootSchema);
+      return isMultiSelect(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
     }
     /** Checks to see if the `schema` combination represents a select
      *
@@ -1609,21 +2244,7 @@
      * @returns - True if schema contains a select, otherwise false
      */
     isSelect(schema) {
-      return isSelect(this.validator, schema, this.rootSchema);
-    }
-    /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
-     * the two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
-     * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed,
-     * then `validationData` is returned.
-     *
-     * @param validationData - The current `ValidationData` into which to merge the additional errors
-     * @param [additionalErrorSchema] - The additional set of errors
-     * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
-     * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
-     *        removed in the next major release.
-     */
-    mergeValidationData(validationData, additionalErrorSchema) {
-      return mergeValidationData(this.validator, validationData, additionalErrorSchema);
+      return isSelect(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
     }
     /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
      * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
@@ -1634,7 +2255,13 @@
      * @returns - The schema having its conditions, additional properties, references and dependencies resolved
      */
     retrieveSchema(schema, rawFormData) {
-      return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
+      return retrieveSchema(
+        this.validator,
+        schema,
+        this.rootSchema,
+        rawFormData,
+        this.experimental_customMergeAllOf
+      );
     }
     /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
      * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the
@@ -1648,7 +2275,14 @@
      *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
      */
     sanitizeDataForNewSchema(newSchema, oldSchema, data) {
-      return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
+      return sanitizeDataForNewSchema(
+        this.validator,
+        this.rootSchema,
+        newSchema,
+        oldSchema,
+        data,
+        this.experimental_customMergeAllOf
+      );
     }
     /** Generates an `IdSchema` object for the `schema`, recursively
      *
@@ -1660,7 +2294,16 @@
      * @returns - The `IdSchema` object for the `schema`
      */
     toIdSchema(schema, id, formData, idPrefix = "root", idSeparator = "_") {
-      return toIdSchema(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
+      return toIdSchema(
+        this.validator,
+        schema,
+        id,
+        this.rootSchema,
+        formData,
+        idPrefix,
+        idSeparator,
+        this.experimental_customMergeAllOf
+      );
     }
     /** Generates an `PathSchema` object for the `schema`, recursively
      *
@@ -1670,11 +2313,23 @@
      * @returns - The `PathSchema` object for the `schema`
      */
     toPathSchema(schema, name, formData) {
-      return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
+      return toPathSchema(
+        this.validator,
+        schema,
+        name,
+        this.rootSchema,
+        formData,
+        this.experimental_customMergeAllOf
+      );
     }
   };
-  function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
-    return new SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior);
+  function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}, experimental_customMergeAllOf) {
+    return new SchemaUtils(
+      validator,
+      rootSchema,
+      experimental_defaultFormStateBehavior,
+      experimental_customMergeAllOf
+    );
   }
 
   // src/dataURItoBlob.ts
@@ -1770,15 +2425,17 @@
   function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
     const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
     if (Array.isArray(selected)) {
-      return selected.filter((v) => !isEqual4(v, value));
+      return selected.filter((v) => !deepEquals(v, value));
     }
-    return isEqual4(value, selected) ? void 0 : selected;
+    return deepEquals(value, selected) ? void 0 : selected;
   }
+
+  // src/enumOptionsIsSelected.ts
   function enumOptionsIsSelected(value, selected) {
     if (Array.isArray(selected)) {
-      return selected.some((sel) => isEqual4(sel, value));
+      return selected.some((sel) => deepEquals(sel, value));
     }
-    return isEqual4(selected, value);
+    return deepEquals(selected, value);
   }
 
   // src/enumOptionsIndexForValue.ts
@@ -1825,10 +2482,10 @@
      */
     getOrCreateErrorBlock(pathOfError) {
       const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-      let errorBlock = hasPath ? get8(this.errorSchema, pathOfError) : this.errorSchema;
+      let errorBlock = hasPath ? get12(this.errorSchema, pathOfError) : this.errorSchema;
       if (!errorBlock && pathOfError) {
         errorBlock = {};
-        set3(this.errorSchema, pathOfError, errorBlock);
+        setWith(this.errorSchema, pathOfError, errorBlock, Object);
       }
       return errorBlock;
     }
@@ -1851,15 +2508,15 @@
      */
     addErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      let errorsList = get8(errorBlock, ERRORS_KEY);
+      let errorsList = get12(errorBlock, ERRORS_KEY);
       if (!Array.isArray(errorsList)) {
         errorsList = [];
         errorBlock[ERRORS_KEY] = errorsList;
       }
       if (Array.isArray(errorOrList)) {
-        errorsList.push(...errorOrList);
+        set(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
       } else {
-        errorsList.push(errorOrList);
+        set(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, errorOrList])]);
       }
       return this;
     }
@@ -1873,8 +2530,8 @@
      */
     setErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList];
-      set3(errorBlock, ERRORS_KEY, listToAdd);
+      const listToAdd = Array.isArray(errorOrList) ? [.../* @__PURE__ */ new Set([...errorOrList])] : [errorOrList];
+      set(errorBlock, ERRORS_KEY, listToAdd);
       return this;
     }
     /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
@@ -1886,7 +2543,7 @@
      */
     clearErrors(pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      set3(errorBlock, ERRORS_KEY, []);
+      set(errorBlock, ERRORS_KEY, []);
       return this;
     }
   };
@@ -1958,6 +2615,9 @@
     if (options.autocomplete) {
       inputProps.autoComplete = options.autocomplete;
     }
+    if (options.accept) {
+      inputProps.accept = options.accept;
+    }
     return inputProps;
   }
 
@@ -1984,12 +2644,33 @@
     if (name === "ButtonTemplates") {
       return templates[name];
     }
+    if (Object.hasOwn(uiOptions, name) && typeof uiOptions[name] === "string" && Object.hasOwn(templates, uiOptions[name])) {
+      const key = uiOptions[name];
+      return templates[key];
+    }
     return (
       // Evaluating uiOptions[name] results in TS2590: Expression produces a union type that is too complex to represent
       // To avoid that, we cast uiOptions to `any` before accessing the name field
       uiOptions[name] || templates[name]
     );
   }
+  function getTestIds() {
+    if (typeof process === "undefined" || get12(process, "env.NODE_ENV") !== "test") {
+      return {};
+    }
+    const ids = /* @__PURE__ */ new Map();
+    return new Proxy(
+      {},
+      {
+        get(_obj, prop) {
+          if (!ids.has(prop)) {
+            ids.set(prop, nanoid.nanoid());
+          }
+          return ids.get(prop);
+        }
+      }
+    );
+  }
   var widgetMap = {
     boolean: {
       checkbox: "CheckboxWidget",
@@ -2043,13 +2724,13 @@
     }
   };
   function mergeWidgetOptions(AWidget) {
-    let MergedWidget = get8(AWidget, "MergedWidget");
+    let MergedWidget = get12(AWidget, "MergedWidget");
     if (!MergedWidget) {
       const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
       MergedWidget = ({ options, ...props }) => {
         return /* @__PURE__ */ jsxRuntime.jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
       };
-      set3(AWidget, "MergedWidget", MergedWidget);
+      set(AWidget, "MergedWidget", MergedWidget);
     }
     return MergedWidget;
   }
@@ -2087,10 +2768,16 @@
     }
     return hash.toString(16);
   }
-  function hashForSchema(schema) {
+  function sortedJSONStringify(object) {
     const allKeys = /* @__PURE__ */ new Set();
-    JSON.stringify(schema, (key, value) => (allKeys.add(key), value));
-    return hashString(JSON.stringify(schema, Array.from(allKeys).sort()));
+    JSON.stringify(object, (key, value) => (allKeys.add(key), value));
+    return JSON.stringify(object, Array.from(allKeys).sort());
+  }
+  function hashObject(object) {
+    return hashString(sortedJSONStringify(object));
+  }
+  function hashForSchema(schema) {
+    return hashObject(schema);
   }
 
   // src/hasWidget.ts
@@ -2132,6 +2819,9 @@
   function optionId(id, optionIndex) {
     return `${id}-${optionIndex}`;
   }
+  function buttonId(id, btn) {
+    return idGenerator(id, btn);
+  }
 
   // src/labelValue.ts
   function labelValue(label, hideLabel, fallback) {
@@ -2142,60 +2832,12 @@
   function localToUTC(dateString) {
     return dateString ? new Date(dateString).toJSON() : void 0;
   }
-
-  // src/toConstant.ts
-  function toConstant(schema) {
-    if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
-      return schema.enum[0];
-    }
-    if (CONST_KEY in schema) {
-      return schema.const;
-    }
-    throw new Error("schema cannot be inferred as a constant");
-  }
-
-  // src/optionsList.ts
-  function optionsList(schema, uiSchema) {
-    const schemaWithEnumNames = schema;
-    if (schema.enum) {
-      let enumNames;
-      if (uiSchema) {
-        const { enumNames: uiEnumNames } = getUiOptions(uiSchema);
-        enumNames = uiEnumNames;
-      }
-      if (!enumNames && schemaWithEnumNames.enumNames) {
-        {
-          console.warn(
-            'The "enumNames" property in the schema is deprecated and will be removed in a future major release. Use the "ui:enumNames" property in the uiSchema instead.'
-          );
-        }
-        enumNames = schemaWithEnumNames.enumNames;
-      }
-      return schema.enum.map((value, i) => {
-        const label = enumNames?.[i] || String(value);
-        return { label, value };
-      });
-    }
-    let altSchemas = void 0;
-    let altUiSchemas = void 0;
-    if (schema.anyOf) {
-      altSchemas = schema.anyOf;
-      altUiSchemas = uiSchema?.anyOf;
-    } else if (schema.oneOf) {
-      altSchemas = schema.oneOf;
-      altUiSchemas = uiSchema?.oneOf;
+  function lookupFromFormContext(regOrFc, toLookup, fallback) {
+    const lookupPath = [LOOKUP_MAP_NAME];
+    if (has5(regOrFc, FORM_CONTEXT_NAME)) {
+      lookupPath.unshift(FORM_CONTEXT_NAME);
     }
-    return altSchemas && altSchemas.map((aSchemaDef, index) => {
-      const { title } = getUiOptions(altUiSchemas?.[index]);
-      const aSchema = aSchemaDef;
-      const value = toConstant(aSchema);
-      const label = title || aSchema.title || String(value);
-      return {
-        schema: aSchema,
-        label,
-        value
-      };
-    });
+    return get12(regOrFc, [...lookupPath, toLookup], fallback);
   }
 
   // src/orderProperties.ts
@@ -2308,7 +2950,7 @@
     return Object.keys(errorSchema).reduce((acc, key) => {
       if (key !== ERRORS_KEY) {
         const childSchema = errorSchema[key];
-        if (isPlainObject(childSchema)) {
+        if (isPlainObject4(childSchema)) {
           acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
         }
       }
@@ -2337,7 +2979,7 @@
         return acc;
       } else {
         const childSchema = errorHandler[key];
-        if (isPlainObject(childSchema)) {
+        if (isPlainObject4(childSchema)) {
           return {
             ...acc,
             [key]: unwrapErrorHandler(childSchema)
@@ -2370,7 +3012,7 @@
     const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
     let errors = toErrorList(additionalErrorSchema);
     let errorSchema = additionalErrorSchema;
-    if (!isEmpty(oldErrorSchema)) {
+    if (!isEmpty2(oldErrorSchema)) {
       errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
       errors = [...oldErrors].concat(errors);
     }
@@ -2398,16 +3040,33 @@
     if (Array.isArray(schemaNode)) {
       return withIdRefPrefixArray([...schemaNode]);
     }
-    if (isObject2(schemaNode)) {
+    if (isObject3(schemaNode)) {
       return withIdRefPrefixObject({ ...schemaNode });
     }
     return schemaNode;
   }
+  function getChangedFields(a, b) {
+    const aIsPlainObject = isPlainObject4(a);
+    const bIsPlainObject = isPlainObject4(b);
+    if (a === b || !aIsPlainObject && !bIsPlainObject) {
+      return [];
+    }
+    if (aIsPlainObject && !bIsPlainObject) {
+      return keys(a);
+    } else if (!aIsPlainObject && bIsPlainObject) {
+      return keys(b);
+    } else {
+      const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get12(b, key))));
+      const diffFields = difference(keys(b), keys(a));
+      return [...unequalFields, ...diffFields];
+    }
+  }
 
   // src/enums.ts
   var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
     TranslatableString2["ArrayItemTitle"] = "Item";
     TranslatableString2["MissingItems"] = "Missing items definition";
+    TranslatableString2["EmptyArray"] = "No items yet. Use the button below to add some.";
     TranslatableString2["YesLabel"] = "Yes";
     TranslatableString2["NoLabel"] = "No";
     TranslatableString2["CloseLabel"] = "Close";
@@ -2462,12 +3121,12 @@
      * @param hash - The hash value at which to map the schema
      */
     addSchema(schema, hash) {
-      const key = get8(schema, ID_KEY, hash);
+      const key = get12(schema, ID_KEY, hash);
       const identifiedSchema = { ...schema, [ID_KEY]: key };
       const existing = this.schemaMap[key];
       if (!existing) {
         this.schemaMap[key] = identifiedSchema;
-      } else if (!isEqual4(existing, identifiedSchema)) {
+      } else if (!deepEquals(existing, identifiedSchema)) {
         console.error("existing schema:", JSON.stringify(existing, null, 2));
         console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
         throw new Error(
@@ -2489,7 +3148,7 @@
      * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
      */
     isValid(schema, _formData, rootSchema) {
-      if (!isEqual4(rootSchema, this.rootSchema)) {
+      if (!deepEquals(rootSchema, this.rootSchema)) {
         throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
       }
       this.addSchema(schema, hashForSchema(schema));
@@ -2529,7 +3188,7 @@
   function parseSchema(validator, recurseList, rootSchema, schema) {
     const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
     schemas.forEach((schema2) => {
-      const sameSchemaIndex = recurseList.findIndex((item) => isEqual4(item, schema2));
+      const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema2));
       if (sameSchemaIndex === -1) {
         recurseList.push(schema2);
         const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);
@@ -2561,21 +3220,27 @@
   exports.DEFAULT_KEY = DEFAULT_KEY;
   exports.DEFINITIONS_KEY = DEFINITIONS_KEY;
   exports.DEPENDENCIES_KEY = DEPENDENCIES_KEY;
+  exports.DISCRIMINATOR_PATH = DISCRIMINATOR_PATH;
   exports.ENUM_KEY = ENUM_KEY;
   exports.ERRORS_KEY = ERRORS_KEY;
   exports.ErrorSchemaBuilder = ErrorSchemaBuilder;
+  exports.FORM_CONTEXT_NAME = FORM_CONTEXT_NAME;
   exports.ID_KEY = ID_KEY;
   exports.IF_KEY = IF_KEY;
   exports.ITEMS_KEY = ITEMS_KEY;
+  exports.JSON_SCHEMA_DRAFT_2020_12 = JSON_SCHEMA_DRAFT_2020_12;
   exports.JUNK_OPTION_ID = JUNK_OPTION_ID;
+  exports.LOOKUP_MAP_NAME = LOOKUP_MAP_NAME;
   exports.NAME_KEY = NAME_KEY;
   exports.ONE_OF_KEY = ONE_OF_KEY;
+  exports.PATTERN_PROPERTIES_KEY = PATTERN_PROPERTIES_KEY;
   exports.PROPERTIES_KEY = PROPERTIES_KEY;
+  exports.READONLY_KEY = READONLY_KEY;
   exports.REF_KEY = REF_KEY;
   exports.REQUIRED_KEY = REQUIRED_KEY;
   exports.RJSF_ADDITIONAL_PROPERTIES_FLAG = RJSF_ADDITIONAL_PROPERTIES_FLAG;
-  exports.RJSF_ADDITONAL_PROPERTIES_FLAG = RJSF_ADDITONAL_PROPERTIES_FLAG;
   exports.ROOT_SCHEMA_PREFIX = ROOT_SCHEMA_PREFIX;
+  exports.SCHEMA_KEY = SCHEMA_KEY;
   exports.SUBMIT_BTN_OPTIONS_KEY = SUBMIT_BTN_OPTIONS_KEY;
   exports.TranslatableString = TranslatableString;
   exports.UI_FIELD_KEY = UI_FIELD_KEY;
@@ -2585,6 +3250,7 @@
   exports.allowAdditionalItems = allowAdditionalItems;
   exports.ariaDescribedByIds = ariaDescribedByIds;
   exports.asNumber = asNumber;
+  exports.buttonId = buttonId;
   exports.canExpand = canExpand;
   exports.createErrorHandler = createErrorHandler;
   exports.createSchemaUtils = createSchemaUtils;
@@ -2600,24 +3266,30 @@
   exports.enumOptionsValueForIndex = enumOptionsValueForIndex;
   exports.errorId = errorId;
   exports.examplesId = examplesId;
+  exports.findFieldInSchema = findFieldInSchema;
   exports.findSchemaDefinition = findSchemaDefinition;
+  exports.findSelectedOptionInXxxOf = findSelectedOptionInXxxOf;
+  exports.getChangedFields = getChangedFields;
   exports.getClosestMatchingOption = getClosestMatchingOption;
   exports.getDateElementProps = getDateElementProps;
   exports.getDefaultFormState = getDefaultFormState;
   exports.getDiscriminatorFieldFromSchema = getDiscriminatorFieldFromSchema;
   exports.getDisplayLabel = getDisplayLabel;
   exports.getFirstMatchingOption = getFirstMatchingOption;
+  exports.getFromSchema = getFromSchema;
   exports.getInputProps = getInputProps;
-  exports.getMatchingOption = getMatchingOption;
   exports.getOptionMatchingSimpleDiscriminator = getOptionMatchingSimpleDiscriminator;
   exports.getSchemaType = getSchemaType;
   exports.getSubmitButtonOptions = getSubmitButtonOptions;
   exports.getTemplate = getTemplate;
+  exports.getTestIds = getTestIds;
   exports.getUiOptions = getUiOptions;
   exports.getWidget = getWidget;
   exports.guessType = guessType;
   exports.hasWidget = hasWidget;
   exports.hashForSchema = hashForSchema;
+  exports.hashObject = hashObject;
+  exports.hashString = hashString;
   exports.helpId = helpId;
   exports.isConstant = isConstant;
   exports.isCustomWidget = isCustomWidget;
@@ -2628,10 +3300,10 @@
   exports.isSelect = isSelect;
   exports.labelValue = labelValue;
   exports.localToUTC = localToUTC;
+  exports.lookupFromFormContext = lookupFromFormContext;
   exports.mergeDefaultsWithFormData = mergeDefaultsWithFormData;
   exports.mergeObjects = mergeObjects;
   exports.mergeSchemas = mergeSchemas;
-  exports.mergeValidationData = mergeValidationData;
   exports.optionId = optionId;
   exports.optionsList = optionsList;
   exports.orderProperties = orderProperties;
@@ -2644,6 +3316,7 @@
   exports.schemaParser = schemaParser;
   exports.schemaRequiresTrueValue = schemaRequiresTrueValue;
   exports.shouldRender = shouldRender;
+  exports.sortedJSONStringify = sortedJSONStringify;
   exports.titleId = titleId;
   exports.toConstant = toConstant;
   exports.toDateString = toDateString;