@rjsf/utils 6.8.0 → 6.10.0

package/dist/utils.umd.js

@@ -1,18 +1,18 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/isPlainObject'), require('lodash/get'), require('fast-equals'), require('fast-uri'), require('jsonpointer'), require('lodash/isEmpty'), require('lodash/isObject'), require('lodash/omit'), require('lodash/has'), require('lodash/isString'), require('lodash/flattenDeep'), require('lodash/merge'), require('lodash/set'), require('lodash/times'), require('lodash/transform'), require('lodash/uniq'), require('lodash/union'), require('lodash/isNumber'), require('@x0k/json-schema-merge'), require('@x0k/json-schema-merge/lib/array'), require('lodash/reduce'), require('lodash/isNil'), require('lodash/pick'), require('lodash/cloneDeep'), require('lodash/setWith'), require('lodash/difference'), require('lodash/keys'), require('lodash/pickBy'), require('lodash/uniqueId'), require('react'), require('react-is'), require('react/jsx-runtime'), require('lodash/toPath'), require('lodash/forEach')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash/isPlainObject', 'lodash/get', 'fast-equals', 'fast-uri', 'jsonpointer', 'lodash/isEmpty', 'lodash/isObject', 'lodash/omit', 'lodash/has', 'lodash/isString', 'lodash/flattenDeep', 'lodash/merge', 'lodash/set', 'lodash/times', 'lodash/transform', 'lodash/uniq', 'lodash/union', 'lodash/isNumber', '@x0k/json-schema-merge', '@x0k/json-schema-merge/lib/array', 'lodash/reduce', 'lodash/isNil', 'lodash/pick', 'lodash/cloneDeep', 'lodash/setWith', 'lodash/difference', 'lodash/keys', 'lodash/pickBy', 'lodash/uniqueId', 'react', 'react-is', 'react/jsx-runtime', 'lodash/toPath', 'lodash/forEach'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.isPlainObject2, global.get14, global.fastEquals, global.UriResolver, global.jsonpointer, global.isEmpty4, global.isObject2, global.omit, global.has5, global.isString, global.flattenDeep, global.merge, global.set3, global.times, global.transform, global.uniq, global.union, global.isNumber, global.jsonSchemaMerge, global.array, global.reduce, global.isNil, global.pick, global.cloneDeep, global.setWith, global.difference, global.keys, global.pickBy, global.uniqueId, global.react, global.ReactIs, global.jsxRuntime, global.toPath, global.forEach));
-})(this, (function (exports, isPlainObject2, get14, fastEquals, UriResolver, jsonpointer, isEmpty4, isObject2, omit, has5, isString, flattenDeep, merge, set3, times, transform, uniq, union, isNumber, jsonSchemaMerge, array, reduce, isNil, pick, cloneDeep, setWith, difference, keys, pickBy, uniqueId, react, ReactIs, jsxRuntime, toPath, forEach) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fast-equals'), require('fast-uri'), require('jsonpointer'), require('@x0k/json-schema-merge'), require('@x0k/json-schema-merge/lib/array'), require('react'), require('react-is'), require('react/jsx-runtime')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'fast-equals', 'fast-uri', 'jsonpointer', '@x0k/json-schema-merge', '@x0k/json-schema-merge/lib/array', 'react', 'react-is', 'react/jsx-runtime'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@rjsf/utils"] = {}, global.fastEquals, global.UriResolver, global.jsonpointer, global.jsonSchemaMerge, global.array, global.react, global.ReactIs, global.jsxRuntime));
+})(this, (function (exports, fastEquals, UriResolver, jsonpointer, jsonSchemaMerge, array, react, ReactIs, jsxRuntime) { 'use strict';
 
   // src/isObject.ts
   function isObject(thing) {
     if (typeof thing !== "object" || thing === null) {
       return false;
     }
-    if (typeof thing.lastModified === "number" && typeof File !== "undefined" && thing instanceof File) {
+    if ("lastModified" in thing && typeof thing.lastModified === "number" && typeof File !== "undefined" && thing instanceof File) {
       return false;
     }
-    if (typeof thing.getMonth === "function" && typeof Date !== "undefined" && thing instanceof Date) {
+    if ("getMonth" in thing && typeof thing.getMonth === "function" && typeof Date !== "undefined" && thing instanceof Date) {
       return false;
     }
     return !Array.isArray(thing);
@@ -141,6 +141,17 @@
     }
     return true;
   }
+
+  // src/isPlainObject.ts
+  function isPlainObject(thing) {
+    if (typeof thing !== "object" || thing === null) {
+      return false;
+    }
+    const proto = Object.getPrototypeOf(thing);
+    return proto === null || proto === Object.prototype;
+  }
+
+  // src/createErrorHandler.ts
   function createErrorHandler(formData) {
     const handler = {
       // We store the list of errors for this node in a property named __errors
@@ -154,10 +165,9 @@
     if (Array.isArray(formData)) {
       return formData.reduce((acc, value, key) => ({ ...acc, [key]: createErrorHandler(value) }), handler);
     }
-    if (isPlainObject2(formData)) {
-      const formObject = formData;
-      return Object.keys(formObject).reduce(
-        (acc, key) => ({ ...acc, [key]: createErrorHandler(formObject[key]) }),
+    if (isPlainObject(formData)) {
+      return Object.keys(formData).reduce(
+        (acc, key) => ({ ...acc, [key]: createErrorHandler(formData[key]) }),
         handler
       );
     }
@@ -179,14 +189,14 @@
     for (const subSchema of Object.values(schema)) {
       if (Array.isArray(subSchema)) {
         for (const item of subSchema) {
-          if (isObject2(item)) {
+          if (isObject(item)) {
             const result = findEmbeddedSchemaRecursive(item, ref);
             if (result !== void 0) {
               return result;
             }
           }
         }
-      } else if (isObject2(subSchema)) {
+      } else if (isObject(subSchema)) {
         const result = findEmbeddedSchemaRecursive(subSchema, ref);
         if (result !== void 0) {
           return result;
@@ -196,7 +206,7 @@
     return void 0;
   }
   function makeAllReferencesAbsolute(schema, baseURI) {
-    const currentURI = get14(schema, ID_KEY, baseURI);
+    const currentURI = schema[ID_KEY] ?? baseURI;
     let result = schema;
     if (REF_KEY in result) {
       result = { ...result, [REF_KEY]: UriResolver.resolve(currentURI, result[REF_KEY]) };
@@ -205,20 +215,19 @@
       if (Array.isArray(subSchema)) {
         result = {
           ...result,
-          [key]: subSchema.map((item) => isObject2(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
+          [key]: subSchema.map((item) => isObject(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
         };
-      } else if (isObject2(subSchema)) {
+      } else if (isObject(subSchema)) {
         result = { ...result, [key]: makeAllReferencesAbsolute(subSchema, currentURI) };
       }
     }
     return result;
   }
   function splitKeyElementFromObject(key, object) {
-    const value = object[key];
-    const remaining = omit(object, [key]);
+    const { [key]: value, ...remaining } = object;
     return [remaining, value];
   }
-  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get14(rootSchema, [ID_KEY])) {
+  function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = rootSchema[ID_KEY]) {
     const ref = $ref || "";
     let current = void 0;
     let currentBaseURI = baseURI;
@@ -238,7 +247,7 @@
       current = findEmbeddedSchemaRecursive(rootSchema, refId.replace(/\/$/, ""));
       if (current !== void 0) {
         currentBaseURI = current[ID_KEY];
-        if (!isEmpty4(refAnchor)) {
+        if (refAnchor.length > 0) {
           current = jsonpointer.get(current, decodeURIComponent(refAnchor.join("#")));
         }
       }
@@ -268,14 +277,116 @@
     }
     return current;
   }
-  function findSchemaDefinition($ref, rootSchema = {}, baseURI = get14(rootSchema, [ID_KEY])) {
+  function findSchemaDefinition($ref, rootSchema = {}, baseURI = rootSchema[ID_KEY]) {
     const recurseList = [];
     return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
   }
+
+  // src/pathUtils.ts
+  var reIsIndex = /^(?:0|[1-9]\d*)$/;
+  function toPath(path) {
+    return path.split(/[.[\]]+/).filter(Boolean);
+  }
+  function normalizePath(path) {
+    return Array.isArray(path) ? path : [path];
+  }
+  function isUnsafeSegment(segment) {
+    return segment === "__proto__";
+  }
+  function isIndex(segment) {
+    return typeof segment === "number" ? Number.isInteger(segment) && segment >= 0 : reIsIndex.test(segment);
+  }
+  function isSettable(value) {
+    return value != null && (typeof value === "object" || typeof value === "function");
+  }
+  function getByPath(obj, path, defaultValue) {
+    let current;
+    if (!Array.isArray(path)) {
+      current = isSettable(obj) && Object.hasOwn(obj, path) ? obj[path] : void 0;
+    } else if (path.length === 0) {
+      current = void 0;
+    } else {
+      current = obj;
+      for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        if (!isSettable(current) || !Object.hasOwn(current, segment)) {
+          current = void 0;
+          break;
+        }
+        current = current[segment];
+      }
+    }
+    return current === void 0 ? defaultValue : current;
+  }
+  function setByPath(obj, path, value, createIntermediateObjects = false) {
+    if (!isSettable(obj)) {
+      return obj;
+    }
+    if (!Array.isArray(path)) {
+      if (!isUnsafeSegment(path)) {
+        const target = obj;
+        target[path] = value;
+      }
+      return obj;
+    }
+    const segments = path;
+    if (segments.some(isUnsafeSegment)) {
+      return obj;
+    }
+    let current = obj;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (i === segments.length - 1) {
+        current[segment] = value;
+      } else {
+        const existing = Object.hasOwn(current, segment) ? current[segment] : void 0;
+        if (isSettable(existing)) {
+          current = existing;
+        } else {
+          const next = createIntermediateObjects || !isIndex(segments[i + 1]) ? {} : [];
+          current[segment] = next;
+          if (isSettable(next)) {
+            current = next;
+          }
+        }
+      }
+    }
+    return obj;
+  }
+  function hasByPath(obj, path) {
+    if (!Array.isArray(path)) {
+      return isSettable(obj) && Object.hasOwn(obj, path);
+    }
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+      if (!isSettable(current) || !Object.hasOwn(current, path[i])) {
+        return false;
+      }
+      current = current[path[i]];
+    }
+    return path.length > 0;
+  }
+  function unsetByPath(obj, path) {
+    const segments = normalizePath(path);
+    if (segments.length === 0) {
+      return true;
+    }
+    const parent = segments.length > 1 ? getByPath(obj, segments.slice(0, -1)) : obj;
+    if (parent == null) {
+      return true;
+    }
+    try {
+      return Reflect.deleteProperty(parent, segments[segments.length - 1]);
+    } catch {
+      return false;
+    }
+  }
+
+  // src/getDiscriminatorFieldFromSchema.ts
   function getDiscriminatorFieldFromSchema(schema) {
     let discriminator;
-    const maybeString = get14(schema, DISCRIMINATOR_PATH);
-    if (isString(maybeString)) {
+    const maybeString = getByPath(schema, DISCRIMINATOR_PATH);
+    if (typeof maybeString === "string") {
       discriminator = maybeString;
     } else if (maybeString !== void 0) {
       console.warn(`Expecting discriminator to be a string, got "${typeof maybeString}" instead`);
@@ -336,7 +447,7 @@
       if (obj1 && key in obj1 && isObject(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)) {
-        accumulator[key] = union(left, right);
+        accumulator[key] = [.../* @__PURE__ */ new Set([...left, ...right])];
       } else {
         accumulator[key] = right;
       }
@@ -347,20 +458,28 @@
     }
     return result;
   }
+
+  // src/getPropertySchema.ts
+  function getPropertySchema(schema, property) {
+    return schema?.[PROPERTIES_KEY]?.[property] ?? {};
+  }
+
+  // src/getOptionMatchingSimpleDiscriminator.ts
   function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
     if (formData && discriminatorField) {
-      const value = get14(formData, discriminatorField);
+      const value = getByPath(formData, discriminatorField);
       if (value === void 0) {
         return void 0;
       }
       for (let i = 0; i < options.length; i += 1) {
         const option = options[i];
-        const discriminator = get14(option, [PROPERTIES_KEY, discriminatorField], {});
+        const discriminator = getPropertySchema(option, discriminatorField);
         if (discriminator.type !== "object" && discriminator.type !== "array") {
           if (discriminator.const === value) {
             return i;
           }
-          if (discriminator.enum?.includes(value)) {
+          const enumValues = discriminator.enum;
+          if (enumValues?.includes(value)) {
             return i;
           }
         }
@@ -375,14 +494,14 @@
       return 0;
     }
     const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-    if (isNumber(simpleDiscriminatorMatch)) {
+    if (typeof simpleDiscriminatorMatch === "number") {
       return simpleDiscriminatorMatch;
     }
     for (let i = 0; i < options.length; i += 1) {
       const option = options[i];
-      if (discriminatorField && has5(option, [PROPERTIES_KEY, discriminatorField])) {
-        const value = get14(formData, discriminatorField);
-        const discriminator = get14(option, [PROPERTIES_KEY, discriminatorField], {});
+      const discriminator = discriminatorField ? option[PROPERTIES_KEY]?.[discriminatorField] : void 0;
+      if (discriminatorField && discriminator !== void 0) {
+        const value = getByPath(formData, discriminatorField);
         if (validator.isValid(discriminator, value, rootSchema)) {
           return i;
         }
@@ -511,7 +630,7 @@
     const allPermutations = listOfLists.reduce(
       (permutations, list) => {
         if (list.length > 1) {
-          return list.flatMap((element) => times(permutations.length, (i) => [...permutations[i]].concat(element)));
+          return list.flatMap((element) => permutations.map((permutation) => [...permutation, element]));
         }
         permutations.forEach((permutation) => permutation.push(list[0]));
         return permutations;
@@ -522,12 +641,9 @@
     return allPermutations;
   }
   function getMatchingPatternProperties(schema, key) {
-    return Object.keys(schema.patternProperties).filter((pattern) => RegExp(pattern).test(key)).reduce(
-      (obj, pattern) => {
-        set3(obj, [pattern], schema.patternProperties[pattern]);
-        return obj;
-      },
-      {}
+    const patternProperties = schema.patternProperties ?? {};
+    return Object.fromEntries(
+      Object.entries(patternProperties).filter(([pattern]) => RegExp(pattern).test(key))
     );
   }
   function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
@@ -622,23 +738,24 @@
     }
     if (PROPERTIES_KEY in resolvedSchema) {
       const childrenLists = [];
-      const updatedProps = transform(
-        resolvedSchema[PROPERTIES_KEY],
-        (acc, value, key) => {
-          const childList = [...recurseList];
-          acc[key] = resolveAllReferences(
-            value,
-            rootSchema,
-            childList,
-            currentBaseURI,
-            resolveAnyOfOrOneOfRefs,
-            !resolveAnyOfOrOneOfRefs
-          );
-          childrenLists.push(childList);
-        },
-        {}
-      );
-      merge(recurseList, uniq(flattenDeep(childrenLists)));
+      const updatedProps = {};
+      for (const [key, value] of Object.entries(resolvedSchema[PROPERTIES_KEY] ?? {})) {
+        const childList = [...recurseList];
+        updatedProps[key] = resolveAllReferences(
+          value,
+          rootSchema,
+          childList,
+          currentBaseURI,
+          resolveAnyOfOrOneOfRefs,
+          !resolveAnyOfOrOneOfRefs
+        );
+        childrenLists.push(childList);
+      }
+      for (const ref of new Set(childrenLists.flat())) {
+        if (!recurseList.includes(ref)) {
+          recurseList.push(ref);
+        }
+      }
       resolvedSchema = { ...resolvedSchema, [PROPERTIES_KEY]: updatedProps };
     }
     if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== "boolean") {
@@ -687,12 +804,12 @@
       }
       if (PATTERN_PROPERTIES_KEY in schema) {
         const matchingProperties = getMatchingPatternProperties(schema, key);
-        if (!isEmpty4(matchingProperties)) {
+        if (Object.keys(matchingProperties).length > 0) {
           schema.properties[key] = retrieveSchema(
             validator,
             { [ALL_OF_KEY]: Object.values(matchingProperties) },
             rootSchema,
-            get14(formData, [key]),
+            formData[key],
             experimental_customMergeAllOf
           );
           schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
@@ -705,9 +822,9 @@
           if (REF_KEY in schema.additionalProperties) {
             additionalProperties = retrieveSchema(
               validator,
-              { [REF_KEY]: get14(schema.additionalProperties, [REF_KEY]) },
+              { [REF_KEY]: schema.additionalProperties[REF_KEY] },
               rootSchema,
-              get14(formData, [key]),
+              formData[key],
               experimental_customMergeAllOf
             );
           } else if ("type" in schema.additionalProperties) {
@@ -718,10 +835,10 @@
               ...schema.additionalProperties
             };
           } else {
-            additionalProperties = { type: guessType(get14(formData, [key])) };
+            additionalProperties = { type: guessType(formData[key]) };
           }
         } else {
-          additionalProperties = { type: guessType(get14(formData, [key])) };
+          additionalProperties = { type: guessType(formData[key]) };
         }
         schema.properties[key] = additionalProperties;
         schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
@@ -803,12 +920,12 @@
         resolvedSchema = Object.keys(resolvedSchema.properties).reduce(
           (acc, key) => {
             const matchingProperties = getMatchingPatternProperties(acc, key);
-            if (!isEmpty4(matchingProperties)) {
+            if (Object.keys(matchingProperties).length > 0) {
               acc.properties[key] = retrieveSchema(
                 validator,
                 { allOf: [acc.properties[key], ...Object.values(matchingProperties)] },
                 rootSchema,
-                get14(rawFormData, [key]),
+                getByPath(rawFormData, key),
                 experimental_customMergeAllOf
               );
             }
@@ -889,7 +1006,7 @@
   function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
     let schemas = [resolvedSchema];
     for (const dependencyKey in dependencies) {
-      if ((expandAllBranches || get14(formData, [dependencyKey]) !== void 0) && (!resolvedSchema.properties || dependencyKey in resolvedSchema.properties)) {
+      if ((expandAllBranches || getByPath(formData, dependencyKey) !== void 0) && (!resolvedSchema.properties || dependencyKey in resolvedSchema.properties)) {
         const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
           dependencyKey,
           dependencies
@@ -1016,14 +1133,14 @@
       const xxxOfs = schema[xxx].map(
         (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
       );
-      const data = get14(formData, selectorField);
+      const data = getByPath(formData, selectorField);
       if (data !== void 0) {
         return xxxOfs.find(
           (xxxOfOption) => deepEquals_default(
-            get14(
+            getByPath(
               xxxOfOption,
               [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
-              get14(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
+              getByPath(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
             ),
             data
           )
@@ -1032,18 +1149,20 @@
     }
     return void 0;
   }
+
+  // src/schema/getFromSchema.ts
   function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
     let fieldSchema = schema;
-    if (has5(schema, REF_KEY)) {
+    if (hasByPath(schema, REF_KEY)) {
       fieldSchema = retrieveSchema(validator, schema, rootSchema, void 0, experimental_customMergeAllOf);
     }
-    if (isEmpty4(path)) {
+    if (path.length === 0) {
       return fieldSchema;
     }
-    const pathList = Array.isArray(path) ? [...path] : path.split(".");
+    const pathList = Array.isArray(path) ? [...path] : toPath(path);
     const [part, ...nestedPath] = pathList;
-    if (part !== void 0 && part !== "" && has5(fieldSchema, part)) {
-      fieldSchema = get14(fieldSchema, part);
+    if (part !== void 0 && part !== "" && hasByPath(fieldSchema, part)) {
+      fieldSchema = getByPath(fieldSchema, part);
       return getFromSchemaInternal(
         validator,
         rootSchema,
@@ -1079,30 +1198,30 @@
           {},
           experimental_customMergeAllOf
         );
-        if (has5(parentField, ONE_OF_KEY)) {
+        if (hasByPath(parentField, ONE_OF_KEY)) {
           parentField = findSelectedOptionInXxxOf(
             validator,
             rootSchema,
             parentField,
             fieldNameKey,
             ONE_OF_KEY,
-            get14(formData, subPath),
+            getByPath(formData, subPath),
             experimental_customMergeAllOf
           );
-        } else if (has5(parentField, ANY_OF_KEY)) {
+        } else if (hasByPath(parentField, ANY_OF_KEY)) {
           parentField = findSelectedOptionInXxxOf(
             validator,
             rootSchema,
             parentField,
             fieldNameKey,
             ANY_OF_KEY,
-            get14(formData, subPath),
+            getByPath(formData, subPath),
             experimental_customMergeAllOf
           );
         }
       });
     }
-    if (has5(parentField, ONE_OF_KEY)) {
+    if (hasByPath(parentField, ONE_OF_KEY)) {
       parentField = findSelectedOptionInXxxOf(
         validator,
         rootSchema,
@@ -1112,7 +1231,7 @@
         formData,
         experimental_customMergeAllOf
       );
-    } else if (has5(parentField, ANY_OF_KEY)) {
+    } else if (hasByPath(parentField, ANY_OF_KEY)) {
       parentField = findSelectedOptionInXxxOf(
         validator,
         rootSchema,
@@ -1148,6 +1267,8 @@
     }
     return { field, isRequired };
   }
+
+  // src/schema/getClosestMatchingOption.ts
   var JUNK_OPTION = {
     type: "object",
     $id: JUNK_OPTION_ID,
@@ -1160,61 +1281,57 @@
   function calculateIndexScore(validator, rootSchema, schema, formData, experimental_customMergeAllOf) {
     let totalScore = 0;
     if (schema) {
-      if (isObject2(schema.properties)) {
-        totalScore += reduce(
-          schema.properties,
-          (score, value, key) => {
-            const formValue = get14(formData, key);
-            if (typeof value === "boolean") {
-              return score;
-            }
-            if (has5(value, REF_KEY)) {
-              const newSchema = retrieveSchema(
-                validator,
-                value,
-                rootSchema,
-                formValue,
-                experimental_customMergeAllOf
-              );
-              return score + calculateIndexScore(
-                validator,
-                rootSchema,
-                newSchema,
-                formValue || {},
-                experimental_customMergeAllOf
-              );
-            }
-            if ((has5(value, ONE_OF_KEY) || has5(value, ANY_OF_KEY)) && formValue) {
-              const xxxOfKey = has5(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
-              const discriminator = getDiscriminatorFieldFromSchema(value);
-              return score + getClosestMatchingOption(
-                validator,
-                rootSchema,
-                formValue,
-                get14(value, xxxOfKey),
-                -1,
-                discriminator,
-                experimental_customMergeAllOf
-              );
-            }
-            if (value.type === "object") {
-              const structureBoost = isObject2(formValue) ? 1 : 0;
-              return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
-            }
-            if (value.type === guessType(formValue)) {
-              let newScore = score + 1;
-              if (value.default) {
-                newScore += formValue === value.default ? 1 : -1;
-              } else if (value.const) {
-                newScore += formValue === value.const ? 1 : -1;
-              }
-              return newScore;
-            }
+      if (isObject(schema.properties)) {
+        totalScore += Object.entries(schema.properties).reduce((score, [key, value]) => {
+          const formValue = formData?.[key];
+          if (typeof value === "boolean") {
             return score;
-          },
-          0
-        );
-      } else if (isString(schema.type) && schema.type === guessType(formData)) {
+          }
+          if (hasByPath(value, REF_KEY)) {
+            const newSchema = retrieveSchema(
+              validator,
+              value,
+              rootSchema,
+              formValue,
+              experimental_customMergeAllOf
+            );
+            return score + calculateIndexScore(
+              validator,
+              rootSchema,
+              newSchema,
+              formValue || {},
+              experimental_customMergeAllOf
+            );
+          }
+          if ((hasByPath(value, ONE_OF_KEY) || hasByPath(value, ANY_OF_KEY)) && formValue) {
+            const xxxOfKey = hasByPath(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const discriminator = getDiscriminatorFieldFromSchema(value);
+            return score + getClosestMatchingOption(
+              validator,
+              rootSchema,
+              formValue,
+              getByPath(value, xxxOfKey),
+              -1,
+              discriminator,
+              experimental_customMergeAllOf
+            );
+          }
+          if (value.type === "object") {
+            const structureBoost = typeof formValue === "object" && formValue !== null ? 1 : 0;
+            return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
+          }
+          if (value.type === guessType(formValue)) {
+            let newScore = score + 1;
+            if (value.default) {
+              newScore += formValue === value.default ? 1 : -1;
+            } else if (value.const) {
+              newScore += formValue === value.const ? 1 : -1;
+            }
+            return newScore;
+          }
+          return score;
+        }, 0);
+      } else if (typeof schema.type === "string" && schema.type === guessType(formData)) {
         totalScore += 1;
       }
     }
@@ -1223,7 +1340,7 @@
   function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField, experimental_customMergeAllOf) {
     const resolvedOptions = options.map((option) => resolveAllReferences(option, rootSchema, []));
     const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-    if (isNumber(simpleDiscriminatorMatch)) {
+    if (typeof simpleDiscriminatorMatch === "number") {
       return simpleDiscriminatorMatch;
     }
     const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
@@ -1238,7 +1355,7 @@
       return allValidIndexes[0];
     }
     if (!allValidIndexes.length) {
-      times(resolvedOptions.length, (i) => allValidIndexes.push(i));
+      allValidIndexes.push(...resolvedOptions.keys());
     }
     const scoreCount = /* @__PURE__ */ new Set();
     const { bestIndex } = allValidIndexes.reduce(
@@ -1259,10 +1376,12 @@
     }
     return bestIndex;
   }
+
+  // src/constIsAjvDataReference.ts
   function constIsAjvDataReference(schema) {
     const schemaConst = schema[CONST_KEY];
     const schemaType = getSchemaType(schema);
-    return isObject(schemaConst) && isString(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+    return isObject(schemaConst) && typeof schemaConst?.$data === "string" && schemaType !== "object" && schemaType !== "array";
   }
 
   // src/isConstant.ts
@@ -1274,6 +1393,8 @@
   function isFixedItems(schema) {
     return Array.isArray(schema.items) && schema.items.every((item) => isObject(item));
   }
+
+  // src/mergeDefaultsWithFormData.ts
   function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
     if (Array.isArray(formData)) {
       const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -1298,23 +1419,25 @@
     }
     if (isObject(formData)) {
       const acc = Object.assign({}, defaults);
-      return Object.keys(formData).reduce((accumulator, key) => {
-        const keyValue = get14(formData, key);
-        const keyExistsInDefaults = isObject(defaults) && key in defaults;
-        const keyExistsInFormData = key in formData;
-        const keyDefault = get14(defaults, key) ?? {};
-        const defaultValueIsNestedObject = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
-        const keyDefaultIsObject = keyExistsInDefaults && isObject(get14(defaults, key));
+      const formDataObj = formData;
+      const defaultsObj = isObject(defaults) ? defaults : void 0;
+      return Object.keys(formDataObj).reduce((accumulator, key) => {
+        const keyValue = formDataObj[key];
+        const keyExistsInDefaults = defaultsObj !== void 0 && key in defaultsObj;
+        const keyExistsInFormData = key in formDataObj;
+        const keyDefault = defaultsObj?.[key] ?? {};
+        const defaultValueNeedsDeepMerge = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v) || Array.isArray(v));
+        const keyDefaultIsObject = keyExistsInDefaults && isObject(defaultsObj?.[key]);
         const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
-        if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
+        if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueNeedsDeepMerge) {
           accumulator[key] = {
-            ...get14(defaults, key),
+            ...defaultsObj?.[key],
             ...keyValue
           };
           return accumulator;
         }
         accumulator[key] = mergeDefaultsWithFormData(
-          get14(defaults, key),
+          defaultsObj?.[key],
           keyValue,
           mergeExtraArrayDefaults,
           defaultSupercedesUndefined,
@@ -1325,7 +1448,7 @@
         return acc;
       }, acc);
     }
-    if (defaultSupercedesUndefined && (!(defaults === void 0) && isNil(formData) || typeof formData === "number" && Number.isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
+    if (defaultSupercedesUndefined && (!(defaults === void 0) && formData == null || typeof formData === "number" && Number.isNaN(formData)) || overrideFormDataWithDefaults && formData != null) {
       return defaults;
     }
     return formData;
@@ -1420,8 +1543,8 @@
       let value;
       let label = title;
       if (selectorField) {
-        const innerSchema = get14(aSchema, [PROPERTIES_KEY, selectorField], {});
-        value = get14(innerSchema, DEFAULT_KEY, get14(innerSchema, CONST_KEY));
+        const innerSchema = getPropertySchema(aSchema, selectorField);
+        value = getByPath(innerSchema, DEFAULT_KEY, getByPath(innerSchema, CONST_KEY));
         label = label ?? innerSchema?.title ?? aSchema.title ?? String(value);
       } else {
         value = toConstant(aSchema);
@@ -1474,9 +1597,18 @@
     }
     return {};
   }
+  function hasContent(value) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      return value.length > 0;
+    }
+    if (typeof value === "object" && value !== null) {
+      return Object.keys(value).length > 0;
+    }
+    return false;
+  }
   function computeDefaultBasedOnSchemaTypeAndDefaults(schema, computedDefault) {
     const { default: schemaDefault, type } = schema;
-    const shouldReturnNullAsDefault = Array.isArray(type) && type.includes("null") && isEmpty4(computedDefault) && schemaDefault === null;
+    const shouldReturnNullAsDefault = Array.isArray(type) && type.includes("null") && !hasContent(computedDefault) && schemaDefault === null;
     return shouldReturnNullAsDefault ? null : computedDefault;
   }
   function maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}, isConst = false, isNullType = false) {
@@ -1484,17 +1616,17 @@
     if (includeUndefinedValues === true || isConst) {
       acc[key] = computedDefault;
     } else if (includeUndefinedValues === "excludeObjectChildren") {
-      if (isNullType && computedDefault !== void 0 || !isObject(computedDefault) || !isEmpty4(computedDefault)) {
+      if (isNullType && computedDefault !== void 0 || !isObject(computedDefault) || Object.keys(computedDefault).length > 0) {
         acc[key] = computedDefault;
       }
     } else if (emptyObjectFields !== "skipDefaults") {
       const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
       if (isObject(computedDefault)) {
         if (emptyObjectFields === "skipEmptyDefaults") {
-          if (!isEmpty4(computedDefault)) {
+          if (Object.keys(computedDefault).length > 0) {
             acc[key] = computedDefault;
           }
-        } else if ((!isEmpty4(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
+        } else if ((Object.keys(computedDefault).length > 0 || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
           acc[key] = computedDefault;
         }
       } else if (
@@ -1544,7 +1676,7 @@
         updatedRecurseList = _recurseList.concat(refName);
         schemaToCompute = findSchemaDefinition(refName, rootSchema);
       }
-      const hasNoExistingData = rawFormData === void 0 || isObject(rawFormData) && isEmpty4(rawFormData);
+      const hasNoExistingData = rawFormData === void 0 || isObject(rawFormData) && Object.keys(rawFormData).length === 0;
       if (schemaToCompute && !defaults && hasNoExistingData) {
         defaults = schema.default;
       }
@@ -1677,13 +1809,13 @@
     } else if (isObject(validFormData) && isObject(schemaToMatch.properties)) {
       validFormData = Object.keys(schemaToMatch.properties).reduce(
         (acc, key) => {
-          const propertySchema = get14(schemaToMatch, [PROPERTIES_KEY, key], {});
+          const propertySchema = getPropertySchema(schemaToMatch, key);
           if (key in acc && (shouldRetrieveAllOf || isObject(propertySchema) && ALL_OF_KEY in propertySchema)) {
             acc[key] = ensureFormDataMatchingSchema(
               validator,
               propertySchema,
               rootSchema,
-              get14(acc, key),
+              acc[key],
               experimental_defaultFormStateBehavior,
               experimental_customMergeAllOf
             );
@@ -1714,7 +1846,7 @@
       const parentConst = retrievedSchema[CONST_KEY];
       const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
         (acc, key) => {
-          const propertySchema = get14(retrievedSchema, [PROPERTIES_KEY, key], {});
+          const propertySchema = getPropertySchema(retrievedSchema, 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, {
@@ -1723,8 +1855,8 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get14(defaults, [key]),
-            rawFormData: get14(formData, [key]),
+            parentDefaults: getByPath(defaults, key),
+            rawFormData: getByPath(formData, key),
             required: retrievedSchema.required?.includes(key),
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1746,24 +1878,24 @@
       );
       if (retrievedSchema.additionalProperties && !initialDefaultsGenerated) {
         const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
-        const keys2 = /* @__PURE__ */ new Set();
+        const keys = /* @__PURE__ */ new Set();
         const formDataRequired = [];
         Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
-          keys2.add(key);
+          keys.add(key);
           formDataRequired.push(key);
         });
         if (isObject(defaults) && formDataRequired.length === 0) {
-          Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys2.add(key));
+          Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
         }
-        keys2.forEach((key) => {
+        keys.forEach((key) => {
           const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
             rootSchema,
             _recurseList,
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get14(defaults, [key]),
-            rawFormData: get14(formData, [key]),
+            parentDefaults: getByPath(defaults, key),
+            rawFormData: getByPath(formData, key),
             required: retrievedSchema.required?.includes(key),
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1831,7 +1963,7 @@
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
             rawFormData: item,
-            parentDefaults: get14(defaults, [idx]),
+            parentDefaults: getByPath(defaults, idx),
             required,
             shouldMergeDefaultsIntoFormData,
             initialDefaultsGenerated
@@ -1883,6 +2015,12 @@
       case "array": {
         return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
       }
+      case "boolean": {
+        if (computeDefaultsProps.required && defaults === void 0) {
+          return false;
+        }
+        return void 0;
+      }
       default:
         return void 0;
     }
@@ -1983,18 +2121,32 @@
     }
     return displayLabel;
   }
+
+  // src/schema/omitExtraData.ts
   function getUsedFormData(formData, fields) {
     if (fields.length === 0 && typeof formData !== "object") {
       return formData;
     }
-    const data = pick(formData, fields);
+    const data = {};
+    fields.forEach((field) => {
+      const path = Array.isArray(field) ? field : toPath(field);
+      if (hasByPath(formData, path)) {
+        setByPath(data, path, getByPath(formData, path));
+      }
+    });
     if (Array.isArray(formData)) {
       return Object.keys(data).map((key) => data[key]);
     }
     return data;
   }
   function getFieldNames(pathSchema, formData) {
-    const formValueHasData = (value, isLeaf) => typeof value !== "object" || isEmpty4(value) || isLeaf && !isEmpty4(value);
+    const formValueHasData = (value, isLeaf) => {
+      if (typeof value !== "object" || value === null) {
+        return true;
+      }
+      const isEmptyValue = Array.isArray(value) ? value.length === 0 : Object.keys(value).length === 0;
+      return isEmptyValue || isLeaf;
+    };
     const getAllPaths = (_obj, acc = [], paths = [[]]) => {
       const objKeys = Object.keys(_obj);
       objKeys.forEach((key) => {
@@ -2008,7 +2160,7 @@
           }
         } else if (key === NAME_KEY && data !== "") {
           paths.forEach((path) => {
-            const formValue = get14(formData, path);
+            const formValue = getByPath(formData, path);
             const isLeaf = objKeys.length === 1;
             if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
               acc.push(path);
@@ -2021,7 +2173,7 @@
     return getAllPaths(pathSchema);
   }
   function isValueEmpty(value) {
-    if (isNil(value) || value === "") {
+    if (value == null || value === "") {
       return true;
     }
     if (Array.isArray(value)) {
@@ -2043,19 +2195,17 @@
       return isObject(schemaDef);
     }
     function handleObject(childSchema, source, target) {
-      const { properties, additionalProperties, patternProperties, propertyNames } = childSchema;
+      const { properties, additionalProperties, patternProperties } = childSchema;
       const requiredSet = new Set(childSchema.required ?? []);
       function setProperty(key, schemaDef, value, required = false) {
-        const v = omit2(schemaDef, value, target[key]);
+        const v = omit(schemaDef, value, target[key]);
         if (!required && isObject(v)) {
           let sd = isSchemaObj(schemaDef) ? schemaDef : {};
           if (sd.$ref !== void 0) {
             sd = findSchemaDefinition(sd.$ref, rootSchema);
           }
           const innerRequired = new Set(sd.required ?? []);
-          const shouldDrop = Object.entries(v).every(
-            ([k, val]) => !innerRequired.has(k) && isValueEmpty(val)
-          );
+          const shouldDrop = Object.entries(v).every(([k, val]) => !innerRequired.has(k) && isValueEmpty(val));
           if (shouldDrop) {
             return;
           }
@@ -2103,31 +2253,29 @@
           }
         }
       }
-      if (propertyNames !== void 0) {
-        for (const [key, value] of Object.entries(source)) {
-          target[key] = value;
-        }
-      }
       return target;
     }
     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 += 1) {
-            target.push(omit2(items[i], source[i]));
-          }
-        } else {
-          for (let i = 0; i < source.length; i += 1) {
-            target.push(omit2(items, source[i]));
-          }
+      if (Array.isArray(items)) {
+        const tupleLength = Math.min(items.length, source.length);
+        let i = 0;
+        for (; i < tupleLength; i += 1) {
+          target[i] = omit(items[i], source[i]);
         }
-      }
-      if (additionalItems) {
-        for (let i = target.length; i < source.length; i += 1) {
-          target.push(omit2(additionalItems, source[i]));
+        if (!additionalItems) {
+          target.length = tupleLength;
+          return target;
+        }
+        for (; i < source.length; i += 1) {
+          target[i] = omit(additionalItems, source[i]);
+        }
+      } else {
+        for (let i = 0; i < source.length; i += 1) {
+          target[i] = omit(items, source[i]);
         }
       }
+      target.length = source.length;
       return target;
     }
     function handleConditions(childSchema, source, target) {
@@ -2137,7 +2285,7 @@
       }
       const isThenBranch = isSchemaObj(condition) ? validator.isValid(condition, source, rootSchema) : condition;
       const branch = isThenBranch ? then : otherwise;
-      return branch === void 0 ? target : omit2(branch, source, target);
+      return branch === void 0 ? target : omit(branch, source, target, false);
     }
     function handleOneOf(oneOf, childSchema, source, target) {
       if (!Array.isArray(oneOf) || isSelect(validator, childSchema, rootSchema, experimental_customMergeAllOf)) {
@@ -2155,7 +2303,7 @@
       );
       const winning = oneOf[bestIndex];
       const resolved = isObject(winning) ? resolveAllReferences(winning, rootSchema, []) : scoringOptions[bestIndex];
-      return omit2(resolved, source, target);
+      return omit(resolved, source, target, false);
     }
     function handleAnyOf(childSchema, source, target) {
       const { anyOf } = childSchema;
@@ -2165,7 +2313,7 @@
       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) {
-          result = omit2(branch, source, result);
+          result = omit(branch, source, result, false);
         }
         return result;
       }
@@ -2179,29 +2327,29 @@
       let result = target;
       for (const [key, deps] of Object.entries(dependencies)) {
         if (key in source && !Array.isArray(deps)) {
-          result = omit2(deps, source, result);
+          result = omit(deps, source, result, false);
         }
       }
       return result;
     }
-    function omit2(schemaDef, source, target) {
+    function omit(schemaDef, source, target, useSourceAsFallback = true) {
       if (source === void 0 || schemaDef === false) {
         return void 0;
       }
-      if (schemaDef === true || isEmpty4(schemaDef)) {
-        return source;
+      if (schemaDef === true || !schemaDef || Object.keys(schemaDef).length === 0) {
+        return target ?? (useSourceAsFallback ? source : void 0);
       }
       let localSchema = schemaDef;
       const { $ref: ref, allOf } = localSchema;
       if (ref !== void 0) {
-        return omit2(findSchemaDefinition(ref, rootSchema), source, target);
+        return omit(findSchemaDefinition(ref, rootSchema), source, target, useSourceAsFallback);
       }
       if (allOf) {
         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 = omit(remainingAllOf[i], source, target, false);
           }
         }
       }
@@ -2216,14 +2364,27 @@
         if (!Array.isArray(source)) {
           return void 0;
         }
-        filtered = handleArray(localSchema, source, Array.isArray(filtered) ? filtered : []);
-      } else if (filtered === void 0) {
-        filtered = source;
+        if (localSchema.items !== void 0) {
+          filtered = handleArray(localSchema, source, Array.isArray(filtered) ? filtered : []);
+        }
+      }
+      const afterConditions = handleConditions(localSchema, source, filtered);
+      if (localSchema.additionalProperties === false && isObjectValue(afterConditions)) {
+        const knownKeys = new Set(Object.keys(localSchema.properties ?? {}));
+        const patterns = localSchema.patternProperties ? Object.keys(localSchema.patternProperties).map((p) => new RegExp(p)) : [];
+        for (const key of Object.keys(afterConditions)) {
+          if (!knownKeys.has(key) && !patterns.some((re) => re.test(key))) {
+            delete afterConditions[key];
+          }
+        }
       }
-      return handleDependencies(localSchema, source, handleConditions(localSchema, source, filtered));
+      const result = handleDependencies(localSchema, source, afterConditions);
+      return result ?? (useSourceAsFallback ? source : void 0);
     }
-    return omit2(schema, formData);
+    return omit(schema, formData);
   }
+
+  // src/schema/sanitizeDataForNewSchema.ts
   var NO_VALUE = /* @__PURE__ */ Symbol("no Value");
   function enumValuesForSchema(schema) {
     if (Array.isArray(schema.enum)) {
@@ -2246,7 +2407,7 @@
     if (!enumValues || enumValues.some((value) => deepEquals_default(value, formValue))) {
       return NO_VALUE;
     }
-    const defaultValue = get14(schema, DEFAULT_KEY, NO_VALUE);
+    const defaultValue = getByPath(schema, DEFAULT_KEY, NO_VALUE);
     if (defaultValue !== NO_VALUE && enumValues.some((value) => deepEquals_default(value, defaultValue))) {
       return defaultValue;
     }
@@ -2254,23 +2415,25 @@
   }
   function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
     let newFormData;
-    if (has5(newSchema, PROPERTIES_KEY)) {
+    const newProperties = newSchema?.[PROPERTIES_KEY];
+    if (newProperties) {
       const removeOldSchemaData = {};
-      if (has5(oldSchema, PROPERTIES_KEY)) {
-        const properties = get14(oldSchema, PROPERTIES_KEY, {});
-        Object.keys(properties).forEach((key) => {
-          if (has5(data, key)) {
+      const oldProperties = oldSchema?.[PROPERTIES_KEY];
+      if (oldProperties) {
+        Object.keys(oldProperties).forEach((key) => {
+          if (hasByPath(data, key)) {
             removeOldSchemaData[key] = void 0;
           }
         });
       }
-      const keys2 = Object.keys(get14(newSchema, PROPERTIES_KEY, {}));
+      const keys = Object.keys(newProperties);
       const nestedData = {};
-      keys2.forEach((key) => {
-        const formValue = get14(data, key);
-        let oldKeyedSchema = get14(oldSchema, [PROPERTIES_KEY, key], {});
-        let newKeyedSchema = get14(newSchema, [PROPERTIES_KEY, key], {});
-        if (has5(oldKeyedSchema, REF_KEY)) {
+      keys.forEach((key) => {
+        const formValue = data?.[key];
+        const isNewProperty = !hasByPath(oldSchema, [PROPERTIES_KEY, key]);
+        let oldKeyedSchema = getPropertySchema(oldSchema, key);
+        let newKeyedSchema = getPropertySchema(newSchema, key);
+        if (hasByPath(oldKeyedSchema, REF_KEY)) {
           oldKeyedSchema = retrieveSchema(
             validator,
             oldKeyedSchema,
@@ -2279,7 +2442,7 @@
             experimental_customMergeAllOf
           );
         }
-        if (has5(newKeyedSchema, REF_KEY)) {
+        if (hasByPath(newKeyedSchema, REF_KEY)) {
           newKeyedSchema = retrieveSchema(
             validator,
             newKeyedSchema,
@@ -2288,10 +2451,10 @@
             experimental_customMergeAllOf
           );
         }
-        const oldSchemaTypeForKey = get14(oldKeyedSchema, "type");
-        const newSchemaTypeForKey = get14(newKeyedSchema, "type");
+        const oldSchemaTypeForKey = oldKeyedSchema.type;
+        const newSchemaTypeForKey = newKeyedSchema.type;
         if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-          if (has5(removeOldSchemaData, key)) {
+          if (key in removeOldSchemaData) {
             delete removeOldSchemaData[key];
           }
           if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
@@ -2299,7 +2462,7 @@
               validator,
               rootSchema,
               newKeyedSchema,
-              oldKeyedSchema,
+              isNewProperty && newSchemaTypeForKey === "array" ? newKeyedSchema : oldKeyedSchema,
               formValue,
               experimental_customMergeAllOf
             );
@@ -2307,21 +2470,21 @@
               nestedData[key] = itemData;
             }
           } else {
-            const newOptionDefault = get14(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
-            const oldOptionDefault = get14(oldKeyedSchema, DEFAULT_KEY, NO_VALUE);
+            const newOptionDefault = getByPath(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
+            const oldOptionDefault = getByPath(oldKeyedSchema, DEFAULT_KEY, NO_VALUE);
             if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
-              if (oldOptionDefault === formValue) {
+              if (isNewProperty && formValue === void 0 || oldOptionDefault === formValue) {
                 removeOldSchemaData[key] = newOptionDefault;
-              } else if (get14(newKeyedSchema, "readOnly") === true) {
+              } else if (newKeyedSchema.readOnly === true) {
                 removeOldSchemaData[key] = void 0;
               }
             }
-            const newOptionConst = get14(newKeyedSchema, CONST_KEY, NO_VALUE);
-            const oldOptionConst = get14(oldKeyedSchema, CONST_KEY, NO_VALUE);
+            const newOptionConst = getByPath(newKeyedSchema, CONST_KEY, NO_VALUE);
+            const oldOptionConst = getByPath(oldKeyedSchema, CONST_KEY, NO_VALUE);
             if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
               removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
             }
-            if (has5(data, key)) {
+            if (hasByPath(data, key)) {
               const enumReplacement = replacementForInvalidEnumValue(newKeyedSchema, formValue);
               if (enumReplacement !== NO_VALUE) {
                 removeOldSchemaData[key] = enumReplacement;
@@ -2335,11 +2498,11 @@
         ...removeOldSchemaData,
         ...nestedData
       };
-    } else if (get14(oldSchema, "type") === "array" && get14(newSchema, "type") === "array" && Array.isArray(data)) {
-      let oldSchemaItems = get14(oldSchema, "items");
-      let newSchemaItems = get14(newSchema, "items");
+    } else if (oldSchema?.type === "array" && newSchema?.type === "array" && Array.isArray(data)) {
+      let oldSchemaItems = oldSchema.items;
+      let newSchemaItems = newSchema.items;
       if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
-        if (has5(oldSchemaItems, REF_KEY)) {
+        if (hasByPath(oldSchemaItems, REF_KEY)) {
           oldSchemaItems = retrieveSchema(
             validator,
             oldSchemaItems,
@@ -2348,7 +2511,7 @@
             experimental_customMergeAllOf
           );
         }
-        if (has5(newSchemaItems, REF_KEY)) {
+        if (hasByPath(newSchemaItems, REF_KEY)) {
           newSchemaItems = retrieveSchema(
             validator,
             newSchemaItems,
@@ -2357,10 +2520,10 @@
             experimental_customMergeAllOf
           );
         }
-        const oldSchemaType = get14(oldSchemaItems, "type");
-        const newSchemaType = get14(newSchemaItems, "type");
+        const oldSchemaType = getByPath(oldSchemaItems, "type");
+        const newSchemaType = getByPath(newSchemaItems, "type");
         if (!oldSchemaType || oldSchemaType === newSchemaType) {
-          const maxItems = get14(newSchema, "maxItems", -1);
+          const maxItems = newSchema.maxItems ?? -1;
           if (newSchemaType === "object") {
             newFormData = data.reduce((newValue, aValue) => {
               const itemValue = sanitizeDataForNewSchema(
@@ -2388,6 +2551,8 @@
     }
     return newFormData;
   }
+
+  // src/schema/toPathSchema.ts
   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 innerSchema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
@@ -2434,9 +2599,9 @@
       };
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-      set3(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-      const additionalSchema = isObject2(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-      const definedProperties = get14(schema, PROPERTIES_KEY, {});
+      setByPath(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+      const additionalSchema = isObject(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
+      const definedProperties = schema[PROPERTIES_KEY] ?? {};
       for (const key of Object.keys(formData ?? {})) {
         if (!(key in definedProperties)) {
           pathSchema[key] = toPathSchemaInternal(
@@ -2444,7 +2609,7 @@
             additionalSchema,
             `${name}.${key}`,
             rootSchema,
-            get14(formData, [key]),
+            getByPath(formData, key),
             _recurseList,
             experimental_customMergeAllOf
           );
@@ -2494,7 +2659,7 @@
       }
     } else if (PROPERTIES_KEY in schema) {
       for (const property in schema.properties) {
-        const field = get14(schema, [PROPERTIES_KEY, property], {});
+        const field = getPropertySchema(schema, property);
         pathSchema[property] = toPathSchemaInternal(
           validator,
           field,
@@ -2502,7 +2667,7 @@
           rootSchema,
           // It's possible that formData is not an object -- this can happen if an
           // array item has just been added, but not populated with data yet
-          get14(formData, [property]),
+          getByPath(formData, property),
           _recurseList,
           experimental_customMergeAllOf
         );
@@ -2516,6 +2681,10 @@
 
   // src/createSchemaUtils.ts
   var SchemaUtils = class {
+    rootSchema;
+    validator;
+    experimental_defaultFormStateBehavior;
+    experimental_customMergeAllOf;
     /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
      *
      * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
@@ -2525,7 +2694,7 @@
      */
     constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
       if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-        this.rootSchema = makeAllReferencesAbsolute(rootSchema, get14(rootSchema, ID_KEY, "#"));
+        this.rootSchema = makeAllReferencesAbsolute(rootSchema, rootSchema[ID_KEY] ?? "#");
       } else {
         this.rootSchema = rootSchema;
       }
@@ -2916,8 +3085,8 @@
 
   // src/enumOptionSelectedValue.ts
   function enumOptionSelectedValue(value, enumOptions, multiple, format = "indexed", emptyValue) {
-    const isEmpty9 = typeof value === "undefined" || multiple && Array.isArray(value) && value.length < 1 || !multiple && value === emptyValue;
-    if (isEmpty9) {
+    const isEmpty = typeof value === "undefined" || multiple && Array.isArray(value) && value.length < 1 || !multiple && value === emptyValue;
+    if (isEmpty) {
       return emptyValue;
     }
     if (format === "realValue") {
@@ -2926,9 +3095,11 @@
     const indexes = enumOptionsIndexForValue(value, enumOptions, multiple);
     return typeof indexes === "undefined" ? emptyValue : indexes;
   }
+
+  // src/enumOptionsSelectValue.ts
   function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
     const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-    if (!isNil(value)) {
+    if (value != null) {
       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));
@@ -2961,11 +3132,13 @@
     }
     return decodeSingle(value, enumOptions, emptyValue);
   }
+
+  // src/enumOptionValueEncoder.ts
   function enumOptionValueEncoder(value, index, format = "indexed") {
     if (format !== "realValue") {
       return String(index);
     }
-    if (isNil(value)) {
+    if (value == null) {
       return "";
     }
     if (typeof value === "object") {
@@ -2973,17 +3146,19 @@
     }
     return String(value);
   }
+
+  // src/ErrorSchemaBuilder.ts
   var ErrorSchemaBuilder = class {
+    /** The error schema being built
+     *
+     * @private
+     */
+    errorSchema = {};
     /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
      *
      * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
      */
     constructor(initialSchema) {
-      /** The error schema being built
-       *
-       * @private
-       */
-      this.errorSchema = {};
       this.resetAllErrors(initialSchema);
     }
     /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
@@ -2998,11 +3173,14 @@
      * @private
      */
     getOrCreateErrorBlock(pathOfError) {
-      const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-      let errorBlock = hasPath ? get14(this.errorSchema, pathOfError) : this.errorSchema;
-      if (!errorBlock && pathOfError) {
+      const path = typeof pathOfError === "string" ? toPath(pathOfError) : pathOfError ?? [];
+      if (path.length === 0) {
+        return this.errorSchema;
+      }
+      let errorBlock = getByPath(this.errorSchema, path);
+      if (!errorBlock) {
         errorBlock = {};
-        setWith(this.errorSchema, pathOfError, errorBlock, Object);
+        setByPath(this.errorSchema, path, errorBlock, true);
       }
       return errorBlock;
     }
@@ -3012,12 +3190,12 @@
      * @returns - The `ErrorSchemaBuilder` object for chaining purposes
      */
     resetAllErrors(initialSchema) {
-      this.errorSchema = initialSchema ? cloneDeep(initialSchema) : {};
+      this.errorSchema = initialSchema ? structuredClone(initialSchema) : {};
       return this;
     }
     /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
-     * the schema described by the `pathOfError`. For more information about how to specify the path see the
-     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     * the schema described by the `pathOfError`. The path is either a dotted string (with optional bracketed array
+     * indexes, e.g. `'a.b[0]'`) or a list of path segments; keys containing dots require the list form.
      *
      * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
@@ -3025,21 +3203,21 @@
      */
     addErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      let errorsList = get14(errorBlock, ERRORS_KEY);
+      let errorsList = errorBlock[ERRORS_KEY];
       if (!Array.isArray(errorsList)) {
         errorsList = [];
         errorBlock[ERRORS_KEY] = errorsList;
       }
       if (Array.isArray(errorOrList)) {
-        set3(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
+        errorBlock[ERRORS_KEY] = [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])];
       } else {
-        set3(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, errorOrList])]);
+        errorBlock[ERRORS_KEY] = [.../* @__PURE__ */ new Set([...errorsList, errorOrList])];
       }
       return this;
     }
     /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
-     * within the schema described by the `pathOfError`. For more information about how to specify the path see the
-     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     * within the schema described by the `pathOfError`. The path is either a dotted string (with optional bracketed array
+     * indexes, e.g. `'a.b[0]'`) or a list of path segments; keys containing dots require the list form.
      *
      * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
@@ -3048,36 +3226,59 @@
     setErrors(errorOrList, pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
       const listToAdd = Array.isArray(errorOrList) ? [.../* @__PURE__ */ new Set([...errorOrList])] : [errorOrList];
-      set3(errorBlock, ERRORS_KEY, listToAdd);
+      errorBlock[ERRORS_KEY] = listToAdd;
       return this;
     }
     /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
-     * the `pathOfError`. For more information about how to specify the path see the
-     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     * the `pathOfError`. The path is either a dotted string (with optional bracketed array
+     * indexes, e.g. `'a.b[0]'`) or a list of path segments; keys containing dots require the list form.
      *
      * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
      * @returns - The `ErrorSchemaBuilder` object for chaining purposes
      */
     clearErrors(pathOfError) {
       const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-      set3(errorBlock, ERRORS_KEY, []);
+      errorBlock[ERRORS_KEY] = [];
       return this;
     }
   };
-  function getChangedFields(a, b) {
-    const aIsPlainObject = isPlainObject2(a);
-    const bIsPlainObject = isPlainObject2(b);
-    if (a === b || !aIsPlainObject && !bIsPlainObject) {
+
+  // src/getChangedFields.ts
+  function getChangedDescendants(a, b) {
+    if (isPlainObject(a) && isPlainObject(b)) {
+      return getChangedFields(a, b, true);
+    }
+    if (Array.isArray(a) && Array.isArray(b) && a.length === b.length) {
+      return a.flatMap((value, index) => {
+        if (deepEquals_default(value, b[index])) {
+          return [];
+        }
+        const descendants = getChangedDescendants(value, b[index]);
+        return descendants.length ? descendants.map((path) => `${index}.${path}`) : [String(index)];
+      });
+    }
+    return [];
+  }
+  function getChangedFields(a, b, deep = false) {
+    if (a === b) {
       return [];
     }
-    if (aIsPlainObject && !bIsPlainObject) {
-      return keys(a);
+    if (!isPlainObject(a)) {
+      return isPlainObject(b) ? Object.keys(b) : [];
     }
-    if (!aIsPlainObject && bIsPlainObject) {
-      return keys(b);
+    if (!isPlainObject(b)) {
+      return Object.keys(a);
     }
-    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals_default(value, get14(b, key))));
-    const diffFields = difference(keys(b), keys(a));
+    const aKeys = Object.keys(a);
+    const aKeySet = new Set(aKeys);
+    const unequalFields = aKeys.filter((key) => !deepEquals_default(a[key], getByPath(b, key))).flatMap((key) => {
+      if (!deep) {
+        return [key];
+      }
+      const descendants = getChangedDescendants(a[key], getByPath(b, key));
+      return descendants.length ? descendants.map((path) => `${key}.${path}`) : [key];
+    });
+    const diffFields = Object.keys(b).filter((key) => !aKeySet.has(key));
     return [...unequalFields, ...diffFields];
   }
 
@@ -3156,6 +3357,9 @@
     if (options.autocomplete) {
       inputProps.autoComplete = options.autocomplete;
     }
+    if (options.autocapitalize) {
+      inputProps.autoCapitalize = options.autocapitalize;
+    }
     if (options.accept) {
       inputProps.accept = options.accept;
     }
@@ -3200,8 +3404,11 @@
       uiOptions[name] || templates[name]
     );
   }
+
+  // src/getTestIds.ts
+  var testIdCounter = 0;
   function getTestIds() {
-    if (get14(globalThis, "process.env.NODE_ENV") !== "test") {
+    if (getByPath(globalThis, ["process", "env", "NODE_ENV"]) !== "test") {
       return {};
     }
     const ids = /* @__PURE__ */ new Map();
@@ -3210,7 +3417,8 @@
       {
         get(_obj, prop) {
           if (!ids.has(prop)) {
-            ids.set(prop, uniqueId("test-id-"));
+            testIdCounter += 1;
+            ids.set(prop, `test-id-${testIdCounter}`);
           }
           return ids.get(prop);
         }
@@ -3270,11 +3478,11 @@
     }
   };
   function mergeWidgetOptions(AWidget) {
-    let MergedWidget = get14(AWidget, "MergedWidget");
+    let { MergedWidget } = AWidget;
     if (!MergedWidget) {
       const defaultOptions = AWidget.defaultProps?.options || {};
       MergedWidget = ({ options, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
-      set3(AWidget, "MergedWidget", MergedWidget);
+      AWidget.MergedWidget = MergedWidget;
     }
     return MergedWidget;
   }
@@ -3346,8 +3554,10 @@
       throw e;
     }
   }
+
+  // src/idGenerators.ts
   function idGenerator(id, suffix) {
-    const theId = isString(id) ? id : id[ID_KEY];
+    const theId = typeof id === "string" ? id : id[ID_KEY];
     return `${theId}__${suffix}`;
   }
   function descriptionId(id) {
@@ -3378,8 +3588,16 @@
   function optionalControlsId(id, element) {
     return idGenerator(id, `optional${element}`);
   }
+
+  // src/isFormDataAvailable.ts
   function isFormDataAvailable(formData) {
-    return !isNil(formData) && (!isObject2(formData) || Array.isArray(formData) || !isEmpty4(formData));
+    if (formData === void 0 || formData === null) {
+      return false;
+    }
+    if (typeof formData !== "object" || Array.isArray(formData)) {
+      return true;
+    }
+    return Object.keys(formData).length > 0;
   }
 
   // src/isRootSchema.ts
@@ -3413,12 +3631,14 @@
       );
     }
   }
+
+  // src/lookupFromFormContext.ts
   function lookupFromFormContext(regOrFc, toLookup, fallback) {
     const lookupPath = [LOOKUP_MAP_NAME];
-    if (has5(regOrFc, FORM_CONTEXT_NAME)) {
+    if (hasByPath(regOrFc, FORM_CONTEXT_NAME)) {
       lookupPath.unshift(FORM_CONTEXT_NAME);
     }
-    return get14(regOrFc, [...lookupPath, toLookup], fallback);
+    return getByPath(regOrFc, [...lookupPath, toLookup], fallback);
   }
 
   // src/nameGenerators.ts
@@ -3441,6 +3661,10 @@
     return `${idPrefix}.${path.map(String).join(".")}`;
   };
 
+  // src/noop.ts
+  function noop() {
+  }
+
   // src/orderProperties.ts
   function orderProperties(properties, order) {
     if (!Array.isArray(order)) {
@@ -3553,6 +3777,8 @@
     }
     return result;
   }
+
+  // src/resolveUiSchema.ts
   function resolveUiSchema(schema, localUiSchema, registry) {
     const ref = schema[RJSF_REF_KEY] ?? schema[REF_KEY];
     const definitions = registry.uiSchemaDefinitions;
@@ -3560,7 +3786,7 @@
     let result;
     if (!definitionUiSchema) {
       result = localUiSchema || {};
-    } else if (!localUiSchema || isEmpty4(localUiSchema)) {
+    } else if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
       result = { ...definitionUiSchema };
     } else {
       result = mergeObjects(definitionUiSchema, localUiSchema);
@@ -3686,10 +3912,14 @@
     const { props, state } = component;
     return !deepEquals_default(props, nextProps) || !deepEquals_default(state, nextState);
   }
+
+  // src/shouldRenderOptionalField.ts
   function getSchemaTypesForXxxOf(schemas) {
-    const allTypes = uniq(
-      schemas.map((s) => isObject2(s) ? getSchemaType(s) : void 0).flat().filter((t) => t !== void 0)
-    );
+    const allTypes = [
+      ...new Set(
+        schemas.map((s) => isObject(s) ? getSchemaType(s) : void 0).flat().filter((t) => t !== void 0)
+      )
+    ];
     return allTypes.length === 1 ? allTypes[0] : allTypes;
   }
   function shouldRenderOptionalField(registry, schema, required, uiSchema) {
@@ -3712,42 +3942,31 @@
     const datetime = new Date(utcTime).toJSON();
     return time ? datetime : datetime.slice(0, 10);
   }
+
+  // src/toErrorList.ts
   function toErrorList(errorSchema, fieldPath = []) {
-    if (!errorSchema) {
-      return [];
-    }
-    let errorList = [];
-    if (ERRORS_KEY in errorSchema) {
-      errorList = errorList.concat(
-        errorSchema[ERRORS_KEY].map((message) => {
-          const property = `.${fieldPath.join(".")}`;
-          return {
-            property,
-            message,
-            stack: `${property} ${message}`
-          };
-        })
-      );
-    }
+    return errorSchema ? errorsFrom(errorSchema, fieldPath) : [];
+  }
+  function errorsFrom(errorSchema, fieldPath) {
+    const errors = errorSchema[ERRORS_KEY];
+    const property = `.${fieldPath.join(".")}`;
+    const errorList = Array.isArray(errors) ? errors.map((message) => ({ property, message, stack: `${property} ${message}` })) : [];
     return Object.keys(errorSchema).reduce((currentList, key) => {
-      if (key !== ERRORS_KEY) {
-        const childSchema = errorSchema[key];
-        if (isPlainObject2(childSchema)) {
-          return currentList.concat(toErrorList(childSchema, [...fieldPath, key]));
-        }
+      const childSchema = errorSchema[key];
+      if (key !== ERRORS_KEY && isPlainObject(childSchema)) {
+        return currentList.concat(errorsFrom(childSchema, [...fieldPath, key]));
       }
       return currentList;
     }, errorList);
   }
+
+  // src/toErrorSchema.ts
   function toErrorSchema(errors) {
     const builder = new ErrorSchemaBuilder();
     if (errors.length) {
       errors.forEach((error) => {
         const { property, message } = error;
-        const path = property === "." ? [] : toPath(property);
-        if (path.length > 0 && path[0] === "") {
-          path.splice(0, 1);
-        }
+        const path = property ? toPath(property) : [];
         if (message) {
           builder.addErrors(message, path);
         }
@@ -3768,16 +3987,21 @@
     }
     return { path, [ID_KEY]: id, ...name !== void 0 && { name } };
   }
+
+  // src/unwrapErrorHandler.ts
   function unwrapErrorHandler(errorHandler) {
-    return Object.keys(errorHandler).reduce((acc, key) => {
+    return unwrapErrors(errorHandler);
+  }
+  function unwrapErrors(errors) {
+    return Object.keys(errors).reduce((acc, key) => {
       if (key === "addError") {
         return acc;
       }
-      const childSchema = errorHandler[key];
-      if (isPlainObject2(childSchema)) {
+      const childSchema = errors[key];
+      if (isPlainObject(childSchema)) {
         return {
           ...acc,
-          [key]: unwrapErrorHandler(childSchema)
+          [key]: unwrapErrors(childSchema)
         };
       }
       return { ...acc, [key]: childSchema };
@@ -3990,6 +4214,8 @@
     const SSS = pad(date.getMilliseconds(), 3);
     return `${yyyy}-${MM}-${dd}T${hh}:${mm}:${ss}.${SSS}`;
   }
+
+  // src/validationDataMerge.ts
   function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
     if (!additionalErrorSchema) {
       return validationData;
@@ -3997,7 +4223,7 @@
     const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
     let errors = toErrorList(additionalErrorSchema);
     let errorSchema = additionalErrorSchema;
-    if (!isEmpty4(oldErrorSchema)) {
+    if (oldErrorSchema && Object.keys(oldErrorSchema).length > 0) {
       errorSchema = mergeObjects(
         oldErrorSchema,
         additionalErrorSchema,
@@ -4007,6 +4233,8 @@
     }
     return { errorSchema, errors };
   }
+
+  // src/withIdRefPrefix.ts
   function withIdRefPrefixObject(node) {
     const realObj = node;
     for (const key in realObj) {
@@ -4028,7 +4256,7 @@
     if (Array.isArray(schemaNode)) {
       return withIdRefPrefixArray([...schemaNode]);
     }
-    if (isObject2(schemaNode)) {
+    if (isObject(schemaNode)) {
       return withIdRefPrefixObject({ ...schemaNode });
     }
     return schemaNode;
@@ -4077,15 +4305,19 @@
     TranslatableString2["FilesInfo"] = "**%1** (%2, %3 bytes)";
     return TranslatableString2;
   })(TranslatableString || {});
+
+  // src/parser/ParserValidator.ts
   var ParserValidator = class {
+    /** The rootSchema provided during construction of the class */
+    rootSchema;
+    /** The map of schemas encountered by the ParserValidator */
+    schemaMap = {};
     /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
      * first.
      *
      * @param rootSchema - The root schema against which this validator will be executed
      */
     constructor(rootSchema) {
-      /** The map of schemas encountered by the ParserValidator */
-      this.schemaMap = {};
       this.rootSchema = rootSchema;
       this.addSchema(rootSchema, hashForSchema(rootSchema));
     }
@@ -4102,7 +4334,7 @@
      * @param hash - The hash value at which to map the schema
      */
     addSchema(schema, hash) {
-      const key = get14(schema, ID_KEY, hash);
+      const key = schema[ID_KEY] ?? hash;
       const identifiedSchema = { ...schema, [ID_KEY]: key };
       const existing = this.schemaMap[key];
       if (!existing) {
@@ -4175,9 +4407,9 @@
         const allOptions = resolveAnyOrOneOfSchemas(validator, localSchema, rootSchema, true);
         allOptions.forEach((s) => {
           if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
-            forEach(localSchema[PROPERTIES_KEY], (value) => {
+            for (const value of Object.values(localSchema[PROPERTIES_KEY] ?? {})) {
               parseSchema(validator, recurseList, rootSchema, value);
-            });
+            }
           }
         });
         if (ITEMS_KEY in localSchema && !Array.isArray(localSchema.items) && typeof localSchema.items !== "boolean") {
@@ -4264,6 +4496,7 @@
   exports.findFieldInSchema = findFieldInSchema;
   exports.findSchemaDefinition = findSchemaDefinition;
   exports.findSelectedOptionInXxxOf = findSelectedOptionInXxxOf;
+  exports.getByPath = getByPath;
   exports.getChangedFields = getChangedFields;
   exports.getClosestMatchingOption = getClosestMatchingOption;
   exports.getDateElementProps = getDateElementProps;
@@ -4277,6 +4510,7 @@
   exports.getInputProps = getInputProps;
   exports.getOptionMatchingSimpleDiscriminator = getOptionMatchingSimpleDiscriminator;
   exports.getOptionValueFormat = getOptionValueFormat;
+  exports.getPropertySchema = getPropertySchema;
   exports.getSchemaType = getSchemaType;
   exports.getSubmitButtonOptions = getSubmitButtonOptions;
   exports.getTemplate = getTemplate;
@@ -4285,6 +4519,7 @@
   exports.getUsedFormData = getUsedFormData;
   exports.getWidget = getWidget;
   exports.guessType = guessType;
+  exports.hasByPath = hasByPath;
   exports.hasWidget = hasWidget;
   exports.hashForSchema = hashForSchema;
   exports.hashObject = hashObject;
@@ -4297,6 +4532,7 @@
   exports.isFormDataAvailable = isFormDataAvailable;
   exports.isMultiSelect = isMultiSelect;
   exports.isObject = isObject;
+  exports.isPlainObject = isPlainObject;
   exports.isRootSchema = isRootSchema;
   exports.isSelect = isSelect;
   exports.isValueEmpty = isValueEmpty;
@@ -4307,6 +4543,7 @@
   exports.mergeDefaultsWithFormData = mergeDefaultsWithFormData;
   exports.mergeObjects = mergeObjects;
   exports.mergeSchemas = mergeSchemas;
+  exports.noop = noop;
   exports.omitExtraData = omitExtraData;
   exports.optionId = optionId;
   exports.optionalControlsId = optionalControlsId;
@@ -4323,6 +4560,7 @@
   exports.sanitizeDataForNewSchema = sanitizeDataForNewSchema;
   exports.schemaParser = schemaParser;
   exports.schemaRequiresTrueValue = schemaRequiresTrueValue;
+  exports.setByPath = setByPath;
   exports.shallowEquals = shallowEquals;
   exports.shouldRender = shouldRender;
   exports.shouldRenderOptionalField = shouldRenderOptionalField;
@@ -4333,7 +4571,9 @@
   exports.toErrorList = toErrorList;
   exports.toErrorSchema = toErrorSchema;
   exports.toFieldPathId = toFieldPathId;
+  exports.toPath = toPath;
   exports.toPathSchema = toPathSchema;
+  exports.unsetByPath = unsetByPath;
   exports.unwrapErrorHandler = unwrapErrorHandler;
   exports.useAltDateWidgetProps = useAltDateWidgetProps;
   exports.useDeepCompareMemo = useDeepCompareMemo;