@rjsf/utils 6.6.1 → 6.7.0

package/dist/utils.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/get'), require('fast-equals'), require('fast-uri'), require('jsonpointer'), require('lodash/isEmpty'), require('lodash/isObject'), require('lodash/omit'), require('lodash/has'), require('lodash/isString'), require('lodash/flattenDeep'), require('lodash/merge'), require('lodash/set'), require('lodash/times'), require('lodash/transform'), require('lodash/uniq'), require('lodash/union'), require('lodash/isNumber'), require('@x0k/json-schema-merge'), require('@x0k/json-schema-merge/lib/array'), require('lodash/reduce'), require('lodash/isNil'), require('lodash/pick'), require('lodash/cloneDeep'), require('lodash/setWith'), require('lodash/difference'), require('lodash/keys'), require('lodash/pickBy'), require('lodash/uniqueId'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
   typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/get', 'fast-equals', 'fast-uri', 'jsonpointer', 'lodash/isEmpty', 'lodash/isObject', 'lodash/omit', 'lodash/has', 'lodash/isString', 'lodash/flattenDeep', 'lodash/merge', 'lodash/set', 'lodash/times', 'lodash/transform', 'lodash/uniq', 'lodash/union', 'lodash/isNumber', '@x0k/json-schema-merge', '@x0k/json-schema-merge/lib/array', 'lodash/reduce', 'lodash/isNil', 'lodash/pick', 'lodash/cloneDeep', 'lodash/setWith', 'lodash/difference', 'lodash/keys', 'lodash/pickBy', 'lodash/uniqueId', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject2, global.get15, global.fastEquals, global.UriResolver, global.jsonpointer, global.isEmpty4, global.isObject2, global.omit, global.has5, global.isString, global.flattenDeep, global.merge, global.set, global.times, global.transform, global.uniq, global.union, global.isNumber, global.jsonSchemaMerge, global.array, global.reduce, global.isNil, global.pick, global.cloneDeep, global.setWith, global.difference, global.keys, global.pickBy, global.uniqueId, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
