@rjsf/utils 6.6.1 → 6.7.0

package/dist/utils.esm.js

@@ -43,7 +43,7 @@ function asNumber(value) {
 }
 
 // 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";
@@ -65,15 +65,17 @@ var READONLY_KEY = "readonly";
 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";
@@ -87,7 +89,7 @@ function getUiOptions(uiSchema = {}, globalOptions = {}) {
   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)) {
@@ -131,21 +133,20 @@ function createErrorHandler(formData) {
     }
   };
   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 (isPlainObject(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;
 }
 
 // src/createSchemaUtils.ts
-import get17 from "lodash/get";
+import get16 from "lodash/get";
 
 // src/deepEquals.ts
 import { createCustomEqual } from "fast-equals";
@@ -191,20 +192,21 @@ function findEmbeddedSchemaRecursive(schema, ref) {
 }
 function makeAllReferencesAbsolute(schema, baseURI) {
   const currentURI = get(schema, ID_KEY, baseURI);
-  if (REF_KEY in schema) {
-    schema = { ...schema, [REF_KEY]: UriResolver.resolve(currentURI, schema[REF_KEY]) };
+  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];
@@ -214,22 +216,23 @@ function splitKeyElementFromObject(key, object) {
 function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get(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 (!isEmpty(refAnchor)) {
         current = jsonpointer.get(current, decodeURIComponent(refAnchor.join("#")));
       }
@@ -249,13 +252,12 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
       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;
   }
@@ -311,7 +313,7 @@ function guessType(value) {
   if (typeof value === "boolean") {
     return "boolean";
   }
-  if (!isNaN(value)) {
+  if (typeof value === "number" && !Number.isNaN(value)) {
     return "number";
   }
   if (typeof value === "object") {
@@ -337,7 +339,7 @@ function getSchemaType(schema) {
   }
   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];
     }
@@ -347,18 +349,22 @@ function getSchemaType(schema) {
 
 // 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;
 }
 
 // src/schema/getFirstMatchingOption.ts
@@ -372,23 +378,22 @@ function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorFi
   if (formData && discriminatorField) {
     const value = get3(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 = get3(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;
+      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
@@ -400,7 +405,7 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
   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 && has(option, [PROPERTIES_KEY, discriminatorField])) {
       const value = get4(formData, discriminatorField);
@@ -425,7 +430,7 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
         shallowClone.allOf.push(requiresAnyOf);
         augmentedSchema = shallowClone;
       } else {
-        augmentedSchema = Object.assign({}, option, requiresAnyOf);
+        augmentedSchema = { ...option, ...requiresAnyOf };
       }
       delete augmentedSchema.required;
       if (validator.isValid(augmentedSchema, formData, rootSchema)) {
@@ -461,6 +466,12 @@ function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experim
     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);
@@ -468,10 +479,11 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recu
   let schemas = [];
   if (expandAllBranches) {
     if (then && typeof then !== "boolean") {
+      const thenSchema = then;
       schemas = schemas.concat(
         retrieveSchemaInternal(
           validator,
-          then,
+          thenSchema,
           rootSchema,
           formData,
           expandAllBranches,
@@ -481,10 +493,11 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recu
       );
     }
     if (otherwise && typeof otherwise !== "boolean") {
+      const otherwiseSchema = otherwise;
       schemas = schemas.concat(
         retrieveSchemaInternal(
           validator,
-          otherwise,
+          otherwiseSchema,
           rootSchema,
           formData,
           expandAllBranches,
@@ -494,8 +507,9 @@ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recu
       );
     }
   } 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,
@@ -571,8 +585,8 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       formData,
       experimental_customMergeAllOf
     );
-    return resolvedSchemas.flatMap((s) => {
-      return retrieveSchemaInternal(
+    return resolvedSchemas.flatMap(
+      (s) => retrieveSchemaInternal(
         validator,
         s,
         rootSchema,
@@ -580,8 +594,8 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
         expandAllBranches,
         recurseList,
         experimental_customMergeAllOf
-      );
-    });
+      )
+    );
   }
   if (ALL_OF_KEY in schema && Array.isArray(schema[ALL_OF_KEY])) {
     const allOfSchemaElements = schema.allOf.map(
@@ -619,30 +633,38 @@ function resolveReference(validator, schema, rootSchema, expandAllBranches, recu
   }
   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);
       },
       {}
@@ -653,7 +675,14 @@ function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveA
   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) {
@@ -670,7 +699,7 @@ function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveA
       resolvedSchema = {
         ...resolvedSchema,
         [key]: schemas.map(
-          (s) => resolveAllReferences(s, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs)
+          (s) => resolveAllReferences(s, rootSchema, recurseList, currentBaseURI, resolveAnyOfOrOneOfRefs)
         )
       };
     }
@@ -697,7 +726,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
           get5(formData, [key]),
           experimental_customMergeAllOf
         );
-        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
         return;
       }
     }
@@ -709,7 +738,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
             validator,
             { [REF_KEY]: get5(schema.additionalProperties, [REF_KEY]) },
             rootSchema,
-            formData,
+            get5(formData, [key]),
             experimental_customMergeAllOf
           );
         } else if ("type" in schema.additionalProperties) {
@@ -726,10 +755,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
         additionalProperties = { type: guessType(get5(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;
@@ -772,17 +801,26 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
       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;
         }
@@ -794,18 +832,18 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     }
     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 (!isEmpty2(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,
               get5(rawFormData, [key]),
               experimental_customMergeAllOf
             );
           }
-          return schema2;
+          return acc;
         },
         {
           ...resolvedSchema,
@@ -837,23 +875,21 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
   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;
@@ -884,43 +920,39 @@ function resolveDependencies(validator, schema, rootSchema, expandAllBranches, r
 function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
   let schemas = [resolvedSchema];
   for (const dependencyKey in dependencies) {
-    if (!expandAllBranches && get5(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 || get5(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;
 }
@@ -943,9 +975,9 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
   );
   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)) {
@@ -957,7 +989,7 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
     return allPermutations.flatMap(
       (resolvedOneOf) => withExactlyOneSubschema(
         validator,
-        schema,
+        mergedSchema,
         rootSchema,
         dependencyKey,
         resolvedOneOf,
@@ -971,7 +1003,7 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
 }
 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;
@@ -1003,7 +1035,7 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
       recurseList,
       experimental_customMergeAllOf
     );
-    return schemas.map((s2) => mergeSchemas(schema, s2));
+    return schemas.map((resolvedSubschema) => mergeSchemas(schema, resolvedSubschema));
   });
 }
 
@@ -1017,12 +1049,16 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
     );
     const data = get6(formData, selectorField);
     if (data !== void 0) {
-      return xxxOfs.find((xxx2) => {
-        return deepEquals_default(
-          get6(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get6(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+      return xxxOfs.find(
+        (xxxOfOption) => deepEquals_default(
+          get6(
+            xxxOfOption,
+            [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
+            get6(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
+          ),
           data
-        );
-      });
+        )
+      );
     }
   }
   return void 0;
@@ -1194,23 +1230,21 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
             );
           }
           if ((has4(value, ONE_OF_KEY) || has4(value, ANY_OF_KEY)) && formValue) {
-            const key2 = has4(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const xxxOfKey = has4(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
             const discriminator = getDiscriminatorFieldFromSchema(value);
             return score + getClosestMatchingOption(
               validator,
               rootSchema,
               formValue,
-              get9(value, key2),
+              get9(value, xxxOfKey),
               -1,
               discriminator,
               experimental_customMergeAllOf
             );
           }
           if (value.type === "object") {
-            if (isObject3(formValue)) {
-              score += 1;
-            }
-            return score + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
+            const structureBoost = isObject3(formValue) ? 1 : 0;
+            return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
           }
           if (value.type === guessType(formValue)) {
             let newScore = score + 1;
@@ -1232,9 +1266,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
   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 (isNumber2(simpleDiscriminatorMatch)) {
     return simpleDiscriminatorMatch;
@@ -1292,7 +1324,7 @@ function isConstant(schema) {
 
 // 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));
 }
 
 // src/mergeDefaultsWithFormData.ts
@@ -1322,7 +1354,7 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
   }
   if (isObject(formData)) {
     const acc = Object.assign({}, defaults);
-    return Object.keys(formData).reduce((acc2, key) => {
+    return Object.keys(formData).reduce((accumulator, key) => {
       const keyValue = get10(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in defaults;
       const keyExistsInFormData = key in formData;
@@ -1331,13 +1363,13 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       const keyDefaultIsObject = keyExistsInDefaults && isObject(get10(defaults, key));
       const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
       if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
-        acc2[key] = {
+        accumulator[key] = {
           ...get10(defaults, key),
           ...keyValue
         };
-        return acc2;
+        return accumulator;
       }
-      acc2[key] = mergeDefaultsWithFormData(
+      accumulator[key] = mergeDefaultsWithFormData(
         get10(defaults, key),
         keyValue,
         mergeExtraArrayDefaults,
@@ -1346,10 +1378,10 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
         // 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;
@@ -1378,7 +1410,7 @@ function mergeObjects(obj1, obj2, concatArrays = false) {
       }
       return acc;
     },
-    Object.assign({}, obj1)
+    { ...obj1 }
   );
 }
 
@@ -1441,7 +1473,7 @@ function optionsList(schema, uiSchema) {
     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;
@@ -1449,10 +1481,10 @@ function optionsList(schema, uiSchema) {
     if (selectorField) {
       const innerSchema = get11(aSchema, [PROPERTIES_KEY, selectorField], {});
       value = get11(innerSchema, DEFAULT_KEY, get11(innerSchema, CONST_KEY));
-      label = label || innerSchema?.title || aSchema.title || String(value);
+      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,
@@ -1470,7 +1502,7 @@ function isSelect(validator, theSchema, rootSchema = {}, experimental_customMerg
     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;
 }
@@ -1506,23 +1538,23 @@ function computeDefaultBasedOnSchemaTypeAndDefaults(schema, computedDefault) {
   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
@@ -1531,7 +1563,7 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
       // 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;
     }
   }
 }
@@ -1542,8 +1574,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     rootSchema = {},
     includeUndefinedValues = false,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = void 0,
-    experimental_customMergeAllOf = void 0,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     shouldMergeDefaultsIntoFormData = false,
     initialDefaultsGenerated
@@ -1551,14 +1583,19 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
   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];
@@ -1587,8 +1624,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       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,
@@ -1684,16 +1721,36 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
   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 = get12(schemaToMatch, [PROPERTIES_KEY, key], {});
+        if (key in acc && (shouldRetrieveAllOf || isObject(propertySchema) && ALL_OF_KEY in propertySchema)) {
+          acc[key] = ensureFormDataMatchingSchema(
+            validator,
+            propertySchema,
+            rootSchema,
+            get12(acc, key),
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf
+          );
+        }
+        return acc;
+      },
+      { ...validFormData }
+    );
   }
   return validFormData;
 }
@@ -1702,8 +1759,8 @@ function getObjectDefaults(validator, rawSchema, {
   rootSchema = {},
   includeUndefinedValues = false,
   _recurseList = [],
-  experimental_defaultFormStateBehavior = void 0,
-  experimental_customMergeAllOf = void 0,
+  experimental_defaultFormStateBehavior,
+  experimental_customMergeAllOf,
   required,
   shouldMergeDefaultsIntoFormData,
   initialDefaultsGenerated
@@ -1787,13 +1844,14 @@ function getArrayDefaults(validator, rawSchema, {
   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;
@@ -1825,8 +1883,8 @@ function getArrayDefaults(validator, rawSchema, {
     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,
@@ -1836,20 +1894,27 @@ function getArrayDefaults(validator, rawSchema, {
           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 {
@@ -1881,11 +1946,13 @@ function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps
     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, {
@@ -1907,9 +1974,17 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
   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,
@@ -1921,15 +1996,12 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
   return defaults;
 }
 
-// src/schema/getDisplayLabel.ts
-import get13 from "lodash/get";
-
 // src/isCustomWidget.ts
 function isCustomWidget(uiSchema = {}) {
   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"
   );
 }
 
@@ -1958,7 +2030,7 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   let displayLabel = Boolean(label);
   if (displayLabel) {
     const schemaType = getSchemaType(schema);
-    const addedByAdditionalProperty = get13(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);
     }
@@ -1968,7 +2040,7 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
     if (schemaType === "boolean" && uiSchema && !uiSchema[UI_WIDGET_KEY]) {
       displayLabel = false;
     }
-    if (uiSchema && uiSchema[UI_FIELD_KEY]) {
+    if (uiSchema?.[UI_FIELD_KEY]) {
       displayLabel = false;
     }
   }
@@ -1976,7 +2048,7 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
 }
 
 // src/schema/omitExtraData.ts
-import get14 from "lodash/get";
+import get13 from "lodash/get";
 import isEmpty5 from "lodash/isEmpty";
 import isNil2 from "lodash/isNil";
 import pick from "lodash/pick";
@@ -2005,7 +2077,7 @@ function getFieldNames(pathSchema, formData) {
         }
       } else if (key === NAME_KEY && data !== "") {
         paths.forEach((path) => {
-          const formValue = get14(formData, path);
+          const formValue = get13(formData, path);
           const isLeaf = objKeys.length === 1;
           if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
             acc.push(path);
@@ -2039,11 +2111,11 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
   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) {
@@ -2075,15 +2147,14 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
       ]);
       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) {
@@ -2095,10 +2166,9 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
       } 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);
         }
       }
     }
@@ -2109,37 +2179,37 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
     }
     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);
@@ -2149,96 +2219,130 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
       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 || isEmpty5(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);
 }
 
 // src/schema/sanitizeDataForNewSchema.ts
-import get15 from "lodash/get";
+import get14 from "lodash/get";
 import has5 from "lodash/has";
 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,
@@ -2257,8 +2361,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           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];
@@ -2276,31 +2380,37 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             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(
@@ -2320,10 +2430,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           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(
@@ -2340,7 +2450,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             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) {
@@ -2351,21 +2463,21 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toPathSchema.ts
-import get16 from "lodash/get";
+import get15 from "lodash/get";
 import isObject4 from "lodash/isObject";
 import set2 from "lodash/set";
 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
       );
     }
@@ -2385,12 +2497,12 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
       discriminator,
       experimental_customMergeAllOf
     );
-    const _schema = xxxOf[index];
+    const innerSchema = xxxOf[index];
     pathSchema = {
       ...pathSchema,
       ...toPathSchemaInternal(
         validator,
-        _schema,
+        innerSchema,
         name,
         rootSchema,
         formData,
@@ -2402,7 +2514,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
     set2(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
     const additionalSchema = isObject4(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-    const definedProperties = get16(schema, PROPERTIES_KEY, {});
+    const definedProperties = get15(schema, PROPERTIES_KEY, {});
     for (const key of Object.keys(formData ?? {})) {
       if (!(key in definedProperties)) {
         pathSchema[key] = toPathSchemaInternal(
@@ -2410,7 +2522,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
           additionalSchema,
           `${name}.${key}`,
           rootSchema,
-          get16(formData, [key]),
+          get15(formData, [key]),
           _recurseList,
           experimental_customMergeAllOf
         );
@@ -2460,7 +2572,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = get16(schema, [PROPERTIES_KEY, property], {});
+      const field = get15(schema, [PROPERTIES_KEY, property], {});
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -2468,7 +2580,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        get16(formData, [property]),
+        get15(formData, [property]),
         _recurseList,
         experimental_customMergeAllOf
       );
@@ -2490,8 +2602,8 @@ var SchemaUtils = class {
    * @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, get17(rootSchema, ID_KEY, "#"));
+    if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, get16(rootSchema, ID_KEY, "#"));
     } else {
       this.rootSchema = rootSchema;
     }
@@ -2742,6 +2854,7 @@ var SchemaUtils = class {
    * @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,
@@ -2764,7 +2877,7 @@ function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateB
 
 // 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);
@@ -2783,13 +2896,13 @@ function dataURItoBlob(dataURILike) {
   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}`);
   }
 }
 
@@ -2797,24 +2910,26 @@ function dataURItoBlob(dataURILike) {
 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;
@@ -2913,7 +3028,7 @@ function decodeSingle(value, enumOptions, emptyValue) {
     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;
@@ -2945,7 +3060,7 @@ function enumOptionValueEncoder(value, index, format = "indexed") {
 
 // src/ErrorSchemaBuilder.ts
 import cloneDeep from "lodash/cloneDeep";
-import get18 from "lodash/get";
+import get17 from "lodash/get";
 import set3 from "lodash/set";
 import setWith from "lodash/setWith";
 var ErrorSchemaBuilder = class {
@@ -2974,7 +3089,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? get18(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? get17(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       setWith(this.errorSchema, pathOfError, errorBlock, Object);
@@ -3000,7 +3115,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get18(errorBlock, ERRORS_KEY);
+    let errorsList = get17(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -3042,7 +3157,7 @@ var ErrorSchemaBuilder = class {
 
 // src/getChangedFields.ts
 import difference from "lodash/difference";
-import get19 from "lodash/get";
+import get18 from "lodash/get";
 import isPlainObject2 from "lodash/isPlainObject";
 import keys from "lodash/keys";
 import pickBy from "lodash/pickBy";
@@ -3054,13 +3169,13 @@ function getChangedFields(a, b) {
   }
   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, get19(b, key))));
-    const diffFields = difference(keys(b), keys(a));
-    return [...unequalFields, ...diffFields];
   }
+  const unequalFields = keys(pickBy(a, (value, key) => !deepEquals_default(value, get18(b, key))));
+  const diffFields = difference(keys(b), keys(a));
+  return [...unequalFields, ...diffFields];
 }
 
 // src/getDateElementProps.ts
@@ -3159,7 +3274,7 @@ var DEFAULT_OPTIONS = {
 };
 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 };
   }
@@ -3184,10 +3299,10 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-import get20 from "lodash/get";
+import get19 from "lodash/get";
 import uniqueId from "lodash/uniqueId";
 function getTestIds() {
-  if (get20(globalThis, "process.env.NODE_ENV") !== "test") {
+  if (get19(globalThis, "process.env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3206,7 +3321,7 @@ function getTestIds() {
 
 // src/getWidget.tsx
 import { createElement } from "react";
-import get21 from "lodash/get";
+import get20 from "lodash/get";
 import set4 from "lodash/set";
 import ReactIs from "react-is";
 import { jsx } from "react/jsx-runtime";
@@ -3263,12 +3378,10 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get21(AWidget, "MergedWidget");
+  let MergedWidget = get20(AWidget, "MergedWidget");
   if (!MergedWidget) {
-    const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
-    MergedWidget = ({ options, ...props }) => {
-      return /* @__PURE__ */ jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
-    };
+    const defaultOptions = AWidget.defaultProps?.options || {};
+    MergedWidget = ({ options, ...props }) => /* @__PURE__ */ jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
     set4(AWidget, "MergedWidget", MergedWidget);
   }
   return MergedWidget;
@@ -3300,23 +3413,26 @@ function getWidget(schema, widget, registeredWidgets = {}) {
 // 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
@@ -3377,7 +3493,6 @@ function isFormDataAvailable(formData) {
 }
 
 // src/isRootSchema.ts
-import omit2 from "lodash/omit";
 function isRootSchema(registry, schemaToCompare) {
   const { rootSchema, schemaUtils } = registry;
   if (deepEquals_default(schemaToCompare, rootSchema)) {
@@ -3385,7 +3500,7 @@ function isRootSchema(registry, schemaToCompare) {
   }
   if (REF_KEY in rootSchema) {
     const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-    return deepEquals_default(schemaToCompare, omit2(resolvedSchema, RJSF_REF_KEY));
+    return deepEquals_default(schemaToCompare, resolvedSchema);
   }
   return false;
 }
@@ -3400,15 +3515,24 @@ 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}"`
+    );
+  }
+}
+
 // src/lookupFromFormContext.ts
-import get22 from "lodash/get";
+import get21 from "lodash/get";
 import has6 from "lodash/has";
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
   if (has6(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return get22(regOrFc, [...lookupPath, toLookup], fallback);
+  return get21(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/nameGenerators.ts
@@ -3436,9 +3560,9 @@ function orderProperties(properties, order) {
   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);
@@ -3474,7 +3598,7 @@ function parseDateString(dateString, includeTime = true) {
   }
   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(),
@@ -3527,11 +3651,10 @@ function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
     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)) {
@@ -3571,23 +3694,22 @@ function resolveUiSchema(schema, localUiSchema, registry) {
     }
     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;
       }
     }
   }
@@ -3599,13 +3721,13 @@ function schemaRequiresTrueValue(schema) {
   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) {
@@ -3615,6 +3737,38 @@ function schemaRequiresTrueValue(schema) {
   return false;
 }
 
+// src/SelectedOptionDescription.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+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__ */ jsx2(
+    DescriptionFieldTemplate,
+    {
+      id: descriptionId(id),
+      description,
+      schema: option.schema,
+      uiSchema,
+      registry
+    }
+  );
+}
+
 // src/shallowEquals.ts
 function shallowEquals(a, b) {
   if (Object.is(a, b)) {
@@ -3631,9 +3785,9 @@ function shallowEquals(a, b) {
   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;
     }
   }
@@ -3702,14 +3856,14 @@ function toErrorList(errorSchema, fieldPath = []) {
       })
     );
   }
