@rjsf/utils 6.6.1 → 6.7.0

package/dist/index.cjs

@@ -61,10 +61,13 @@ __export(index_exports, {
   REF_KEY: () => REF_KEY,
   REQUIRED_KEY: () => REQUIRED_KEY,
   RJSF_ADDITIONAL_PROPERTIES_FLAG: () => RJSF_ADDITIONAL_PROPERTIES_FLAG,
+  RJSF_PREFIX_KEY: () => RJSF_PREFIX_KEY,
+  RJSF_REF_CYCLE_KEY: () => RJSF_REF_CYCLE_KEY,
   RJSF_REF_KEY: () => RJSF_REF_KEY,
   ROOT_SCHEMA_PREFIX: () => ROOT_SCHEMA_PREFIX,
   SCHEMA_KEY: () => SCHEMA_KEY,
   SUBMIT_BTN_OPTIONS_KEY: () => SUBMIT_BTN_OPTIONS_KEY,
+  SelectedOptionDescription: () => SelectedOptionDescription,
   TranslatableString: () => TranslatableString,
   UI_DEFINITIONS_KEY: () => UI_DEFINITIONS_KEY,
   UI_FIELD_KEY: () => UI_FIELD_KEY,
@@ -135,6 +138,7 @@ __export(index_exports, {
   isValueEmpty: () => isValueEmpty,
   labelValue: () => labelValue,
   localToUTC: () => localToUTC,
+  logUnsupportedDefaultForEnum: () => logUnsupportedDefaultForEnum,
   lookupFromFormContext: () => lookupFromFormContext,
   mergeDefaultsWithFormData: () => mergeDefaultsWithFormData,
   mergeObjects: () => mergeObjects,
@@ -221,7 +225,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";
@@ -243,15 +247,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";
@@ -265,7 +271,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)) {
@@ -309,21 +315,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 ((0, import_isPlainObject.default)(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
-var import_get17 = __toESM(require("lodash/get"), 1);
+var import_get16 = __toESM(require("lodash/get"), 1);
 
 // src/deepEquals.ts
 var import_fast_equals = require("fast-equals");
@@ -369,20 +374,21 @@ function findEmbeddedSchemaRecursive(schema, ref) {
 }
 function makeAllReferencesAbsolute(schema, baseURI) {
   const currentURI = (0, import_get.default)(schema, ID_KEY, baseURI);
-  if (REF_KEY in schema) {
-    schema = { ...schema, [REF_KEY]: import_fast_uri.default.resolve(currentURI, schema[REF_KEY]) };
+  let result = schema;
+  if (REF_KEY in result) {
+    result = { ...result, [REF_KEY]: import_fast_uri.default.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) => (0, import_isObject3.default)(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
       };
     } else if ((0, import_isObject3.default)(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];
@@ -392,22 +398,23 @@ function splitKeyElementFromObject(key, object) {
 function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = (0, import_get.default)(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 = import_jsonpointer.default.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 = import_jsonpointer.default.get(current, decodedRef);
       }
     }
   } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-    const resolvedRef = baseURI ? import_fast_uri.default.resolve(baseURI, ref) : ref;
+    const resolvedRef = currentBaseURI ? import_fast_uri.default.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 (!(0, import_isEmpty.default)(refAnchor)) {
         current = import_jsonpointer.default.get(current, decodeURIComponent(refAnchor.join("#")));
       }
@@ -427,13 +434,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;
   }
@@ -489,7 +495,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") {
@@ -515,7 +521,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];
     }
@@ -525,18 +531,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] = (0, import_union.default)(left, right);
+      accumulator[key] = (0, import_union.default)(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
@@ -550,23 +560,22 @@ function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorFi
   if (formData && discriminatorField) {
     const value = (0, import_get3.default)(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 = (0, import_get3.default)(option, [PROPERTIES_KEY, discriminatorField], {});
-      if (discriminator.type === "object" || discriminator.type === "array") {
-        continue;
-      }
-      if (discriminator.const === value) {
-        return i;
-      }
-      if (discriminator.enum?.includes(value)) {
-        return i;
+      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
@@ -578,7 +587,7 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
   if ((0, import_isNumber.default)(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 && (0, import_has.default)(option, [PROPERTIES_KEY, discriminatorField])) {
       const value = (0, import_get4.default)(formData, discriminatorField);
@@ -603,7 +612,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)) {
@@ -639,6 +648,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);
@@ -646,10 +661,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,
@@ -659,10 +675,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,
@@ -672,8 +689,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,
@@ -749,8 +767,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,
@@ -758,8 +776,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(
@@ -797,30 +815,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 = (0, import_transform.default)(
       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);
       },
       {}
@@ -831,7 +857,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) {
@@ -848,7 +881,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)
         )
       };
     }
@@ -875,7 +908,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
           (0, import_get5.default)(formData, [key]),
           experimental_customMergeAllOf
         );
-        (0, import_set.default)(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
         return;
       }
     }
@@ -887,7 +920,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
             validator,
             { [REF_KEY]: (0, import_get5.default)(schema.additionalProperties, [REF_KEY]) },
             rootSchema,
-            formData,
+            (0, import_get5.default)(formData, [key]),
             experimental_customMergeAllOf
           );
         } else if ("type" in schema.additionalProperties) {
@@ -904,10 +937,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
         additionalProperties = { type: guessType((0, import_get5.default)(formData, [key])) };
       }
       schema.properties[key] = additionalProperties;
