@rjsf/utils 6.8.0 → 6.10.0

package/dist/utils.esm.js

@@ -3,10 +3,10 @@ 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);
@@ -136,8 +136,16 @@ function canExpand(schema, uiSchema = {}, formData) {
   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
-import isPlainObject from "lodash/isPlainObject";
 function createErrorHandler(formData) {
   const handler = {
     // We store the list of errors for this node in a property named __errors
@@ -152,18 +160,14 @@ function createErrorHandler(formData) {
     return formData.reduce((acc, value, key) => ({ ...acc, [key]: createErrorHandler(value) }), handler);
   }
   if (isPlainObject(formData)) {
-    const formObject = formData;
-    return Object.keys(formObject).reduce(
-      (acc, key) => ({ ...acc, [key]: createErrorHandler(formObject[key]) }),
+    return Object.keys(formData).reduce(
+      (acc, key) => ({ ...acc, [key]: createErrorHandler(formData[key]) }),
       handler
     );
   }
   return handler;
 }
 
-// src/createSchemaUtils.ts
-import get16 from "lodash/get";
-
 // src/deepEquals.ts
 import { createCustomEqual } from "fast-equals";
 var deepEquals = createCustomEqual({
@@ -179,10 +183,6 @@ var deepEquals_default = deepEquals;
 // src/findSchemaDefinition.ts
 import UriResolver from "fast-uri";
 import jsonpointer from "jsonpointer";
-import get from "lodash/get";
-import isEmpty from "lodash/isEmpty";
-import isObject2 from "lodash/isObject";
-import omit from "lodash/omit";
 function findEmbeddedSchemaRecursive(schema, ref) {
   if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY], ref)) {
     return schema;
@@ -190,14 +190,14 @@ function findEmbeddedSchemaRecursive(schema, ref) {
   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;
@@ -207,7 +207,7 @@ function findEmbeddedSchemaRecursive(schema, ref) {
   return void 0;
 }
 function makeAllReferencesAbsolute(schema, baseURI) {
-  const currentURI = get(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]) };
@@ -216,20 +216,19 @@ function makeAllReferencesAbsolute(schema, baseURI) {
     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 = get(rootSchema, [ID_KEY])) {
+function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = rootSchema[ID_KEY]) {
   const ref = $ref || "";
   let current = void 0;
   let currentBaseURI = baseURI;
@@ -249,7 +248,7 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
     current = findEmbeddedSchemaRecursive(rootSchema, refId.replace(/\/$/, ""));
     if (current !== void 0) {
       currentBaseURI = current[ID_KEY];
-      if (!isEmpty(refAnchor)) {
+      if (refAnchor.length > 0) {
         current = jsonpointer.get(current, decodeURIComponent(refAnchor.join("#")));
       }
     }
@@ -279,25 +278,116 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
   }
   return current;
 }
-function findSchemaDefinition($ref, rootSchema = {}, baseURI = get(rootSchema, [ID_KEY])) {
+function findSchemaDefinition($ref, rootSchema = {}, baseURI = rootSchema[ID_KEY]) {
   const recurseList = [];
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }
 
-// src/schema/findFieldInSchema.ts
-import get8 from "lodash/get";
-import has3 from "lodash/has";
-
-// src/schema/findSelectedOptionInXxxOf.ts
-import get6 from "lodash/get";
+// 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
-import get2 from "lodash/get";
-import isString from "lodash/isString";
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = get2(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`);
@@ -305,16 +395,6 @@ function getDiscriminatorFieldFromSchema(schema) {
   return discriminator;
 }
 
-// src/schema/retrieveSchema.ts
-import flattenDeep from "lodash/flattenDeep";
-import get5 from "lodash/get";
-import isEmpty2 from "lodash/isEmpty";
-import merge from "lodash/merge";
-import set from "lodash/set";
-import times from "lodash/times";
-import transform from "lodash/transform";
-import uniq from "lodash/uniq";
-
 // src/guessType.ts
 function guessType(value) {
   if (Array.isArray(value)) {
@@ -338,9 +418,6 @@ function guessType(value) {
   return "string";
 }
 
-// src/mergeSchemas.ts
-import union from "lodash/union";
-
 // src/getSchemaType.ts
 function getSchemaType(schema) {
   let { type } = schema;
@@ -371,7 +448,7 @@ function mergeSchemas(obj1, obj2) {
     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;
     }
@@ -383,27 +460,27 @@ function mergeSchemas(obj1, obj2) {
   return result;
 }
 
-// src/schema/getFirstMatchingOption.ts
-import get4 from "lodash/get";
-import has from "lodash/has";
-import isNumber from "lodash/isNumber";
+// src/getPropertySchema.ts
+function getPropertySchema(schema, property) {
+  return schema?.[PROPERTIES_KEY]?.[property] ?? {};
+}
 
 // src/getOptionMatchingSimpleDiscriminator.ts
-import get3 from "lodash/get";
 function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
   if (formData && discriminatorField) {
-    const value = get3(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 = get3(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;
         }
       }
@@ -418,14 +495,14 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
     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 && has(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = get4(formData, discriminatorField);
-      const discriminator = get4(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;
       }
@@ -558,7 +635,7 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   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;
@@ -569,12 +646,9 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   return allPermutations;
 }
 function getMatchingPatternProperties(schema, key) {
-  return Object.keys(schema.patternProperties).filter((pattern) => RegExp(pattern).test(key)).reduce(
-    (obj, pattern) => {
-      set(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) {
@@ -669,23 +743,24 @@ function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveA
   }
   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") {
@@ -734,12 +809,12 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
     }
     if (PATTERN_PROPERTIES_KEY in schema) {
       const matchingProperties = getMatchingPatternProperties(schema, key);
-      if (!isEmpty2(matchingProperties)) {
+      if (Object.keys(matchingProperties).length > 0) {
         schema.properties[key] = retrieveSchema(
           validator,
           { [ALL_OF_KEY]: Object.values(matchingProperties) },
           rootSchema,
-          get5(formData, [key]),
+          formData[key],
           experimental_customMergeAllOf
         );
         schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
@@ -752,9 +827,9 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
         if (REF_KEY in schema.additionalProperties) {
           additionalProperties = retrieveSchema(
             validator,
-            { [REF_KEY]: get5(schema.additionalProperties, [REF_KEY]) },
+            { [REF_KEY]: schema.additionalProperties[REF_KEY] },
             rootSchema,
-            get5(formData, [key]),
+            formData[key],
             experimental_customMergeAllOf
           );
         } else if ("type" in schema.additionalProperties) {
@@ -765,10 +840,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
             ...schema.additionalProperties
           };
         } else {
-          additionalProperties = { type: guessType(get5(formData, [key])) };
+          additionalProperties = { type: guessType(formData[key]) };
         }
       } else {
-        additionalProperties = { type: guessType(get5(formData, [key])) };
+        additionalProperties = { type: guessType(formData[key]) };
       }
       schema.properties[key] = additionalProperties;
       schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
@@ -850,12 +925,12 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
       resolvedSchema = Object.keys(resolvedSchema.properties).reduce(
         (acc, key) => {
           const matchingProperties = getMatchingPatternProperties(acc, key);
-          if (!isEmpty2(matchingProperties)) {
+          if (Object.keys(matchingProperties).length > 0) {
             acc.properties[key] = retrieveSchema(
               validator,
               { allOf: [acc.properties[key], ...Object.values(matchingProperties)] },
               rootSchema,
-              get5(rawFormData, [key]),
+              getByPath(rawFormData, key),
               experimental_customMergeAllOf
             );
           }
@@ -936,7 +1011,7 @@ function resolveDependencies(validator, schema, rootSchema, expandAllBranches, r
 function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
   let schemas = [resolvedSchema];
   for (const dependencyKey in dependencies) {
-    if ((expandAllBranches || get5(formData, [dependencyKey]) !== void 0) && (!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
@@ -1063,14 +1138,14 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
     const xxxOfs = schema[xxx].map(
       (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
     );
-    const data = get6(formData, selectorField);
+    const data = getByPath(formData, selectorField);
     if (data !== void 0) {
       return xxxOfs.find(
         (xxxOfOption) => deepEquals_default(
-          get6(
+          getByPath(
             xxxOfOption,
             [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
-            get6(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
+            getByPath(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
           ),
           data
         )
@@ -1081,21 +1156,18 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
 }
 
 // src/schema/getFromSchema.ts
-import get7 from "lodash/get";
-import has2 from "lodash/has";
-import isEmpty3 from "lodash/isEmpty";
 function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
   let fieldSchema = schema;
-  if (has2(schema, REF_KEY)) {
+  if (hasByPath(schema, REF_KEY)) {
     fieldSchema = retrieveSchema(validator, schema, rootSchema, void 0, experimental_customMergeAllOf);
   }
-  if (isEmpty3(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 !== "" && has2(fieldSchema, part)) {
-    fieldSchema = get7(fieldSchema, part);
+  if (part !== void 0 && part !== "" && hasByPath(fieldSchema, part)) {
+    fieldSchema = getByPath(fieldSchema, part);
     return getFromSchemaInternal(
       validator,
       rootSchema,
@@ -1131,30 +1203,30 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
         {},
         experimental_customMergeAllOf
       );
-      if (has3(parentField, ONE_OF_KEY)) {
+      if (hasByPath(parentField, ONE_OF_KEY)) {
         parentField = findSelectedOptionInXxxOf(
           validator,
           rootSchema,
           parentField,
           fieldNameKey,
           ONE_OF_KEY,
-          get8(formData, subPath),
+          getByPath(formData, subPath),
           experimental_customMergeAllOf
         );
-      } else if (has3(parentField, ANY_OF_KEY)) {
+      } else if (hasByPath(parentField, ANY_OF_KEY)) {
         parentField = findSelectedOptionInXxxOf(
           validator,
           rootSchema,
           parentField,
           fieldNameKey,
           ANY_OF_KEY,
-          get8(formData, subPath),
+          getByPath(formData, subPath),
           experimental_customMergeAllOf
         );
       }
     });
   }
-  if (has3(parentField, ONE_OF_KEY)) {
+  if (hasByPath(parentField, ONE_OF_KEY)) {
     parentField = findSelectedOptionInXxxOf(
       validator,
       rootSchema,
@@ -1164,7 +1236,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
       formData,
       experimental_customMergeAllOf
     );
-  } else if (has3(parentField, ANY_OF_KEY)) {
+  } else if (hasByPath(parentField, ANY_OF_KEY)) {
     parentField = findSelectedOptionInXxxOf(
       validator,
       rootSchema,
@@ -1202,13 +1274,6 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
 }
 
 // src/schema/getClosestMatchingOption.ts
-import get9 from "lodash/get";
-import has4 from "lodash/has";
-import isNumber2 from "lodash/isNumber";
-import isObject3 from "lodash/isObject";
-import isString2 from "lodash/isString";
-import reduce from "lodash/reduce";
-import times2 from "lodash/times";
 var JUNK_OPTION = {
   type: "object",
   $id: JUNK_OPTION_ID,
@@ -1221,61 +1286,57 @@ var JUNK_OPTION = {
 function calculateIndexScore(validator, rootSchema, schema, formData, experimental_customMergeAllOf) {
   let totalScore = 0;
   if (schema) {
-    if (isObject3(schema.properties)) {
-      totalScore += reduce(
-        schema.properties,
-        (score, value, key) => {
-          const formValue = get9(formData, key);
-          if (typeof value === "boolean") {
-            return score;
-          }
-          if (has4(value, REF_KEY)) {
-            const newSchema = retrieveSchema(
-              validator,
-              value,
-              rootSchema,
-              formValue,
-              experimental_customMergeAllOf
-            );
-            return score + calculateIndexScore(
-              validator,
-              rootSchema,
-              newSchema,
-              formValue || {},
-              experimental_customMergeAllOf
-            );
-          }
-          if ((has4(value, ONE_OF_KEY) || has4(value, ANY_OF_KEY)) && formValue) {
-            const xxxOfKey = has4(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
-            const discriminator = getDiscriminatorFieldFromSchema(value);
-            return score + getClosestMatchingOption(
-              validator,
-              rootSchema,
-              formValue,
-              get9(value, xxxOfKey),
-              -1,
-              discriminator,
-              experimental_customMergeAllOf
-            );
-          }
-          if (value.type === "object") {
-            const structureBoost = isObject3(formValue) ? 1 : 0;
-            return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
-          }
-          if (value.type === guessType(formValue)) {
-            let newScore = score + 1;
-            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 (isString2(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;
     }
   }
@@ -1284,7 +1345,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
 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 (isNumber2(simpleDiscriminatorMatch)) {
+  if (typeof simpleDiscriminatorMatch === "number") {
     return simpleDiscriminatorMatch;
   }
   const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
@@ -1299,7 +1360,7 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
     return allValidIndexes[0];
   }
   if (!allValidIndexes.length) {
-    times2(resolvedOptions.length, (i) => allValidIndexes.push(i));
+    allValidIndexes.push(...resolvedOptions.keys());
   }
   const scoreCount = /* @__PURE__ */ new Set();
   const { bestIndex } = allValidIndexes.reduce(
@@ -1321,16 +1382,11 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
   return bestIndex;
 }
 
-// src/schema/getDefaultFormState.ts
-import get12 from "lodash/get";
-import isEmpty4 from "lodash/isEmpty";
-
 // src/constIsAjvDataReference.ts
-import isString3 from "lodash/isString";
 function constIsAjvDataReference(schema) {
   const schemaConst = schema[CONST_KEY];
   const schemaType = getSchemaType(schema);
-  return isObject(schemaConst) && isString3(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+  return isObject(schemaConst) && typeof schemaConst?.$data === "string" && schemaType !== "object" && schemaType !== "array";
 }
 
 // src/isConstant.ts
@@ -1344,8 +1400,6 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-import get10 from "lodash/get";
-import isNil from "lodash/isNil";
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -1370,23 +1424,25 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
   }
   if (isObject(formData)) {
     const acc = Object.assign({}, defaults);
-    return Object.keys(formData).reduce((accumulator, key) => {
-      const keyValue = get10(formData, key);
-      const keyExistsInDefaults = isObject(defaults) && key in defaults;
-      const keyExistsInFormData = key in formData;
-      const keyDefault = get10(defaults, key) ?? {};
-      const defaultValueIsNestedObject = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
-      const keyDefaultIsObject = keyExistsInDefaults && isObject(get10(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] = {
-          ...get10(defaults, key),
+          ...defaultsObj?.[key],
           ...keyValue
         };
         return accumulator;
       }
       accumulator[key] = mergeDefaultsWithFormData(
-        get10(defaults, key),
+        defaultsObj?.[key],
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -1397,7 +1453,7 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       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;
@@ -1430,9 +1486,6 @@ function mergeObjects(obj1, obj2, concatArrays = false) {
   );
 }
 
-// src/optionsList.ts
-import get11 from "lodash/get";
-
 // src/toConstant.ts
 function toConstant(schema) {
   if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
@@ -1495,8 +1548,8 @@ function optionsList(schema, uiSchema) {
     let value;
     let label = title;
     if (selectorField) {
-      const innerSchema = get11(aSchema, [PROPERTIES_KEY, selectorField], {});
-      value = get11(innerSchema, DEFAULT_KEY, get11(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);
@@ -1549,9 +1602,18 @@ function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, id
   }
   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) {
@@ -1559,17 +1621,17 @@ function maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValu
   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 (
@@ -1619,7 +1681,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       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;
     }
@@ -1752,13 +1814,13 @@ function ensureFormDataMatchingSchema(validator, schema, rootSchema, formData, e
   } else if (isObject(validFormData) && isObject(schemaToMatch.properties)) {
     validFormData = Object.keys(schemaToMatch.properties).reduce(
       (acc, key) => {
-        const propertySchema = get12(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,
-            get12(acc, key),
+            acc[key],
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf
           );
@@ -1789,7 +1851,7 @@ function getObjectDefaults(validator, rawSchema, {
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc, key) => {
-        const propertySchema = get12(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, {
@@ -1798,8 +1860,8 @@ function getObjectDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get12(defaults, [key]),
-          rawFormData: get12(formData, [key]),
+          parentDefaults: getByPath(defaults, key),
+          rawFormData: getByPath(formData, key),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated
@@ -1821,24 +1883,24 @@ function getObjectDefaults(validator, rawSchema, {
     );
     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: get12(defaults, [key]),
-          rawFormData: get12(formData, [key]),
+          parentDefaults: getByPath(defaults, key),
+          rawFormData: getByPath(formData, key),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated
@@ -1906,7 +1968,7 @@ function getArrayDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           rawFormData: item,
-          parentDefaults: get12(defaults, [idx]),
+          parentDefaults: getByPath(defaults, idx),
           required,
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated
@@ -1958,6 +2020,12 @@ function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps
     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;
   }
@@ -2060,22 +2128,30 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
 }
 
 // src/schema/omitExtraData.ts
-import get13 from "lodash/get";
-import isEmpty5 from "lodash/isEmpty";
-import isNil2 from "lodash/isNil";
-import pick from "lodash/pick";
 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" || isEmpty5(value) || isLeaf && !isEmpty5(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) => {
@@ -2089,7 +2165,7 @@ function getFieldNames(pathSchema, formData) {
         }
       } else if (key === NAME_KEY && data !== "") {
         paths.forEach((path) => {
-          const formValue = get13(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);
@@ -2102,7 +2178,7 @@ function getFieldNames(pathSchema, formData) {
   return getAllPaths(pathSchema);
 }
 function isValueEmpty(value) {
-  if (isNil2(value) || value === "") {
+  if (value == null || value === "") {
     return true;
   }
   if (Array.isArray(value)) {
@@ -2124,19 +2200,17 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
     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;
         }
@@ -2184,31 +2258,29 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
         }
       }
     }
-    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) {
@@ -2218,7 +2290,7 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
     }
     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)) {
@@ -2236,7 +2308,7 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
     );
     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;
@@ -2246,7 +2318,7 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
     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;
     }
@@ -2260,29 +2332,29 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
     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 || isEmpty5(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);
         }
       }
     }
@@ -2297,18 +2369,27 @@ function omitExtraData(validator, schema, rootSchema = {}, formData, experimenta
       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 : []);
+      }
     }
-    return handleDependencies(localSchema, source, handleConditions(localSchema, source, 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];
+        }
+      }
+    }
+    const result = handleDependencies(localSchema, source, afterConditions);
+    return result ?? (useSourceAsFallback ? source : void 0);
   }
-  return omit2(schema, formData);
+  return omit(schema, formData);
 }
 
 // src/schema/sanitizeDataForNewSchema.ts
-import get14 from "lodash/get";
-import has5 from "lodash/has";
 var NO_VALUE = /* @__PURE__ */ Symbol("no Value");
 function enumValuesForSchema(schema) {
   if (Array.isArray(schema.enum)) {
@@ -2331,7 +2412,7 @@ function replacementForInvalidEnumValue(schema, formValue) {
   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;
   }
@@ -2339,23 +2420,25 @@ function replacementForInvalidEnumValue(schema, formValue) {
 }
 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,
@@ -2364,7 +2447,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      if (has5(newKeyedSchema, REF_KEY)) {
+      if (hasByPath(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema(
           validator,
           newKeyedSchema,
@@ -2373,10 +2456,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           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)) {
@@ -2384,7 +2467,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             validator,
             rootSchema,
             newKeyedSchema,
-            oldKeyedSchema,
+            isNewProperty && newSchemaTypeForKey === "array" ? newKeyedSchema : oldKeyedSchema,
             formValue,
             experimental_customMergeAllOf
           );
@@ -2392,21 +2475,21 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             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;
@@ -2420,11 +2503,11 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...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,
@@ -2433,7 +2516,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      if (has5(newSchemaItems, REF_KEY)) {
+      if (hasByPath(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema(
           validator,
           newSchemaItems,
@@ -2442,10 +2525,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           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(
@@ -2475,9 +2558,6 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toPathSchema.ts
-import get15 from "lodash/get";
-import isObject4 from "lodash/isObject";
-import set2 from "lodash/set";
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
     const innerSchema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
@@ -2524,9 +2604,9 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     };
   }
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-    set2(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-    const additionalSchema = isObject4(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-    const definedProperties = get15(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(
@@ -2534,7 +2614,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
           additionalSchema,
           `${name}.${key}`,
           rootSchema,
-          get15(formData, [key]),
+          getByPath(formData, key),
           _recurseList,
           experimental_customMergeAllOf
         );
@@ -2584,7 +2664,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = get15(schema, [PROPERTIES_KEY, property], {});
+      const field = getPropertySchema(schema, property);
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -2592,7 +2672,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        get15(formData, [property]),
+        getByPath(formData, property),
         _recurseList,
         experimental_customMergeAllOf
       );
@@ -2606,6 +2686,10 @@ function toPathSchema(validator, schema, name = "", rootSchema, formData, experi
 
 // 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
@@ -2615,7 +2699,7 @@ var SchemaUtils = class {
    */
   constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
     if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-      this.rootSchema = makeAllReferencesAbsolute(rootSchema, get16(rootSchema, ID_KEY, "#"));
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, rootSchema[ID_KEY] ?? "#");
     } else {
       this.rootSchema = rootSchema;
     }
@@ -3006,8 +3090,8 @@ function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false)
 
 // 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") {
@@ -3018,10 +3102,9 @@ function enumOptionSelectedValue(value, enumOptions, multiple, format = "indexed
 }
 
 // src/enumOptionsSelectValue.ts
-import isNil3 from "lodash/isNil";
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!isNil3(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));
@@ -3056,12 +3139,11 @@ function enumOptionValueDecoder(value, enumOptions, format = "indexed", emptyVal
 }
 
 // src/enumOptionValueEncoder.ts
-import isNil4 from "lodash/isNil";
 function enumOptionValueEncoder(value, index, format = "indexed") {
   if (format !== "realValue") {
     return String(index);
   }
-  if (isNil4(value)) {
+  if (value == null) {
     return "";
   }
   if (typeof value === "object") {
@@ -3071,21 +3153,17 @@ function enumOptionValueEncoder(value, index, format = "indexed") {
 }
 
 // src/ErrorSchemaBuilder.ts
-import cloneDeep from "lodash/cloneDeep";
-import get17 from "lodash/get";
-import set3 from "lodash/set";
-import setWith from "lodash/setWith";
 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`
@@ -3100,11 +3178,14 @@ var ErrorSchemaBuilder = class {
    * @private
    */
   getOrCreateErrorBlock(pathOfError) {
-    const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? get17(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;
   }
@@ -3114,12 +3195,12 @@ var ErrorSchemaBuilder = class {
    * @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)
@@ -3127,21 +3208,21 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get17(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)
@@ -3150,43 +3231,59 @@ var ErrorSchemaBuilder = class {
   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;
   }
 };
 
 // src/getChangedFields.ts
-import difference from "lodash/difference";
-import get18 from "lodash/get";
-import isPlainObject2 from "lodash/isPlainObject";
-import keys from "lodash/keys";
-import pickBy from "lodash/pickBy";
-function getChangedFields(a, b) {
-  const aIsPlainObject = isPlainObject2(a);
-  const bIsPlainObject = isPlainObject2(b);
-  if (a === b || !aIsPlainObject && !bIsPlainObject) {
+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, get18(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];
 }
 
@@ -3265,6 +3362,9 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
   if (options.autocomplete) {
     inputProps.autoComplete = options.autocomplete;
   }
+  if (options.autocapitalize) {
+    inputProps.autoCapitalize = options.autocapitalize;
+  }
   if (options.accept) {
     inputProps.accept = options.accept;
   }
@@ -3311,10 +3411,9 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-import get19 from "lodash/get";
-import uniqueId from "lodash/uniqueId";
+var testIdCounter = 0;
 function getTestIds() {
-  if (get19(globalThis, "process.env.NODE_ENV") !== "test") {
+  if (getByPath(globalThis, ["process", "env", "NODE_ENV"]) !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3323,7 +3422,8 @@ function getTestIds() {
     {
       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);
       }
@@ -3333,8 +3433,6 @@ function getTestIds() {
 
 // src/getWidget.tsx
 import { createElement } from "react";
-import get20 from "lodash/get";
-import set4 from "lodash/set";
 import ReactIs from "react-is";
 import { jsx } from "react/jsx-runtime";
 var widgetMap = {
@@ -3390,11 +3488,11 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get20(AWidget, "MergedWidget");
+  let { MergedWidget } = AWidget;
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps?.options || {};
     MergedWidget = ({ options, ...props }) => /* @__PURE__ */ jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
-    set4(AWidget, "MergedWidget", MergedWidget);
+    AWidget.MergedWidget = MergedWidget;
   }
   return MergedWidget;
 }
@@ -3468,9 +3566,8 @@ function hasWidget(schema, widget, registeredWidgets = {}) {
 }
 
 // src/idGenerators.ts
-import isString4 from "lodash/isString";
 function idGenerator(id, suffix) {
-  const theId = isString4(id) ? id : id[ID_KEY];
+  const theId = typeof id === "string" ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
 function descriptionId(id) {
@@ -3503,11 +3600,14 @@ function optionalControlsId(id, element) {
 }
 
 // src/isFormDataAvailable.ts
-import isEmpty6 from "lodash/isEmpty";
-import isNil5 from "lodash/isNil";
-import isObject5 from "lodash/isObject";
 function isFormDataAvailable(formData) {
-  return !isNil5(formData) && (!isObject5(formData) || Array.isArray(formData) || !isEmpty6(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
@@ -3543,14 +3643,12 @@ function logUnsupportedDefaultForEnum(id, schema, enumOptions, multiple = false)
 }
 
 // src/lookupFromFormContext.ts
-import get21 from "lodash/get";
-import has6 from "lodash/has";
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
-  if (has6(regOrFc, FORM_CONTEXT_NAME)) {
+  if (hasByPath(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return get21(regOrFc, [...lookupPath, toLookup], fallback);
+  return getByPath(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/nameGenerators.ts
@@ -3573,6 +3671,10 @@ var dotNotationNameGenerator = (path, idPrefix, _isMultiValue) => {
   return `${idPrefix}.${path.map(String).join(".")}`;
 };
 
+// src/noop.ts
+function noop() {
+}
+
 // src/orderProperties.ts
 function orderProperties(properties, order) {
   if (!Array.isArray(order)) {
@@ -3687,7 +3789,6 @@ function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
 }
 
 // src/resolveUiSchema.ts
-import isEmpty7 from "lodash/isEmpty";
 function resolveUiSchema(schema, localUiSchema, registry) {
   const ref = schema[RJSF_REF_KEY] ?? schema[REF_KEY];
   const definitions = registry.uiSchemaDefinitions;
@@ -3695,7 +3796,7 @@ function resolveUiSchema(schema, localUiSchema, registry) {
   let result;
   if (!definitionUiSchema) {
     result = localUiSchema || {};
-  } else if (!localUiSchema || isEmpty7(localUiSchema)) {
+  } else if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
     result = { ...definitionUiSchema };
   } else {
     result = mergeObjects(definitionUiSchema, localUiSchema);
@@ -3826,12 +3927,12 @@ function shouldRender(component, nextProps, nextState, updateStrategy = "customD
 }
 
 // src/shouldRenderOptionalField.ts
-import isObject6 from "lodash/isObject";
-import uniq2 from "lodash/uniq";
 function getSchemaTypesForXxxOf(schemas) {
-  const allTypes = uniq2(
-    schemas.map((s) => isObject6(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) {
@@ -3856,46 +3957,29 @@ function toDateString(dateObject, time = true) {
 }
 
 // src/toErrorList.ts
-import isPlainObject3 from "lodash/isPlainObject";
 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 (isPlainObject3(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
-import toPath from "lodash/toPath";
 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);
       }
@@ -3918,17 +4002,19 @@ function toFieldPathId(fieldPath, globalFormOptions, parentPath, isMultiValue) {
 }
 
 // src/unwrapErrorHandler.ts
-import isPlainObject4 from "lodash/isPlainObject";
 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 (isPlainObject4(childSchema)) {
+    const childSchema = errors[key];
+    if (isPlainObject(childSchema)) {
       return {
         ...acc,
-        [key]: unwrapErrorHandler(childSchema)
+        [key]: unwrapErrors(childSchema)
       };
     }
     return { ...acc, [key]: childSchema };
@@ -4153,7 +4239,6 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-import isEmpty8 from "lodash/isEmpty";
 function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -4161,7 +4246,7 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!isEmpty8(oldErrorSchema)) {
+  if (oldErrorSchema && Object.keys(oldErrorSchema).length > 0) {
     errorSchema = mergeObjects(
       oldErrorSchema,
       additionalErrorSchema,
@@ -4173,7 +4258,6 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
 }
 
 // src/withIdRefPrefix.ts
-import isObject7 from "lodash/isObject";
 function withIdRefPrefixObject(node) {
   const realObj = node;
   for (const key in realObj) {
@@ -4195,7 +4279,7 @@ function withIdRefPrefix(schemaNode) {
   if (Array.isArray(schemaNode)) {
     return withIdRefPrefixArray([...schemaNode]);
   }
-  if (isObject7(schemaNode)) {
+  if (isObject(schemaNode)) {
     return withIdRefPrefixObject({ ...schemaNode });
   }
   return schemaNode;
@@ -4245,20 +4329,18 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   return TranslatableString2;
 })(TranslatableString || {});
 
-// src/parser/schemaParser.ts
-import forEach from "lodash/forEach";
-
 // src/parser/ParserValidator.ts
-import get22 from "lodash/get";
 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));
   }
@@ -4275,7 +4357,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get22(schema, ID_KEY, hash);
+    const key = schema[ID_KEY] ?? hash;
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -4348,9 +4430,9 @@ function parseSchema(validator, recurseList, rootSchema, schema) {
       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") {
@@ -4437,6 +4519,7 @@ export {
   findFieldInSchema,
   findSchemaDefinition,
   findSelectedOptionInXxxOf,
+  getByPath,
   getChangedFields,
   getClosestMatchingOption,
   getDateElementProps,
@@ -4450,6 +4533,7 @@ export {
   getInputProps,
   getOptionMatchingSimpleDiscriminator,
   getOptionValueFormat,
+  getPropertySchema,
   getSchemaType,
   getSubmitButtonOptions,
   getTemplate,
@@ -4458,6 +4542,7 @@ export {
   getUsedFormData,
   getWidget,
   guessType,
+  hasByPath,
   hasWidget,
   hashForSchema,
   hashObject,
@@ -4470,6 +4555,7 @@ export {
   isFormDataAvailable,
   isMultiSelect,
   isObject,
+  isPlainObject,
   isRootSchema,
   isSelect,
   isValueEmpty,
@@ -4480,6 +4566,7 @@ export {
   mergeDefaultsWithFormData,
   mergeObjects,
   mergeSchemas,
+  noop,
   omitExtraData,
   optionId,
   optionalControlsId,
@@ -4496,6 +4583,7 @@ export {
   sanitizeDataForNewSchema,
   schemaParser,
   schemaRequiresTrueValue,
+  setByPath,
   shallowEquals,
   shouldRender,
   shouldRenderOptionalField,
@@ -4506,7 +4594,9 @@ export {
   toErrorList,
   toErrorSchema,
   toFieldPathId,
+  toPath,
   toPathSchema,
+  unsetByPath,
   unwrapErrorHandler,
   useAltDateWidgetProps,
   useDeepCompareMemo,