-  return Object.keys(errorSchema).reduce((acc, key) => {
+  return Object.keys(errorSchema).reduce((currentList, key) => {
     if (key !== ERRORS_KEY) {
       const childSchema = errorSchema[key];
       if (isPlainObject3(childSchema)) {
-        acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
+        return currentList.concat(toErrorList(childSchema, [...fieldPath, key]));
       }
     }
-    return acc;
+    return currentList;
   }, errorList);
 }
 
@@ -3751,22 +3905,21 @@ function unwrapErrorHandler(errorHandler) {
   return Object.keys(errorHandler).reduce((acc, key) => {
     if (key === "addError") {
       return acc;
-    } else {
-      const childSchema = errorHandler[key];
-      if (isPlainObject4(childSchema)) {
-        return {
-          ...acc,
-          [key]: unwrapErrorHandler(childSchema)
-        };
-      }
-      return { ...acc, [key]: childSchema };
     }
+    const childSchema = errorHandler[key];
+    if (isPlainObject4(childSchema)) {
+      return {
+        ...acc,
+        [key]: unwrapErrorHandler(childSchema)
+      };
+    }
+    return { ...acc, [key]: childSchema };
   }, {});
 }
 
 // src/useAltDateWidgetProps.tsx
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx as jsx3 } from "react/jsx-runtime";
 function readyForChange(state) {
   return Object.values(state).every((value) => value !== -1);
 }