-      (0, import_set.default)(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+      schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
     } else {
       schema.properties[key] = { type: "null" };
-      (0, import_set.default)(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+      schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
     }
   });
   return schema;
@@ -950,17 +983,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;
         }
@@ -972,18 +1014,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 (!(0, import_isEmpty2.default)(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,
               (0, import_get5.default)(rawFormData, [key]),
               experimental_customMergeAllOf
             );
           }
-          return schema2;
+          return acc;
         },
         {
           ...resolvedSchema,
@@ -1015,23 +1057,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;
@@ -1062,43 +1102,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 && (0, import_get5.default)(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 || (0, import_get5.default)(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;
 }
@@ -1121,9 +1157,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)) {
@@ -1135,7 +1171,7 @@ function withDependentSchema(validator, schema, rootSchema, dependencyKey, depen
     return allPermutations.flatMap(
       (resolvedOneOf) => withExactlyOneSubschema(
         validator,
-        schema,
+        mergedSchema,
         rootSchema,
         dependencyKey,
         resolvedOneOf,
@@ -1149,7 +1185,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;
@@ -1181,7 +1217,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));
   });
 }
 
@@ -1195,12 +1231,16 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
     );
     const data = (0, import_get6.default)(formData, selectorField);
     if (data !== void 0) {
-      return xxxOfs.find((xxx2) => {
-        return deepEquals_default(
-          (0, import_get6.default)(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], (0, import_get6.default)(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+      return xxxOfs.find(
+        (xxxOfOption) => deepEquals_default(
+          (0, import_get6.default)(
+            xxxOfOption,
+            [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
+            (0, import_get6.default)(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
+          ),
           data
-        );
-      });
+        )
+      );
     }
   }
   return void 0;
@@ -1372,23 +1412,21 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
             );
           }
           if (((0, import_has4.default)(value, ONE_OF_KEY) || (0, import_has4.default)(value, ANY_OF_KEY)) && formValue) {
-            const key2 = (0, import_has4.default)(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const xxxOfKey = (0, import_has4.default)(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
             const discriminator = getDiscriminatorFieldFromSchema(value);
             return score + getClosestMatchingOption(
               validator,
               rootSchema,
               formValue,
-              (0, import_get9.default)(value, key2),
+              (0, import_get9.default)(value, xxxOfKey),
               -1,
               discriminator,
               experimental_customMergeAllOf
             );
           }
           if (value.type === "object") {
-            if ((0, import_isObject6.default)(formValue)) {
-              score += 1;
-            }
-            return score + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
+            const structureBoost = (0, import_isObject6.default)(formValue) ? 1 : 0;
+            return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
           }
           if (value.type === guessType(formValue)) {
             let newScore = score + 1;
@@ -1410,9 +1448,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 ((0, import_isNumber2.default)(simpleDiscriminatorMatch)) {
     return simpleDiscriminatorMatch;
@@ -1470,7 +1506,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
@@ -1500,7 +1536,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 = (0, import_get10.default)(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in defaults;
       const keyExistsInFormData = key in formData;
@@ -1509,13 +1545,13 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       const keyDefaultIsObject = keyExistsInDefaults && isObject((0, import_get10.default)(defaults, key));
       const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
       if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
-        acc2[key] = {
+        accumulator[key] = {
           ...(0, import_get10.default)(defaults, key),
           ...keyValue
         };
-        return acc2;
+        return accumulator;
       }
-      acc2[key] = mergeDefaultsWithFormData(
+      accumulator[key] = mergeDefaultsWithFormData(
         (0, import_get10.default)(defaults, key),
         keyValue,
         mergeExtraArrayDefaults,
@@ -1524,10 +1560,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) && (0, import_isNil.default)(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(formData)) {
+  if (defaultSupercedesUndefined && (!(defaults === void 0) && (0, import_isNil.default)(formData) || typeof formData === "number" && Number.isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(formData)) {
     return defaults;
   }
   return formData;
@@ -1556,7 +1592,7 @@ function mergeObjects(obj1, obj2, concatArrays = false) {
       }
       return acc;
     },
-    Object.assign({}, obj1)
+    { ...obj1 }
   );
 }
 
@@ -1619,7 +1655,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;
@@ -1627,10 +1663,10 @@ function optionsList(schema, uiSchema) {
     if (selectorField) {
       const innerSchema = (0, import_get11.default)(aSchema, [PROPERTIES_KEY, selectorField], {});
       value = (0, import_get11.default)(innerSchema, DEFAULT_KEY, (0, import_get11.default)(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,
@@ -1648,7 +1684,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;
 }
@@ -1684,23 +1720,23 @@ function computeDefaultBasedOnSchemaTypeAndDefaults(schema, computedDefault) {
   const shouldReturnNullAsDefault = Array.isArray(type) && type.includes("null") && (0, import_isEmpty4.default)(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) || !(0, import_isEmpty4.default)(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 (!(0, import_isEmpty4.default)(computedDefault)) {
-          obj[key] = computedDefault;
+          acc[key] = computedDefault;
         }
       } else if ((!(0, import_isEmpty4.default)(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
@@ -1709,7 +1745,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;
     }
   }
 }
@@ -1720,8 +1756,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
@@ -1729,14 +1765,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];
@@ -1765,8 +1806,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,
@@ -1862,16 +1903,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 = (0, import_get12.default)(schemaToMatch, [PROPERTIES_KEY, key], {});
+        if (key in acc && (shouldRetrieveAllOf || isObject(propertySchema) && ALL_OF_KEY in propertySchema)) {
+          acc[key] = ensureFormDataMatchingSchema(
+            validator,
+            propertySchema,
+            rootSchema,
+            (0, import_get12.default)(acc, key),
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf
+          );
+        }
+        return acc;
+      },
+      { ...validFormData }
+    );
   }
   return validFormData;
 }
@@ -1880,8 +1941,8 @@ function getObjectDefaults(validator, rawSchema, {
   rootSchema = {},
   includeUndefinedValues = false,
   _recurseList = [],
-  experimental_defaultFormStateBehavior = void 0,
-  experimental_customMergeAllOf = void 0,
+  experimental_defaultFormStateBehavior,
+  experimental_customMergeAllOf,
   required,
   shouldMergeDefaultsIntoFormData,
   initialDefaultsGenerated
@@ -1965,13 +2026,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;
@@ -2003,8 +2065,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,
@@ -2014,20 +2076,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 {
@@ -2059,11 +2128,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, {
@@ -2085,9 +2156,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,
@@ -2099,15 +2178,12 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
   return defaults;
 }
 
-// src/schema/getDisplayLabel.ts
-var import_get13 = __toESM(require("lodash/get"), 1);
-
 // 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"
   );
 }
 
@@ -2136,7 +2212,7 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   let displayLabel = Boolean(label);
   if (displayLabel) {
     const schemaType = getSchemaType(schema);
-    const addedByAdditionalProperty = (0, import_get13.default)(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);
     }
@@ -2146,7 +2222,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;
     }
   }
@@ -2154,7 +2230,7 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
 }
 
 // src/schema/omitExtraData.ts
-var import_get14 = __toESM(require("lodash/get"), 1);
+var import_get13 = __toESM(require("lodash/get"), 1);
 var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
 var import_isNil2 = __toESM(require("lodash/isNil"), 1);
 var import_pick = __toESM(require("lodash/pick"), 1);
@@ -2183,7 +2259,7 @@ function getFieldNames(pathSchema, formData) {
         }
       } else if (key === NAME_KEY && data !== "") {
         paths.forEach((path) => {
-          const formValue = (0, import_get14.default)(formData, path);
+          const formValue = (0, import_get13.default)(formData, path);
           const isLeaf = objKeys.length === 1;
           if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
             acc.push(path);
@@ -2217,11 +2293,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) {
@@ -2253,15 +2329,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) {
@@ -2273,10 +2348,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);
         }
       }
     }