-})(this, (function (exports, isPlainObject2, get15, fastEquals, UriResolver, jsonpointer, isEmpty4, isObject2, omit, has5, isString, flattenDeep, merge, set, times, transform, uniq, union, isNumber, jsonSchemaMerge, array, reduce, isNil, pick, cloneDeep, setWith, difference, keys, pickBy, uniqueId, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject2, global.get14, global.fastEquals, global.UriResolver, global.jsonpointer, global.isEmpty4, global.isObject2, global.omit, global.has5, global.isString, global.flattenDeep, global.merge, global.set3, global.times, global.transform, global.uniq, global.union, global.isNumber, global.jsonSchemaMerge, global.array, global.reduce, global.isNil, global.pick, global.cloneDeep, global.setWith, global.difference, global.keys, global.pickBy, global.uniqueId, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
+})(this, (function (exports, isPlainObject2, get14, fastEquals, UriResolver, jsonpointer, isEmpty4, isObject2, omit, has5, isString, flattenDeep, merge, set3, times, transform, uniq, union, isNumber, jsonSchemaMerge, array, reduce, isNil, pick, cloneDeep, setWith, difference, keys, pickBy, uniqueId, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
 
   // src/isObject.ts
   function isObject(thing) {
@@ -49,7 +49,7 @@
   }
 
   // src/constants.ts
-  var ADDITIONAL_PROPERTY_FLAG = "__additional_property";
+  var ADDITIONAL_PROPERTY_FLAG = /* @__PURE__ */ Symbol("__additional_property");
   var ADDITIONAL_PROPERTIES_KEY = "additionalProperties";
   var ALL_OF_KEY = "allOf";
   var ANY_OF_KEY = "anyOf";
@@ -71,15 +71,17 @@
   var REQUIRED_KEY = "required";
   var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
   var REF_KEY = "$ref";
-  var RJSF_REF_KEY = "__rjsf_ref";
+  var RJSF_REF_KEY = /* @__PURE__ */ Symbol("__rjsf_ref");
+  var RJSF_REF_CYCLE_KEY = /* @__PURE__ */ Symbol("__rjsf_ref_cycle");
   var SCHEMA_KEY = "$schema";
   var DEFAULT_ID_PREFIX = "root";
   var DEFAULT_ID_SEPARATOR = "_";
   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 RJSF_PREFIX_KEY = "__rjsf";
+  var RJSF_ADDITIONAL_PROPERTIES_FLAG = `${RJSF_PREFIX_KEY}_additionalProperties`;
+  var ROOT_SCHEMA_PREFIX = `${RJSF_PREFIX_KEY}_rootSchema`;
   var UI_FIELD_KEY = "ui:field";
   var UI_WIDGET_KEY = "ui:widget";
   var UI_OPTIONS_KEY = "ui:options";
@@ -93,7 +95,7 @@
     if (!uiSchema) {
       return { ...globalOptions };
     }
-    return Object.keys(uiSchema).filter((key) => key.indexOf("ui:") === 0).reduce(
+    return Object.keys(uiSchema).filter((key) => key.startsWith("ui:")).reduce(
       (options, key) => {
         const value = uiSchema[key];
         if (key === UI_WIDGET_KEY && isObject(value)) {
@@ -134,15 +136,14 @@
       }
     };
     if (Array.isArray(formData)) {
-      return formData.reduce((acc, value, key) => {
-        return { ...acc, [key]: createErrorHandler(value) };
-      }, handler);
+      return formData.reduce((acc, value, key) => ({ ...acc, [key]: createErrorHandler(value) }), handler);
     }
     if (isPlainObject2(formData)) {
       const formObject = formData;
-      return Object.keys(formObject).reduce((acc, key) => {
-        return { ...acc, [key]: createErrorHandler(formObject[key]) };
-      }, handler);
+      return Object.keys(formObject).reduce(
+        (acc, key) => ({ ...acc, [key]: createErrorHandler(formObject[key]) }),
+        handler
+      );
     }
     return handler;
   }
@@ -179,46 +180,48 @@
     return void 0;
   }
   function makeAllReferencesAbsolute(schema, baseURI) {
-    const currentURI = get15(schema, ID_KEY, baseURI);
-    if (REF_KEY in schema) {
-      schema = { ...schema, [REF_KEY]: UriResolver.resolve(currentURI, schema[REF_KEY]) };
+    const currentURI = get14(schema, ID_KEY, baseURI);
+    let result = schema;
+    if (REF_KEY in result) {
+      result = { ...result, [REF_KEY]: UriResolver.resolve(currentURI, result[REF_KEY]) };
     }
-    for (const [key, subSchema] of Object.entries(schema)) {
+    for (const [key, subSchema] of Object.entries(result)) {
       if (Array.isArray(subSchema)) {
-        schema = {
-          ...schema,
+        result = {
+          ...result,
           [key]: subSchema.map((item) => isObject2(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
         };
       } else if (isObject2(subSchema)) {
-        schema = { ...schema, [key]: makeAllReferencesAbsolute(subSchema, currentURI) };
+        result = { ...result, [key]: makeAllReferencesAbsolute(subSchema, currentURI) };
       }
     }
-    return schema;
+    return result;
   }
   function splitKeyElementFromObject(key, object) {
     const value = object[key];
     const remaining = omit(object, [key]);
     return [remaining, value];
   }
-  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get15(rootSchema, [ID_KEY])) {
+  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get14(rootSchema, [ID_KEY])) {
     const ref = $ref || "";
     let current = void 0;
+    let currentBaseURI = baseURI;
     if (ref.startsWith("#")) {
       const decodedRef = decodeURIComponent(ref.substring(1));
-      if (baseURI === void 0 || ID_KEY in rootSchema && rootSchema[ID_KEY] === baseURI) {
+      if (currentBaseURI === void 0 || ID_KEY in rootSchema && rootSchema[ID_KEY] === currentBaseURI) {
         current = jsonpointer.get(rootSchema, decodedRef);
       } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-        current = findEmbeddedSchemaRecursive(rootSchema, baseURI.replace(/\/$/, ""));
+        current = findEmbeddedSchemaRecursive(rootSchema, currentBaseURI.replace(/\/$/, ""));
         if (current !== void 0) {
           current = jsonpointer.get(current, decodedRef);
         }
       }
     } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-      const resolvedRef = baseURI ? UriResolver.resolve(baseURI, ref) : ref;
+      const resolvedRef = currentBaseURI ? UriResolver.resolve(currentBaseURI, ref) : ref;
       const [refId, ...refAnchor] = resolvedRef.replace(/#\/?$/, "").split("#");
       current = findEmbeddedSchemaRecursive(rootSchema, refId.replace(/\/$/, ""));
       if (current !== void 0) {
-        baseURI = current[ID_KEY];
+        currentBaseURI = current[ID_KEY];
         if (!isEmpty4(refAnchor)) {
           current = jsonpointer.get(current, decodeURIComponent(refAnchor.join("#")));
         }
@@ -238,25 +241,24 @@
         throw new Error(`Definition for ${firstRef} contains a circular reference through ${circularPath}`);
       }
       const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
-      const subSchema = findSchemaDefinitionRecursive(theRef, rootSchema, [...recurseList, ref], baseURI);
+      const subSchema = findSchemaDefinitionRecursive(theRef, rootSchema, [...recurseList, ref], currentBaseURI);
       if (Object.keys(remaining).length > 0) {
         if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2019_09 || rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
           return { [ALL_OF_KEY]: [remaining, subSchema] };
-        } else {
-          return { ...remaining, ...subSchema };
         }
+        return { ...remaining, ...subSchema };
       }
       return subSchema;
     }
     return current;
   }
-  function findSchemaDefinition($ref, rootSchema = {}, baseURI = get15(rootSchema, [ID_KEY])) {
+  function findSchemaDefinition($ref, rootSchema = {}, baseURI = get14(rootSchema, [ID_KEY])) {
     const recurseList = [];
     return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
   }
   function getDiscriminatorFieldFromSchema(schema) {
     let discriminator;
-    const maybeString = get15(schema, DISCRIMINATOR_PATH);
+    const maybeString = get14(schema, DISCRIMINATOR_PATH);
     if (isString(maybeString)) {
       discriminator = maybeString;
     } else if (maybeString !== void 0) {
@@ -279,7 +281,7 @@
     if (typeof value === "boolean") {
       return "boolean";
     }
-    if (!isNaN(value)) {
+    if (typeof value === "number" && !Number.isNaN(value)) {
       return "number";
     }
     if (typeof value === "object") {
@@ -302,7 +304,7 @@
     }
     if (Array.isArray(type)) {
       if (type.length === 2 && type.includes("null")) {
-        type = type.find((type2) => type2 !== "null");
+        type = type.find((t) => t !== "null");
       } else {
         type = type[0];
       }
@@ -312,40 +314,43 @@
 
   // src/mergeSchemas.ts
   function mergeSchemas(obj1, obj2) {
-    const acc = Object.assign({}, obj1);
-    return Object.keys(obj2).reduce((acc2, key) => {
+    const acc = { ...obj1 };
+    const result = Object.keys(obj2).reduce((accumulator, key) => {
       const left = obj1 ? obj1[key] : {}, right = obj2[key];
       if (obj1 && key in obj1 && isObject(right)) {
-        acc2[key] = mergeSchemas(left, right);
+        accumulator[key] = mergeSchemas(left, right);
       } else if (obj1 && obj2 && (getSchemaType(obj1) === "object" || getSchemaType(obj2) === "object") && key === REQUIRED_KEY && Array.isArray(left) && Array.isArray(right)) {
-        acc2[key] = union(left, right);
+        accumulator[key] = union(left, right);
       } else {
-        acc2[key] = right;
+        accumulator[key] = right;
       }
-      return acc2;
+      return accumulator;
     }, acc);
+    for (const sym of Object.getOwnPropertySymbols(obj2)) {
+      result[sym] = obj2[sym];
+    }
+    return result;
   }
   function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
     if (formData && discriminatorField) {
-      const value = get15(formData, discriminatorField);
+      const value = get14(formData, discriminatorField);
       if (value === void 0) {
-        return;
+        return void 0;
       }
-      for (let i = 0; i < options.length; i++) {
+      for (let i = 0; i < options.length; i += 1) {
         const option = options[i];
-        const discriminator = get15(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;
+        const discriminator = get14(option, [PROPERTIES_KEY, discriminatorField], {});
+        if (discriminator.type !== "object" && discriminator.type !== "array") {
+          if (discriminator.const === value) {
+            return i;
+          }
+          if (discriminator.enum?.includes(value)) {
+            return i;
+          }
         }
       }
     }
-    return;
+    return void 0;
   }
 
   // src/schema/getFirstMatchingOption.ts
@@ -357,11 +362,11 @@
     if (isNumber(simpleDiscriminatorMatch)) {
       return simpleDiscriminatorMatch;
     }
-    for (let i = 0; i < options.length; i++) {
+    for (let i = 0; i < options.length; i += 1) {
       const option = options[i];
       if (discriminatorField && has5(option, [PROPERTIES_KEY, discriminatorField])) {
-        const value = get15(formData, discriminatorField);
-        const discriminator = get15(option, [PROPERTIES_KEY, discriminatorField], {});
+        const value = get14(formData, discriminatorField);
+        const discriminator = get14(option, [PROPERTIES_KEY, discriminatorField], {});
         if (validator.isValid(discriminator, value, rootSchema)) {
           return i;
         }
@@ -382,7 +387,7 @@
           shallowClone.allOf.push(requiresAnyOf);
           augmentedSchema = shallowClone;
         } else {
-          augmentedSchema = Object.assign({}, option, requiresAnyOf);
+          augmentedSchema = { ...option, ...requiresAnyOf };
         }
         delete augmentedSchema.required;
         if (validator.isValid(augmentedSchema, formData, rootSchema)) {
@@ -414,6 +419,12 @@
       resolveAnyOfOrOneOfRefs
     )[0];
   }
+  function normalizeBooleanSchema(schema) {
+    if (typeof schema !== "boolean") {
+      return schema;
+    }
+    return schema ? {} : { not: {} };
+  }
   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);
@@ -421,10 +432,11 @@
     let schemas = [];
     if (expandAllBranches) {
       if (then && typeof then !== "boolean") {
+        const thenSchema = then;
         schemas = schemas.concat(
           retrieveSchemaInternal(
             validator,
-            then,
+            thenSchema,
             rootSchema,
             formData,
             expandAllBranches,
@@ -434,10 +446,11 @@
         );
       }
       if (otherwise && typeof otherwise !== "boolean") {
+        const otherwiseSchema = otherwise;
         schemas = schemas.concat(
           retrieveSchemaInternal(
             validator,
-            otherwise,
+            otherwiseSchema,
             rootSchema,
             formData,
             expandAllBranches,
@@ -447,8 +460,9 @@
         );
       }
     } else {
-      const conditionalSchema = conditionValue ? then : otherwise;
-      if (conditionalSchema && typeof conditionalSchema !== "boolean") {
+      const conditionalBranch = conditionValue ? then : otherwise;
+      if (conditionalBranch !== void 0) {
+        const conditionalSchema = normalizeBooleanSchema(conditionalBranch);
         schemas = schemas.concat(
           retrieveSchemaInternal(
             validator,
@@ -494,7 +508,7 @@
   function getMatchingPatternProperties(schema, key) {
     return Object.keys(schema.patternProperties).filter((pattern) => RegExp(pattern).test(key)).reduce(
       (obj, pattern) => {
-        set(obj, [pattern], schema.patternProperties[pattern]);
+        set3(obj, [pattern], schema.patternProperties[pattern]);
         return obj;
       },
       {}
@@ -524,8 +538,8 @@
         formData,
         experimental_customMergeAllOf
       );
-      return resolvedSchemas.flatMap((s) => {
-        return retrieveSchemaInternal(
+      return resolvedSchemas.flatMap(
+        (s) => retrieveSchemaInternal(
           validator,
           s,
           rootSchema,
@@ -533,8 +547,8 @@
           expandAllBranches,
           recurseList,
           experimental_customMergeAllOf
-        );
-      });
+        )
+      );
     }
     if (ALL_OF_KEY in schema && Array.isArray(schema[ALL_OF_KEY])) {
       const allOfSchemaElements = schema.allOf.map(
@@ -572,30 +586,38 @@
     }
     return [schema];
   }
-  function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs) {
+  function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs, markCycleOnDetection = false) {
     if (!isObject(schema)) {
       return schema;
     }
     let resolvedSchema = schema;
+    let currentBaseURI = baseURI;
     if (REF_KEY in resolvedSchema) {
       const { $ref, ...localSchema } = resolvedSchema;
       if (recurseList.includes($ref)) {
-        return resolvedSchema;
+        return markCycleOnDetection ? { ...resolvedSchema, [RJSF_REF_CYCLE_KEY]: true } : resolvedSchema;
       }
       recurseList.push($ref);
-      const refSchema = findSchemaDefinition($ref, rootSchema, baseURI);
+      const refSchema = findSchemaDefinition($ref, rootSchema, currentBaseURI);
       resolvedSchema = { ...refSchema, ...localSchema, [RJSF_REF_KEY]: $ref };
       if (ID_KEY in resolvedSchema) {
-        baseURI = resolvedSchema[ID_KEY];
+        currentBaseURI = resolvedSchema[ID_KEY];
       }
     }
     if (PROPERTIES_KEY in resolvedSchema) {
       const childrenLists = [];
       const updatedProps = transform(
         resolvedSchema[PROPERTIES_KEY],
-        (result, value, key) => {
+        (acc, value, key) => {
           const childList = [...recurseList];
-          result[key] = resolveAllReferences(value, rootSchema, childList, baseURI, resolveAnyOfOrOneOfRefs);
+          acc[key] = resolveAllReferences(
+            value,
+            rootSchema,
+            childList,
+            currentBaseURI,
+            resolveAnyOfOrOneOfRefs,
+            !resolveAnyOfOrOneOfRefs
+          );
           childrenLists.push(childList);
         },
         {}
@@ -606,7 +628,14 @@
     if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== "boolean") {
       resolvedSchema = {
         ...resolvedSchema,
-        items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs)
+        // Array items are only rendered when data exists, so a $ref cycle here does NOT cause an infinite render.
+        items: resolveAllReferences(
+          resolvedSchema.items,
+          rootSchema,
+          recurseList,
+          currentBaseURI,
+          resolveAnyOfOrOneOfRefs
+        )
       };
     }
     if (resolveAnyOfOrOneOfRefs) {
@@ -623,7 +652,7 @@
         resolvedSchema = {
           ...resolvedSchema,
           [key]: schemas.map(
-            (s) => resolveAllReferences(s, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs)
+            (s) => resolveAllReferences(s, rootSchema, recurseList, currentBaseURI, resolveAnyOfOrOneOfRefs)
           )
         };
       }
@@ -647,10 +676,10 @@
             validator,
             { [ALL_OF_KEY]: Object.values(matchingProperties) },
             rootSchema,
-            get15(formData, [key]),
+            get14(formData, [key]),
             experimental_customMergeAllOf
           );
-          set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+          schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
           return;
         }
       }
@@ -660,9 +689,9 @@
           if (REF_KEY in schema.additionalProperties) {
             additionalProperties = retrieveSchema(
               validator,
-              { [REF_KEY]: get15(schema.additionalProperties, [REF_KEY]) },
+              { [REF_KEY]: get14(schema.additionalProperties, [REF_KEY]) },
               rootSchema,
-              formData,
+              get14(formData, [key]),
               experimental_customMergeAllOf
             );
           } else if ("type" in schema.additionalProperties) {
@@ -673,16 +702,16 @@
               ...schema.additionalProperties
             };
           } else {
-            additionalProperties = { type: guessType(get15(formData, [key])) };
+            additionalProperties = { type: guessType(get14(formData, [key])) };
           }
         } else {
-          additionalProperties = { type: guessType(get15(formData, [key])) };
+          additionalProperties = { type: guessType(get14(formData, [key])) };
         }
         schema.properties[key] = additionalProperties;
-        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
       } else {
         schema.properties[key] = { type: "null" };
-        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
       }
     });
     return schema;
@@ -725,17 +754,26 @@
         try {
           const withContainsSchemas = [];
           const withoutContainsSchemas = [];
-          resolvedSchema.allOf?.forEach((s2) => {
-            if (typeof s2 === "object" && s2.contains) {
-              withContainsSchemas.push(s2);
+          const allOfSymbols = {};
+          resolvedSchema.allOf?.forEach((allOfItem) => {
+            if (typeof allOfItem === "object" && allOfItem.contains) {
+              withContainsSchemas.push(allOfItem);
             } else {
-              withoutContainsSchemas.push(s2);
+              withoutContainsSchemas.push(allOfItem);
+              for (const sym of Object.getOwnPropertySymbols(allOfItem)) {
+                if (!(sym in allOfSymbols)) {
+                  allOfSymbols[sym] = allOfItem[sym];
+                }
+              }
             }
           });
           if (withContainsSchemas.length) {
             resolvedSchema = { ...resolvedSchema, allOf: withoutContainsSchemas };
           }
           resolvedSchema = experimental_customMergeAllOf ? experimental_customMergeAllOf(resolvedSchema) : mergeAllOf(resolvedSchema);
+          for (const sym of Object.getOwnPropertySymbols(allOfSymbols)) {
+            resolvedSchema[sym] = allOfSymbols[sym];
+          }
           if (withContainsSchemas.length) {
             resolvedSchema.allOf = withContainsSchemas;
           }
@@ -747,18 +785,18 @@
       }
       if (PROPERTIES_KEY in resolvedSchema && PATTERN_PROPERTIES_KEY in resolvedSchema) {
         resolvedSchema = Object.keys(resolvedSchema.properties).reduce(
-          (schema2, key) => {
-            const matchingProperties = getMatchingPatternProperties(schema2, key);
+          (acc, key) => {
+            const matchingProperties = getMatchingPatternProperties(acc, key);
             if (!isEmpty4(matchingProperties)) {
-              schema2.properties[key] = retrieveSchema(
+              acc.properties[key] = retrieveSchema(
                 validator,
-                { allOf: [schema2.properties[key], ...Object.values(matchingProperties)] },
+                { allOf: [acc.properties[key], ...Object.values(matchingProperties)] },
                 rootSchema,
-                get15(rawFormData, [key]),
+                get14(rawFormData, [key]),
                 experimental_customMergeAllOf
               );
             }
-            return schema2;
+            return acc;
           },
           {
             ...resolvedSchema,
@@ -790,23 +828,21 @@
     if (anyOrOneOf) {
       const formData = rawFormData === void 0 && expandAllBranches ? {} : rawFormData;
       const discriminator = getDiscriminatorFieldFromSchema(schema);
-      anyOrOneOf = anyOrOneOf.map((s) => {
-        return resolveAllReferences(s, rootSchema, []);
-      });
+      anyOrOneOf = anyOrOneOf.map((s) => resolveAllReferences(s, rootSchema, []));
       const option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
       if (expandAllBranches) {
         const relaxed = relaxOptionsForScoring(anyOrOneOf, false, rootSchema);
         getFirstMatchingOption(validator, formData, relaxed, rootSchema, discriminator);
         return anyOrOneOf.map((item) => mergeSchemas(remaining, item));
       }
-      schema = mergeSchemas(remaining, anyOrOneOf[option]);
+      return [mergeSchemas(remaining, anyOrOneOf[option])];
     }
     return [schema];
   }
   function relaxOptionsForScoring(options, resolveRefs = false, rootSchema) {
     return options.map((d) => {
       if (!isObject(d)) {
-        return d ? {} : { not: {} };
+        return normalizeBooleanSchema(d);
       }
       const schema = resolveRefs && rootSchema ? resolveAllReferences(d, rootSchema, []) : d;
       return schema.additionalProperties === false ? { ...schema, additionalProperties: true } : schema;
@@ -837,43 +873,39 @@
   function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     let schemas = [resolvedSchema];
     for (const dependencyKey in dependencies) {
-      if (!expandAllBranches && get15(formData, [dependencyKey]) === void 0) {
-        continue;
-      }
-      if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
-        continue;
-      }
-      const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
-        dependencyKey,
-        dependencies
-      );
-      if (Array.isArray(dependencyValue)) {
-        schemas[0] = withDependentProperties(resolvedSchema, dependencyValue);
-      } else if (isObject(dependencyValue)) {
-        schemas = withDependentSchema(
-          validator,
-          resolvedSchema,
-          rootSchema,
+      if ((expandAllBranches || get14(formData, [dependencyKey]) !== void 0) && (!resolvedSchema.properties || dependencyKey in resolvedSchema.properties)) {
+        const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
           dependencyKey,
-          dependencyValue,
-          expandAllBranches,
-          recurseList,
-          formData,
-          experimental_customMergeAllOf
+          dependencies
+        );
+        if (Array.isArray(dependencyValue)) {
+          schemas[0] = withDependentProperties(resolvedSchema, dependencyValue);
+        } else if (isObject(dependencyValue)) {
+          schemas = withDependentSchema(
+            validator,
+            resolvedSchema,
+            rootSchema,
+            dependencyKey,
+            dependencyValue,
+            expandAllBranches,
+            recurseList,
+            formData,
+            experimental_customMergeAllOf
+          );
+        }
+        return schemas.flatMap(
+          (schema) => processDependencies(
+            validator,
+            remainingDependencies,
+            schema,
+            rootSchema,
+            expandAllBranches,
+            recurseList,
+            formData,
+            experimental_customMergeAllOf
+          )
         );
       }
-      return schemas.flatMap(
-        (schema) => processDependencies(
-          validator,
-          remainingDependencies,
-          schema,
-          rootSchema,
-          expandAllBranches,
-          recurseList,
-          formData,
-          experimental_customMergeAllOf
-        )
-      );
     }
     return schemas;
   }
@@ -896,9 +928,9 @@
     );
     return dependentSchemas.flatMap((dependent) => {
       const { oneOf, ...dependentSchema } = dependent;
-      schema = mergeSchemas(schema, dependentSchema);
+      const mergedSchema = mergeSchemas(schema, dependentSchema);
       if (oneOf === void 0) {
-        return schema;
+        return mergedSchema;
       }
       const resolvedOneOfs = oneOf.map((subschema) => {
         if (typeof subschema === "boolean" || !(REF_KEY in subschema)) {
@@ -910,7 +942,7 @@
       return allPermutations.flatMap(
         (resolvedOneOf) => withExactlyOneSubschema(
           validator,
-          schema,
+          mergedSchema,
           rootSchema,
           dependencyKey,
           resolvedOneOf,
@@ -924,7 +956,7 @@
   }
   function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const validSubschemas = oneOf.filter((subschema) => {
-      if (typeof subschema === "boolean" || !subschema || !subschema.properties) {
+      if (typeof subschema === "boolean" || !subschema?.properties) {
         return false;
       }
       const { [dependencyKey]: conditionPropertySchema } = subschema.properties;
@@ -956,7 +988,7 @@
         recurseList,
         experimental_customMergeAllOf
       );
-      return schemas.map((s2) => mergeSchemas(schema, s2));
+      return schemas.map((resolvedSubschema) => mergeSchemas(schema, resolvedSubschema));
     });
   }
 
@@ -968,14 +1000,18 @@
       const xxxOfs = schema[xxx].map(
         (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
       );
-      const data = get15(formData, selectorField);
+      const data = get14(formData, selectorField);
       if (data !== void 0) {
-        return xxxOfs.find((xxx2) => {
-          return deepEquals_default(
-            get15(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get15(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+        return xxxOfs.find(
+          (xxxOfOption) => deepEquals_default(
+            get14(
+              xxxOfOption,
+              [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
+              get14(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
+            ),
             data
-          );
-        });
+          )
+        );
       }
     }
     return void 0;
@@ -991,7 +1027,7 @@
     const pathList = Array.isArray(path) ? [...path] : path.split(".");
     const [part, ...nestedPath] = pathList;
     if (part !== void 0 && part !== "" && has5(fieldSchema, part)) {
-      fieldSchema = get15(fieldSchema, part);
+      fieldSchema = get14(fieldSchema, part);
       return getFromSchemaInternal(
         validator,
         rootSchema,
@@ -1034,7 +1070,7 @@
             parentField,
             fieldNameKey,
             ONE_OF_KEY,
-            get15(formData, subPath),
+            get14(formData, subPath),
             experimental_customMergeAllOf
           );
         } else if (has5(parentField, ANY_OF_KEY)) {
@@ -1044,7 +1080,7 @@
             parentField,
             fieldNameKey,
             ANY_OF_KEY,
-            get15(formData, subPath),
+            get14(formData, subPath),
             experimental_customMergeAllOf
           );
         }
@@ -1112,7 +1148,7 @@
         totalScore += reduce(
           schema.properties,
           (score, value, key) => {
-            const formValue = get15(formData, key);
+            const formValue = get14(formData, key);
             if (typeof value === "boolean") {
               return score;
             }
@@ -1133,23 +1169,21 @@
               );
             }
             if ((has5(value, ONE_OF_KEY) || has5(value, ANY_OF_KEY)) && formValue) {
-              const key2 = has5(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+              const xxxOfKey = has5(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
               const discriminator = getDiscriminatorFieldFromSchema(value);
               return score + getClosestMatchingOption(
                 validator,
                 rootSchema,
                 formValue,
-                get15(value, key2),
+                get14(value, xxxOfKey),
                 -1,
                 discriminator,
                 experimental_customMergeAllOf
               );
             }
             if (value.type === "object") {
-              if (isObject2(formValue)) {
-                score += 1;
-              }
-              return score + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
+              const structureBoost = isObject2(formValue) ? 1 : 0;
+              return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
             }
             if (value.type === guessType(formValue)) {
               let newScore = score + 1;
@@ -1171,9 +1205,7 @@
     return totalScore;
   }
   function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField, experimental_customMergeAllOf) {
-    const resolvedOptions = options.map((option) => {
-      return resolveAllReferences(option, rootSchema, []);
-    });
+    const resolvedOptions = options.map((option) => resolveAllReferences(option, rootSchema, []));
     const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
     if (isNumber(simpleDiscriminatorMatch)) {
       return simpleDiscriminatorMatch;
@@ -1224,7 +1256,7 @@
 
   // src/isFixedItems.ts
   function isFixedItems(schema) {
-    return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item));
+    return Array.isArray(schema.items) && schema.items.every((item) => isObject(item));
   }
   function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
     if (Array.isArray(formData)) {
@@ -1250,23 +1282,23 @@
     }
     if (isObject(formData)) {
       const acc = Object.assign({}, defaults);
-      return Object.keys(formData).reduce((acc2, key) => {
-        const keyValue = get15(formData, key);
+      return Object.keys(formData).reduce((accumulator, key) => {
+        const keyValue = get14(formData, key);
         const keyExistsInDefaults = isObject(defaults) && key in defaults;
         const keyExistsInFormData = key in formData;
-        const keyDefault = get15(defaults, key) ?? {};
+        const keyDefault = get14(defaults, key) ?? {};
         const defaultValueIsNestedObject = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
-        const keyDefaultIsObject = keyExistsInDefaults && isObject(get15(defaults, key));
+        const keyDefaultIsObject = keyExistsInDefaults && isObject(get14(defaults, key));
         const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
         if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
-          acc2[key] = {
-            ...get15(defaults, key),
+          accumulator[key] = {
+            ...get14(defaults, key),
             ...keyValue
           };
-          return acc2;
+          return accumulator;
         }
-        acc2[key] = mergeDefaultsWithFormData(
-          get15(defaults, key),
+        accumulator[key] = mergeDefaultsWithFormData(
+          get14(defaults, key),
           keyValue,
           mergeExtraArrayDefaults,
           defaultSupercedesUndefined,
@@ -1274,10 +1306,10 @@
           // Or if the key value doesn't exist in formData
           overrideFormDataWithDefaults && (keyExistsInDefaults || !keyExistsInFormData)
         );
-        return acc2;
+        return acc;
       }, acc);
     }
-    if (defaultSupercedesUndefined && (!(defaults === void 0) && isNil(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
+    if (defaultSupercedesUndefined && (!(defaults === void 0) && isNil(formData) || typeof formData === "number" && Number.isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
       return defaults;
     }
     return formData;
@@ -1306,7 +1338,7 @@
         }
         return acc;
       },
-      Object.assign({}, obj1)
+      { ...obj1 }
     );
   }
 
@@ -1366,18 +1398,18 @@
       const { optionsSchemaSelector = selectorField } = getUiOptions(uiSchema);
       selectorField = optionsSchemaSelector;
     }
-    return altSchemas && altSchemas.map((aSchemaDef, index) => {
+    return altSchemas?.map((aSchemaDef, index) => {
       const { title } = getUiOptions(altUiSchemas?.[index]);
       const aSchema = aSchemaDef;
       let value;
       let label = title;
       if (selectorField) {
-        const innerSchema = get15(aSchema, [PROPERTIES_KEY, selectorField], {});
-        value = get15(innerSchema, DEFAULT_KEY, get15(innerSchema, CONST_KEY));
-        label = label || innerSchema?.title || aSchema.title || String(value);
+        const innerSchema = get14(aSchema, [PROPERTIES_KEY, selectorField], {});
+        value = get14(innerSchema, DEFAULT_KEY, get14(innerSchema, CONST_KEY));
+        label = label ?? innerSchema?.title ?? aSchema.title ?? String(value);
       } else {
         value = toConstant(aSchema);
-        label = label || aSchema.title || String(value);
+        label = label ?? aSchema.title ?? String(value);
       }
       return {
         schema: aSchema,
@@ -1395,7 +1427,7 @@
       return true;
     }
     if (Array.isArray(altSchemas)) {
-      return altSchemas.every((altSchemas2) => typeof altSchemas2 !== "boolean" && isConstant(altSchemas2));
+      return altSchemas.every((altSchema) => typeof altSchema !== "boolean" && isConstant(altSchema));
     }
     return false;
   }
@@ -1431,23 +1463,23 @@
     const shouldReturnNullAsDefault = Array.isArray(type) && type.includes("null") && isEmpty4(computedDefault) && schemaDefault === null;
     return shouldReturnNullAsDefault ? null : computedDefault;
   }
-  function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}, isConst = false, isNullType = false) {
+  function maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}, isConst = false, isNullType = false) {
     const { emptyObjectFields = "populateAllDefaults" } = experimental_defaultFormStateBehavior;
     if (includeUndefinedValues === true || isConst) {
-      obj[key] = computedDefault;
+      acc[key] = computedDefault;
     } else if (includeUndefinedValues === "excludeObjectChildren") {
       if (isNullType && computedDefault !== void 0 || !isObject(computedDefault) || !isEmpty4(computedDefault)) {
-        obj[key] = computedDefault;
+        acc[key] = computedDefault;
       }
     } else if (emptyObjectFields !== "skipDefaults") {
       const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
       if (isObject(computedDefault)) {
         if (emptyObjectFields === "skipEmptyDefaults") {
           if (!isEmpty4(computedDefault)) {
-            obj[key] = computedDefault;
+            acc[key] = computedDefault;
           }
         } else if ((!isEmpty4(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
-          obj[key] = computedDefault;
+          acc[key] = computedDefault;
         }
       } else if (
         // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
@@ -1456,7 +1488,7 @@
         // 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;
+        acc[key] = computedDefault;
       }
     }
   }
@@ -1467,8 +1499,8 @@
       rootSchema = {},
       includeUndefinedValues = false,
       _recurseList = [],
-      experimental_defaultFormStateBehavior = void 0,
-      experimental_customMergeAllOf = void 0,
+      experimental_defaultFormStateBehavior,
+      experimental_customMergeAllOf,
       required,
       shouldMergeDefaultsIntoFormData = false,
       initialDefaultsGenerated
@@ -1476,14 +1508,19 @@
     let formData = isObject(rawFormData) ? rawFormData : {};
     const schema = isObject(rawSchema) ? rawSchema : {};
     let defaults = parentDefaults;
+    const preferParentDefaults = defaults && experimental_defaultFormStateBehavior?.nestedDefaultsPrecedence === "ancestorWins";
     let schemaToCompute = null;
     let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
     let updatedRecurseList = _recurseList;
     if (schema[CONST_KEY] !== void 0 && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
       defaults = schema[CONST_KEY];
     } else if (isObject(defaults) && isObject(schema.default) && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
-      defaults = mergeObjects(defaults, schema.default);
-    } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
+      if (preferParentDefaults) {
+        defaults = mergeObjects(schema.default, defaults);
+      } else {
+        defaults = mergeObjects(defaults, schema.default);
+      }
+    } else if (DEFAULT_KEY in schema && !preferParentDefaults && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
       defaults = schema.default;
     } else if (REF_KEY in schema) {
       const refName = schema[REF_KEY];
@@ -1512,8 +1549,8 @@
         defaultFormData,
         experimental_customMergeAllOf
       );
-      schemaToCompute = resolvedSchema[0];
-    } else if (isFixedItems(schema)) {
+      [schemaToCompute] = resolvedSchema;
+    } else if (isFixedItems(schema) && !preferParentDefaults) {
       defaults = schema.items.map(
         (itemSchema, idx) => computeDefaults(validator, itemSchema, {
           rootSchema,
@@ -1609,16 +1646,36 @@
     return defaultsWithFormData;
   }
   function ensureFormDataMatchingSchema(validator, schema, rootSchema, formData, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
-    const isSelectField = !isConstant(schema) && isSelect(validator, schema, rootSchema, experimental_customMergeAllOf);
+    const shouldRetrieveAllOf = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema;
+    const schemaToMatch = shouldRetrieveAllOf ? retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf) : schema;
+    const isSelectField = !isConstant(schemaToMatch) && isSelect(validator, schemaToMatch, rootSchema, experimental_customMergeAllOf);
     let validFormData = formData;
     if (isSelectField) {
-      const getOptionsList = optionsList(schema);
+      const getOptionsList = optionsList(schemaToMatch);
       const isValid = getOptionsList?.some((option) => deepEquals_default(option.value, formData));
       validFormData = isValid ? formData : void 0;
     }
-    const constTakesPrecedence = schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === "always";
+    const constTakesPrecedence = schemaToMatch[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === "always";
     if (constTakesPrecedence) {
-      validFormData = schema.const;
+      validFormData = schemaToMatch.const;
+    } else if (isObject(validFormData) && isObject(schemaToMatch.properties)) {
+      validFormData = Object.keys(schemaToMatch.properties).reduce(
+        (acc, key) => {
+          const propertySchema = get14(schemaToMatch, [PROPERTIES_KEY, key], {});
+          if (key in acc && (shouldRetrieveAllOf || isObject(propertySchema) && ALL_OF_KEY in propertySchema)) {
+            acc[key] = ensureFormDataMatchingSchema(
+              validator,
+              propertySchema,
+              rootSchema,
+              get14(acc, key),
+              experimental_defaultFormStateBehavior,
+              experimental_customMergeAllOf
+            );
+          }
+          return acc;
+        },
+        { ...validFormData }
+      );
     }
     return validFormData;
   }
@@ -1627,8 +1684,8 @@
     rootSchema = {},
     includeUndefinedValues = false,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = void 0,
-    experimental_customMergeAllOf = void 0,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     shouldMergeDefaultsIntoFormData,
     initialDefaultsGenerated
@@ -1641,7 +1698,7 @@
       const parentConst = retrievedSchema[CONST_KEY];
       const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
         (acc, key) => {
-          const propertySchema = get15(retrievedSchema, [PROPERTIES_KEY, key], {});
+          const propertySchema = get14(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, {
@@ -1650,8 +1707,8 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get15(defaults, [key]),
-            rawFormData: get15(formData, [key]),
+            parentDefaults: get14(defaults, [key]),
+            rawFormData: get14(formData, [key]),
             required: retrievedSchema.required?.includes(key),
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1689,8 +1746,8 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get15(defaults, [key]),
-            rawFormData: get15(formData, [key]),
+            parentDefaults: get14(defaults, [key]),
+            rawFormData: get14(formData, [key]),
             required: retrievedSchema.required?.includes(key),
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1712,13 +1769,14 @@
     rawFormData,
     rootSchema = {},
     _recurseList = [],
-    experimental_defaultFormStateBehavior = void 0,
-    experimental_customMergeAllOf = void 0,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     requiredAsRoot = false,
     shouldMergeDefaultsIntoFormData,
     initialDefaultsGenerated
-  } = {}, defaults) {
+  } = {}, initialDefaults) {
+    let defaults = initialDefaults;
     const schema = rawSchema;
     const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
     const { populate: arrayMinItemsPopulate, mergeExtraDefaults: arrayMergeExtraDefaults } = arrayMinItemsStateBehavior;
@@ -1750,31 +1808,38 @@
       if (neverPopulate) {
         defaults = rawFormData;
       } else {
-        const itemDefaults = rawFormData.map((item, idx) => {
-          return computeDefaults(validator, schemaItem, {
+        const itemDefaults = rawFormData.map(
+          (item, idx) => computeDefaults(validator, schemaItem, {
             rootSchema,
             _recurseList,
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             rawFormData: item,
-            parentDefaults: get15(defaults, [idx]),
+            parentDefaults: get14(defaults, [idx]),
             required,
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
-          });
-        });
+          })
+        );
         const mergeExtraDefaults = (ignoreMinItemsFlagSet && required || isPopulateAll) && arrayMergeExtraDefaults;
         defaults = mergeDefaultsWithFormData(defaults, itemDefaults, mergeExtraDefaults);
       }
     }
+    const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
     if (neverPopulate) {
+      if (shouldMergeDefaultsIntoFormData) {
+        if (schema.minItems && schema.minItems > defaultsLength) {
+          const fillerEntries = Array.from({ length: schema.minItems - defaultsLength }, () => null);
+          return (defaults ?? []).concat(fillerEntries);
+        }
+        return defaults;
+      }
       return defaults ?? emptyDefault;
     }
     if (ignoreMinItemsFlagSet && !required) {
-      return defaults ? defaults : void 0;
+      return defaults || void 0;
     }
     let arrayDefault;
-    const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
     if (!schema.minItems || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
       arrayDefault = defaults || !required && !requiredAsRoot ? defaults : emptyDefault;
     } else {
@@ -1806,11 +1871,13 @@
       case "array": {
         return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
       }
+      default:
+        return void 0;
     }
   }
   function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior, experimental_customMergeAllOf, initialDefaultsGenerated) {
     if (!isObject(theSchema)) {
-      throw new Error("Invalid schema: " + theSchema);
+      throw new Error(`Invalid schema: ${theSchema}`);
     }
     const schema = retrieveSchema(validator, theSchema, rootSchema, formData, experimental_customMergeAllOf);
     const defaults = computeDefaults(validator, schema, {
@@ -1832,9 +1899,17 @@
     if (isObject(formData) || Array.isArray(formData)) {
       const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
       const defaultSupercedesUndefined = mergeDefaultsIntoFormData === "useDefaultIfFormDataUndefined";
+      const matchingFormData = ensureFormDataMatchingSchema(
+        validator,
+        schema,
+        rootSchema ?? schema,
+        formData,
+        experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf
+      );
       const result = mergeDefaultsWithFormData(
         defaults,
-        formData,
+        matchingFormData,
         true,
         // set to true to add any additional default array entries.
         defaultSupercedesUndefined,
@@ -1851,7 +1926,7 @@
     return (
       // TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays.
       // https://rjsf-team.github.io/react-jsonschema-form/docs/usage/widgets/#hidden-widgets
-      "widget" in getUiOptions(uiSchema) && getUiOptions(uiSchema)["widget"] !== "hidden"
+      "widget" in getUiOptions(uiSchema) && getUiOptions(uiSchema).widget !== "hidden"
     );
   }
 
@@ -1880,7 +1955,7 @@
     let displayLabel = Boolean(label);
     if (displayLabel) {
       const schemaType = getSchemaType(schema);
-      const addedByAdditionalProperty = get15(schema, ADDITIONAL_PROPERTY_FLAG, false);
+      const addedByAdditionalProperty = Boolean(schema[ADDITIONAL_PROPERTY_FLAG]);
       if (schemaType === "array") {
         displayLabel = addedByAdditionalProperty || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || isFilesArray(validator, schema, uiSchema, rootSchema, experimental_customMergeAllOf) || isCustomWidget(uiSchema);
       }
@@ -1890,7 +1965,7 @@
       if (schemaType === "boolean" && uiSchema && !uiSchema[UI_WIDGET_KEY]) {
         displayLabel = false;
       }
-      if (uiSchema && uiSchema[UI_FIELD_KEY]) {
+      if (uiSchema?.[UI_FIELD_KEY]) {
         displayLabel = false;
       }
     }
@@ -1921,7 +1996,7 @@
           }
         } else if (key === NAME_KEY && data !== "") {
           paths.forEach((path) => {
-            const formValue = get15(formData, path);
+            const formValue = get14(formData, path);
             const isLeaf = objKeys.length === 1;
             if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
               acc.push(path);
@@ -1955,11 +2030,11 @@
     function isSchemaObj(schemaDef) {
       return isObject(schemaDef);
     }
-    function handleObject(schema2, source, target) {
-      const { properties, additionalProperties, patternProperties, propertyNames } = schema2;
-      const requiredSet = new Set(schema2.required ?? []);
+    function handleObject(childSchema, source, target) {
+      const { properties, additionalProperties, patternProperties, propertyNames } = childSchema;
+      const requiredSet = new Set(childSchema.required ?? []);
       function setProperty(key, schemaDef, value, required = false) {
-        const v = omit3(schemaDef, value, target[key]);
+        const v = omit2(schemaDef, value, target[key]);
         if (!required && isObject(v)) {
           let sd = isSchemaObj(schemaDef) ? schemaDef : {};
           if (sd.$ref !== void 0) {
@@ -1991,15 +2066,14 @@
         ]);
         const knownProperties = new Set(Object.keys(properties ?? {}));
         for (const [key, value] of Object.entries(source)) {
-          if (knownProperties.has(key)) {
-            continue;
-          }
-          const matched = patterns.find(([re]) => re.test(key));
-          if (matched === void 0) {
-            patternPropertiesRest.push(key);
-            continue;
+          if (!knownProperties.has(key)) {
+            const matched = patterns.find(([re]) => re.test(key));
+            if (matched === void 0) {
+              patternPropertiesRest.push(key);
+            } else {
+              setProperty(key, matched[1], value);
+            }
           }
-          setProperty(key, matched[1], value);
         }
       }
       if (additionalProperties !== void 0 && additionalProperties !== false) {
@@ -2011,10 +2085,9 @@
         } else {
           const knownProperties = new Set(Object.keys(properties ?? {}));
           for (const [key, value] of Object.entries(source)) {
-            if (knownProperties.has(key)) {
-              continue;
+            if (!knownProperties.has(key)) {
+              setProperty(key, addlSchema, value);
             }
-            setProperty(key, addlSchema, value);
           }
         }
       }
@@ -2025,37 +2098,37 @@
       }
       return target;
     }
-    function handleArray(schema2, source, target) {
-      const { items, additionalItems } = schema2;
+    function handleArray(childSchema, source, target) {
+      const { items, additionalItems } = childSchema;
       if (items !== void 0) {
         if (Array.isArray(items)) {
-          for (let i = 0; i < items.length; i++) {
-            target.push(omit3(items[i], source[i]));
+          for (let i = 0; i < items.length; i += 1) {
+            target.push(omit2(items[i], source[i]));
           }
         } else {
-          for (let i = 0; i < source.length; i++) {
-            target.push(omit3(items, source[i]));
+          for (let i = 0; i < source.length; i += 1) {
+            target.push(omit2(items, source[i]));
           }
         }
       }
       if (additionalItems) {
-        for (let i = target.length; i < source.length; i++) {
-          target.push(omit3(additionalItems, source[i]));
+        for (let i = target.length; i < source.length; i += 1) {
+          target.push(omit2(additionalItems, source[i]));
         }
       }
       return target;
     }
-    function handleConditions(schema2, source, target) {
-      const { if: condition, then, else: otherwise } = schema2;
+    function handleConditions(childSchema, source, target) {
+      const { if: condition, then, else: otherwise } = childSchema;
       if (condition === void 0) {
         return target;
       }
       const isThenBranch = isSchemaObj(condition) ? validator.isValid(condition, source, rootSchema) : condition;
       const branch = isThenBranch ? then : otherwise;
-      return branch === void 0 ? target : omit3(branch, source, target);
+      return branch === void 0 ? target : omit2(branch, source, target);
     }
-    function handleOneOf(oneOf, schema2, source, target) {
-      if (!Array.isArray(oneOf) || isSelect(validator, schema2, rootSchema, experimental_customMergeAllOf)) {
+    function handleOneOf(oneOf, childSchema, source, target) {
+      if (!Array.isArray(oneOf) || isSelect(validator, childSchema, rootSchema, experimental_customMergeAllOf)) {
         return target;
       }
       const scoringOptions = relaxOptionsForScoring(oneOf, true, rootSchema);
@@ -2065,92 +2138,126 @@
         source,
         scoringOptions,
         0,
-        getDiscriminatorFieldFromSchema(schema2),
+        getDiscriminatorFieldFromSchema(childSchema),
         experimental_customMergeAllOf
       );
       const winning = oneOf[bestIndex];
       const resolved = isObject(winning) ? resolveAllReferences(winning, rootSchema, []) : scoringOptions[bestIndex];
-      return omit3(resolved, source, target);
+      return omit2(resolved, source, target);
     }
-    function handleAnyOf(schema2, source, target) {
-      const { anyOf } = schema2;
+    function handleAnyOf(childSchema, source, target) {
+      const { anyOf } = childSchema;
       if (!Array.isArray(anyOf)) {
         return target;
       }
       if (source === void 0 || Array.isArray(source) && source.length === 0 || isObject(source) && Object.keys(source).length === 0) {
+        let result = target;
         for (const branch of anyOf) {
-          target = omit3(branch, source, target);
+          result = omit2(branch, source, result);
         }
-        return target;
+        return result;
       }
-      return handleOneOf(anyOf, schema2, source, target);
+      return handleOneOf(anyOf, childSchema, source, target);
     }
-    function handleDependencies(schema2, source, target) {
-      const { dependencies } = schema2;
+    function handleDependencies(childSchema, source, target) {
+      const { dependencies } = childSchema;
       if (dependencies === void 0 || !isObjectValue(source)) {
         return target;
       }
+      let result = target;
       for (const [key, deps] of Object.entries(dependencies)) {
-        if (!(key in source) || Array.isArray(deps)) {
-          continue;
+        if (key in source && !Array.isArray(deps)) {
+          result = omit2(deps, source, result);
         }
-        target = omit3(deps, source, target);
       }
-      return target;
+      return result;
     }
-    function omit3(schemaDef, source, target) {
+    function omit2(schemaDef, source, target) {
       if (source === void 0 || schemaDef === false) {
         return void 0;
       }
       if (schemaDef === true || isEmpty4(schemaDef)) {
         return source;
       }
-      let schema2 = schemaDef;
-      const { $ref: ref, allOf } = schema2;
+      let localSchema = schemaDef;
+      const { $ref: ref, allOf } = localSchema;
       if (ref !== void 0) {
-        return omit3(findSchemaDefinition(ref, rootSchema), source, target);
+        return omit2(findSchemaDefinition(ref, rootSchema), source, target);
       }
       if (allOf) {
-        schema2 = doMergeAllOf(schema2, experimental_customMergeAllOf);
+        localSchema = doMergeAllOf(localSchema, experimental_customMergeAllOf);
+        const remainingAllOf = localSchema.allOf;
+        if (remainingAllOf) {
+          for (let i = 0; i < remainingAllOf.length; i++) {
+            target = omit2(remainingAllOf[i], source, target);
+          }
+        }
       }
-      target = handleAnyOf(schema2, source, handleOneOf(schema2.oneOf, schema2, source, target));
-      const type = getSchemaType(schema2);
+      let filtered = handleAnyOf(localSchema, source, handleOneOf(localSchema.oneOf, localSchema, source, target));
+      const type = getSchemaType(localSchema);
       if (type === "object") {
         if (!isObjectValue(source)) {
           return void 0;
         }
-        target = handleObject(schema2, source, isObjectValue(target) ? target : {});
+        filtered = handleObject(localSchema, source, isObjectValue(filtered) ? filtered : {});
       } else if (type === "array") {
         if (!Array.isArray(source)) {
           return void 0;
         }
-        target = handleArray(schema2, source, Array.isArray(target) ? target : []);
-      } else if (target === void 0) {
-        target = source;
+        filtered = handleArray(localSchema, source, Array.isArray(filtered) ? filtered : []);
+      } else if (filtered === void 0) {
+        filtered = source;
       }
-      return handleDependencies(schema2, source, handleConditions(schema2, source, target));
+      return handleDependencies(localSchema, source, handleConditions(localSchema, source, filtered));
     }
-    return omit3(schema, formData);
+    return omit2(schema, formData);
   }
   var NO_VALUE = /* @__PURE__ */ Symbol("no Value");
+  function enumValuesForSchema(schema) {
+    if (Array.isArray(schema.enum)) {
+      return schema.enum;
+    }
+    const options = schema.oneOf || schema.anyOf;
+    if (!Array.isArray(options)) {
+      return void 0;
+    }
+    const values = options.map((option) => {
+      if (CONST_KEY in option) {
+        return option[CONST_KEY];
+      }
+      return Array.isArray(option.enum) && option.enum.length === 1 ? option.enum[0] : NO_VALUE;
+    }).filter((value) => value !== NO_VALUE);
+    return values.length > 0 ? values : void 0;
+  }
+  function replacementForInvalidEnumValue(schema, formValue) {
+    const enumValues = enumValuesForSchema(schema);
+    if (!enumValues || enumValues.some((value) => deepEquals_default(value, formValue))) {
+      return NO_VALUE;
+    }
+    const defaultValue = get14(schema, DEFAULT_KEY, NO_VALUE);
+    if (defaultValue !== NO_VALUE && enumValues.some((value) => deepEquals_default(value, defaultValue))) {
+      return defaultValue;
+    }
+    return enumValues.length === 1 ? enumValues[0] : void 0;
+  }
   function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
     let newFormData;
     if (has5(newSchema, PROPERTIES_KEY)) {
       const removeOldSchemaData = {};
       if (has5(oldSchema, PROPERTIES_KEY)) {
-        const properties = get15(oldSchema, PROPERTIES_KEY, {});
+        const properties = get14(oldSchema, PROPERTIES_KEY, {});
         Object.keys(properties).forEach((key) => {
           if (has5(data, key)) {
             removeOldSchemaData[key] = void 0;
           }
         });
       }
-      const keys2 = Object.keys(get15(newSchema, PROPERTIES_KEY, {}));
+      const keys2 = Object.keys(get14(newSchema, PROPERTIES_KEY, {}));
       const nestedData = {};
       keys2.forEach((key) => {
-        const formValue = get15(data, key);
-        let oldKeyedSchema = get15(oldSchema, [PROPERTIES_KEY, key], {});
-        let newKeyedSchema = get15(newSchema, [PROPERTIES_KEY, key], {});
+        const formValue = get14(data, key);
+        let oldKeyedSchema = get14(oldSchema, [PROPERTIES_KEY, key], {});
+        let newKeyedSchema = get14(newSchema, [PROPERTIES_KEY, key], {});
         if (has5(oldKeyedSchema, REF_KEY)) {
           oldKeyedSchema = retrieveSchema(
             validator,
@@ -2169,8 +2276,8 @@
             experimental_customMergeAllOf
           );
         }
-        const oldSchemaTypeForKey = get15(oldKeyedSchema, "type");
-        const newSchemaTypeForKey = get15(newKeyedSchema, "type");
+        const oldSchemaTypeForKey = get14(oldKeyedSchema, "type");
+        const newSchemaTypeForKey = get14(newKeyedSchema, "type");
         if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
           if (has5(removeOldSchemaData, key)) {
             delete removeOldSchemaData[key];
@@ -2188,31 +2295,37 @@
               nestedData[key] = itemData;
             }
           } else {
-            const newOptionDefault = get15(newKeyedSchema, "default", NO_VALUE);
-            const oldOptionDefault = get15(oldKeyedSchema, "default", NO_VALUE);
+            const newOptionDefault = get14(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
+            const oldOptionDefault = get14(oldKeyedSchema, DEFAULT_KEY, NO_VALUE);
             if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
               if (oldOptionDefault === formValue) {
                 removeOldSchemaData[key] = newOptionDefault;
-              } else if (get15(newKeyedSchema, "readOnly") === true) {
+              } else if (get14(newKeyedSchema, "readOnly") === true) {
                 removeOldSchemaData[key] = void 0;
               }
             }
-            const newOptionConst = get15(newKeyedSchema, "const", NO_VALUE);
-            const oldOptionConst = get15(oldKeyedSchema, "const", NO_VALUE);
+            const newOptionConst = get14(newKeyedSchema, CONST_KEY, NO_VALUE);
+            const oldOptionConst = get14(oldKeyedSchema, CONST_KEY, NO_VALUE);
             if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
               removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
             }
+            if (has5(data, key)) {
+              const enumReplacement = replacementForInvalidEnumValue(newKeyedSchema, formValue);
+              if (enumReplacement !== NO_VALUE) {
+                removeOldSchemaData[key] = enumReplacement;
+              }
+            }
           }
         }
       });
       newFormData = {
-        ...typeof data == "string" || Array.isArray(data) ? void 0 : data,
+        ...typeof data === "string" || Array.isArray(data) ? void 0 : data,
         ...removeOldSchemaData,
         ...nestedData
       };
-    } else if (get15(oldSchema, "type") === "array" && get15(newSchema, "type") === "array" && Array.isArray(data)) {
-      let oldSchemaItems = get15(oldSchema, "items");
-      let newSchemaItems = get15(newSchema, "items");
+    } else if (get14(oldSchema, "type") === "array" && get14(newSchema, "type") === "array" && Array.isArray(data)) {
+      let oldSchemaItems = get14(oldSchema, "items");
+      let newSchemaItems = get14(newSchema, "items");
       if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
         if (has5(oldSchemaItems, REF_KEY)) {
           oldSchemaItems = retrieveSchema(
@@ -2232,10 +2345,10 @@
             experimental_customMergeAllOf
           );
         }
-        const oldSchemaType = get15(oldSchemaItems, "type");
-        const newSchemaType = get15(newSchemaItems, "type");
+        const oldSchemaType = get14(oldSchemaItems, "type");
+        const newSchemaType = get14(newSchemaItems, "type");
         if (!oldSchemaType || oldSchemaType === newSchemaType) {
-          const maxItems = get15(newSchema, "maxItems", -1);
+          const maxItems = get14(newSchema, "maxItems", -1);
           if (newSchemaType === "object") {
             newFormData = data.reduce((newValue, aValue) => {
               const itemValue = sanitizeDataForNewSchema(
@@ -2252,7 +2365,9 @@
               return newValue;
             }, []);
           } else {
-            newFormData = maxItems > 0 && data.length > maxItems ? data.slice(0, maxItems) : data;
+            const newItemEnumValues = enumValuesForSchema(newSchemaItems);
+            const filteredData = newItemEnumValues ? data.filter((item) => newItemEnumValues.some((v) => deepEquals_default(v, item))) : data;
+            newFormData = maxItems > 0 && filteredData.length > maxItems ? filteredData.slice(0, maxItems) : filteredData;
           }
         }
       } else if (typeof oldSchemaItems === "boolean" && typeof newSchemaItems === "boolean" && oldSchemaItems === newSchemaItems) {
@@ -2263,16 +2378,16 @@
   }
   function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
     if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
-      const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-      const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals_default(item, _schema));
+      const innerSchema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+      const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals_default(item, innerSchema));
       if (sameSchemaIndex === -1) {
         return toPathSchemaInternal(
           validator,
-          _schema,
+          innerSchema,
           name,
           rootSchema,
           formData,
-          _recurseList.concat(_schema),
+          _recurseList.concat(innerSchema),
           experimental_customMergeAllOf
         );
       }
@@ -2292,12 +2407,12 @@
         discriminator,
         experimental_customMergeAllOf
       );
-      const _schema = xxxOf[index];
+      const innerSchema = xxxOf[index];
       pathSchema = {
         ...pathSchema,
         ...toPathSchemaInternal(
           validator,
-          _schema,
+          innerSchema,
           name,
           rootSchema,
           formData,
@@ -2307,9 +2422,9 @@
       };
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-      set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+      set3(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
       const additionalSchema = isObject2(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-      const definedProperties = get15(schema, PROPERTIES_KEY, {});
+      const definedProperties = get14(schema, PROPERTIES_KEY, {});
       for (const key of Object.keys(formData ?? {})) {
         if (!(key in definedProperties)) {
           pathSchema[key] = toPathSchemaInternal(
@@ -2317,7 +2432,7 @@
             additionalSchema,
             `${name}.${key}`,
             rootSchema,
-            get15(formData, [key]),
+            get14(formData, [key]),
             _recurseList,
             experimental_customMergeAllOf
           );
@@ -2367,7 +2482,7 @@
       }
     } else if (PROPERTIES_KEY in schema) {
       for (const property in schema.properties) {
-        const field = get15(schema, [PROPERTIES_KEY, property], {});
+        const field = get14(schema, [PROPERTIES_KEY, property], {});
         pathSchema[property] = toPathSchemaInternal(
           validator,
           field,
@@ -2375,7 +2490,7 @@
           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
-          get15(formData, [property]),
+          get14(formData, [property]),
           _recurseList,
           experimental_customMergeAllOf
         );
@@ -2397,8 +2512,8 @@
      * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
      */
     constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
-      if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-        this.rootSchema = makeAllReferencesAbsolute(rootSchema, get15(rootSchema, ID_KEY, "#"));
+      if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+        this.rootSchema = makeAllReferencesAbsolute(rootSchema, get14(rootSchema, ID_KEY, "#"));
       } else {
         this.rootSchema = rootSchema;
       }
@@ -2649,6 +2764,7 @@
      * @param [formData] - The current formData, if any, onto which to provide any missing defaults
      * @returns - The `PathSchema` object for the `schema`
      */
+    // oxlint-disable-next-line typescript/no-deprecated
     toPathSchema(schema, name, formData) {
       return toPathSchema(
         this.validator,
@@ -2671,7 +2787,7 @@
 
   // src/dataURItoBlob.ts
   function dataURItoBlob(dataURILike) {
-    if (dataURILike.indexOf("data:") === -1) {
+    if (!dataURILike.includes("data:")) {
       throw new Error("File is invalid: URI must be a dataURI");
     }
     const dataURI = dataURILike.slice(5);
@@ -2690,13 +2806,13 @@
     try {
       const binary = atob(base64);
       const array = new Array(binary.length);
-      for (let i = 0; i < binary.length; i++) {
+      for (let i = 0; i < binary.length; i += 1) {
         array[i] = binary.charCodeAt(i);
       }
       const blob = new window.Blob([new Uint8Array(array)], { type });
       return { blob, name };
     } catch (error) {
-      throw new Error("File is invalid: " + error.message);
+      throw new Error(`File is invalid: ${error.message}`);
     }
   }
 
@@ -2704,24 +2820,26 @@
   function pad(num, width) {
     let s = String(num);
     while (s.length < width) {
-      s = "0" + s;
+      s = `0${s}`;
     }
     return s;
   }
 
   // src/dateRangeOptions.ts
   function dateRangeOptions(start, stop) {
-    if (start <= 0 && stop <= 0) {
-      start = (/* @__PURE__ */ new Date()).getFullYear() + start;
-      stop = (/* @__PURE__ */ new Date()).getFullYear() + stop;
-    } else if (start < 0 || stop < 0) {
+    const bothRelative = start <= 0 && stop <= 0;
+    const eitherNegative = start < 0 || stop < 0;
+    if (!bothRelative && eitherNegative) {
       throw new Error(`Both start (${start}) and stop (${stop}) must both be <= 0 or > 0, got one of each`);
     }
-    if (start > stop) {
+    const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+    const resolvedStart = bothRelative ? currentYear + start : start;
+    const resolvedStop = bothRelative ? currentYear + stop : stop;
+    if (resolvedStart > resolvedStop) {
       return dateRangeOptions(stop, start).reverse();
     }
     const options = [];
-    for (let i = start; i <= stop; i++) {
+    for (let i = resolvedStart; i <= resolvedStop; i += 1) {
       options.push({ value: i, label: pad(i, 2) });
     }
     return options;
@@ -2817,7 +2935,7 @@
       return match.value;
     }
     const index = Number(value);
-    if (!isNaN(index) && index >= 0 && index < enumOptions.length) {
+    if (!Number.isNaN(index) && index >= 0 && index < enumOptions.length) {
       return enumOptions[index].value;
     }
     return emptyValue;
@@ -2869,7 +2987,7 @@
      */
     getOrCreateErrorBlock(pathOfError) {
       const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-      let errorBlock = hasPath ? get15(this.errorSchema, pathOfError) : this.errorSchema;
+      let errorBlock = hasPath ? get14(this.errorSchema, pathOfError) : this.errorSchema;
       if (!errorBlock && pathOfError) {
         errorBlock = {};
         setWith(this.errorSchema, pathOfError, errorBlock, Object);
@@ -2895,15 +3013,15 @@
      */
     addErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      let errorsList = get15(errorBlock, ERRORS_KEY);
+      let errorsList = get14(errorBlock, ERRORS_KEY);
       if (!Array.isArray(errorsList)) {
         errorsList = [];
         errorBlock[ERRORS_KEY] = errorsList;
       }
       if (Array.isArray(errorOrList)) {
-        set(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
+        set3(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
       } else {
-        set(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, errorOrList])]);
+        set3(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, errorOrList])]);
       }
       return this;
     }
@@ -2918,7 +3036,7 @@
     setErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
       const listToAdd = Array.isArray(errorOrList) ? [.../* @__PURE__ */ new Set([...errorOrList])] : [errorOrList];
-      set(errorBlock, ERRORS_KEY, listToAdd);
+      set3(errorBlock, ERRORS_KEY, listToAdd);
       return this;
     }
     /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
@@ -2930,7 +3048,7 @@
      */
     clearErrors(pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      set(errorBlock, ERRORS_KEY, []);
+      set3(errorBlock, ERRORS_KEY, []);
       return this;
     }
   };
@@ -2942,13 +3060,13 @@
     }
     if (aIsPlainObject && !bIsPlainObject) {
       return keys(a);
-    } else if (!aIsPlainObject && bIsPlainObject) {
+    }
+    if (!aIsPlainObject && bIsPlainObject) {
       return keys(b);
-    } else {
-      const unequalFields = keys(pickBy(a, (value, key) => !deepEquals_default(value, get15(b, key))));
-      const diffFields = difference(keys(b), keys(a));
-      return [...unequalFields, ...diffFields];
     }
+    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals_default(value, get14(b, key))));
+    const diffFields = difference(keys(b), keys(a));
+    return [...unequalFields, ...diffFields];
   }
 
   // src/getDateElementProps.ts
@@ -3047,7 +3165,7 @@
   };
   function getSubmitButtonOptions(uiSchema = {}) {
     const uiOptions = getUiOptions(uiSchema);
-    if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
+    if (uiOptions?.[SUBMIT_BTN_OPTIONS_KEY]) {
       const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
       return { ...DEFAULT_OPTIONS, ...options };
     }
@@ -3071,7 +3189,7 @@
     );
   }
   function getTestIds() {
-    if (get15(globalThis, "process.env.NODE_ENV") !== "test") {
+    if (get14(globalThis, "process.env.NODE_ENV") !== "test") {
       return {};
     }
     const ids = /* @__PURE__ */ new Map();
@@ -3140,13 +3258,11 @@
     }
   };
   function mergeWidgetOptions(AWidget) {
-    let MergedWidget = get15(AWidget, "MergedWidget");
+    let MergedWidget = get14(AWidget, "MergedWidget");
     if (!MergedWidget) {
-      const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
-      MergedWidget = ({ options, ...props }) => {
-        return /* @__PURE__ */ jsxRuntime.jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
-      };
-      set(AWidget, "MergedWidget", MergedWidget);
+      const defaultOptions = AWidget.defaultProps?.options || {};
+      MergedWidget = ({ options, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
+      set3(AWidget, "MergedWidget", MergedWidget);
     }
     return MergedWidget;
   }
@@ -3177,23 +3293,26 @@
   // src/hashForSchema.ts
   function hashString(string) {
     let hash = 0;
-    for (let i = 0; i < string.length; i += 1) {
+    for (let i = 0; i < string.length; i++) {
       const chr = string.charCodeAt(i);
       hash = (hash << 5) - hash + chr;
-      hash = hash & hash;
+      hash &= hash;
     }
     return hash.toString(16);
   }
   function sortedJSONStringify(object) {
     const allKeys = /* @__PURE__ */ new Set();
-    JSON.stringify(object, (key, value) => (allKeys.add(key), value));
+    JSON.stringify(object, (key, value) => {
+      allKeys.add(key);
+      return value;
+    });
     return JSON.stringify(object, Array.from(allKeys).sort());
   }
   function hashObject(object) {
     return hashString(sortedJSONStringify(object));
   }
   function hashForSchema(schema) {
-    return hashObject(schema);
+    return hashString(sortedJSONStringify(schema));
   }
 
   // src/hasWidget.ts
@@ -3244,6 +3363,8 @@
   function isFormDataAvailable(formData) {
     return !isNil(formData) && (!isObject2(formData) || Array.isArray(formData) || !isEmpty4(formData));
   }
+
+  // src/isRootSchema.ts
   function isRootSchema(registry, schemaToCompare) {
     const { rootSchema, schemaUtils } = registry;
     if (deepEquals_default(schemaToCompare, rootSchema)) {
@@ -3251,7 +3372,7 @@
     }
     if (REF_KEY in rootSchema) {
       const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-      return deepEquals_default(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
+      return deepEquals_default(schemaToCompare, resolvedSchema);
     }
     return false;
   }
@@ -3265,12 +3386,21 @@
   function localToUTC(dateString) {
     return dateString ? new Date(dateString).toJSON() : void 0;
   }
+
+  // src/logUnsupportedDefaultForEnum.ts
+  function logUnsupportedDefaultForEnum(id, schema, enumOptions, multiple = false) {
+    if (!multiple && Array.isArray(enumOptions) && schema.default !== void 0 && enumOptionsIndexForValue(schema.default, enumOptions, multiple) === void 0) {
+      console.error(
+        `The schema default value "${schema.default}" is not one of the values in the enum options for "${id}"`
+      );
+    }
+  }
   function lookupFromFormContext(regOrFc, toLookup, fallback) {
     const lookupPath = [LOOKUP_MAP_NAME];
     if (has5(regOrFc, FORM_CONTEXT_NAME)) {
       lookupPath.unshift(FORM_CONTEXT_NAME);
     }
-    return get15(regOrFc, [...lookupPath, toLookup], fallback);
+    return get14(regOrFc, [...lookupPath, toLookup], fallback);
   }
 
   // src/nameGenerators.ts
@@ -3298,9 +3428,9 @@
     if (!Array.isArray(order)) {
       return properties;
     }
-    const arrayToHash = (arr) => arr.reduce((prev, curr) => {
-      prev[curr] = true;
-      return prev;
+    const arrayToHash = (arr) => arr.reduce((acc, curr) => {
+      acc[curr] = true;
+      return acc;
     }, {});
     const errorPropList = (arr) => arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`;
     const propertyHash = arrayToHash(properties);
@@ -3336,7 +3466,7 @@
     }
     const date = new Date(dateString);
     if (Number.isNaN(date.getTime())) {
-      throw new Error("Unable to parse date " + dateString);
+      throw new Error(`Unable to parse date ${dateString}`);
     }
     return {
       year: date.getUTCFullYear(),
@@ -3389,11 +3519,10 @@
       const isArr = Array.isArray(value);
       if ((isObj || isArr) && properties[key]) {
         const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
-        if (!isRequired && isValueEmpty(cleaned)) {
-          continue;
+        if (isRequired || !isValueEmpty(cleaned)) {
+          result[key] = cleaned;
+          hasAnyValue = true;
         }
-        result[key] = cleaned;
-        hasAnyValue = true;
       } else if (isRequired || !isValueEmpty(value) || !properties[key]) {
         result[key] = value;
         if (!isValueEmpty(value)) {
@@ -3430,23 +3559,22 @@
       }
       for (const keyword of [ONE_OF_KEY, ANY_OF_KEY]) {
         const schemaOptions = resolvedSchema[keyword];
-        if (!Array.isArray(schemaOptions) || schemaOptions.length === 0) {
-          continue;
-        }
-        const currentUiSchemaArray = result[keyword];
-        const uiSchemaArray = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
-        let hasExpanded = false;
-        for (let i = 0; i < schemaOptions.length; i++) {
-          const option = schemaOptions[i];
-          const optionRef = option?.[RJSF_REF_KEY] ?? option?.[REF_KEY];
-          if (optionRef && optionRef in definitions) {
-            const optionUiSchema = uiSchemaArray[i] || {};
-            uiSchemaArray[i] = mergeObjects(definitions[optionRef], optionUiSchema);
-            hasExpanded = true;
+        if (Array.isArray(schemaOptions) && schemaOptions.length > 0) {
+          const currentUiSchemaArray = result[keyword];
+          const uiSchemaArray = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
+          let hasExpanded = false;
+          for (let i = 0; i < schemaOptions.length; i++) {
+            const option = schemaOptions[i];
+            const optionRef = option?.[RJSF_REF_KEY] ?? option?.[REF_KEY];
+            if (optionRef && optionRef in definitions) {
+              const optionUiSchema = uiSchemaArray[i] || {};
+              uiSchemaArray[i] = mergeObjects(definitions[optionRef], optionUiSchema);
+              hasExpanded = true;
+            }
+          }
+          if (hasExpanded) {
+            result[keyword] = uiSchemaArray;
           }
-        }
-        if (hasExpanded) {
-          result[keyword] = uiSchemaArray;
         }
       }
     }
@@ -3458,13 +3586,13 @@
     if (schema.const) {
       return true;
     }
-    if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
+    if (schema.enum?.length === 1 && schema.enum[0] === true) {
       return true;
     }
-    if (schema.anyOf && schema.anyOf.length === 1) {
+    if (schema.anyOf?.length === 1) {
       return schemaRequiresTrueValue(schema.anyOf[0]);
     }
-    if (schema.oneOf && schema.oneOf.length === 1) {
+    if (schema.oneOf?.length === 1) {
       return schemaRequiresTrueValue(schema.oneOf[0]);
     }
     if (schema.allOf) {
@@ -3473,6 +3601,35 @@
     }
     return false;
   }
+  function SelectedOptionDescription({ hideLabel, id, multiple, options, registry, uiSchema, value }) {
+    if (multiple || hideLabel) {
+      return null;
+    }
+    const { label = true } = getUiOptions(uiSchema, registry.globalUiOptions);
+    if (!label) {
+      return null;
+    }
+    const option = options.enumOptions?.find(({ value: enumValue }) => enumOptionsIsSelected(enumValue, value));
+    const description = option?.schema?.description;
+    if (!description) {
+      return null;
+    }
+    const DescriptionFieldTemplate = getTemplate(
+      "DescriptionFieldTemplate",
+      registry,
+      options
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      DescriptionFieldTemplate,
+      {
+        id: descriptionId(id),
+        description,
+        schema: option.schema,
+        uiSchema,
+        registry
+      }
+    );
+  }
 
   // src/shallowEquals.ts
   function shallowEquals(a, b) {
@@ -3490,9 +3647,9 @@
     if (keysA.length !== keysB.length) {
       return false;
     }
-    for (let i = 0; i < keysA.length; i++) {
+    for (let i = 0; i < keysA.length; i += 1) {
       const key = keysA[i];
-      if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      if (!Object.hasOwn(b, key) || !Object.is(a[key], b[key])) {
         return false;
       }
     }
@@ -3554,14 +3711,14 @@
         })
       );
     }
-    return Object.keys(errorSchema).reduce((acc, key) => {
+    return Object.keys(errorSchema).reduce((currentList, key) => {
       if (key !== ERRORS_KEY) {
         const childSchema = errorSchema[key];
         if (isPlainObject2(childSchema)) {
-          acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
+          return currentList.concat(toErrorList(childSchema, [...fieldPath, key]));
         }
       }
-      return acc;
+      return currentList;
     }, errorList);
   }
   function toErrorSchema(errors) {
@@ -3597,16 +3754,15 @@
     return Object.keys(errorHandler).reduce((acc, key) => {
       if (key === "addError") {
         return acc;
-      } else {
-        const childSchema = errorHandler[key];
-        if (isPlainObject2(childSchema)) {
-          return {
-            ...acc,
-            [key]: unwrapErrorHandler(childSchema)
-          };
-        }
-        return { ...acc, [key]: childSchema };
       }
+      const childSchema = errorHandler[key];
+      if (isPlainObject2(childSchema)) {
+        return {
+          ...acc,
+          [key]: unwrapErrorHandler(childSchema)
+        };
+      }
+      return { ...acc, [key]: childSchema };
     }, {});
   }
   function readyForChange(state) {
@@ -3630,7 +3786,7 @@
     } = props;
     const id = `${rootId}_${type}`;
     const { SelectWidget } = registry.widgets;
-    const onChange = react.useCallback((value2) => select(type, value2), [select, type]);
+    const onChange = react.useCallback((newValue) => select(type, newValue), [select, type]);
     return /* @__PURE__ */ jsxRuntime.jsx(
       SelectWidget,
       {
@@ -3660,10 +3816,10 @@
       setState(parseDateString(value, time));
     }, [time, value]);
     const handleChange = react.useCallback(
-      (property, value2) => {
+      (property, newValue) => {
         const nextState = {
           ...state,
-          [property]: typeof value2 === "undefined" ? -1 : value2
+          [property]: typeof newValue === "undefined" ? -1 : newValue
         };
         if (readyForChange(nextState)) {
           onChange(toDateString(nextState, time));
@@ -3715,7 +3871,7 @@
   function addNameToDataURL(dataURL, name) {
     return dataURL.replace(";base64", `;name=${encodeURIComponent(name)};base64`);
   }
-  function processFile(file) {
+  async function processFile(file) {
     const { name, size, type } = file;
     return new Promise((resolve, reject) => {
       const reader = new window.FileReader();
@@ -3740,7 +3896,7 @@
       reader.readAsDataURL(file);
     });
   }
-  function processFiles(files) {
+  async function processFiles(files) {
     return Promise.all(Array.from(files).map(processFile));
   }
   function extractFileInfo(dataURLs) {
@@ -3834,22 +3990,21 @@
     return { errorSchema, errors };
   }
   function withIdRefPrefixObject(node) {
-    for (const key in node) {
-      const realObj = node;
-      const value = realObj[key];
-      if (key === REF_KEY && typeof value === "string" && value.startsWith("#")) {
-        realObj[key] = ROOT_SCHEMA_PREFIX + value;
-      } else {
-        realObj[key] = withIdRefPrefix(value);
+    const realObj = node;
+    for (const key in realObj) {
+      if (Object.hasOwn(realObj, key)) {
+        const value = realObj[key];
+        if (key === REF_KEY && typeof value === "string" && value.startsWith("#")) {
+          realObj[key] = ROOT_SCHEMA_PREFIX + value;
+        } else {
+          realObj[key] = withIdRefPrefix(value);
+        }
       }
     }
     return node;
   }
   function withIdRefPrefixArray(node) {
-    for (let i = 0; i < node.length; i++) {
-      node[i] = withIdRefPrefix(node[i]);
-    }
-    return node;
+    return node.map((item) => withIdRefPrefix(item));
   }
   function withIdRefPrefix(schemaNode) {
     if (Array.isArray(schemaNode)) {
@@ -3874,6 +4029,7 @@
     TranslatableString2["AddButton"] = "Add";
     TranslatableString2["AddItemButton"] = "Add Item";
     TranslatableString2["CopyButton"] = "Copy";
+    TranslatableString2["ExpandButton"] = "Expand Cycle";
     TranslatableString2["MoveDownButton"] = "Move down";
     TranslatableString2["MoveUpButton"] = "Move up";
     TranslatableString2["RemoveButton"] = "Remove";
@@ -3894,6 +4050,7 @@
     TranslatableString2["TitleOptionPrefix"] = "%1 option %2";
     TranslatableString2["KeyLabel"] = "%1 Key";
     TranslatableString2["DeprecatedLabel"] = "%1 (deprecated)";
+    TranslatableString2["CycleDetected"] = 'Circular reference ($ref cycle) detected for field "%1". You may choose to expand to the next cycle break';
     TranslatableString2["InvalidObjectField"] = 'Invalid "%1" object field configuration: _%2_.';
     TranslatableString2["UnsupportedField"] = "Unsupported field schema.";
     TranslatableString2["UnsupportedFieldWithId"] = "Unsupported field schema for field `%1`.";
@@ -3927,7 +4084,7 @@
      * @param hash - The hash value at which to map the schema
      */
     addSchema(schema, hash) {
-      const key = get15(schema, ID_KEY, hash);
+      const key = get14(schema, ID_KEY, hash);
       const identifiedSchema = { ...schema, [ID_KEY]: key };
       const existing = this.schemaMap[key];
       if (!existing) {
@@ -3993,20 +4150,20 @@
   // src/parser/schemaParser.ts
   function parseSchema(validator, recurseList, rootSchema, schema) {
     const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
-    schemas.forEach((schema2) => {
-      const sameSchemaIndex = recurseList.findIndex((item) => deepEquals_default(item, schema2));
+    schemas.forEach((localSchema) => {
+      const sameSchemaIndex = recurseList.findIndex((item) => deepEquals_default(item, localSchema));
       if (sameSchemaIndex === -1) {
-        recurseList.push(schema2);
-        const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);
+        recurseList.push(localSchema);
+        const allOptions = resolveAnyOrOneOfSchemas(validator, localSchema, rootSchema, true);
         allOptions.forEach((s) => {
           if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
-            forEach(schema2[PROPERTIES_KEY], (value) => {
+            forEach(localSchema[PROPERTIES_KEY], (value) => {
               parseSchema(validator, recurseList, rootSchema, value);
             });
           }
         });
-        if (ITEMS_KEY in schema2 && !Array.isArray(schema2.items) && typeof schema2.items !== "boolean") {
-          parseSchema(validator, recurseList, rootSchema, schema2.items);
+        if (ITEMS_KEY in localSchema && !Array.isArray(localSchema.items) && typeof localSchema.items !== "boolean") {
+          parseSchema(validator, recurseList, rootSchema, localSchema.items);
         }
       }
     });
@@ -4049,10 +4206,13 @@
   exports.REF_KEY = REF_KEY;
   exports.REQUIRED_KEY = REQUIRED_KEY;
   exports.RJSF_ADDITIONAL_PROPERTIES_FLAG = RJSF_ADDITIONAL_PROPERTIES_FLAG;
+  exports.RJSF_PREFIX_KEY = RJSF_PREFIX_KEY;
+  exports.RJSF_REF_CYCLE_KEY = RJSF_REF_CYCLE_KEY;
   exports.RJSF_REF_KEY = RJSF_REF_KEY;
   exports.ROOT_SCHEMA_PREFIX = ROOT_SCHEMA_PREFIX;
   exports.SCHEMA_KEY = SCHEMA_KEY;
   exports.SUBMIT_BTN_OPTIONS_KEY = SUBMIT_BTN_OPTIONS_KEY;
+  exports.SelectedOptionDescription = SelectedOptionDescription;
   exports.TranslatableString = TranslatableString;
   exports.UI_DEFINITIONS_KEY = UI_DEFINITIONS_KEY;
   exports.UI_FIELD_KEY = UI_FIELD_KEY;
@@ -4123,6 +4283,7 @@
   exports.isValueEmpty = isValueEmpty;
   exports.labelValue = labelValue;
   exports.localToUTC = localToUTC;
+  exports.logUnsupportedDefaultForEnum = logUnsupportedDefaultForEnum;
   exports.lookupFromFormContext = lookupFromFormContext;
   exports.mergeDefaultsWithFormData = mergeDefaultsWithFormData;
   exports.mergeObjects = mergeObjects;