@@ -3788,8 +3941,8 @@ function DateElement(props) {
   } = props;
   const id = `${rootId}_${type}`;
   const { SelectWidget } = registry.widgets;
-  const onChange = useCallback((value2) => select(type, value2), [select, type]);
-  return /* @__PURE__ */ jsx2(
+  const onChange = useCallback((newValue) => select(type, newValue), [select, type]);
+  return /* @__PURE__ */ jsx3(
     SelectWidget,
     {
       schema: { type: "integer" },
@@ -3818,10 +3971,10 @@ function useAltDateWidgetProps(props) {
     setState(parseDateString(value, time));
   }, [time, value]);
   const handleChange = 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));
@@ -3879,7 +4032,7 @@ import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
 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();
@@ -3904,7 +4057,7 @@ function processFile(file) {
     reader.readAsDataURL(file);
   });
 }
-function processFiles(files) {
+async function processFiles(files) {
   return Promise.all(Array.from(files).map(processFile));
 }
 function extractFileInfo(dataURLs) {
@@ -4004,22 +4157,21 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
 // src/withIdRefPrefix.ts
 import isObject7 from "lodash/isObject";
 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)) {
@@ -4044,6 +4196,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   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";
@@ -4064,6 +4217,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   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`.";
@@ -4077,7 +4231,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 import forEach from "lodash/forEach";
 
 // src/parser/ParserValidator.ts
-import get23 from "lodash/get";
+import get22 from "lodash/get";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -4103,7 +4257,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get23(schema, ID_KEY, hash);
+    const key = get22(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -4169,20 +4323,20 @@ var ParserValidator = class {
 // 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);
       }
     }
   });
@@ -4225,10 +4379,13 @@ export {
   REF_KEY,
   REQUIRED_KEY,
   RJSF_ADDITIONAL_PROPERTIES_FLAG,
+  RJSF_PREFIX_KEY,
+  RJSF_REF_CYCLE_KEY,
   RJSF_REF_KEY,
   ROOT_SCHEMA_PREFIX,
   SCHEMA_KEY,
   SUBMIT_BTN_OPTIONS_KEY,
+  SelectedOptionDescription,
   TranslatableString,
   UI_DEFINITIONS_KEY,
   UI_FIELD_KEY,
@@ -4299,6 +4456,7 @@ export {
   isValueEmpty,
   labelValue,
   localToUTC,
+  logUnsupportedDefaultForEnum,
   lookupFromFormContext,
   mergeDefaultsWithFormData,
   mergeObjects,