@rjsf/utils 6.5.3 → 6.6.0

package/dist/utils.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('fast-equals'), require('lodash/get'), require('lodash/has'), require('lodash/set'), require('lodash/times'), require('lodash/transform'), require('lodash/merge'), require('lodash/flattenDeep'), require('lodash/uniq'), require('lodash/isEmpty'), require('@x0k/json-schema-merge'), require('@x0k/json-schema-merge/lib/array'), require('jsonpointer'), require('lodash/omit'), require('lodash/isObject'), require('fast-uri'), require('lodash/isString'), require('lodash/union'), require('lodash/isNumber'), require('lodash/reduce'), require('lodash/isNil'), require('lodash/pick'), require('lodash/cloneDeep'), require('lodash/setWith'), require('lodash/keys'), require('lodash/pickBy'), require('lodash/difference'), require('lodash/uniqueId'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'fast-equals', 'lodash/get', 'lodash/has', 'lodash/set', 'lodash/times', 'lodash/transform', 'lodash/merge', 'lodash/flattenDeep', 'lodash/uniq', 'lodash/isEmpty', '@x0k/json-schema-merge', '@x0k/json-schema-merge/lib/array', 'jsonpointer', 'lodash/omit', 'lodash/isObject', 'fast-uri', 'lodash/isString', 'lodash/union', 'lodash/isNumber', 'lodash/reduce', 'lodash/isNil', 'lodash/pick', 'lodash/cloneDeep', 'lodash/setWith', 'lodash/keys', 'lodash/pickBy', 'lodash/difference', 'lodash/uniqueId', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject2, global.fastEquals, global.get16, global.has5, global.set, global.times, global.transform, global.merge, global.flattenDeep, global.uniq, global.isEmpty4, global.jsonSchemaMerge, global.array, global.jsonpointer, global.omit, global.isObject2, global.UriResolver, global.isString, global.union, global.isNumber, global.reduce, global.isNil, global.pick, global.cloneDeep, global.setWith, global.keys, global.pickBy, global.difference, global.uniqueId, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
-})(this, (function (exports, isPlainObject2, fastEquals, get16, has5, set, times, transform, merge, flattenDeep, uniq, isEmpty4, jsonSchemaMerge, array, jsonpointer, omit, isObject2, UriResolver, isString, union, isNumber, reduce, isNil, pick, cloneDeep, setWith, keys, pickBy, difference, uniqueId, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/get'), require('fast-equals'), require('fast-uri'), require('jsonpointer'), require('lodash/isEmpty'), require('lodash/isObject'), require('lodash/omit'), require('lodash/has'), require('lodash/isString'), require('lodash/flattenDeep'), require('lodash/merge'), require('lodash/set'), require('lodash/times'), require('lodash/transform'), require('lodash/uniq'), require('lodash/union'), require('lodash/isNumber'), require('@x0k/json-schema-merge'), require('@x0k/json-schema-merge/lib/array'), require('lodash/reduce'), require('lodash/isNil'), require('lodash/pick'), require('lodash/cloneDeep'), require('lodash/setWith'), require('lodash/difference'), require('lodash/keys'), require('lodash/pickBy'), require('lodash/uniqueId'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/get', 'fast-equals', 'fast-uri', 'jsonpointer', 'lodash/isEmpty', 'lodash/isObject', 'lodash/omit', 'lodash/has', 'lodash/isString', 'lodash/flattenDeep', 'lodash/merge', 'lodash/set', 'lodash/times', 'lodash/transform', 'lodash/uniq', 'lodash/union', 'lodash/isNumber', '@x0k/json-schema-merge', '@x0k/json-schema-merge/lib/array', 'lodash/reduce', 'lodash/isNil', 'lodash/pick', 'lodash/cloneDeep', 'lodash/setWith', 'lodash/difference', 'lodash/keys', 'lodash/pickBy', 'lodash/uniqueId', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject2, global.get15, global.fastEquals, global.UriResolver, global.jsonpointer, global.isEmpty4, global.isObject2, global.omit, global.has5, global.isString, global.flattenDeep, global.merge, global.set, global.times, global.transform, global.uniq, global.union, global.isNumber, global.jsonSchemaMerge, global.array, global.reduce, global.isNil, global.pick, global.cloneDeep, global.setWith, global.difference, global.keys, global.pickBy, global.uniqueId, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
+})(this, (function (exports, isPlainObject2, get15, fastEquals, UriResolver, jsonpointer, isEmpty4, isObject2, omit, has5, isString, flattenDeep, merge, set, times, transform, uniq, union, isNumber, jsonSchemaMerge, array, reduce, isNil, pick, cloneDeep, setWith, difference, keys, pickBy, uniqueId, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
 
   // src/isObject.ts
   function isObject(thing) {
@@ -179,7 +179,7 @@
     return void 0;
   }
   function makeAllReferencesAbsolute(schema, baseURI) {
-    const currentURI = get16(schema, ID_KEY, baseURI);
+    const currentURI = get15(schema, ID_KEY, baseURI);
     if (REF_KEY in schema) {
       schema = { ...schema, [REF_KEY]: UriResolver.resolve(currentURI, schema[REF_KEY]) };
     }
@@ -200,7 +200,7 @@
     const remaining = omit(object, [key]);
     return [remaining, value];
   }
-  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get16(rootSchema, [ID_KEY])) {
+  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get15(rootSchema, [ID_KEY])) {
     const ref = $ref || "";
     let current = void 0;
     if (ref.startsWith("#")) {
@@ -250,13 +250,13 @@
     }
     return current;
   }
-  function findSchemaDefinition($ref, rootSchema = {}, baseURI = get16(rootSchema, [ID_KEY])) {
+  function findSchemaDefinition($ref, rootSchema = {}, baseURI = get15(rootSchema, [ID_KEY])) {
     const recurseList = [];
     return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
   }
   function getDiscriminatorFieldFromSchema(schema) {
     let discriminator;
-    const maybeString = get16(schema, DISCRIMINATOR_PATH);
+    const maybeString = get15(schema, DISCRIMINATOR_PATH);
     if (isString(maybeString)) {
       discriminator = maybeString;
     } else if (maybeString !== void 0) {
@@ -327,13 +327,13 @@
   }
   function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
     if (formData && discriminatorField) {
-      const value = get16(formData, discriminatorField);
+      const value = get15(formData, discriminatorField);
       if (value === void 0) {
         return;
       }
       for (let i = 0; i < options.length; i++) {
         const option = options[i];
-        const discriminator = get16(option, [PROPERTIES_KEY, discriminatorField], {});
+        const discriminator = get15(option, [PROPERTIES_KEY, discriminatorField], {});
         if (discriminator.type === "object" || discriminator.type === "array") {
           continue;
         }
@@ -360,8 +360,8 @@
     for (let i = 0; i < options.length; i++) {
       const option = options[i];
       if (discriminatorField && has5(option, [PROPERTIES_KEY, discriminatorField])) {
-        const value = get16(formData, discriminatorField);
-        const discriminator = get16(option, [PROPERTIES_KEY, discriminatorField], {});
+        const value = get15(formData, discriminatorField);
+        const discriminator = get15(option, [PROPERTIES_KEY, discriminatorField], {});
         if (validator.isValid(discriminator, value, rootSchema)) {
           return i;
         }
@@ -394,6 +394,12 @@
     }
     return 0;
   }
+  var { compareSchemaDefinitions, compareSchemaValues } = jsonSchemaMerge.createComparator();
+  var { mergeArrayOfSchemaDefinitions } = jsonSchemaMerge.createMerger({
+    intersectJson: array.createIntersector(compareSchemaValues),
+    deduplicateJsonSchemaDef: array.createDeduplicator(compareSchemaDefinitions)
+  });
+  var shallowAllOfMerge_default = jsonSchemaMerge.createShallowAllOfMerge(mergeArrayOfSchemaDefinitions);
 
   // src/schema/retrieveSchema.ts
   function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs = false) {
@@ -641,7 +647,7 @@
             validator,
             { [ALL_OF_KEY]: Object.values(matchingProperties) },
             rootSchema,
-            get16(formData, [key]),
+            get15(formData, [key]),
             experimental_customMergeAllOf
           );
           set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
@@ -654,7 +660,7 @@
           if (REF_KEY in schema.additionalProperties) {
             additionalProperties = retrieveSchema(
               validator,
-              { [REF_KEY]: get16(schema.additionalProperties, [REF_KEY]) },
+              { [REF_KEY]: get15(schema.additionalProperties, [REF_KEY]) },
               rootSchema,
               formData,
               experimental_customMergeAllOf
@@ -667,10 +673,10 @@
               ...schema.additionalProperties
             };
           } else {
-            additionalProperties = { type: guessType(get16(formData, [key])) };
+            additionalProperties = { type: guessType(get15(formData, [key])) };
           }
         } else {
-          additionalProperties = { type: guessType(get16(formData, [key])) };
+          additionalProperties = { type: guessType(get15(formData, [key])) };
         }
         schema.properties[key] = additionalProperties;
         set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
@@ -681,14 +687,8 @@
     });
     return schema;
   }
-  var { compareSchemaDefinitions, compareSchemaValues } = jsonSchemaMerge.createComparator();
-  var { mergeArrayOfSchemaDefinitions } = jsonSchemaMerge.createMerger({
-    intersectJson: array.createIntersector(compareSchemaValues),
-    deduplicateJsonSchemaDef: array.createDeduplicator(compareSchemaDefinitions)
-  });
-  var shallowAllOfMerge = jsonSchemaMerge.createShallowAllOfMerge(mergeArrayOfSchemaDefinitions);
   function mergeAllOf(schema) {
-    return shallowAllOfMerge(schema);
+    return shallowAllOfMerge_default(schema);
   }
   function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
     if (!isObject(schema)) {
@@ -754,7 +754,7 @@
                 validator,
                 { allOf: [schema2.properties[key], ...Object.values(matchingProperties)] },
                 rootSchema,
-                get16(rawFormData, [key]),
+                get15(rawFormData, [key]),
                 experimental_customMergeAllOf
               );
             }
@@ -795,12 +795,23 @@
       });
       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 [schema];
   }
