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

package/dist/index.js

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   ADDITIONAL_PROPERTIES_KEY: () => ADDITIONAL_PROPERTIES_KEY,
   ADDITIONAL_PROPERTY_FLAG: () => ADDITIONAL_PROPERTY_FLAG,
   ALL_OF_KEY: () => ALL_OF_KEY,
@@ -38,20 +38,24 @@ __export(src_exports, {
   DEFAULT_KEY: () => DEFAULT_KEY,
   DEFINITIONS_KEY: () => DEFINITIONS_KEY,
   DEPENDENCIES_KEY: () => DEPENDENCIES_KEY,
+  DISCRIMINATOR_PATH: () => DISCRIMINATOR_PATH,
   ENUM_KEY: () => ENUM_KEY,
   ERRORS_KEY: () => ERRORS_KEY,
   ErrorSchemaBuilder: () => ErrorSchemaBuilder,
+  FORM_CONTEXT_NAME: () => FORM_CONTEXT_NAME,
   ID_KEY: () => ID_KEY,
   IF_KEY: () => IF_KEY,
   ITEMS_KEY: () => ITEMS_KEY,
   JUNK_OPTION_ID: () => JUNK_OPTION_ID,
+  LOOKUP_MAP_NAME: () => LOOKUP_MAP_NAME,
   NAME_KEY: () => NAME_KEY,
   ONE_OF_KEY: () => ONE_OF_KEY,
+  PATTERN_PROPERTIES_KEY: () => PATTERN_PROPERTIES_KEY,
   PROPERTIES_KEY: () => PROPERTIES_KEY,
+  READONLY_KEY: () => READONLY_KEY,
   REF_KEY: () => REF_KEY,
   REQUIRED_KEY: () => REQUIRED_KEY,
   RJSF_ADDITIONAL_PROPERTIES_FLAG: () => RJSF_ADDITIONAL_PROPERTIES_FLAG,
-  RJSF_ADDITONAL_PROPERTIES_FLAG: () => RJSF_ADDITONAL_PROPERTIES_FLAG,
   ROOT_SCHEMA_PREFIX: () => ROOT_SCHEMA_PREFIX,
   SUBMIT_BTN_OPTIONS_KEY: () => SUBMIT_BTN_OPTIONS_KEY,
   TranslatableString: () => TranslatableString,
@@ -62,6 +66,7 @@ __export(src_exports, {
   allowAdditionalItems: () => allowAdditionalItems,
   ariaDescribedByIds: () => ariaDescribedByIds,
   asNumber: () => asNumber,
+  buttonId: () => buttonId,
   canExpand: () => canExpand,
   createErrorHandler: () => createErrorHandler,
   createSchemaUtils: () => createSchemaUtils,
@@ -77,24 +82,30 @@ __export(src_exports, {
   enumOptionsValueForIndex: () => enumOptionsValueForIndex,
   errorId: () => errorId,
   examplesId: () => examplesId,
+  findFieldInSchema: () => findFieldInSchema,
   findSchemaDefinition: () => findSchemaDefinition,
+  findSelectedOptionInXxxOf: () => findSelectedOptionInXxxOf,
+  getChangedFields: () => getChangedFields,
   getClosestMatchingOption: () => getClosestMatchingOption,
   getDateElementProps: () => getDateElementProps,
   getDefaultFormState: () => getDefaultFormState,
   getDiscriminatorFieldFromSchema: () => getDiscriminatorFieldFromSchema,
   getDisplayLabel: () => getDisplayLabel,
   getFirstMatchingOption: () => getFirstMatchingOption,
+  getFromSchema: () => getFromSchema,
   getInputProps: () => getInputProps,
-  getMatchingOption: () => getMatchingOption,
   getOptionMatchingSimpleDiscriminator: () => getOptionMatchingSimpleDiscriminator,
   getSchemaType: () => getSchemaType,
   getSubmitButtonOptions: () => getSubmitButtonOptions,
   getTemplate: () => getTemplate,
+  getTestIds: () => getTestIds,
   getUiOptions: () => getUiOptions,
   getWidget: () => getWidget,
   guessType: () => guessType,
   hasWidget: () => hasWidget,
   hashForSchema: () => hashForSchema,
+  hashObject: () => hashObject,
+  hashString: () => hashString,
   helpId: () => helpId,
   isConstant: () => isConstant,
   isCustomWidget: () => isCustomWidget,
@@ -105,10 +116,10 @@ __export(src_exports, {
   isSelect: () => isSelect,
   labelValue: () => labelValue,
   localToUTC: () => localToUTC,
+  lookupFromFormContext: () => lookupFromFormContext,
   mergeDefaultsWithFormData: () => mergeDefaultsWithFormData,
   mergeObjects: () => mergeObjects,
   mergeSchemas: () => mergeSchemas,
-  mergeValidationData: () => mergeValidationData,
   optionId: () => optionId,
   optionsList: () => optionsList,
   orderProperties: () => orderProperties,
@@ -121,6 +132,7 @@ __export(src_exports, {
   schemaParser: () => schemaParser,
   schemaRequiresTrueValue: () => schemaRequiresTrueValue,
   shouldRender: () => shouldRender,
+  sortedJSONStringify: () => sortedJSONStringify,
   titleId: () => titleId,
   toConstant: () => toConstant,
   toDateString: () => toDateString,
@@ -133,17 +145,20 @@ __export(src_exports, {
   validationDataMerge: () => validationDataMerge,
   withIdRefPrefix: () => withIdRefPrefix
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // 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
@@ -193,11 +208,15 @@ var ITEMS_KEY = "items";
 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 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";
@@ -225,7 +244,7 @@ function getUiOptions(uiSchema = {}, globalOptions = {}) {
 
 // src/canExpand.ts
 function canExpand(schema, uiSchema = {}, formData) {
-  if (!schema.additionalProperties) {
+  if (!(schema.additionalProperties || schema.patternProperties)) {
     return false;
   }
   const { expandable = true } = getUiOptions(uiSchema);
@@ -239,7 +258,7 @@ function canExpand(schema, uiSchema = {}, formData) {
 }
 
 // src/createErrorHandler.ts
-var import_isPlainObject = __toESM(require("lodash/isPlainObject"));
+var import_isPlainObject = __toESM(require("lodash/isPlainObject"), 1);
 function createErrorHandler(formData) {
   const handler = {
     // We store the list of errors for this node in a property named __errors
@@ -265,7 +284,7 @@ function createErrorHandler(formData) {
 }
 
 // src/deepEquals.ts
-var import_isEqualWith = __toESM(require("lodash/isEqualWith"));
+var import_isEqualWith = __toESM(require("lodash/isEqualWith"), 1);
 function deepEquals(a, b) {
   return (0, import_isEqualWith.default)(a, b, (obj, other) => {
     if (typeof obj === "function" && typeof other === "function") {
@@ -275,13 +294,27 @@ function deepEquals(a, b) {
   });
 }
 
-// src/schema/getDefaultFormState.ts
-var import_get7 = __toESM(require("lodash/get"));
-var import_isEmpty = __toESM(require("lodash/isEmpty"));
+// src/schema/findFieldInSchema.ts
+var import_get7 = __toESM(require("lodash/get"), 1);
+var import_has3 = __toESM(require("lodash/has"), 1);
+
+// src/schema/findSelectedOptionInXxxOf.ts
+var import_get5 = __toESM(require("lodash/get"), 1);
+var import_isEqual = __toESM(require("lodash/isEqual"), 1);
+
+// src/schema/retrieveSchema.ts
+var import_get4 = __toESM(require("lodash/get"), 1);
+var import_set = __toESM(require("lodash/set"), 1);
+var import_times = __toESM(require("lodash/times"), 1);
+var import_transform = __toESM(require("lodash/transform"), 1);
+var import_merge = __toESM(require("lodash/merge"), 1);
+var import_flattenDeep = __toESM(require("lodash/flattenDeep"), 1);
+var import_uniq = __toESM(require("lodash/uniq"), 1);
+var import_json_schema_merge_allof = __toESM(require("json-schema-merge-allof"), 1);
 
 // src/findSchemaDefinition.ts
-var import_jsonpointer = __toESM(require("jsonpointer"));
-var import_omit = __toESM(require("lodash/omit"));
+var import_jsonpointer = __toESM(require("jsonpointer"), 1);
+var import_omit = __toESM(require("lodash/omit"), 1);
 function splitKeyElementFromObject(key, object) {
   const value = object[key];
   const remaining = (0, import_omit.default)(object, [key]);
@@ -323,114 +356,12 @@ function findSchemaDefinition($ref, rootSchema = {}) {
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList);
 }
 
-// src/schema/getClosestMatchingOption.ts
-var import_get5 = __toESM(require("lodash/get"));
-var import_has2 = __toESM(require("lodash/has"));
-var import_isNumber2 = __toESM(require("lodash/isNumber"));
-var import_isObject5 = __toESM(require("lodash/isObject"));
-var import_isString2 = __toESM(require("lodash/isString"));
-var import_reduce = __toESM(require("lodash/reduce"));
-var import_times2 = __toESM(require("lodash/times"));
-
-// src/schema/getMatchingOption.ts
-var import_get2 = __toESM(require("lodash/get"));
-var import_has = __toESM(require("lodash/has"));
-var import_isNumber = __toESM(require("lodash/isNumber"));
-
-// src/getOptionMatchingSimpleDiscriminator.ts
-var import_get = __toESM(require("lodash/get"));
-function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
-  if (formData && discriminatorField) {
-    const value = (0, import_get.default)(formData, discriminatorField);
-    if (value === void 0) {
-      return;
-    }
-    for (let i = 0; i < options.length; i++) {
-      const option = options[i];
-      const discriminator = (0, import_get.default)(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 ((0, import_isNumber.default)(simpleDiscriminatorMatch)) {
-    return simpleDiscriminatorMatch;
-  }
-  for (let i = 0; i < options.length; i++) {
-    const option = options[i];
-    if (discriminatorField && (0, import_has.default)(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = (0, import_get2.default)(formData, discriminatorField);
-      const discriminator = (0, import_get2.default)(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);
-}
-
-// src/schema/retrieveSchema.ts
-var import_get4 = __toESM(require("lodash/get"));
-var import_isEqual = __toESM(require("lodash/isEqual"));
-var import_set = __toESM(require("lodash/set"));
-var import_times = __toESM(require("lodash/times"));
-var import_transform = __toESM(require("lodash/transform"));
-var import_merge = __toESM(require("lodash/merge"));
-var import_flattenDeep = __toESM(require("lodash/flattenDeep"));
-var import_uniq = __toESM(require("lodash/uniq"));
-var import_json_schema_merge_allof = __toESM(require("json-schema-merge-allof"));
-
 // src/getDiscriminatorFieldFromSchema.ts
-var import_get3 = __toESM(require("lodash/get"));
-var import_isString = __toESM(require("lodash/isString"));
+var import_get = __toESM(require("lodash/get"), 1);
+var import_isString = __toESM(require("lodash/isString"), 1);
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = (0, import_get3.default)(schema, "discriminator.propertyName", void 0);
+  const maybeString = (0, import_get.default)(schema, DISCRIMINATOR_PATH);
   if ((0, import_isString.default)(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== void 0) {
@@ -463,7 +394,7 @@ function guessType(value) {
 }
 
 // src/mergeSchemas.ts
-var import_union = __toESM(require("lodash/union"));
+var import_union = __toESM(require("lodash/union"), 1);
 
 // src/getSchemaType.ts
 function getSchemaType(schema) {
@@ -474,7 +405,7 @@ function getSchemaType(schema) {
   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)) {
@@ -503,11 +434,97 @@ function mergeSchemas(obj1, obj2) {
   }, acc);
 }
 
+// src/schema/getFirstMatchingOption.ts
+var import_get3 = __toESM(require("lodash/get"), 1);
+var import_has = __toESM(require("lodash/has"), 1);
+var import_isNumber = __toESM(require("lodash/isNumber"), 1);
+
+// src/getOptionMatchingSimpleDiscriminator.ts
+var import_get2 = __toESM(require("lodash/get"), 1);
+function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
+  if (formData && discriminatorField) {
+    const value = (0, import_get2.default)(formData, discriminatorField);
+    if (value === void 0) {
+      return;
+    }
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
+      const discriminator = (0, import_get2.default)(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/getFirstMatchingOption.ts
+function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
+  if (formData === void 0) {
+    return 0;
+  }
+  const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
+  if ((0, import_isNumber.default)(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
+  for (let i = 0; i < options.length; i++) {
+    const option = options[i];
+    if (discriminatorField && (0, import_has.default)(option, [PROPERTIES_KEY, discriminatorField])) {
+      const value = (0, import_get3.default)(formData, discriminatorField);
+      const discriminator = (0, import_get3.default)(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/retrieveSchema.ts
-function retrieveSchema(validator, schema, rootSchema = {}, rawFormData) {
-  return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
+var import_isEmpty = __toESM(require("lodash/isEmpty"), 1);
+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) {
+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];
@@ -515,12 +532,28 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recu
   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 {
@@ -533,7 +566,8 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recu
           rootSchema,
           formData,
           expandAllBranches,
-          recurseList
+          recurseList,
+          experimental_customMergeAllOf
         )
       );
     }
@@ -542,7 +576,15 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recu
     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) {
@@ -559,7 +601,16 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   );
   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) => {
+      (0, import_set.default)(obj, [pattern], schema.patternProperties[pattern]);
+      return obj;
+    },
+    {}
+  );
+}
+function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
   const updatedSchemas = resolveReference(
     validator,
     schema,
@@ -581,7 +632,15 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       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)) {
@@ -592,15 +651,19 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
         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(
@@ -609,7 +672,8 @@ function resolveReference(validator, schema, rootSchema, expandAllBranches, recu
       rootSchema,
       formData,
       expandAllBranches,
-      recurseList
+      recurseList,
+      experimental_customMergeAllOf
     );
   }
   return [schema];
@@ -648,9 +712,9 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
       items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
     };
   }
-  return (0, import_isEqual.default)(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 }
@@ -660,34 +724,54 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
     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 (!(0, import_isEmpty.default)(matchingProperties)) {
+        schema.properties[key] = retrieveSchema(
           validator,
-          { $ref: (0, import_get4.default)(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
-        };
+        (0, import_set.default)(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: (0, import_get4.default)(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((0, import_get4.default)(formData, [key])) };
+        }
       } else {
         additionalProperties = { type: guessType((0, import_get4.default)(formData, [key])) };
       }
+      schema.properties[key] = additionalProperties;
+      (0, import_set.default)(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     } else {
-      additionalProperties = { type: guessType((0, import_get4.default)(formData, [key])) };
+      schema.properties[key] = { type: "null" };
+      (0, import_set.default)(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     }
-    schema.properties[key] = additionalProperties;
-    (0, import_set.default)(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 [{}];
   }
@@ -697,7 +781,8 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     rootSchema,
     expandAllBranches,
     recurseList,
-    rawFormData
+    rawFormData,
+    experimental_customMergeAllOf
   );
   return resolvedSchemas.flatMap((s) => {
     let resolvedSchema = s;
@@ -708,7 +793,8 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
         rootSchema,
         expandAllBranches,
         recurseList,
-        rawFormData
+        rawFormData,
+        experimental_customMergeAllOf
       );
     }
     if (ALL_OF_KEY in resolvedSchema) {
@@ -717,18 +803,60 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
         return [...allOf, restOfSchema];
       }
       try {
-        resolvedSchema = (0, import_json_schema_merge_allof.default)(resolvedSchema, {
+        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) : (0, import_json_schema_merge_allof.default)(resolvedSchema, {
           deep: false
         });
+        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 (!(0, import_isEmpty.default)(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;
   });
@@ -755,7 +883,7 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
   }
   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,
@@ -772,11 +900,12 @@ function resolveDependencies(validator, schema, rootSchema, expandAllBranches, r
       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 && (0, import_get4.default)(formData, [dependencyKey]) === void 0) {
@@ -800,7 +929,8 @@ function processDependencies(validator, dependencies, resolvedSchema, rootSchema
         dependencyValue,
         expandAllBranches,
         recurseList,
-        formData
+        formData,
+        experimental_customMergeAllOf
       );
     }
     return schemas.flatMap(
@@ -811,7 +941,8 @@ function processDependencies(validator, dependencies, resolvedSchema, rootSchema
         rootSchema,
         expandAllBranches,
         recurseList,
-        formData
+        formData,
+        experimental_customMergeAllOf
       )
     );
   }
@@ -824,14 +955,15 @@ function withDependentProperties(schema, additionallyRequired) {
   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;
@@ -855,12 +987,13 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
         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;
@@ -891,13 +1024,166 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
       rootSchema,
       formData,
       expandAllBranches,
-      recurseList
+      recurseList,
+      experimental_customMergeAllOf
     );
     return schemas.map((s2) => mergeSchemas(schema, s2));
   });
 }
 
+// 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 = (0, import_get5.default)(formData, selectorField);
+    if (data !== void 0) {
+      return xxxOfs.find((xxx2) => {
+        return (0, import_isEqual.default)(
+          (0, import_get5.default)(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], (0, import_get5.default)(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+          data
+        );
+      });
+    }
+  }
+  return void 0;
+}
+
+// src/schema/getFromSchema.ts
+var import_get6 = __toESM(require("lodash/get"), 1);
+var import_has2 = __toESM(require("lodash/has"), 1);
+var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
+function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
+  let fieldSchema = schema;
+  if ((0, import_has2.default)(schema, REF_KEY)) {
+    fieldSchema = retrieveSchema(validator, schema, rootSchema, void 0, experimental_customMergeAllOf);
+  }
+  if ((0, import_isEmpty2.default)(path)) {
+    return fieldSchema;
+  }
+  const pathList = Array.isArray(path) ? path : path.split(".");
+  const [part, ...nestedPath] = pathList;
+  if (part && (0, import_has2.default)(fieldSchema, part)) {
+    fieldSchema = (0, import_get6.default)(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 ((0, import_has3.default)(parentField, ONE_OF_KEY)) {
+        parentField = findSelectedOptionInXxxOf(
+          validator,
+          rootSchema,
+          parentField,
+          fieldName,
+          ONE_OF_KEY,
+          (0, import_get7.default)(formData, subPath),
+          experimental_customMergeAllOf
+        );
+      } else if ((0, import_has3.default)(parentField, ANY_OF_KEY)) {
+        parentField = findSelectedOptionInXxxOf(
+          validator,
+          rootSchema,
+          parentField,
+          fieldName,
+          ANY_OF_KEY,
+          (0, import_get7.default)(formData, subPath),
+          experimental_customMergeAllOf
+        );
+      }
+    });
+  }
+  if ((0, import_has3.default)(parentField, ONE_OF_KEY)) {
+    parentField = findSelectedOptionInXxxOf(
+      validator,
+      rootSchema,
+      parentField,
+      fieldName,
+      ONE_OF_KEY,
+      formData,
+      experimental_customMergeAllOf
+    );
+  } else if ((0, import_has3.default)(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 };
+}
+
+// src/schema/getDefaultFormState.ts
+var import_get11 = __toESM(require("lodash/get"), 1);
+var import_isEmpty3 = __toESM(require("lodash/isEmpty"), 1);
+
 // src/schema/getClosestMatchingOption.ts
+var import_get8 = __toESM(require("lodash/get"), 1);
+var import_has4 = __toESM(require("lodash/has"), 1);
+var import_isNumber2 = __toESM(require("lodash/isNumber"), 1);
+var import_isObject5 = __toESM(require("lodash/isObject"), 1);
+var import_isString2 = __toESM(require("lodash/isString"), 1);
+var import_reduce = __toESM(require("lodash/reduce"), 1);
+var import_times2 = __toESM(require("lodash/times"), 1);
 var JUNK_OPTION = {
   type: "object",
   $id: JUNK_OPTION_ID,
@@ -907,35 +1193,51 @@ var JUNK_OPTION = {
     }
   }
 };
-function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
+function calculateIndexScore(validator, rootSchema, schema, formData, experimental_customMergeAllOf) {
   let totalScore = 0;
   if (schema) {
     if ((0, import_isObject5.default)(schema.properties)) {
       totalScore += (0, import_reduce.default)(
         schema.properties,
         (score, value, key) => {
-          const formValue = (0, import_get5.default)(formData, key);
+          const formValue = (0, import_get8.default)(formData, key);
           if (typeof value === "boolean") {
             return score;
           }
-          if ((0, import_has2.default)(value, REF_KEY)) {
-            const newSchema = retrieveSchema(validator, value, rootSchema, formValue);
-            return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
+          if ((0, import_has4.default)(value, REF_KEY)) {
+            const newSchema = retrieveSchema(
+              validator,
+              value,
+              rootSchema,
+              formValue,
+              experimental_customMergeAllOf
+            );
+            return score + calculateIndexScore(
+              validator,
+              rootSchema,
+              newSchema,
+              formValue || {},
+              experimental_customMergeAllOf
+            );
           }
-          if (((0, import_has2.default)(value, ONE_OF_KEY) || (0, import_has2.default)(value, ANY_OF_KEY)) && formValue) {
-            const key2 = (0, import_has2.default)(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+          if (((0, import_has4.default)(value, ONE_OF_KEY) || (0, import_has4.default)(value, ANY_OF_KEY)) && formValue) {
+            const key2 = (0, import_has4.default)(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
             const discriminator = getDiscriminatorFieldFromSchema(value);
             return score + getClosestMatchingOption(
               validator,
               rootSchema,
               formValue,
-              (0, import_get5.default)(value, key2),
+              (0, import_get8.default)(value, key2),
               -1,
-              discriminator
+              discriminator,
+              experimental_customMergeAllOf
             );
           }
           if (value.type === "object") {
-            return score + calculateIndexScore(validator, rootSchema, value, formValue || {});
+            if ((0, import_isObject5.default)(formValue)) {
+              score += 1;
+            }
+            return score + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
           }
           if (value.type === guessType(formValue)) {
             let newScore = score + 1;
@@ -956,7 +1258,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
   }
   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, []);
   });
@@ -983,7 +1285,7 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
     (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 };
@@ -1004,57 +1306,79 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-var import_get6 = __toESM(require("lodash/get"));
-function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) {
+var import_get9 = __toESM(require("lodash/get"), 1);
+var import_isNil = __toESM(require("lodash/isNil"), 1);
+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 = (0, import_get9.default)(formData, key);
+      const keyExistsInDefaults = isObject(defaults) && key in defaults;
+      const keyExistsInFormData = key in formData;
       acc2[key] = mergeDefaultsWithFormData(
-        defaults ? (0, import_get6.default)(defaults, key) : {},
-        (0, import_get6.default)(formData, key),
-        mergeExtraArrayDefaults
+        defaults ? (0, import_get9.default)(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 && (!(0, import_isNil.default)(defaults) && (0, import_isNil.default)(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(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
@@ -1063,8 +1387,8 @@ function isConstant(schema) {
 }
 
 // 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;
@@ -1076,14 +1400,85 @@ function isSelect(validator, theSchema, rootSchema = {}) {
 }
 
 // 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);
+}
+
+// src/constIsAjvDataReference.ts
+var import_isString3 = __toESM(require("lodash/isString"), 1);
+function constIsAjvDataReference(schema) {
+  const schemaConst = schema[CONST_KEY];
+  const schemaType = getSchemaType(schema);
+  return isObject(schemaConst) && (0, import_isString3.default)(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+}
+
+// src/optionsList.ts
+var import_get10 = __toESM(require("lodash/get"), 1);
+
+// 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 = (0, import_get10.default)(aSchema, [PROPERTIES_KEY, selectorField], {});
+      value = (0, import_get10.default)(innerSchema, DEFAULT_KEY, (0, import_get10.default)(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) {
@@ -1100,47 +1495,54 @@ function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, id
   }
   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 (!(0, import_isEmpty.default)(computedDefault)) {
+        if (!(0, import_isEmpty3.default)(computedDefault)) {
           obj[key] = computedDefault;
         }
-      } else if ((!(0, import_isEmpty.default)(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
+      } else if ((!(0, import_isEmpty3.default)(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]) {
     defaults = schema.default;
   } else if (REF_KEY in schema) {
     const refName = schema[REF_KEY];
@@ -1149,7 +1551,19 @@ function computeDefaults(validator, rawSchema, {
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
   } 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(
@@ -1158,9 +1572,11 @@ function computeDefaults(validator, rawSchema, {
         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) {
@@ -1169,13 +1585,21 @@ function computeDefaults(validator, rawSchema, {
       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,
-      (0, import_isEmpty.default)(formData) ? void 0 : formData,
+      rawFormData ?? schema.default,
       oneOf,
       0,
-      discriminator
+      discriminator,
+      experimental_customMergeAllOf
     )];
     schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   } else if (ANY_OF_KEY in schema) {
@@ -1187,10 +1611,11 @@ function computeDefaults(validator, rawSchema, {
     schemaToCompute = anyOf[getClosestMatchingOption(
       validator,
       rootSchema,
-      (0, import_isEmpty.default)(formData) ? void 0 : formData,
+      rawFormData ?? schema.default,
       anyOf,
       0,
-      discriminator
+      discriminator,
+      experimental_customMergeAllOf
     )];
     schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   }
@@ -1199,159 +1624,257 @@ function computeDefaults(validator, rawSchema, {
       rootSchema,
       includeUndefinedValues,
       _recurseList: updatedRecurseList,
-      experimental_defaultFormStateBehavior,
+      experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
+      experimental_customMergeAllOf,
       parentDefaults: defaults,
       rawFormData: formData,
-      required
+      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 = (0, import_get11.default)(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: (0, import_get11.default)(defaults, [key]),
+          rawFormData: (0, import_get11.default)(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: (0, import_get11.default)(defaults, [key]),
+          rawFormData: (0, import_get11.default)(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 (defaults === void 0) {
-    defaults = schema.default;
+  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: (0, import_get11.default)(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;
   }
-  switch (getSchemaType(schema)) {
+  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,
+      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, (0, import_get7.default)(retrievedSchema, [PROPERTIES_KEY, key]), {
-            rootSchema,
-            _recurseList,
-            experimental_defaultFormStateBehavior,
-            includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: (0, import_get7.default)(defaults, [key]),
-            rawFormData: (0, import_get7.default)(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: (0, import_get7.default)(defaults, [key]),
-            rawFormData: (0, import_get7.default)(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: (0, import_get7.default)(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
@@ -1364,25 +1887,31 @@ function isCustomWidget(uiSchema = {}) {
 }
 
 // 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;
@@ -1396,54 +1925,50 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   return displayLabel;
 }
 
-// src/schema/mergeValidationData.ts
-var import_isEmpty2 = __toESM(require("lodash/isEmpty"));
-function mergeValidationData(validator, validationData, additionalErrorSchema) {
-  if (!additionalErrorSchema) {
-    return validationData;
-  }
-  const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
-  let errors = validator.toErrorList(additionalErrorSchema);
-  let errorSchema = additionalErrorSchema;
-  if (!(0, import_isEmpty2.default)(oldErrorSchema)) {
-    errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-    errors = [...oldErrors].concat(errors);
-  }
-  return { errorSchema, errors };
-}
-
 // src/schema/sanitizeDataForNewSchema.ts
-var import_get8 = __toESM(require("lodash/get"));
-var import_has3 = __toESM(require("lodash/has"));
+var import_get12 = __toESM(require("lodash/get"), 1);
+var import_has5 = __toESM(require("lodash/has"), 1);
 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 ((0, import_has3.default)(newSchema, PROPERTIES_KEY)) {
+  if ((0, import_has5.default)(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
-    if ((0, import_has3.default)(oldSchema, PROPERTIES_KEY)) {
-      const properties = (0, import_get8.default)(oldSchema, PROPERTIES_KEY, {});
+    if ((0, import_has5.default)(oldSchema, PROPERTIES_KEY)) {
+      const properties = (0, import_get12.default)(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
-        if ((0, import_has3.default)(data, key)) {
+        if ((0, import_has5.default)(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys = Object.keys((0, import_get8.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys((0, import_get12.default)(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
-    keys.forEach((key) => {
-      const formValue = (0, import_get8.default)(data, key);
-      let oldKeyedSchema = (0, import_get8.default)(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = (0, import_get8.default)(newSchema, [PROPERTIES_KEY, key], {});
-      if ((0, import_has3.default)(oldKeyedSchema, REF_KEY)) {
-        oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
+    keys2.forEach((key) => {
+      const formValue = (0, import_get12.default)(data, key);
+      let oldKeyedSchema = (0, import_get12.default)(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = (0, import_get12.default)(newSchema, [PROPERTIES_KEY, key], {});
+      if ((0, import_has5.default)(oldKeyedSchema, REF_KEY)) {
+        oldKeyedSchema = retrieveSchema(
+          validator,
+          oldKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf
+        );
       }
-      if ((0, import_has3.default)(newKeyedSchema, REF_KEY)) {
-        newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
+      if ((0, import_has5.default)(newKeyedSchema, REF_KEY)) {
+        newKeyedSchema = retrieveSchema(
+          validator,
+          newKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf
+        );
       }
-      const oldSchemaTypeForKey = (0, import_get8.default)(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = (0, import_get8.default)(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = (0, import_get12.default)(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = (0, import_get12.default)(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-        if ((0, import_has3.default)(removeOldSchemaData, key)) {
+        if ((0, import_has5.default)(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
         }
         if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
@@ -1452,23 +1977,24 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             rootSchema,
             newKeyedSchema,
             oldKeyedSchema,
-            formValue
+            formValue,
+            experimental_customMergeAllOf
           );
           if (itemData !== void 0 || newSchemaTypeForKey === "array") {
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = (0, import_get8.default)(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = (0, import_get8.default)(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = (0, import_get12.default)(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = (0, import_get12.default)(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if ((0, import_get8.default)(newKeyedSchema, "readOnly") === true) {
+            } else if ((0, import_get12.default)(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = (0, import_get8.default)(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = (0, import_get8.default)(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = (0, import_get12.default)(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = (0, import_get12.default)(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -1480,20 +2006,32 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if ((0, import_get8.default)(oldSchema, "type") === "array" && (0, import_get8.default)(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = (0, import_get8.default)(oldSchema, "items");
-    let newSchemaItems = (0, import_get8.default)(newSchema, "items");
+  } else if ((0, import_get12.default)(oldSchema, "type") === "array" && (0, import_get12.default)(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = (0, import_get12.default)(oldSchema, "items");
+    let newSchemaItems = (0, import_get12.default)(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
-      if ((0, import_has3.default)(oldSchemaItems, REF_KEY)) {
-        oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
+      if ((0, import_has5.default)(oldSchemaItems, REF_KEY)) {
+        oldSchemaItems = retrieveSchema(
+          validator,
+          oldSchemaItems,
+          rootSchema,
+          data,
+          experimental_customMergeAllOf
+        );
       }
-      if ((0, import_has3.default)(newSchemaItems, REF_KEY)) {
-        newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
+      if ((0, import_has5.default)(newSchemaItems, REF_KEY)) {
+        newSchemaItems = retrieveSchema(
+          validator,
+          newSchemaItems,
+          rootSchema,
+          data,
+          experimental_customMergeAllOf
+        );
       }
-      const oldSchemaType = (0, import_get8.default)(oldSchemaItems, "type");
-      const newSchemaType = (0, import_get8.default)(newSchemaItems, "type");
+      const oldSchemaType = (0, import_get12.default)(oldSchemaItems, "type");
+      const newSchemaType = (0, import_get12.default)(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = (0, import_get8.default)(newSchema, "maxItems", -1);
+        const maxItems = (0, import_get12.default)(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -1501,7 +2039,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
               rootSchema,
               newSchemaItems,
               oldSchemaItems,
-              aValue
+              aValue,
+              experimental_customMergeAllOf
             );
             if (itemValue !== void 0 && (maxItems < 0 || newValue.length < maxItems)) {
               newValue.push(itemValue);
@@ -1520,71 +2059,84 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toIdSchema.ts
-var import_get9 = __toESM(require("lodash/get"));
-var import_isEqual2 = __toESM(require("lodash/isEqual"));
-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) => (0, import_isEqual2.default)(item, _schema));
-    if (sameSchemaIndex === -1) {
+var import_get13 = __toESM(require("lodash/get"), 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 && !(0, import_get13.default)(schema, [ITEMS_KEY, REF_KEY])) {
       return toIdSchemaInternal(
         validator,
-        _schema,
+        (0, import_get13.default)(schema, ITEMS_KEY),
         idPrefix,
         idSeparator,
         id,
         rootSchema,
         formData,
-        _recurseList.concat(_schema)
+        _recurseList,
+        experimental_customMergeAllOf
       );
     }
-  }
-  if (ITEMS_KEY in schema && !(0, import_get9.default)(schema, [ITEMS_KEY, REF_KEY])) {
-    return toIdSchemaInternal(
-      validator,
-      (0, import_get9.default)(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 = (0, import_get9.default)(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
-        (0, import_get9.default)(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
+          (0, import_get13.default)(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
+  );
 }
 
 // src/schema/toPathSchema.ts
-var import_get10 = __toESM(require("lodash/get"));
-var import_isEqual3 = __toESM(require("lodash/isEqual"));
-var import_set2 = __toESM(require("lodash/set"));
-function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
+var import_get14 = __toESM(require("lodash/get"), 1);
+var import_set2 = __toESM(require("lodash/set"), 1);
+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) => (0, import_isEqual3.default)(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,
@@ -1592,7 +2144,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         name,
         rootSchema,
         formData,
-        _recurseList.concat(_schema)
+        _recurseList.concat(_schema),
+        experimental_customMergeAllOf
       );
     }
   }
@@ -1602,11 +2155,27 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
   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) {
@@ -1623,7 +2192,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf
           );
         } else if (schemaAdditionalItems) {
           pathSchema[i] = toPathSchemaInternal(
@@ -1632,7 +2202,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf
           );
         } else {
           console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
@@ -1646,13 +2217,14 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
           `${name}.${i}`,
           rootSchema,
           element,
-          _recurseList
+          _recurseList,
+          experimental_customMergeAllOf
         );
       });
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = (0, import_get10.default)(schema, [PROPERTIES_KEY, property]);
+      const field = (0, import_get14.default)(schema, [PROPERTIES_KEY, property], {});
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -1660,15 +2232,16 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         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
-        (0, import_get10.default)(formData, [property]),
-        _recurseList
+        (0, import_get14.default)(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
@@ -1678,11 +2251,13 @@ var SchemaUtils = class {
    * @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`
    *
@@ -1698,13 +2273,55 @@ var SchemaUtils = class {
    * @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`.
@@ -1723,7 +2340,8 @@ var SchemaUtils = class {
       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`
@@ -1735,7 +2353,14 @@ var SchemaUtils = class {
    * @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.
@@ -1757,7 +2382,8 @@ var SchemaUtils = class {
       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.
@@ -1772,18 +2398,16 @@ var SchemaUtils = class {
   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
    *
@@ -1792,7 +2416,7 @@ var SchemaUtils = class {
    * @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
    *
@@ -1800,7 +2424,7 @@ var SchemaUtils = class {
    * @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
    *
@@ -1808,21 +2432,7 @@ var SchemaUtils = class {
    * @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
@@ -1833,7 +2443,13 @@ var SchemaUtils = class {
    * @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
@@ -1847,7 +2463,14 @@ var SchemaUtils = class {
    *      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
    *
@@ -1859,7 +2482,16 @@ var SchemaUtils = class {
    * @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
    *
@@ -1869,11 +2501,23 @@ var SchemaUtils = class {
    * @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
@@ -1955,9 +2599,6 @@ function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
-// src/enumOptionsDeselectValue.ts
-var import_isEqual4 = __toESM(require("lodash/isEqual"));
-
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
@@ -1972,18 +2613,17 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !(0, import_isEqual4.default)(v, value));
+    return selected.filter((v) => !deepEquals(v, value));
   }
-  return (0, import_isEqual4.default)(value, selected) ? void 0 : selected;
+  return deepEquals(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
-var import_isEqual5 = __toESM(require("lodash/isEqual"));
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => (0, import_isEqual5.default)(sel, value));
+    return selected.some((sel) => deepEquals(sel, value));
   }
-  return (0, import_isEqual5.default)(selected, value);
+  return deepEquals(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -1996,10 +2636,10 @@ function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false)
 }
 
 // src/enumOptionsSelectValue.ts
-var import_isNil = __toESM(require("lodash/isNil"));
+var import_isNil2 = __toESM(require("lodash/isNil"), 1);
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!(0, import_isNil.default)(value)) {
+  if (!(0, import_isNil2.default)(value)) {
     const index = allEnumOptions.findIndex((opt) => value === opt.value);
     const all = allEnumOptions.map(({ value: val }) => val);
     const updated = selected.slice(0, index).concat(value, selected.slice(index));
@@ -2009,9 +2649,10 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 }
 
 // src/ErrorSchemaBuilder.ts
-var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
-var import_get11 = __toESM(require("lodash/get"));
-var import_set3 = __toESM(require("lodash/set"));
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
+var import_get15 = __toESM(require("lodash/get"), 1);
+var import_set3 = __toESM(require("lodash/set"), 1);
+var import_setWith = __toESM(require("lodash/setWith"), 1);
 var ErrorSchemaBuilder = class {
   /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
    *
@@ -2038,10 +2679,10 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? (0, import_get11.default)(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? (0, import_get15.default)(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
-      (0, import_set3.default)(this.errorSchema, pathOfError, errorBlock);
+      (0, import_setWith.default)(this.errorSchema, pathOfError, errorBlock, Object);
     }
     return errorBlock;
   }
@@ -2064,15 +2705,15 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = (0, import_get11.default)(errorBlock, ERRORS_KEY);
+    let errorsList = (0, import_get15.default)(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
     }
     if (Array.isArray(errorOrList)) {
-      errorsList.push(...errorOrList);
+      (0, import_set3.default)(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
     } else {
-      errorsList.push(errorOrList);
+      (0, import_set3.default)(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, errorOrList])]);
     }
     return this;
   }
@@ -2086,7 +2727,7 @@ var ErrorSchemaBuilder = class {
    */
   setErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList];
+    const listToAdd = Array.isArray(errorOrList) ? [.../* @__PURE__ */ new Set([...errorOrList])] : [errorOrList];
     (0, import_set3.default)(errorBlock, ERRORS_KEY, listToAdd);
     return this;
   }
@@ -2171,6 +2812,9 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
   if (options.autocomplete) {
     inputProps.autoComplete = options.autocomplete;
   }
+  if (options.accept) {
+    inputProps.accept = options.accept;
+  }
   return inputProps;
 }
 
@@ -2197,6 +2841,10 @@ function getTemplate(name, registry, uiOptions = {}) {
   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
@@ -2204,11 +2852,32 @@ function getTemplate(name, registry, uiOptions = {}) {
   );
 }
 
+// src/getTestIds.ts
+var import_nanoid = require("nanoid");
+var import_get16 = __toESM(require("lodash/get"), 1);
+function getTestIds() {
+  if (typeof process === "undefined" || (0, import_get16.default)(process, "env.NODE_ENV") !== "test") {
+    return {};
+  }
+  const ids = /* @__PURE__ */ new Map();
+  return new Proxy(
+    {},
+    {
+      get(_obj, prop) {
+        if (!ids.has(prop)) {
+          ids.set(prop, (0, import_nanoid.nanoid)());
+        }
+        return ids.get(prop);
+      }
+    }
+  );
+}
+
 // src/getWidget.tsx
 var import_react = require("react");
-var import_react_is = __toESM(require("react-is"));
-var import_get12 = __toESM(require("lodash/get"));
-var import_set4 = __toESM(require("lodash/set"));
+var import_react_is = __toESM(require("react-is"), 1);
+var import_get17 = __toESM(require("lodash/get"), 1);
+var import_set4 = __toESM(require("lodash/set"), 1);
 var import_jsx_runtime = require("react/jsx-runtime");
 var widgetMap = {
   boolean: {
@@ -2263,7 +2932,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = (0, import_get12.default)(AWidget, "MergedWidget");
+  let MergedWidget = (0, import_get17.default)(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -2307,10 +2976,16 @@ function hashString(string) {
   }
   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
@@ -2328,9 +3003,9 @@ function hasWidget(schema, widget, registeredWidgets = {}) {
 }
 
 // src/idGenerators.ts
-var import_isString3 = __toESM(require("lodash/isString"));
+var import_isString4 = __toESM(require("lodash/isString"), 1);
 function idGenerator(id, suffix) {
-  const theId = (0, import_isString3.default)(id) ? id : id[ID_KEY];
+  const theId = (0, import_isString4.default)(id) ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
 function descriptionId(id) {
@@ -2355,6 +3030,9 @@ function ariaDescribedByIds(id, includeExamples = false) {
 function optionId(id, optionIndex) {
   return `${id}-${optionIndex}`;
 }
+function buttonId(id, btn) {
+  return idGenerator(id, btn);
+}
 
 // src/labelValue.ts
 function labelValue(label, hideLabel, fallback) {
@@ -2366,59 +3044,15 @@ 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) {
-      if (true) {
-        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;
+// src/lookupFromFormContext.ts
+var import_get18 = __toESM(require("lodash/get"), 1);
+var import_has6 = __toESM(require("lodash/has"), 1);
+function lookupFromFormContext(regOrFc, toLookup, fallback) {
+  const lookupPath = [LOOKUP_MAP_NAME];
+  if ((0, import_has6.default)(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 (0, import_get18.default)(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/orderProperties.ts
@@ -2513,7 +3147,7 @@ function toDateString(dateObject, time = true) {
 }
 
 // src/toErrorList.ts
-var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"));
+var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
 function toErrorList(errorSchema, fieldPath = []) {
   if (!errorSchema) {
     return [];
@@ -2543,7 +3177,7 @@ function toErrorList(errorSchema, fieldPath = []) {
 }
 
 // src/toErrorSchema.ts
-var import_toPath = __toESM(require("lodash/toPath"));
+var import_toPath = __toESM(require("lodash/toPath"), 1);
 function toErrorSchema(errors) {
   const builder = new ErrorSchemaBuilder();
   if (errors.length) {
@@ -2562,7 +3196,7 @@ function toErrorSchema(errors) {
 }
 
 // src/unwrapErrorHandler.ts
-var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"));
+var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"), 1);
 function unwrapErrorHandler(errorHandler) {
   return Object.keys(errorHandler).reduce((acc, key) => {
     if (key === "addError") {
@@ -2597,7 +3231,7 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-var import_isEmpty3 = __toESM(require("lodash/isEmpty"));
+var import_isEmpty4 = __toESM(require("lodash/isEmpty"), 1);
 function validationDataMerge(validationData, additionalErrorSchema) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -2605,7 +3239,7 @@ function validationDataMerge(validationData, additionalErrorSchema) {
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!(0, import_isEmpty3.default)(oldErrorSchema)) {
+  if (!(0, import_isEmpty4.default)(oldErrorSchema)) {
     errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
     errors = [...oldErrors].concat(errors);
   }
@@ -2613,7 +3247,7 @@ function validationDataMerge(validationData, additionalErrorSchema) {
 }
 
 // src/withIdRefPrefix.ts
-var import_isObject11 = __toESM(require("lodash/isObject"));
+var import_isObject10 = __toESM(require("lodash/isObject"), 1);
 function withIdRefPrefixObject(node) {
   for (const key in node) {
     const realObj = node;
@@ -2636,16 +3270,40 @@ function withIdRefPrefix(schemaNode) {
   if (Array.isArray(schemaNode)) {
     return withIdRefPrefixArray([...schemaNode]);
   }
-  if ((0, import_isObject11.default)(schemaNode)) {
+  if ((0, import_isObject10.default)(schemaNode)) {
     return withIdRefPrefixObject({ ...schemaNode });
   }
   return schemaNode;
 }
 
+// src/getChangedFields.ts
+var import_keys = __toESM(require("lodash/keys"), 1);
+var import_pickBy = __toESM(require("lodash/pickBy"), 1);
+var import_isPlainObject4 = __toESM(require("lodash/isPlainObject"), 1);
+var import_get19 = __toESM(require("lodash/get"), 1);
+var import_difference = __toESM(require("lodash/difference"), 1);
+function getChangedFields(a, b) {
+  const aIsPlainObject = (0, import_isPlainObject4.default)(a);
+  const bIsPlainObject = (0, import_isPlainObject4.default)(b);
+  if (a === b || !aIsPlainObject && !bIsPlainObject) {
+    return [];
+  }
+  if (aIsPlainObject && !bIsPlainObject) {
+    return (0, import_keys.default)(a);
+  } else if (!aIsPlainObject && bIsPlainObject) {
+    return (0, import_keys.default)(b);
+  } else {
+    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals(value, (0, import_get19.default)(b, key))));
+    const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(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";
@@ -2677,12 +3335,10 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 })(TranslatableString || {});
 
 // src/parser/schemaParser.ts
-var import_forEach = __toESM(require("lodash/forEach"));
-var import_isEqual7 = __toESM(require("lodash/isEqual"));
+var import_forEach = __toESM(require("lodash/forEach"), 1);
 
 // src/parser/ParserValidator.ts
-var import_get13 = __toESM(require("lodash/get"));
-var import_isEqual6 = __toESM(require("lodash/isEqual"));
+var import_get20 = __toESM(require("lodash/get"), 1);
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2708,12 +3364,12 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = (0, import_get13.default)(schema, ID_KEY, hash);
+    const key = (0, import_get20.default)(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!(0, import_isEqual6.default)(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(
@@ -2735,7 +3391,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!(0, import_isEqual6.default)(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));
@@ -2775,7 +3431,7 @@ var ParserValidator = class {
 function parseSchema(validator, recurseList, rootSchema, schema) {
   const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
   schemas.forEach((schema2) => {
-    const sameSchemaIndex = recurseList.findIndex((item) => (0, import_isEqual7.default)(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
       const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);