@@ -2287,37 +2361,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);
@@ -2327,96 +2401,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 || (0, import_isEmpty5.default)(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
-var import_get15 = __toESM(require("lodash/get"), 1);
+var import_get14 = __toESM(require("lodash/get"), 1);
 var import_has5 = __toESM(require("lodash/has"), 1);
 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 = (0, import_get14.default)(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 ((0, import_has5.default)(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if ((0, import_has5.default)(oldSchema, PROPERTIES_KEY)) {
-      const properties = (0, import_get15.default)(oldSchema, PROPERTIES_KEY, {});
+      const properties = (0, import_get14.default)(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if ((0, import_has5.default)(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys((0, import_get15.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys((0, import_get14.default)(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = (0, import_get15.default)(data, key);
-      let oldKeyedSchema = (0, import_get15.default)(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = (0, import_get15.default)(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = (0, import_get14.default)(data, key);
+      let oldKeyedSchema = (0, import_get14.default)(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = (0, import_get14.default)(newSchema, [PROPERTIES_KEY, key], {});
       if ((0, import_has5.default)(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
@@ -2435,8 +2543,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = (0, import_get15.default)(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = (0, import_get15.default)(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = (0, import_get14.default)(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = (0, import_get14.default)(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if ((0, import_has5.default)(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -2454,31 +2562,37 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = (0, import_get15.default)(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = (0, import_get15.default)(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = (0, import_get14.default)(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
+          const oldOptionDefault = (0, import_get14.default)(oldKeyedSchema, DEFAULT_KEY, NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if ((0, import_get15.default)(newKeyedSchema, "readOnly") === true) {
+            } else if ((0, import_get14.default)(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = (0, import_get15.default)(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = (0, import_get15.default)(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = (0, import_get14.default)(newKeyedSchema, CONST_KEY, NO_VALUE);
+          const oldOptionConst = (0, import_get14.default)(oldKeyedSchema, CONST_KEY, NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
+          if ((0, import_has5.default)(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 ((0, import_get15.default)(oldSchema, "type") === "array" && (0, import_get15.default)(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = (0, import_get15.default)(oldSchema, "items");
-    let newSchemaItems = (0, import_get15.default)(newSchema, "items");
+  } else if ((0, import_get14.default)(oldSchema, "type") === "array" && (0, import_get14.default)(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = (0, import_get14.default)(oldSchema, "items");
+    let newSchemaItems = (0, import_get14.default)(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if ((0, import_has5.default)(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
@@ -2498,10 +2612,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = (0, import_get15.default)(oldSchemaItems, "type");
-      const newSchemaType = (0, import_get15.default)(newSchemaItems, "type");
+      const oldSchemaType = (0, import_get14.default)(oldSchemaItems, "type");
+      const newSchemaType = (0, import_get14.default)(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = (0, import_get15.default)(newSchema, "maxItems", -1);
+        const maxItems = (0, import_get14.default)(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -2518,7 +2632,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) {
@@ -2529,21 +2645,21 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toPathSchema.ts
-var import_get16 = __toESM(require("lodash/get"), 1);
+var import_get15 = __toESM(require("lodash/get"), 1);
 var import_isObject12 = __toESM(require("lodash/isObject"), 1);
 var import_set2 = __toESM(require("lodash/set"), 1);
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || 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
       );
     }
@@ -2563,12 +2679,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,
@@ -2580,7 +2696,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
     (0, import_set2.default)(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
     const additionalSchema = (0, import_isObject12.default)(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-    const definedProperties = (0, import_get16.default)(schema, PROPERTIES_KEY, {});
+    const definedProperties = (0, import_get15.default)(schema, PROPERTIES_KEY, {});
     for (const key of Object.keys(formData ?? {})) {
       if (!(key in definedProperties)) {
         pathSchema[key] = toPathSchemaInternal(
@@ -2588,7 +2704,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
           additionalSchema,
           `${name}.${key}`,
           rootSchema,
-          (0, import_get16.default)(formData, [key]),
+          (0, import_get15.default)(formData, [key]),
           _recurseList,
           experimental_customMergeAllOf
         );
@@ -2638,7 +2754,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = (0, import_get16.default)(schema, [PROPERTIES_KEY, property], {});
+      const field = (0, import_get15.default)(schema, [PROPERTIES_KEY, property], {});
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -2646,7 +2762,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
-        (0, import_get16.default)(formData, [property]),
+        (0, import_get15.default)(formData, [property]),
         _recurseList,
         experimental_customMergeAllOf
       );
@@ -2668,8 +2784,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, (0, import_get17.default)(rootSchema, ID_KEY, "#"));
+    if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, (0, import_get16.default)(rootSchema, ID_KEY, "#"));
     } else {
       this.rootSchema = rootSchema;
     }
@@ -2920,6 +3036,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,
@@ -2942,7 +3059,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);
@@ -2961,13 +3078,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}`);
   }
 }
 
@@ -2975,24 +3092,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;
@@ -3091,7 +3210,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;
@@ -3123,7 +3242,7 @@ function enumOptionValueEncoder(value, index, format = "indexed") {
 
 // src/ErrorSchemaBuilder.ts
 var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
-var import_get18 = __toESM(require("lodash/get"), 1);
+var import_get17 = __toESM(require("lodash/get"), 1);
 var import_set3 = __toESM(require("lodash/set"), 1);
 var import_setWith = __toESM(require("lodash/setWith"), 1);
 var ErrorSchemaBuilder = class {
@@ -3152,7 +3271,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? (0, import_get18.default)(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? (0, import_get17.default)(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       (0, import_setWith.default)(this.errorSchema, pathOfError, errorBlock, Object);
@@ -3178,7 +3297,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = (0, import_get18.default)(errorBlock, ERRORS_KEY);
+    let errorsList = (0, import_get17.default)(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -3220,7 +3339,7 @@ var ErrorSchemaBuilder = class {
 
 // src/getChangedFields.ts
 var import_difference = __toESM(require("lodash/difference"), 1);
-var import_get19 = __toESM(require("lodash/get"), 1);
+var import_get18 = __toESM(require("lodash/get"), 1);
 var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
 var import_keys = __toESM(require("lodash/keys"), 1);
 var import_pickBy = __toESM(require("lodash/pickBy"), 1);
@@ -3232,13 +3351,13 @@ function getChangedFields(a, b) {
   }
   if (aIsPlainObject && !bIsPlainObject) {
     return (0, import_keys.default)(a);
-  } else if (!aIsPlainObject && bIsPlainObject) {
+  }
+  if (!aIsPlainObject && bIsPlainObject) {
     return (0, import_keys.default)(b);
-  } else {
-    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals_default(value, (0, import_get19.default)(b, key))));
-    const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
-    return [...unequalFields, ...diffFields];
   }
+  const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals_default(value, (0, import_get18.default)(b, key))));
+  const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
+  return [...unequalFields, ...diffFields];
 }
 
 // src/getDateElementProps.ts
@@ -3337,7 +3456,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 };
   }
@@ -3362,10 +3481,10 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-var import_get20 = __toESM(require("lodash/get"), 1);
+var import_get19 = __toESM(require("lodash/get"), 1);
 var import_uniqueId = __toESM(require("lodash/uniqueId"), 1);
 function getTestIds() {
-  if ((0, import_get20.default)(globalThis, "process.env.NODE_ENV") !== "test") {
+  if ((0, import_get19.default)(globalThis, "process.env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3384,7 +3503,7 @@ function getTestIds() {
 
 // src/getWidget.tsx
 var import_react = require("react");
-var import_get21 = __toESM(require("lodash/get"), 1);
+var import_get20 = __toESM(require("lodash/get"), 1);
 var import_set4 = __toESM(require("lodash/set"), 1);
 var import_react_is = __toESM(require("react-is"), 1);
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -3441,12 +3560,10 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = (0, import_get21.default)(AWidget, "MergedWidget");
+  let MergedWidget = (0, import_get20.default)(AWidget, "MergedWidget");
   if (!MergedWidget) {
-    const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
-    MergedWidget = ({ options, ...props }) => {
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AWidget, { options: { ...defaultOptions, ...options }, ...props });
-    };
+    const defaultOptions = AWidget.defaultProps?.options || {};
+    MergedWidget = ({ options, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AWidget, { options: { ...defaultOptions, ...options }, ...props });
     (0, import_set4.default)(AWidget, "MergedWidget", MergedWidget);
   }
   return MergedWidget;
@@ -3478,23 +3595,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
@@ -3555,7 +3675,6 @@ function isFormDataAvailable(formData) {
 }
 
 // src/isRootSchema.ts
-var import_omit2 = __toESM(require("lodash/omit"), 1);
 function isRootSchema(registry, schemaToCompare) {
   const { rootSchema, schemaUtils } = registry;
   if (deepEquals_default(schemaToCompare, rootSchema)) {
@@ -3563,7 +3682,7 @@ function isRootSchema(registry, schemaToCompare) {
   }
   if (REF_KEY in rootSchema) {
     const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-    return deepEquals_default(schemaToCompare, (0, import_omit2.default)(resolvedSchema, RJSF_REF_KEY));
+    return deepEquals_default(schemaToCompare, resolvedSchema);
   }
   return false;
 }
@@ -3578,15 +3697,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
-var import_get22 = __toESM(require("lodash/get"), 1);
+var import_get21 = __toESM(require("lodash/get"), 1);
 var import_has6 = __toESM(require("lodash/has"), 1);
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
   if ((0, import_has6.default)(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return (0, import_get22.default)(regOrFc, [...lookupPath, toLookup], fallback);
+  return (0, import_get21.default)(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/nameGenerators.ts
@@ -3614,9 +3742,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);
@@ -3652,7 +3780,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(),
@@ -3705,11 +3833,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)) {
@@ -3749,23 +3876,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;
       }
     }
   }
@@ -3777,13 +3903,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) {
@@ -3793,6 +3919,38 @@ function schemaRequiresTrueValue(schema) {
   return false;
 }
 
+// src/SelectedOptionDescription.tsx
+var import_jsx_runtime2 = require("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__ */ (0, import_jsx_runtime2.jsx)(
+    DescriptionFieldTemplate,
+    {
+      id: descriptionId(id),
+      description,
+      schema: option.schema,
+      uiSchema,
+      registry
+    }
+  );
+}
+
 // src/shallowEquals.ts
 function shallowEquals(a, b) {
   if (Object.is(a, b)) {
@@ -3809,9 +3967,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;
     }
   }
@@ -3880,14 +4038,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 ((0, import_isPlainObject3.default)(childSchema)) {
-        acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
+        return currentList.concat(toErrorList(childSchema, [...fieldPath, key]));
       }
     }
-    return acc;
+    return currentList;
   }, errorList);
 }
 
@@ -3929,22 +4087,21 @@ function unwrapErrorHandler(errorHandler) {
   return Object.keys(errorHandler).reduce((acc, key) => {
     if (key === "addError") {
       return acc;
-    } else {
-      const childSchema = errorHandler[key];
-      if ((0, import_isPlainObject4.default)(childSchema)) {
-        return {
-          ...acc,
-          [key]: unwrapErrorHandler(childSchema)
-        };
-      }
-      return { ...acc, [key]: childSchema };
     }
+    const childSchema = errorHandler[key];
+    if ((0, import_isPlainObject4.default)(childSchema)) {
+      return {
+        ...acc,
+        [key]: unwrapErrorHandler(childSchema)
+      };
+    }
+    return { ...acc, [key]: childSchema };
   }, {});
 }
 
 // src/useAltDateWidgetProps.tsx
 var import_react2 = require("react");
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_jsx_runtime3 = require("react/jsx-runtime");
 function readyForChange(state) {
   return Object.values(state).every((value) => value !== -1);
 }
@@ -3966,8 +4123,8 @@ function DateElement(props) {
   } = props;
   const id = `${rootId}_${type}`;
   const { SelectWidget } = registry.widgets;
-  const onChange = (0, import_react2.useCallback)((value2) => select(type, value2), [select, type]);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+  const onChange = (0, import_react2.useCallback)((newValue) => select(type, newValue), [select, type]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
     SelectWidget,
     {
       schema: { type: "integer" },
@@ -3996,10 +4153,10 @@ function useAltDateWidgetProps(props) {
     setState(parseDateString(value, time));
   }, [time, value]);
   const handleChange = (0, import_react2.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));
@@ -4057,7 +4214,7 @@ var import_react4 = require("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();
@@ -4082,7 +4239,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) {
@@ -4182,22 +4339,21 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
 // src/withIdRefPrefix.ts
 var import_isObject16 = __toESM(require("lodash/isObject"), 1);
 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)) {
@@ -4222,6 +4378,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";
@@ -4242,6 +4399,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`.";
@@ -4255,7 +4413,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 var import_forEach = __toESM(require("lodash/forEach"), 1);
 
 // src/parser/ParserValidator.ts
-var import_get23 = __toESM(require("lodash/get"), 1);
+var import_get22 = __toESM(require("lodash/get"), 1);
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -4281,7 +4439,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = (0, import_get23.default)(schema, ID_KEY, hash);
+    const key = (0, import_get22.default)(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -4347,20 +4505,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]) {
-          (0, import_forEach.default)(schema2[PROPERTIES_KEY], (value) => {
+          (0, import_forEach.default)(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);
       }
     }
   });