+  function relaxOptionsForScoring(options, resolveRefs = false, rootSchema) {
+    return options.map((d) => {
+      if (!isObject(d)) {
+        return d ? {} : { not: {} };
+      }
+      const schema = resolveRefs && rootSchema ? resolveAllReferences(d, rootSchema, []) : d;
+      return schema.additionalProperties === false ? { ...schema, additionalProperties: true } : schema;
+    });
+  }
   function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     const { dependencies, ...remainingSchema } = schema;
     const resolvedSchemas = resolveAnyOrOneOfSchemas(
@@ -826,7 +837,7 @@
   function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     let schemas = [resolvedSchema];
     for (const dependencyKey in dependencies) {
-      if (!expandAllBranches && get16(formData, [dependencyKey]) === void 0) {
+      if (!expandAllBranches && get15(formData, [dependencyKey]) === void 0) {
         continue;
       }
       if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
@@ -957,11 +968,11 @@
       const xxxOfs = schema[xxx].map(
         (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
       );
-      const data = get16(formData, selectorField);
+      const data = get15(formData, selectorField);
       if (data !== void 0) {
         return xxxOfs.find((xxx2) => {
           return deepEquals_default(
-            get16(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get16(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+            get15(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get15(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
             data
           );
         });
@@ -980,7 +991,7 @@
     const pathList = Array.isArray(path) ? [...path] : path.split(".");
     const [part, ...nestedPath] = pathList;
     if (part !== void 0 && part !== "" && has5(fieldSchema, part)) {
-      fieldSchema = get16(fieldSchema, part);
+      fieldSchema = get15(fieldSchema, part);
       return getFromSchemaInternal(
         validator,
         rootSchema,
@@ -1023,7 +1034,7 @@
             parentField,
             fieldNameKey,
             ONE_OF_KEY,
-            get16(formData, subPath),
+            get15(formData, subPath),
             experimental_customMergeAllOf
           );
         } else if (has5(parentField, ANY_OF_KEY)) {
@@ -1033,7 +1044,7 @@
             parentField,
             fieldNameKey,
             ANY_OF_KEY,
-            get16(formData, subPath),
+            get15(formData, subPath),
             experimental_customMergeAllOf
           );
         }
@@ -1101,7 +1112,7 @@
         totalScore += reduce(
           schema.properties,
           (score, value, key) => {
-            const formValue = get16(formData, key);
+            const formValue = get15(formData, key);
             if (typeof value === "boolean") {
               return score;
             }
@@ -1128,7 +1139,7 @@
                 validator,
                 rootSchema,
                 formValue,
-                get16(value, key2),
+                get15(value, key2),
                 -1,
                 discriminator,
                 experimental_customMergeAllOf
@@ -1200,6 +1211,16 @@
     }
     return bestIndex;
   }
+  function constIsAjvDataReference(schema) {
+    const schemaConst = schema[CONST_KEY];
+    const schemaType = getSchemaType(schema);
+    return isObject(schemaConst) && isString(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+  }
+
+  // src/isConstant.ts
+  function isConstant(schema) {
+    return Array.isArray(schema.enum) && schema.enum.length === 1 || CONST_KEY in schema;
+  }
 
   // src/isFixedItems.ts
   function isFixedItems(schema) {
@@ -1230,22 +1251,22 @@
     if (isObject(formData)) {
       const acc = Object.assign({}, defaults);
       return Object.keys(formData).reduce((acc2, key) => {
-        const keyValue = get16(formData, key);
+        const keyValue = get15(formData, key);
         const keyExistsInDefaults = isObject(defaults) && key in defaults;
         const keyExistsInFormData = key in formData;
-        const keyDefault = get16(defaults, key) ?? {};
+        const keyDefault = get15(defaults, key) ?? {};
         const defaultValueIsNestedObject = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
-        const keyDefaultIsObject = keyExistsInDefaults && isObject(get16(defaults, key));
+        const keyDefaultIsObject = keyExistsInDefaults && isObject(get15(defaults, key));
         const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
         if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
           acc2[key] = {
-            ...get16(defaults, key),
+            ...get15(defaults, key),
             ...keyValue
           };
           return acc2;
         }
         acc2[key] = mergeDefaultsWithFormData(
-          get16(defaults, key),
+          get15(defaults, key),
           keyValue,
           mergeExtraArrayDefaults,
           defaultSupercedesUndefined,
@@ -1289,37 +1310,6 @@
     );
   }
 
-  // src/isConstant.ts
-  function isConstant(schema) {
-    return Array.isArray(schema.enum) && schema.enum.length === 1 || CONST_KEY in schema;
-  }
-
-  // src/schema/isSelect.ts
-  function isSelect(validator, theSchema, rootSchema = {}, experimental_customMergeAllOf) {
-    const schema = retrieveSchema(validator, theSchema, rootSchema, void 0, experimental_customMergeAllOf);
-    const altSchemas = schema.oneOf || schema.anyOf;
-    if (Array.isArray(schema.enum)) {
-      return true;
-    }
-    if (Array.isArray(altSchemas)) {
-      return altSchemas.every((altSchemas2) => typeof altSchemas2 !== "boolean" && isConstant(altSchemas2));
-    }
-    return false;
-  }
-
-  // src/schema/isMultiSelect.ts
-  function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) {
-    if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
-      return false;
-    }
-    return isSelect(validator, schema.items, rootSchema, experimental_customMergeAllOf);
-  }
-  function constIsAjvDataReference(schema) {
-    const schemaConst = schema[CONST_KEY];
-    const schemaType = getSchemaType(schema);
-    return isObject(schemaConst) && isString(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
-  }
-
   // src/toConstant.ts
   function toConstant(schema) {
     if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
@@ -1382,8 +1372,8 @@
       let value;
       let label = title;
       if (selectorField) {
-        const innerSchema = get16(aSchema, [PROPERTIES_KEY, selectorField], {});
-        value = get16(innerSchema, DEFAULT_KEY, get16(innerSchema, CONST_KEY));
+        const innerSchema = get15(aSchema, [PROPERTIES_KEY, selectorField], {});
+        value = get15(innerSchema, DEFAULT_KEY, get15(innerSchema, CONST_KEY));
         label = label || innerSchema?.title || aSchema.title || String(value);
       } else {
         value = toConstant(aSchema);
@@ -1397,6 +1387,27 @@
     });
   }
 
+  // src/schema/isSelect.ts
+  function isSelect(validator, theSchema, rootSchema = {}, experimental_customMergeAllOf) {
+    const schema = retrieveSchema(validator, theSchema, rootSchema, void 0, experimental_customMergeAllOf);
+    const altSchemas = schema.oneOf || schema.anyOf;
+    if (Array.isArray(schema.enum)) {
+      return true;
+    }
+    if (Array.isArray(altSchemas)) {
+      return altSchemas.every((altSchemas2) => typeof altSchemas2 !== "boolean" && isConstant(altSchemas2));
+    }
+    return false;
+  }
+
+  // src/schema/isMultiSelect.ts
+  function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) {
+    if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
+      return false;
+    }
+    return isSelect(validator, schema.items, rootSchema, experimental_customMergeAllOf);
+  }
+
   // src/schema/getDefaultFormState.ts
   var PRIMITIVE_TYPES = ["string", "number", "integer", "boolean", "null"];
   function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, idx = -1) {
@@ -1630,7 +1641,7 @@
       const parentConst = retrievedSchema[CONST_KEY];
       const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
         (acc, key) => {
-          const propertySchema = get16(retrievedSchema, [PROPERTIES_KEY, key], {});
+          const propertySchema = get15(retrievedSchema, [PROPERTIES_KEY, key], {});
           const hasParentConst = isObject(parentConst) && parentConst[key] !== void 0;
           const hasConst = (isObject(propertySchema) && CONST_KEY in propertySchema || hasParentConst) && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(propertySchema);
           const computedDefault = computeDefaults(validator, propertySchema, {
@@ -1639,8 +1650,8 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get16(defaults, [key]),
-            rawFormData: get16(formData, [key]),
+            parentDefaults: get15(defaults, [key]),
+            rawFormData: get15(formData, [key]),
             required: retrievedSchema.required?.includes(key),
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1678,8 +1689,8 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get16(defaults, [key]),
-            rawFormData: get16(formData, [key]),
+            parentDefaults: get15(defaults, [key]),
+            rawFormData: get15(formData, [key]),
             required: retrievedSchema.required?.includes(key),
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1746,7 +1757,7 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             rawFormData: item,
-            parentDefaults: get16(defaults, [idx]),
+            parentDefaults: get15(defaults, [idx]),
             required,
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1756,14 +1767,11 @@
         defaults = mergeDefaultsWithFormData(defaults, itemDefaults, mergeExtraDefaults);
       }
     }
-    const hasConst = isObject(schema) && CONST_KEY in schema && experimental_defaultFormStateBehavior?.constAsDefaults !== "never";
-    if (hasConst === false) {
-      if (neverPopulate) {
-        return defaults ?? emptyDefault;
-      }
-      if (ignoreMinItemsFlagSet && !required) {
-        return defaults ? defaults : void 0;
-      }
+    if (neverPopulate) {
+      return defaults ?? emptyDefault;
+    }
+    if (ignoreMinItemsFlagSet && !required) {
+      return defaults ? defaults : void 0;
     }
     let arrayDefault;
     const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
@@ -1872,7 +1880,7 @@
     let displayLabel = Boolean(label);
     if (displayLabel) {
       const schemaType = getSchemaType(schema);
-      const addedByAdditionalProperty = get16(schema, ADDITIONAL_PROPERTY_FLAG, false);
+      const addedByAdditionalProperty = get15(schema, ADDITIONAL_PROPERTY_FLAG, false);
       if (schemaType === "array") {
         displayLabel = addedByAdditionalProperty || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || isFilesArray(validator, schema, uiSchema, rootSchema, experimental_customMergeAllOf) || isCustomWidget(uiSchema);
       }
@@ -1888,133 +1896,6 @@
     }
     return displayLabel;
   }
-  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));
-      if (sameSchemaIndex === -1) {
-        return toPathSchemaInternal(
-          validator,
-          _schema,
-          name,
-          rootSchema,
-          formData,
-          _recurseList.concat(_schema),
-          experimental_customMergeAllOf
-        );
-      }
-    }
-    let pathSchema = {
-      [NAME_KEY]: name.replace(/^\./, "")
-    };
-    if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
-      const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
-      const discriminator = getDiscriminatorFieldFromSchema(schema);
-      const index = getClosestMatchingOption(
-        validator,
-        rootSchema,
-        formData,
-        xxxOf,
-        0,
-        discriminator,
-        experimental_customMergeAllOf
-      );
-      const _schema = xxxOf[index];
-      pathSchema = {
-        ...pathSchema,
-        ...toPathSchemaInternal(
-          validator,
-          _schema,
-          name,
-          rootSchema,
-          formData,
-          _recurseList,
-          experimental_customMergeAllOf
-        )
-      };
-    }
-    if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-      set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-      const additionalSchema = isObject2(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-      const definedProperties = get16(schema, PROPERTIES_KEY, {});
-      for (const key of Object.keys(formData ?? {})) {
-        if (!(key in definedProperties)) {
-          pathSchema[key] = toPathSchemaInternal(
-            validator,
-            additionalSchema,
-            `${name}.${key}`,
-            rootSchema,
-            get16(formData, [key]),
-            _recurseList,
-            experimental_customMergeAllOf
-          );
-        }
-      }
-    }
-    if (ITEMS_KEY in schema && Array.isArray(formData)) {
-      const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
-      if (Array.isArray(schemaItems)) {
-        formData.forEach((element, i) => {
-          if (schemaItems[i]) {
-            pathSchema[i] = toPathSchemaInternal(
-              validator,
-              schemaItems[i],
-              `${name}.${i}`,
-              rootSchema,
-              element,
-              _recurseList,
-              experimental_customMergeAllOf
-            );
-          } else if (schemaAdditionalItems) {
-            pathSchema[i] = toPathSchemaInternal(
-              validator,
-              schemaAdditionalItems,
-              `${name}.${i}`,
-              rootSchema,
-              element,
-              _recurseList,
-              experimental_customMergeAllOf
-            );
-          } else {
-            console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
-          }
-        });
-      } else {
-        formData.forEach((element, i) => {
-          pathSchema[i] = toPathSchemaInternal(
-            validator,
-            schemaItems,
-            `${name}.${i}`,
-            rootSchema,
-            element,
-            _recurseList,
-            experimental_customMergeAllOf
-          );
-        });
-      }
-    } else if (PROPERTIES_KEY in schema) {
-      for (const property in schema.properties) {
-        const field = get16(schema, [PROPERTIES_KEY, property], {});
-        pathSchema[property] = toPathSchemaInternal(
-          validator,
-          field,
-          `${name}.${property}`,
-          rootSchema,
-          // It's possible that formData is not an object -- this can happen if an
-          // array item has just been added, but not populated with data yet
-          get16(formData, [property]),
-          _recurseList,
-          experimental_customMergeAllOf
-        );
-      }
-    }
-    return pathSchema;
-  }
-  function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
-    return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
-  }
-
-  // src/schema/omitExtraData.ts
   function getUsedFormData(formData, fields) {
     if (fields.length === 0 && typeof formData !== "object") {
       return formData;
@@ -2040,7 +1921,7 @@
           }
         } else if (key === NAME_KEY && data !== "") {
           paths.forEach((path) => {
-            const formValue = get16(formData, path);
+            const formValue = get15(formData, path);
             const isLeaf = objKeys.length === 1;
             if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
               acc.push(path);
@@ -2052,82 +1933,272 @@
     };
     return getAllPaths(pathSchema);
   }
-  function omitExtraData(validator, schema, rootSchema = {}, formData) {
-    const retrievedSchema = retrieveSchema(validator, schema, rootSchema, formData);
-    const pathSchema = toPathSchema(validator, retrievedSchema, "", rootSchema, formData);
-    const fieldNames = getFieldNames(pathSchema, formData);
-    const lodashFieldNames = fieldNames.map(
-      (fieldPaths) => Array.isArray(fieldPaths) ? fieldPaths.join(".") : fieldPaths
-    );
-    return getUsedFormData(formData, lodashFieldNames);
+  function isValueEmpty(value) {
+    if (isNil(value) || value === "") {
+      return true;
+    }
+    if (Array.isArray(value)) {
+      return value.length === 0;
+    }
+    if (isObject(value)) {
+      return Object.values(value).every(isValueEmpty);
+    }
+    return false;
   }
-  var NO_VALUE = Symbol("no Value");
-  function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
-    let newFormData;
-    if (has5(newSchema, PROPERTIES_KEY)) {
-      const removeOldSchemaData = {};
-      if (has5(oldSchema, PROPERTIES_KEY)) {
-        const properties = get16(oldSchema, PROPERTIES_KEY, {});
-        Object.keys(properties).forEach((key) => {
-          if (has5(data, key)) {
-            removeOldSchemaData[key] = void 0;
+  function doMergeAllOf(schema, experimental_customMergeAllOf) {
+    return experimental_customMergeAllOf ? experimental_customMergeAllOf(schema) : shallowAllOfMerge_default(schema);
+  }
+  function omitExtraData(validator, schema, rootSchema = {}, formData, experimental_customMergeAllOf) {
+    function isObjectValue(value) {
+      return isObject(value);
+    }
+    function isSchemaObj(schemaDef) {
+      return isObject(schemaDef);
+    }
+    function handleObject(schema2, source, target) {
+      const { properties, additionalProperties, patternProperties, propertyNames } = schema2;
+      const requiredSet = new Set(schema2.required ?? []);
+      function setProperty(key, schemaDef, value, required = false) {
+        const v = omit3(schemaDef, value, target[key]);
+        if (!required && isObject(v)) {
+          let sd = isSchemaObj(schemaDef) ? schemaDef : {};
+          if (sd.$ref !== void 0) {
+            sd = findSchemaDefinition(sd.$ref, rootSchema);
           }
-        });
-      }
-      const keys2 = Object.keys(get16(newSchema, PROPERTIES_KEY, {}));
-      const nestedData = {};
-      keys2.forEach((key) => {
-        const formValue = get16(data, key);
-        let oldKeyedSchema = get16(oldSchema, [PROPERTIES_KEY, key], {});
-        let newKeyedSchema = get16(newSchema, [PROPERTIES_KEY, key], {});
-        if (has5(oldKeyedSchema, REF_KEY)) {
-          oldKeyedSchema = retrieveSchema(
-            validator,
-            oldKeyedSchema,
-            rootSchema,
-            formValue,
-            experimental_customMergeAllOf
+          const innerRequired = new Set(sd.required ?? []);
+          const shouldDrop = Object.entries(v).every(
+            ([k, val]) => !innerRequired.has(k) && isValueEmpty(val)
           );
+          if (shouldDrop) {
+            return;
+          }
         }
-        if (has5(newKeyedSchema, REF_KEY)) {
-          newKeyedSchema = retrieveSchema(
-            validator,
-            newKeyedSchema,
-            rootSchema,
-            formValue,
-            experimental_customMergeAllOf
-          );
+        if (v !== void 0) {
+          target[key] = v;
         }
-        const oldSchemaTypeForKey = get16(oldKeyedSchema, "type");
-        const newSchemaTypeForKey = get16(newKeyedSchema, "type");
-        if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-          if (has5(removeOldSchemaData, key)) {
-            delete removeOldSchemaData[key];
+      }
+      if (properties !== void 0) {
+        for (const [key, schemaDef] of Object.entries(properties)) {
+          setProperty(key, schemaDef, source[key], requiredSet.has(key));
+        }
+      }
+      let patternPropertiesRest;
+      if (patternProperties !== void 0) {
+        patternPropertiesRest = [];
+        const patterns = Object.entries(patternProperties).map(([pattern, schemaDef]) => [
+          new RegExp(pattern),
+          schemaDef
+        ]);
+        const knownProperties = new Set(Object.keys(properties ?? {}));
+        for (const [key, value] of Object.entries(source)) {
+          if (knownProperties.has(key)) {
+            continue;
           }
-          if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
-            const itemData = sanitizeDataForNewSchema(
-              validator,
-              rootSchema,
-              newKeyedSchema,
-              oldKeyedSchema,
-              formValue,
-              experimental_customMergeAllOf
-            );
-            if (itemData !== void 0 || newSchemaTypeForKey === "array") {
+          const matched = patterns.find(([re]) => re.test(key));
+          if (matched === void 0) {
+            patternPropertiesRest.push(key);
+            continue;
+          }
+          setProperty(key, matched[1], value);
+        }
+      }
+      if (additionalProperties !== void 0 && additionalProperties !== false) {
+        const addlSchema = additionalProperties;
+        if (patternPropertiesRest !== void 0) {
+          for (const key of patternPropertiesRest) {
+            setProperty(key, addlSchema, source[key]);
+          }
+        } else {
+          const knownProperties = new Set(Object.keys(properties ?? {}));
+          for (const [key, value] of Object.entries(source)) {
+            if (knownProperties.has(key)) {
+              continue;
+            }
+            setProperty(key, addlSchema, value);
+          }
+        }
+      }
+      if (propertyNames !== void 0) {
+        for (const [key, value] of Object.entries(source)) {
+          target[key] = value;
+        }
+      }
+      return target;
+    }
+    function handleArray(schema2, source, target) {
+      const { items, additionalItems } = schema2;
+      if (items !== void 0) {
+        if (Array.isArray(items)) {
+          for (let i = 0; i < items.length; i++) {
+            target.push(omit3(items[i], source[i]));
+          }
+        } else {
+          for (let i = 0; i < source.length; i++) {
+            target.push(omit3(items, source[i]));
+          }
+        }
+      }
+      if (additionalItems) {
+        for (let i = target.length; i < source.length; i++) {
+          target.push(omit3(additionalItems, source[i]));
+        }
+      }
+      return target;
+    }
+    function handleConditions(schema2, source, target) {
+      const { if: condition, then, else: otherwise } = schema2;
+      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);
+    }
+    function handleOneOf(oneOf, schema2, source, target) {
+      if (!Array.isArray(oneOf) || isSelect(validator, schema2, rootSchema, experimental_customMergeAllOf)) {
+        return target;
+      }
+      const scoringOptions = relaxOptionsForScoring(oneOf, true, rootSchema);
+      const bestIndex = getClosestMatchingOption(
+        validator,
+        rootSchema,
+        source,
+        scoringOptions,
+        0,
+        getDiscriminatorFieldFromSchema(schema2),
+        experimental_customMergeAllOf
+      );
+      const winning = oneOf[bestIndex];
+      const resolved = isObject(winning) ? resolveAllReferences(winning, rootSchema, []) : scoringOptions[bestIndex];
+      return omit3(resolved, source, target);
+    }
+    function handleAnyOf(schema2, source, target) {
+      const { anyOf } = schema2;
+      if (!Array.isArray(anyOf)) {
+        return target;
+      }
+      if (source === void 0 || Array.isArray(source) && source.length === 0 || isObject(source) && Object.keys(source).length === 0) {
+        for (const branch of anyOf) {
+          target = omit3(branch, source, target);
+        }
+        return target;
+      }
+      return handleOneOf(anyOf, schema2, source, target);
+    }
+    function handleDependencies(schema2, source, target) {
+      const { dependencies } = schema2;
+      if (dependencies === void 0 || !isObjectValue(source)) {
+        return target;
+      }
+      for (const [key, deps] of Object.entries(dependencies)) {
+        if (!(key in source) || Array.isArray(deps)) {
+          continue;
+        }
+        target = omit3(deps, source, target);
+      }
+      return target;
+    }
+    function omit3(schemaDef, source, target) {
+      if (source === void 0 || schemaDef === false) {
+        return void 0;
+      }
+      if (schemaDef === true || isEmpty4(schemaDef)) {
+        return source;
+      }
+      let schema2 = schemaDef;
+      const { $ref: ref, allOf } = schema2;
+      if (ref !== void 0) {
+        return omit3(findSchemaDefinition(ref, rootSchema), source, target);
+      }
+      if (allOf) {
+        schema2 = doMergeAllOf(schema2, experimental_customMergeAllOf);
+      }
+      target = handleAnyOf(schema2, source, handleOneOf(schema2.oneOf, schema2, source, target));
+      const type = getSchemaType(schema2);
+      if (type === "object") {
+        if (!isObjectValue(source)) {
+          return void 0;
+        }
+        target = handleObject(schema2, source, isObjectValue(target) ? target : {});
+      } 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;
+      }
+      return handleDependencies(schema2, source, handleConditions(schema2, source, target));
+    }
+    return omit3(schema, formData);
+  }
+  var NO_VALUE = /* @__PURE__ */ Symbol("no Value");
+  function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
+    let newFormData;
+    if (has5(newSchema, PROPERTIES_KEY)) {
+      const removeOldSchemaData = {};
+      if (has5(oldSchema, PROPERTIES_KEY)) {
+        const properties = get15(oldSchema, PROPERTIES_KEY, {});
+        Object.keys(properties).forEach((key) => {
+          if (has5(data, key)) {
+            removeOldSchemaData[key] = void 0;
+          }
+        });
+      }
+      const keys2 = Object.keys(get15(newSchema, PROPERTIES_KEY, {}));
+      const nestedData = {};
+      keys2.forEach((key) => {
+        const formValue = get15(data, key);
+        let oldKeyedSchema = get15(oldSchema, [PROPERTIES_KEY, key], {});
+        let newKeyedSchema = get15(newSchema, [PROPERTIES_KEY, key], {});
+        if (has5(oldKeyedSchema, REF_KEY)) {
+          oldKeyedSchema = retrieveSchema(
+            validator,
+            oldKeyedSchema,
+            rootSchema,
+            formValue,
+            experimental_customMergeAllOf
+          );
+        }
+        if (has5(newKeyedSchema, REF_KEY)) {
+          newKeyedSchema = retrieveSchema(
+            validator,
+            newKeyedSchema,
+            rootSchema,
+            formValue,
+            experimental_customMergeAllOf
+          );
+        }
+        const oldSchemaTypeForKey = get15(oldKeyedSchema, "type");
+        const newSchemaTypeForKey = get15(newKeyedSchema, "type");
+        if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
+          if (has5(removeOldSchemaData, key)) {
+            delete removeOldSchemaData[key];
+          }
+          if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
+            const itemData = sanitizeDataForNewSchema(
+              validator,
+              rootSchema,
+              newKeyedSchema,
+              oldKeyedSchema,
+              formValue,
+              experimental_customMergeAllOf
+            );
+            if (itemData !== void 0 || newSchemaTypeForKey === "array") {
               nestedData[key] = itemData;
             }
           } else {
-            const newOptionDefault = get16(newKeyedSchema, "default", NO_VALUE);
-            const oldOptionDefault = get16(oldKeyedSchema, "default", NO_VALUE);
+            const newOptionDefault = get15(newKeyedSchema, "default", NO_VALUE);
+            const oldOptionDefault = get15(oldKeyedSchema, "default", NO_VALUE);
             if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
               if (oldOptionDefault === formValue) {
                 removeOldSchemaData[key] = newOptionDefault;
-              } else if (get16(newKeyedSchema, "readOnly") === true) {
+              } else if (get15(newKeyedSchema, "readOnly") === true) {
                 removeOldSchemaData[key] = void 0;
               }
             }
-            const newOptionConst = get16(newKeyedSchema, "const", NO_VALUE);
-            const oldOptionConst = get16(oldKeyedSchema, "const", NO_VALUE);
+            const newOptionConst = get15(newKeyedSchema, "const", NO_VALUE);
+            const oldOptionConst = get15(oldKeyedSchema, "const", NO_VALUE);
             if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
               removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
             }
@@ -2139,9 +2210,9 @@
         ...removeOldSchemaData,
         ...nestedData
       };
-    } else if (get16(oldSchema, "type") === "array" && get16(newSchema, "type") === "array" && Array.isArray(data)) {
-      let oldSchemaItems = get16(oldSchema, "items");
-      let newSchemaItems = get16(newSchema, "items");
+    } else if (get15(oldSchema, "type") === "array" && get15(newSchema, "type") === "array" && Array.isArray(data)) {
+      let oldSchemaItems = get15(oldSchema, "items");
+      let newSchemaItems = get15(newSchema, "items");
       if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
         if (has5(oldSchemaItems, REF_KEY)) {
           oldSchemaItems = retrieveSchema(
@@ -2161,10 +2232,10 @@
             experimental_customMergeAllOf
           );
         }
-        const oldSchemaType = get16(oldSchemaItems, "type");
-        const newSchemaType = get16(newSchemaItems, "type");
+        const oldSchemaType = get15(oldSchemaItems, "type");
+        const newSchemaType = get15(newSchemaItems, "type");
         if (!oldSchemaType || oldSchemaType === newSchemaType) {
-          const maxItems = get16(newSchema, "maxItems", -1);
+          const maxItems = get15(newSchema, "maxItems", -1);
           if (newSchemaType === "object") {
             newFormData = data.reduce((newValue, aValue) => {
               const itemValue = sanitizeDataForNewSchema(
@@ -2190,6 +2261,133 @@
     }
     return newFormData;
   }
+  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));
+      if (sameSchemaIndex === -1) {
+        return toPathSchemaInternal(
+          validator,
+          _schema,
+          name,
+          rootSchema,
+          formData,
+          _recurseList.concat(_schema),
+          experimental_customMergeAllOf
+        );
+      }
+    }
+    let pathSchema = {
+      [NAME_KEY]: name.replace(/^\./, "")
+    };
+    if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
+      const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
+      const discriminator = getDiscriminatorFieldFromSchema(schema);
+      const index = getClosestMatchingOption(
+        validator,
+        rootSchema,
+        formData,
+        xxxOf,
+        0,
+        discriminator,
+        experimental_customMergeAllOf
+      );
+      const _schema = xxxOf[index];
+      pathSchema = {
+        ...pathSchema,
+        ...toPathSchemaInternal(
+          validator,
+          _schema,
+          name,
+          rootSchema,
+          formData,
+          _recurseList,
+          experimental_customMergeAllOf
+        )
+      };
+    }
+    if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
+      set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+      const additionalSchema = isObject2(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
+      const definedProperties = get15(schema, PROPERTIES_KEY, {});
+      for (const key of Object.keys(formData ?? {})) {
+        if (!(key in definedProperties)) {
+          pathSchema[key] = toPathSchemaInternal(
+            validator,
+            additionalSchema,
+            `${name}.${key}`,
+            rootSchema,
+            get15(formData, [key]),
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        }
+      }
+    }
+    if (ITEMS_KEY in schema && Array.isArray(formData)) {
+      const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
+      if (Array.isArray(schemaItems)) {
+        formData.forEach((element, i) => {
+          if (schemaItems[i]) {
+            pathSchema[i] = toPathSchemaInternal(
+              validator,
+              schemaItems[i],
+              `${name}.${i}`,
+              rootSchema,
+              element,
+              _recurseList,
+              experimental_customMergeAllOf
+            );
+          } else if (schemaAdditionalItems) {
+            pathSchema[i] = toPathSchemaInternal(
+              validator,
+              schemaAdditionalItems,
+              `${name}.${i}`,
+              rootSchema,
+              element,
+              _recurseList,
+              experimental_customMergeAllOf
+            );
+          } else {
+            console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
+          }
+        });
+      } else {
+        formData.forEach((element, i) => {
+          pathSchema[i] = toPathSchemaInternal(
+            validator,
+            schemaItems,
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        });
+      }
+    } else if (PROPERTIES_KEY in schema) {
+      for (const property in schema.properties) {
+        const field = get15(schema, [PROPERTIES_KEY, property], {});
+        pathSchema[property] = toPathSchemaInternal(
+          validator,
+          field,
+          `${name}.${property}`,
+          rootSchema,
+          // It's possible that formData is not an object -- this can happen if an
+          // array item has just been added, but not populated with data yet
+          get15(formData, [property]),
+          _recurseList,
+          experimental_customMergeAllOf
+        );
+      }
+    }
+    return pathSchema;
+  }
+  function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
+    return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
+  }
+
+  // src/createSchemaUtils.ts
   var SchemaUtils = class {
     /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
      *
@@ -2200,7 +2398,7 @@
      */
     constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
       if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-        this.rootSchema = makeAllReferencesAbsolute(rootSchema, get16(rootSchema, ID_KEY, "#"));
+        this.rootSchema = makeAllReferencesAbsolute(rootSchema, get15(rootSchema, ID_KEY, "#"));
       } else {
         this.rootSchema = rootSchema;
       }
@@ -2529,31 +2727,6 @@
     return options;
   }
 
-  // src/shallowEquals.ts
-  function shallowEquals(a, b) {
-    if (Object.is(a, b)) {
-      return true;
-    }
-    if (a == null || b == null) {
-      return false;
-    }
-    if (typeof a !== "object" || typeof b !== "object") {
-      return false;
-    }
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) {
-      return false;
-    }
-    for (let i = 0; i < keysA.length; i++) {
-      const key = keysA[i];
-      if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-
   // src/replaceStringParameters.ts
   function replaceStringParameters(inputString, params) {
     let output = inputString;
@@ -2575,6 +2748,25 @@
     return replaceStringParameters(stringToTranslate, params);
   }
 
+  // src/enumOptionsValueForIndex.ts
+  function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
+    if (Array.isArray(valueIndex)) {
+      return valueIndex.map((index2) => enumOptionsValueForIndex(index2, allEnumOptions)).filter((val) => val !== void 0);
+    }
+    const index = valueIndex === "" || valueIndex === null ? -1 : Number(valueIndex);
+    const option = allEnumOptions[index];
+    return option ? option.value : emptyValue;
+  }
+
+  // src/enumOptionsDeselectValue.ts
+  function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
+    const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+    if (Array.isArray(selected)) {
+      return selected.filter((v) => !deepEquals_default(v, value));
+    }
+    return deepEquals_default(value, selected) ? void 0 : selected;
+  }
+
   // src/enumOptionsIsSelected.ts
   function enumOptionsIsSelected(value, selected) {
     if (Array.isArray(selected)) {
@@ -2604,15 +2796,15 @@
     const indexes = enumOptionsIndexForValue(value, enumOptions, multiple);
     return typeof indexes === "undefined" ? emptyValue : indexes;
   }
-
-  // src/enumOptionsValueForIndex.ts
-  function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
-    if (Array.isArray(valueIndex)) {
-      return valueIndex.map((index2) => enumOptionsValueForIndex(index2, allEnumOptions)).filter((val) => val !== emptyValue);
+  function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
+    const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+    if (!isNil(value)) {
+      const index = allEnumOptions.findIndex((opt) => value === opt.value);
+      const all = allEnumOptions.map(({ value: val }) => val);
+      const updated = selected.slice(0, index).concat(value, selected.slice(index));
+      return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
     }
-    const index = valueIndex === "" || valueIndex === null ? -1 : Number(valueIndex);
-    const option = allEnumOptions[index];
-    return option ? option.value : emptyValue;
+    return selected;
   }
 
   // src/enumOptionValueDecoder.ts
@@ -2651,25 +2843,6 @@
     }
     return String(value);
   }
-
-  // src/enumOptionsDeselectValue.ts
-  function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
-    const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-    if (Array.isArray(selected)) {
-      return selected.filter((v) => !deepEquals_default(v, value));
-    }
-    return deepEquals_default(value, selected) ? void 0 : selected;
-  }
-  function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
-    const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-    if (!isNil(value)) {
-      const index = allEnumOptions.findIndex((opt) => value === opt.value);
-      const all = allEnumOptions.map(({ value: val }) => val);
-      const updated = selected.slice(0, index).concat(value, selected.slice(index));
-      return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
-    }
-    return selected;
-  }
   var ErrorSchemaBuilder = class {
     /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
      *
@@ -2696,7 +2869,7 @@
      */
     getOrCreateErrorBlock(pathOfError) {
       const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-      let errorBlock = hasPath ? get16(this.errorSchema, pathOfError) : this.errorSchema;
+      let errorBlock = hasPath ? get15(this.errorSchema, pathOfError) : this.errorSchema;
       if (!errorBlock && pathOfError) {
         errorBlock = {};
         setWith(this.errorSchema, pathOfError, errorBlock, Object);
@@ -2722,7 +2895,7 @@
      */
     addErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      let errorsList = get16(errorBlock, ERRORS_KEY);
+      let errorsList = get15(errorBlock, ERRORS_KEY);
       if (!Array.isArray(errorsList)) {
         errorsList = [];
         errorBlock[ERRORS_KEY] = errorsList;
@@ -2772,7 +2945,7 @@
     } else if (!aIsPlainObject && bIsPlainObject) {
       return keys(b);
     } else {
-      const unequalFields = keys(pickBy(a, (value, key) => !deepEquals_default(value, get16(b, key))));
+      const unequalFields = keys(pickBy(a, (value, key) => !deepEquals_default(value, get15(b, key))));
       const diffFields = difference(keys(b), keys(a));
       return [...unequalFields, ...diffFields];
     }
@@ -2898,7 +3071,7 @@
     );
   }
   function getTestIds() {
-    if (typeof process === "undefined" || get16(process, "env.NODE_ENV") !== "test") {
+    if (get15(globalThis, "process.env.NODE_ENV") !== "test") {
       return {};
     }
     const ids = /* @__PURE__ */ new Map();
@@ -2967,7 +3140,7 @@
     }
   };
   function mergeWidgetOptions(AWidget) {
-    let MergedWidget = get16(AWidget, "MergedWidget");
+    let MergedWidget = get15(AWidget, "MergedWidget");
     if (!MergedWidget) {
       const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
       MergedWidget = ({ options, ...props }) => {
@@ -3097,80 +3270,28 @@
     if (has5(regOrFc, FORM_CONTEXT_NAME)) {
       lookupPath.unshift(FORM_CONTEXT_NAME);
     }
-    return get16(regOrFc, [...lookupPath, toLookup], fallback);
-  }
-  function isValueEmpty(value) {
-    if (isNil(value) || value === "") {
-      return true;
-    }
-    if (Array.isArray(value)) {
-      return value.length === 0;
-    }
-    if (isObject(value)) {
-      const obj = value;
-      const keys2 = Object.keys(obj);
-      return keys2.every((key) => isValueEmpty(obj[key]));
-    }
-    return false;
+    return get15(regOrFc, [...lookupPath, toLookup], fallback);
   }
-  function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
-    if (!isObject(schema)) {
-      return formData;
-    }
-    const resolvedSchema = retrieveSchema(validator, schema, rootSchema, formData);
-    if (Array.isArray(formData)) {
-      const itemsSchema = resolvedSchema.items;
-      if (!itemsSchema) {
-        return formData;
-      }
-      let hasChanges = false;
-      const mapped = formData.map((item, index) => {
-        let itemSchema = itemsSchema;
-        if (Array.isArray(itemsSchema)) {
-          itemSchema = itemsSchema[index] || resolvedSchema.additionalItems || {};
-        }
-        const cleaned = removeOptionalEmptyObjects(validator, itemSchema, rootSchema, item);
-        if (cleaned !== item) {
-          hasChanges = true;
-        }
-        return cleaned === void 0 ? {} : cleaned;
-      });
-      return hasChanges ? mapped : formData;
-    }
-    const { properties, required: requiredFields = [] } = resolvedSchema;
-    if (!isObject(formData) || !properties) {
-      return formData;
+
+  // src/nameGenerators.ts
+  var bracketNameGenerator = (path, idPrefix, isMultiValue) => {
+    if (!path || path.length === 0) {
+      return idPrefix;
     }
-    const result = {};
-    const data = formData;
-    let hasAnyValue = false;
-    for (const key of Object.keys(data)) {
-      const value = data[key];
-      const propertySchema = properties[key] || {};
-      const isRequired = requiredFields.includes(key);
-      const isObj = isObject(value);
-      const isArr = Array.isArray(value);
-      if ((isObj || isArr) && properties[key]) {
-        const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
-        if (!isRequired && isValueEmpty(cleaned)) {
-          continue;
-        }
-        result[key] = cleaned;
-        hasAnyValue = true;
-      } else if (!isRequired && isValueEmpty(value) && properties[key]) {
-        continue;
-      } else {
-        result[key] = value;
-        if (!isValueEmpty(value)) {
-          hasAnyValue = true;
-        }
+    const baseName = path.reduce((acc, pathUnit, index) => {
+      if (index === 0) {
+        return `${idPrefix}[${String(pathUnit)}]`;
       }
+      return `${acc}[${String(pathUnit)}]`;
+    }, "");
+    return isMultiValue ? `${baseName}[]` : baseName;
+  };
+  var dotNotationNameGenerator = (path, idPrefix, _isMultiValue) => {
+    if (!path || path.length === 0) {
+      return idPrefix;
     }
-    if (!hasAnyValue && Object.keys(result).length === 0) {
-      return void 0;
-    }
-    return result;
-  }
+    return `${idPrefix}.${path.map(String).join(".")}`;
+  };
 
   // src/orderProperties.ts
   function orderProperties(properties, order) {
@@ -3227,6 +3348,64 @@
       second: includeTime ? date.getUTCSeconds() : 0
     };
   }
+
+  // src/removeOptionalEmptyObjects.ts
+  function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
+    if (!isObject(schema)) {
+      return formData;
+    }
+    const resolvedSchema = retrieveSchema(validator, schema, rootSchema, formData);
+    if (Array.isArray(formData)) {
+      const itemsSchema = resolvedSchema.items;
+      if (!itemsSchema) {
+        return formData;
+      }
+      let hasChanges = false;
+      const mapped = formData.map((item, index) => {
+        let itemSchema = itemsSchema;
+        if (Array.isArray(itemsSchema)) {
+          itemSchema = itemsSchema[index] || resolvedSchema.additionalItems || {};
+        }
+        const cleaned = removeOptionalEmptyObjects(validator, itemSchema, rootSchema, item);
+        if (cleaned !== item) {
+          hasChanges = true;
+        }
+        return cleaned === void 0 ? {} : cleaned;
+      });
+      return hasChanges ? mapped : formData;
+    }
+    const { properties, required: requiredFields = [] } = resolvedSchema;
+    if (!isObject(formData) || !properties) {
+      return formData;
+    }
+    const result = {};
+    const data = formData;
+    let hasAnyValue = false;
+    for (const key of Object.keys(data)) {
+      const value = data[key];
+      const propertySchema = properties[key] || {};
+      const isRequired = requiredFields.includes(key);
+      const isObj = isObject(value);
+      const isArr = Array.isArray(value);
+      if ((isObj || isArr) && properties[key]) {
+        const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
+        if (!isRequired && isValueEmpty(cleaned)) {
+          continue;
+        }
+        result[key] = cleaned;
+        hasAnyValue = true;
+      } else if (isRequired || !isValueEmpty(value) || !properties[key]) {
+        result[key] = value;
+        if (!isValueEmpty(value)) {
+          hasAnyValue = true;
+        }
+      }
+    }
+    if (!hasAnyValue && Object.keys(result).length === 0) {
+      return void 0;
+    }
+    return result;
+  }
   function resolveUiSchema(schema, localUiSchema, registry) {
     const ref = schema[RJSF_REF_KEY] ?? schema[REF_KEY];
     const definitions = registry.uiSchemaDefinitions;
@@ -3295,6 +3474,31 @@
     return false;
   }
 
+  // src/shallowEquals.ts
+  function shallowEquals(a, b) {
+    if (Object.is(a, b)) {
+      return true;
+    }
+    if (a == null || b == null) {
+      return false;
+    }
+    if (typeof a !== "object" || typeof b !== "object") {
+      return false;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+      const key = keysA[i];
+      if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   // src/shouldRender.ts
   function shouldRender(component, nextProps, nextState, updateStrategy = "customDeep") {
     if (updateStrategy === "always") {
@@ -3572,15 +3776,14 @@
       [value]
     );
     const handleChange = react.useCallback(
-      (files) => {
-        processFiles(files).then((filesInfoEvent) => {
-          const newValue = filesInfoEvent.map((fileInfo) => fileInfo.dataURL || null);
-          if (multiple) {
-            onChange(values.concat(...newValue));
-          } else {
-            onChange(newValue[0]);
-          }
-        });
+      async (files) => {
+        const filesInfoEvent = await processFiles(files);
+        const newValue = filesInfoEvent.map((fileInfo) => fileInfo.dataURL || null);
+        if (multiple) {
+          onChange(values.concat(...newValue));
+        } else {
+          onChange(newValue[0]);
+        }
       },
       [values, multiple, onChange]
     );
@@ -3658,26 +3861,6 @@
     return schemaNode;
   }
 
-  // src/nameGenerators.ts
-  var bracketNameGenerator = (path, idPrefix, isMultiValue) => {
-    if (!path || path.length === 0) {
-      return idPrefix;
-    }
-    const baseName = path.reduce((acc, pathUnit, index) => {
-      if (index === 0) {
-        return `${idPrefix}[${String(pathUnit)}]`;
-      }
-      return `${acc}[${String(pathUnit)}]`;
-    }, "");
-    return isMultiValue ? `${baseName}[]` : baseName;
-  };
-  var dotNotationNameGenerator = (path, idPrefix, _isMultiValue) => {
-    if (!path || path.length === 0) {
-      return idPrefix;
-    }
-    return `${idPrefix}.${path.map(String).join(".")}`;
-  };
-
   // src/enums.ts
   var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
     TranslatableString2["ArrayItemTitle"] = "Item";
@@ -3744,7 +3927,7 @@
      * @param hash - The hash value at which to map the schema
      */
     addSchema(schema, hash) {
-      const key = get16(schema, ID_KEY, hash);
+      const key = get15(schema, ID_KEY, hash);
       const identifiedSchema = { ...schema, [ID_KEY]: key };
       const existing = this.schemaMap[key];
       if (!existing) {
@@ -3937,6 +4120,7 @@
   exports.isObject = isObject;
   exports.isRootSchema = isRootSchema;
   exports.isSelect = isSelect;
+  exports.isValueEmpty = isValueEmpty;
   exports.labelValue = labelValue;
   exports.localToUTC = localToUTC;
   exports.lookupFromFormContext = lookupFromFormContext;
@@ -3951,6 +4135,7 @@
   exports.pad = pad;
   exports.parseDateString = parseDateString;
   exports.rangeSpec = rangeSpec;
+  exports.relaxOptionsForScoring = relaxOptionsForScoring;
   exports.removeOptionalEmptyObjects = removeOptionalEmptyObjects;
   exports.replaceStringParameters = replaceStringParameters;
   exports.resolveUiSchema = resolveUiSchema;