@rjsf/utils 6.7.1 → 6.10.0

package/dist/index.cjs

@@ -101,6 +101,7 @@ __export(index_exports, {
   findFieldInSchema: () => findFieldInSchema,
   findSchemaDefinition: () => findSchemaDefinition,
   findSelectedOptionInXxxOf: () => findSelectedOptionInXxxOf,
+  getByPath: () => getByPath,
   getChangedFields: () => getChangedFields,
   getClosestMatchingOption: () => getClosestMatchingOption,
   getDateElementProps: () => getDateElementProps,
@@ -114,6 +115,7 @@ __export(index_exports, {
   getInputProps: () => getInputProps,
   getOptionMatchingSimpleDiscriminator: () => getOptionMatchingSimpleDiscriminator,
   getOptionValueFormat: () => getOptionValueFormat,
+  getPropertySchema: () => getPropertySchema,
   getSchemaType: () => getSchemaType,
   getSubmitButtonOptions: () => getSubmitButtonOptions,
   getTemplate: () => getTemplate,
@@ -122,6 +124,7 @@ __export(index_exports, {
   getUsedFormData: () => getUsedFormData,
   getWidget: () => getWidget,
   guessType: () => guessType,
+  hasByPath: () => hasByPath,
   hasWidget: () => hasWidget,
   hashForSchema: () => hashForSchema,
   hashObject: () => hashObject,
@@ -134,6 +137,7 @@ __export(index_exports, {
   isFormDataAvailable: () => isFormDataAvailable,
   isMultiSelect: () => isMultiSelect,
   isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
   isRootSchema: () => isRootSchema,
   isSelect: () => isSelect,
   isValueEmpty: () => isValueEmpty,
@@ -144,6 +148,7 @@ __export(index_exports, {
   mergeDefaultsWithFormData: () => mergeDefaultsWithFormData,
   mergeObjects: () => mergeObjects,
   mergeSchemas: () => mergeSchemas,
+  noop: () => noop,
   omitExtraData: () => omitExtraData,
   optionId: () => optionId,
   optionalControlsId: () => optionalControlsId,
@@ -160,6 +165,7 @@ __export(index_exports, {
   sanitizeDataForNewSchema: () => sanitizeDataForNewSchema,
   schemaParser: () => schemaParser,
   schemaRequiresTrueValue: () => schemaRequiresTrueValue,
+  setByPath: () => setByPath,
   shallowEquals: () => shallowEquals,
   shouldRender: () => shouldRender,
   shouldRenderOptionalField: () => shouldRenderOptionalField,
@@ -170,7 +176,9 @@ __export(index_exports, {
   toErrorList: () => toErrorList,
   toErrorSchema: () => toErrorSchema,
   toFieldPathId: () => toFieldPathId,
+  toPath: () => toPath,
   toPathSchema: () => toPathSchema,
+  unsetByPath: () => unsetByPath,
   unwrapErrorHandler: () => unwrapErrorHandler,
   useAltDateWidgetProps: () => useAltDateWidgetProps,
   useDeepCompareMemo: () => useDeepCompareMemo,
@@ -186,10 +194,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);
@@ -319,8 +327,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
-var import_isPlainObject = __toESM(require("lodash/isPlainObject"), 1);
 function createErrorHandler(formData) {
   const handler = {
     // We store the list of errors for this node in a property named __errors
@@ -334,19 +350,15 @@ function createErrorHandler(formData) {
   if (Array.isArray(formData)) {
     return formData.reduce((acc, value, key) => ({ ...acc, [key]: createErrorHandler(value) }), handler);
   }
-  if ((0, import_isPlainObject.default)(formData)) {
-    const formObject = formData;
-    return Object.keys(formObject).reduce(
-      (acc, key) => ({ ...acc, [key]: createErrorHandler(formObject[key]) }),
+  if (isPlainObject(formData)) {
+    return Object.keys(formData).reduce(
+      (acc, key) => ({ ...acc, [key]: createErrorHandler(formData[key]) }),
       handler
     );
   }
   return handler;
 }
 
-// src/createSchemaUtils.ts
-var import_get16 = __toESM(require("lodash/get"), 1);
-
 // src/deepEquals.ts
 var import_fast_equals = require("fast-equals");
 var deepEquals = (0, import_fast_equals.createCustomEqual)({
@@ -362,10 +374,6 @@ var deepEquals_default = deepEquals;
 // src/findSchemaDefinition.ts
 var import_fast_uri = __toESM(require("fast-uri"), 1);
 var import_jsonpointer = __toESM(require("jsonpointer"), 1);
-var import_get = __toESM(require("lodash/get"), 1);
-var import_isEmpty = __toESM(require("lodash/isEmpty"), 1);
-var import_isObject3 = __toESM(require("lodash/isObject"), 1);
-var import_omit = __toESM(require("lodash/omit"), 1);
 function findEmbeddedSchemaRecursive(schema, ref) {
   if (ID_KEY in schema && import_fast_uri.default.equal(schema[ID_KEY], ref)) {
     return schema;
@@ -373,14 +381,14 @@ function findEmbeddedSchemaRecursive(schema, ref) {
   for (const subSchema of Object.values(schema)) {
     if (Array.isArray(subSchema)) {
       for (const item of subSchema) {
-        if ((0, import_isObject3.default)(item)) {
+        if (isObject(item)) {
           const result = findEmbeddedSchemaRecursive(item, ref);
           if (result !== void 0) {
             return result;
           }
         }
       }
-    } else if ((0, import_isObject3.default)(subSchema)) {
+    } else if (isObject(subSchema)) {
       const result = findEmbeddedSchemaRecursive(subSchema, ref);
       if (result !== void 0) {
         return result;
@@ -390,7 +398,7 @@ function findEmbeddedSchemaRecursive(schema, ref) {
   return void 0;
 }
 function makeAllReferencesAbsolute(schema, baseURI) {
-  const currentURI = (0, import_get.default)(schema, ID_KEY, baseURI);
+  const currentURI = schema[ID_KEY] ?? baseURI;
   let result = schema;
   if (REF_KEY in result) {
     result = { ...result, [REF_KEY]: import_fast_uri.default.resolve(currentURI, result[REF_KEY]) };
@@ -399,20 +407,19 @@ function makeAllReferencesAbsolute(schema, baseURI) {
     if (Array.isArray(subSchema)) {
       result = {
         ...result,
-        [key]: subSchema.map((item) => (0, import_isObject3.default)(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
+        [key]: subSchema.map((item) => isObject(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
       };
-    } else if ((0, import_isObject3.default)(subSchema)) {
+    } else if (isObject(subSchema)) {
       result = { ...result, [key]: makeAllReferencesAbsolute(subSchema, currentURI) };
     }
   }
   return result;
 }
 function splitKeyElementFromObject(key, object) {
-  const value = object[key];
-  const remaining = (0, import_omit.default)(object, [key]);
+  const { [key]: value, ...remaining } = object;
   return [remaining, value];
 }
-function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = (0, import_get.default)(rootSchema, [ID_KEY])) {
+function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = rootSchema[ID_KEY]) {
   const ref = $ref || "";
   let current = void 0;
   let currentBaseURI = baseURI;
@@ -432,7 +439,7 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
     current = findEmbeddedSchemaRecursive(rootSchema, refId.replace(/\/$/, ""));
     if (current !== void 0) {
       currentBaseURI = current[ID_KEY];
-      if (!(0, import_isEmpty.default)(refAnchor)) {
+      if (refAnchor.length > 0) {
         current = import_jsonpointer.default.get(current, decodeURIComponent(refAnchor.join("#")));
       }
     }
@@ -462,25 +469,116 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
   }
   return current;
 }
-function findSchemaDefinition($ref, rootSchema = {}, baseURI = (0, import_get.default)(rootSchema, [ID_KEY])) {
+function findSchemaDefinition($ref, rootSchema = {}, baseURI = rootSchema[ID_KEY]) {
   const recurseList = [];
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }
 
-// src/schema/findFieldInSchema.ts
-var import_get8 = __toESM(require("lodash/get"), 1);
-var import_has3 = __toESM(require("lodash/has"), 1);
-
-// src/schema/findSelectedOptionInXxxOf.ts
-var import_get6 = __toESM(require("lodash/get"), 1);
+// 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
-var import_get2 = __toESM(require("lodash/get"), 1);
-var import_isString = __toESM(require("lodash/isString"), 1);
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = (0, import_get2.default)(schema, DISCRIMINATOR_PATH);
-  if ((0, import_isString.default)(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`);
@@ -488,16 +586,6 @@ function getDiscriminatorFieldFromSchema(schema) {
   return discriminator;
 }
 
-// src/schema/retrieveSchema.ts
-var import_flattenDeep = __toESM(require("lodash/flattenDeep"), 1);
-var import_get5 = __toESM(require("lodash/get"), 1);
-var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
-var import_merge = __toESM(require("lodash/merge"), 1);
-var import_set = __toESM(require("lodash/set"), 1);
-var import_times = __toESM(require("lodash/times"), 1);
-var import_transform = __toESM(require("lodash/transform"), 1);
-var import_uniq = __toESM(require("lodash/uniq"), 1);
-
 // src/guessType.ts
 function guessType(value) {
   if (Array.isArray(value)) {
@@ -521,9 +609,6 @@ function guessType(value) {
   return "string";
 }
 
-// src/mergeSchemas.ts
-var import_union = __toESM(require("lodash/union"), 1);
-
 // src/getSchemaType.ts
 function getSchemaType(schema) {
   let { type } = schema;
@@ -554,7 +639,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] = (0, import_union.default)(left, right);
+      accumulator[key] = [.../* @__PURE__ */ new Set([...left, ...right])];
     } else {
       accumulator[key] = right;
     }
@@ -566,27 +651,27 @@ function mergeSchemas(obj1, obj2) {
   return result;
 }
 
-// src/schema/getFirstMatchingOption.ts
-var import_get4 = __toESM(require("lodash/get"), 1);
-var import_has = __toESM(require("lodash/has"), 1);
-var import_isNumber = __toESM(require("lodash/isNumber"), 1);
+// src/getPropertySchema.ts
+function getPropertySchema(schema, property) {
+  return schema?.[PROPERTIES_KEY]?.[property] ?? {};
+}
 
 // src/getOptionMatchingSimpleDiscriminator.ts
-var import_get3 = __toESM(require("lodash/get"), 1);
 function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
   if (formData && discriminatorField) {
-    const value = (0, import_get3.default)(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 = (0, import_get3.default)(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;
         }
       }
@@ -601,14 +686,14 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
     return 0;
   }
   const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-  if ((0, import_isNumber.default)(simpleDiscriminatorMatch)) {
+  if (typeof simpleDiscriminatorMatch === "number") {
     return simpleDiscriminatorMatch;
   }
   for (let i = 0; i < options.length; i += 1) {
     const option = options[i];
-    if (discriminatorField && (0, import_has.default)(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = (0, import_get4.default)(formData, discriminatorField);
-      const discriminator = (0, import_get4.default)(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;
       }
@@ -741,7 +826,7 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   const allPermutations = listOfLists.reduce(
     (permutations, list) => {
       if (list.length > 1) {
-        return list.flatMap((element) => (0, import_times.default)(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;
@@ -752,12 +837,9 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   return allPermutations;
 }
 function getMatchingPatternProperties(schema, key) {
-  return Object.keys(schema.patternProperties).filter((pattern) => RegExp(pattern).test(key)).reduce(
-    (obj, pattern) => {
-      (0, import_set.default)(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) {
@@ -852,23 +934,24 @@ function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveA
   }
   if (PROPERTIES_KEY in resolvedSchema) {
     const childrenLists = [];
-    const updatedProps = (0, import_transform.default)(
-      resolvedSchema[PROPERTIES_KEY],
-      (acc, value, key) => {
-        const childList = [...recurseList];
-        acc[key] = resolveAllReferences(
-          value,
-          rootSchema,
-          childList,
-          currentBaseURI,
-          resolveAnyOfOrOneOfRefs,
-          !resolveAnyOfOrOneOfRefs
-        );
-        childrenLists.push(childList);
-      },
-      {}
-    );
-    (0, import_merge.default)(recurseList, (0, import_uniq.default)((0, import_flattenDeep.default)(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") {
@@ -917,12 +1000,12 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
     }
     if (PATTERN_PROPERTIES_KEY in schema) {
       const matchingProperties = getMatchingPatternProperties(schema, key);
-      if (!(0, import_isEmpty2.default)(matchingProperties)) {
+      if (Object.keys(matchingProperties).length > 0) {
         schema.properties[key] = retrieveSchema(
           validator,
           { [ALL_OF_KEY]: Object.values(matchingProperties) },
           rootSchema,
-          (0, import_get5.default)(formData, [key]),
+          formData[key],
           experimental_customMergeAllOf
         );
         schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
@@ -935,9 +1018,9 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
         if (REF_KEY in schema.additionalProperties) {
           additionalProperties = retrieveSchema(
             validator,
-            { [REF_KEY]: (0, import_get5.default)(schema.additionalProperties, [REF_KEY]) },
+            { [REF_KEY]: schema.additionalProperties[REF_KEY] },
             rootSchema,
-            (0, import_get5.default)(formData, [key]),
+            formData[key],
             experimental_customMergeAllOf
           );
         } else if ("type" in schema.additionalProperties) {
@@ -948,10 +1031,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
             ...schema.additionalProperties
           };
         } else {
-          additionalProperties = { type: guessType((0, import_get5.default)(formData, [key])) };
+          additionalProperties = { type: guessType(formData[key]) };
         }
       } else {
-        additionalProperties = { type: guessType((0, import_get5.default)(formData, [key])) };
+        additionalProperties = { type: guessType(formData[key]) };
       }
       schema.properties[key] = additionalProperties;
       schema.properties[key][ADDITIONAL_PROPERTY_FLAG] = true;
@@ -1033,12 +1116,12 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
       resolvedSchema = Object.keys(resolvedSchema.properties).reduce(
         (acc, key) => {
           const matchingProperties = getMatchingPatternProperties(acc, key);
-          if (!(0, import_isEmpty2.default)(matchingProperties)) {
+          if (Object.keys(matchingProperties).length > 0) {
             acc.properties[key] = retrieveSchema(
               validator,
               { allOf: [acc.properties[key], ...Object.values(matchingProperties)] },
               rootSchema,
-              (0, import_get5.default)(rawFormData, [key]),
+              getByPath(rawFormData, key),
               experimental_customMergeAllOf
             );
           }
@@ -1119,7 +1202,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 || (0, import_get5.default)(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
@@ -1246,14 +1329,14 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
     const xxxOfs = schema[xxx].map(
       (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
     );
-    const data = (0, import_get6.default)(formData, selectorField);
+    const data = getByPath(formData, selectorField);
     if (data !== void 0) {
       return xxxOfs.find(
         (xxxOfOption) => deepEquals_default(
-          (0, import_get6.default)(
+          getByPath(
             xxxOfOption,
             [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
-            (0, import_get6.default)(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
+            getByPath(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY])
           ),
           data
         )
@@ -1264,21 +1347,18 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
 }
 
 // src/schema/getFromSchema.ts
-var import_get7 = __toESM(require("lodash/get"), 1);
-var import_has2 = __toESM(require("lodash/has"), 1);
-var import_isEmpty3 = __toESM(require("lodash/isEmpty"), 1);
 function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
   let fieldSchema = schema;
-  if ((0, import_has2.default)(schema, REF_KEY)) {
+  if (hasByPath(schema, REF_KEY)) {
     fieldSchema = retrieveSchema(validator, schema, rootSchema, void 0, experimental_customMergeAllOf);
   }
-  if ((0, import_isEmpty3.default)(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 !== "" && (0, import_has2.default)(fieldSchema, part)) {
-    fieldSchema = (0, import_get7.default)(fieldSchema, part);
+  if (part !== void 0 && part !== "" && hasByPath(fieldSchema, part)) {
+    fieldSchema = getByPath(fieldSchema, part);
     return getFromSchemaInternal(
       validator,
       rootSchema,
@@ -1314,30 +1394,30 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
         {},
         experimental_customMergeAllOf
       );
-      if ((0, import_has3.default)(parentField, ONE_OF_KEY)) {
+      if (hasByPath(parentField, ONE_OF_KEY)) {
         parentField = findSelectedOptionInXxxOf(
           validator,
           rootSchema,
           parentField,
           fieldNameKey,
           ONE_OF_KEY,
-          (0, import_get8.default)(formData, subPath),
+          getByPath(formData, subPath),
           experimental_customMergeAllOf
         );
-      } else if ((0, import_has3.default)(parentField, ANY_OF_KEY)) {
+      } else if (hasByPath(parentField, ANY_OF_KEY)) {
         parentField = findSelectedOptionInXxxOf(
           validator,
           rootSchema,
           parentField,
           fieldNameKey,
           ANY_OF_KEY,
-          (0, import_get8.default)(formData, subPath),
+          getByPath(formData, subPath),
           experimental_customMergeAllOf
         );
       }
     });
   }
-  if ((0, import_has3.default)(parentField, ONE_OF_KEY)) {
+  if (hasByPath(parentField, ONE_OF_KEY)) {
     parentField = findSelectedOptionInXxxOf(
       validator,
       rootSchema,
@@ -1347,7 +1427,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
       formData,
       experimental_customMergeAllOf
     );
-  } else if ((0, import_has3.default)(parentField, ANY_OF_KEY)) {
+  } else if (hasByPath(parentField, ANY_OF_KEY)) {
     parentField = findSelectedOptionInXxxOf(
       validator,
       rootSchema,
@@ -1385,13 +1465,6 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
 }
 
 // src/schema/getClosestMatchingOption.ts
-var import_get9 = __toESM(require("lodash/get"), 1);
-var import_has4 = __toESM(require("lodash/has"), 1);
-var import_isNumber2 = __toESM(require("lodash/isNumber"), 1);
-var import_isObject6 = __toESM(require("lodash/isObject"), 1);
-var import_isString2 = __toESM(require("lodash/isString"), 1);
-var import_reduce = __toESM(require("lodash/reduce"), 1);
-var import_times2 = __toESM(require("lodash/times"), 1);
 var JUNK_OPTION = {
   type: "object",
   $id: JUNK_OPTION_ID,
@@ -1404,61 +1477,57 @@ var JUNK_OPTION = {
 function calculateIndexScore(validator, rootSchema, schema, formData, experimental_customMergeAllOf) {
   let totalScore = 0;
   if (schema) {
-    if ((0, import_isObject6.default)(schema.properties)) {
-      totalScore += (0, import_reduce.default)(
-        schema.properties,
-        (score, value, key) => {
-          const formValue = (0, import_get9.default)(formData, key);
-          if (typeof value === "boolean") {
-            return score;
-          }
-          if ((0, import_has4.default)(value, REF_KEY)) {
-            const newSchema = retrieveSchema(
-              validator,
-              value,
-              rootSchema,
-              formValue,
-              experimental_customMergeAllOf
-            );
-            return score + calculateIndexScore(
-              validator,
-              rootSchema,
-              newSchema,
-              formValue || {},
-              experimental_customMergeAllOf
-            );
-          }
-          if (((0, import_has4.default)(value, ONE_OF_KEY) || (0, import_has4.default)(value, ANY_OF_KEY)) && formValue) {
-            const xxxOfKey = (0, import_has4.default)(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
-            const discriminator = getDiscriminatorFieldFromSchema(value);
-            return score + getClosestMatchingOption(
-              validator,
-              rootSchema,
-              formValue,
-              (0, import_get9.default)(value, xxxOfKey),
-              -1,
-              discriminator,
-              experimental_customMergeAllOf
-            );
-          }
-          if (value.type === "object") {
-            const structureBoost = (0, import_isObject6.default)(formValue) ? 1 : 0;
-            return score + structureBoost + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
-          }
-          if (value.type === guessType(formValue)) {
-            let newScore = score + 1;
-            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 ((0, import_isString2.default)(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;
     }
   }
@@ -1467,7 +1536,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 ((0, import_isNumber2.default)(simpleDiscriminatorMatch)) {
+  if (typeof simpleDiscriminatorMatch === "number") {
     return simpleDiscriminatorMatch;
   }
   const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
@@ -1482,7 +1551,7 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
     return allValidIndexes[0];
   }
   if (!allValidIndexes.length) {
-    (0, import_times2.default)(resolvedOptions.length, (i) => allValidIndexes.push(i));
+    allValidIndexes.push(...resolvedOptions.keys());
   }
   const scoreCount = /* @__PURE__ */ new Set();
   const { bestIndex } = allValidIndexes.reduce(
@@ -1504,16 +1573,11 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
   return bestIndex;
 }
 
-// src/schema/getDefaultFormState.ts
-var import_get12 = __toESM(require("lodash/get"), 1);
-var import_isEmpty4 = __toESM(require("lodash/isEmpty"), 1);
-
 // src/constIsAjvDataReference.ts
-var import_isString3 = __toESM(require("lodash/isString"), 1);
 function constIsAjvDataReference(schema) {
   const schemaConst = schema[CONST_KEY];
   const schemaType = getSchemaType(schema);
-  return isObject(schemaConst) && (0, import_isString3.default)(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+  return isObject(schemaConst) && typeof schemaConst?.$data === "string" && schemaType !== "object" && schemaType !== "array";
 }
 
 // src/isConstant.ts
@@ -1527,8 +1591,6 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-var import_get10 = __toESM(require("lodash/get"), 1);
-var import_isNil = __toESM(require("lodash/isNil"), 1);
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -1553,23 +1615,25 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
   }
   if (isObject(formData)) {
     const acc = Object.assign({}, defaults);
-    return Object.keys(formData).reduce((accumulator, key) => {
-      const keyValue = (0, import_get10.default)(formData, key);
-      const keyExistsInDefaults = isObject(defaults) && key in defaults;
-      const keyExistsInFormData = key in formData;
-      const keyDefault = (0, import_get10.default)(defaults, key) ?? {};
-      const defaultValueIsNestedObject = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
-      const keyDefaultIsObject = keyExistsInDefaults && isObject((0, import_get10.default)(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] = {
-          ...(0, import_get10.default)(defaults, key),
+          ...defaultsObj?.[key],
           ...keyValue
         };
         return accumulator;
       }
       accumulator[key] = mergeDefaultsWithFormData(
-        (0, import_get10.default)(defaults, key),
+        defaultsObj?.[key],
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -1580,7 +1644,7 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       return acc;
     }, acc);
   }
-  if (defaultSupercedesUndefined && (!(defaults === void 0) && (0, import_isNil.default)(formData) || typeof formData === "number" && Number.isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(formData)) {
+  if (defaultSupercedesUndefined && (!(defaults === void 0) && formData == null || typeof formData === "number" && Number.isNaN(formData)) || overrideFormDataWithDefaults && formData != null) {
     return defaults;
   }
   return formData;
@@ -1613,9 +1677,6 @@ function mergeObjects(obj1, obj2, concatArrays = false) {
   );
 }
 
-// src/optionsList.ts
-var import_get11 = __toESM(require("lodash/get"), 1);
-
 // src/toConstant.ts
 function toConstant(schema) {
   if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
@@ -1678,8 +1739,8 @@ function optionsList(schema, uiSchema) {
     let value;
     let label = title;
     if (selectorField) {
-      const innerSchema = (0, import_get11.default)(aSchema, [PROPERTIES_KEY, selectorField], {});
-      value = (0, import_get11.default)(innerSchema, DEFAULT_KEY, (0, import_get11.default)(innerSchema, CONST_KEY));
+      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);
@@ -1732,9 +1793,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") && (0, import_isEmpty4.default)(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) {
@@ -1742,17 +1812,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) || !(0, import_isEmpty4.default)(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 (!(0, import_isEmpty4.default)(computedDefault)) {
+        if (Object.keys(computedDefault).length > 0) {
           acc[key] = computedDefault;
         }
-      } else if ((!(0, import_isEmpty4.default)(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 (
@@ -1802,7 +1872,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       updatedRecurseList = _recurseList.concat(refName);
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
-    const hasNoExistingData = rawFormData === void 0 || isObject(rawFormData) && (0, import_isEmpty4.default)(rawFormData);
+    const hasNoExistingData = rawFormData === void 0 || isObject(rawFormData) && Object.keys(rawFormData).length === 0;
     if (schemaToCompute && !defaults && hasNoExistingData) {
       defaults = schema.default;
     }
@@ -1935,13 +2005,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 = (0, import_get12.default)(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,
-            (0, import_get12.default)(acc, key),
+            acc[key],
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf
           );
@@ -1972,7 +2042,7 @@ function getObjectDefaults(validator, rawSchema, {
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc, key) => {
-        const propertySchema = (0, import_get12.default)(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, {
@@ -1981,8 +2051,8 @@ function getObjectDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: (0, import_get12.default)(defaults, [key]),
-          rawFormData: (0, import_get12.default)(formData, [key]),
+          parentDefaults: getByPath(defaults, key),
+          rawFormData: getByPath(formData, key),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated
@@ -2004,24 +2074,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: (0, import_get12.default)(defaults, [key]),
-          rawFormData: (0, import_get12.default)(formData, [key]),
+          parentDefaults: getByPath(defaults, key),
+          rawFormData: getByPath(formData, key),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated
@@ -2089,7 +2159,7 @@ function getArrayDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           rawFormData: item,
-          parentDefaults: (0, import_get12.default)(defaults, [idx]),
+          parentDefaults: getByPath(defaults, idx),
           required,
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated
@@ -2141,6 +2211,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;
   }
@@ -2243,22 +2319,30 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
 }
 
 // src/schema/omitExtraData.ts
-var import_get13 = __toESM(require("lodash/get"), 1);
-var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
-var import_isNil2 = __toESM(require("lodash/isNil"), 1);
-var import_pick = __toESM(require("lodash/pick"), 1);
 function getUsedFormData(formData, fields) {
   if (fields.length === 0 && typeof formData !== "object") {
     return formData;
   }
-  const data = (0, import_pick.default)(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" || (0, import_isEmpty5.default)(value) || isLeaf && !(0, import_isEmpty5.default)(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) => {
@@ -2272,7 +2356,7 @@ function getFieldNames(pathSchema, formData) {
         }
       } else if (key === NAME_KEY && data !== "") {
         paths.forEach((path) => {
-          const formValue = (0, import_get13.default)(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);
@@ -2285,7 +2369,7 @@ function getFieldNames(pathSchema, formData) {
   return getAllPaths(pathSchema);
 }
 function isValueEmpty(value) {
-  if ((0, import_isNil2.default)(value) || value === "") {
+  if (value == null || value === "") {
     return true;
   }
   if (Array.isArray(value)) {
@@ -2307,19 +2391,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;
         }
@@ -2367,31 +2449,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) {
@@ -2401,7 +2481,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)) {
@@ -2419,7 +2499,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;
@@ -2429,7 +2509,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;
     }
@@ -2443,29 +2523,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 || (0, import_isEmpty5.default)(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);
         }
       }
     }
@@ -2480,18 +2560,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 : []);
+      }
+    }
+    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 import_get14 = __toESM(require("lodash/get"), 1);
-var import_has5 = __toESM(require("lodash/has"), 1);
 var NO_VALUE = /* @__PURE__ */ Symbol("no Value");
 function enumValuesForSchema(schema) {
   if (Array.isArray(schema.enum)) {
@@ -2514,7 +2603,7 @@ function replacementForInvalidEnumValue(schema, formValue) {
   if (!enumValues || enumValues.some((value) => deepEquals_default(value, formValue))) {
     return NO_VALUE;
   }
-  const defaultValue = (0, import_get14.default)(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;
   }
@@ -2522,23 +2611,25 @@ function replacementForInvalidEnumValue(schema, formValue) {
 }
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
   let newFormData;
-  if ((0, import_has5.default)(newSchema, PROPERTIES_KEY)) {
+  const newProperties = newSchema?.[PROPERTIES_KEY];
+  if (newProperties) {
     const removeOldSchemaData = {};
-    if ((0, import_has5.default)(oldSchema, PROPERTIES_KEY)) {
-      const properties = (0, import_get14.default)(oldSchema, PROPERTIES_KEY, {});
-      Object.keys(properties).forEach((key) => {
-        if ((0, import_has5.default)(data, key)) {
+    const oldProperties = oldSchema?.[PROPERTIES_KEY];
+    if (oldProperties) {
+      Object.keys(oldProperties).forEach((key) => {
+        if (hasByPath(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys((0, import_get14.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys = Object.keys(newProperties);
     const nestedData = {};
-    keys2.forEach((key) => {
-      const formValue = (0, import_get14.default)(data, key);
-      let oldKeyedSchema = (0, import_get14.default)(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = (0, import_get14.default)(newSchema, [PROPERTIES_KEY, key], {});
-      if ((0, import_has5.default)(oldKeyedSchema, REF_KEY)) {
+    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,
@@ -2547,7 +2638,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      if ((0, import_has5.default)(newKeyedSchema, REF_KEY)) {
+      if (hasByPath(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema(
           validator,
           newKeyedSchema,
@@ -2556,10 +2647,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = (0, import_get14.default)(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = (0, import_get14.default)(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = oldKeyedSchema.type;
+      const newSchemaTypeForKey = newKeyedSchema.type;
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-        if ((0, import_has5.default)(removeOldSchemaData, key)) {
+        if (key in removeOldSchemaData) {
           delete removeOldSchemaData[key];
         }
         if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
@@ -2567,7 +2658,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             validator,
             rootSchema,
             newKeyedSchema,
-            oldKeyedSchema,
+            isNewProperty && newSchemaTypeForKey === "array" ? newKeyedSchema : oldKeyedSchema,
             formValue,
             experimental_customMergeAllOf
           );
@@ -2575,21 +2666,21 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = (0, import_get14.default)(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
-          const oldOptionDefault = (0, import_get14.default)(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 ((0, import_get14.default)(newKeyedSchema, "readOnly") === true) {
+            } else if (newKeyedSchema.readOnly === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = (0, import_get14.default)(newKeyedSchema, CONST_KEY, NO_VALUE);
-          const oldOptionConst = (0, import_get14.default)(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 ((0, import_has5.default)(data, key)) {
+          if (hasByPath(data, key)) {
             const enumReplacement = replacementForInvalidEnumValue(newKeyedSchema, formValue);
             if (enumReplacement !== NO_VALUE) {
               removeOldSchemaData[key] = enumReplacement;
@@ -2603,11 +2694,11 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if ((0, import_get14.default)(oldSchema, "type") === "array" && (0, import_get14.default)(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = (0, import_get14.default)(oldSchema, "items");
-    let newSchemaItems = (0, import_get14.default)(newSchema, "items");
+  } 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 ((0, import_has5.default)(oldSchemaItems, REF_KEY)) {
+      if (hasByPath(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
           validator,
           oldSchemaItems,
@@ -2616,7 +2707,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      if ((0, import_has5.default)(newSchemaItems, REF_KEY)) {
+      if (hasByPath(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema(
           validator,
           newSchemaItems,
@@ -2625,10 +2716,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = (0, import_get14.default)(oldSchemaItems, "type");
-      const newSchemaType = (0, import_get14.default)(newSchemaItems, "type");
+      const oldSchemaType = getByPath(oldSchemaItems, "type");
+      const newSchemaType = getByPath(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = (0, import_get14.default)(newSchema, "maxItems", -1);
+        const maxItems = newSchema.maxItems ?? -1;
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -2658,9 +2749,6 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toPathSchema.ts
-var import_get15 = __toESM(require("lodash/get"), 1);
-var import_isObject12 = __toESM(require("lodash/isObject"), 1);
-var import_set2 = __toESM(require("lodash/set"), 1);
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
     const innerSchema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
@@ -2707,9 +2795,9 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     };
   }
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-    (0, import_set2.default)(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-    const additionalSchema = (0, import_isObject12.default)(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-    const definedProperties = (0, import_get15.default)(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(
@@ -2717,7 +2805,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
           additionalSchema,
           `${name}.${key}`,
           rootSchema,
-          (0, import_get15.default)(formData, [key]),
+          getByPath(formData, key),
           _recurseList,
           experimental_customMergeAllOf
         );
@@ -2767,7 +2855,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = (0, import_get15.default)(schema, [PROPERTIES_KEY, property], {});
+      const field = getPropertySchema(schema, property);
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -2775,7 +2863,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        (0, import_get15.default)(formData, [property]),
+        getByPath(formData, property),
         _recurseList,
         experimental_customMergeAllOf
       );
@@ -2789,6 +2877,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
@@ -2798,7 +2890,7 @@ var SchemaUtils = class {
    */
   constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
     if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-      this.rootSchema = makeAllReferencesAbsolute(rootSchema, (0, import_get16.default)(rootSchema, ID_KEY, "#"));
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, rootSchema[ID_KEY] ?? "#");
     } else {
       this.rootSchema = rootSchema;
     }
@@ -3189,8 +3281,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") {
@@ -3201,10 +3293,9 @@ function enumOptionSelectedValue(value, enumOptions, multiple, format = "indexed
 }
 
 // src/enumOptionsSelectValue.ts
-var import_isNil3 = __toESM(require("lodash/isNil"), 1);
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!(0, import_isNil3.default)(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));
@@ -3239,12 +3330,11 @@ function enumOptionValueDecoder(value, enumOptions, format = "indexed", emptyVal
 }
 
 // src/enumOptionValueEncoder.ts
-var import_isNil4 = __toESM(require("lodash/isNil"), 1);
 function enumOptionValueEncoder(value, index, format = "indexed") {
   if (format !== "realValue") {
     return String(index);
   }
-  if ((0, import_isNil4.default)(value)) {
+  if (value == null) {
     return "";
   }
   if (typeof value === "object") {
@@ -3254,21 +3344,17 @@ function enumOptionValueEncoder(value, index, format = "indexed") {
 }
 
 // src/ErrorSchemaBuilder.ts
-var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
-var import_get17 = __toESM(require("lodash/get"), 1);
-var import_set3 = __toESM(require("lodash/set"), 1);
-var import_setWith = __toESM(require("lodash/setWith"), 1);
 var ErrorSchemaBuilder = class {
+  /** 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`
@@ -3283,11 +3369,14 @@ var ErrorSchemaBuilder = class {
    * @private
    */
   getOrCreateErrorBlock(pathOfError) {
-    const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? (0, import_get17.default)(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 = {};
-      (0, import_setWith.default)(this.errorSchema, pathOfError, errorBlock, Object);
+      setByPath(this.errorSchema, path, errorBlock, true);
     }
     return errorBlock;
   }
@@ -3297,12 +3386,12 @@ var ErrorSchemaBuilder = class {
    * @returns - The `ErrorSchemaBuilder` object for chaining purposes
    */
   resetAllErrors(initialSchema) {
-    this.errorSchema = initialSchema ? (0, import_cloneDeep.default)(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)
@@ -3310,21 +3399,21 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = (0, import_get17.default)(errorBlock, ERRORS_KEY);
+    let errorsList = errorBlock[ERRORS_KEY];
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
     }
     if (Array.isArray(errorOrList)) {
-      (0, import_set3.default)(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
+      errorBlock[ERRORS_KEY] = [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])];
     } else {
-      (0, import_set3.default)(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)
@@ -3333,43 +3422,59 @@ var ErrorSchemaBuilder = class {
   setErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
     const listToAdd = Array.isArray(errorOrList) ? [.../* @__PURE__ */ new Set([...errorOrList])] : [errorOrList];
-    (0, import_set3.default)(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);
-    (0, import_set3.default)(errorBlock, ERRORS_KEY, []);
+    errorBlock[ERRORS_KEY] = [];
     return this;
   }
 };
 
 // src/getChangedFields.ts
-var import_difference = __toESM(require("lodash/difference"), 1);
-var import_get18 = __toESM(require("lodash/get"), 1);
-var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
-var import_keys = __toESM(require("lodash/keys"), 1);
-var import_pickBy = __toESM(require("lodash/pickBy"), 1);
-function getChangedFields(a, b) {
-  const aIsPlainObject = (0, import_isPlainObject2.default)(a);
-  const bIsPlainObject = (0, import_isPlainObject2.default)(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 (0, import_keys.default)(a);
+  if (!isPlainObject(a)) {
+    return isPlainObject(b) ? Object.keys(b) : [];
   }
-  if (!aIsPlainObject && bIsPlainObject) {
-    return (0, import_keys.default)(b);
+  if (!isPlainObject(b)) {
+    return Object.keys(a);
   }
-  const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals_default(value, (0, import_get18.default)(b, key))));
-  const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
+  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];
 }
 
@@ -3448,6 +3553,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;
   }
@@ -3494,10 +3602,9 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-var import_get19 = __toESM(require("lodash/get"), 1);
-var import_uniqueId = __toESM(require("lodash/uniqueId"), 1);
+var testIdCounter = 0;
 function getTestIds() {
-  if ((0, import_get19.default)(globalThis, "process.env.NODE_ENV") !== "test") {
+  if (getByPath(globalThis, ["process", "env", "NODE_ENV"]) !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3506,7 +3613,8 @@ function getTestIds() {
     {
       get(_obj, prop) {
         if (!ids.has(prop)) {
-          ids.set(prop, (0, import_uniqueId.default)("test-id-"));
+          testIdCounter += 1;
+          ids.set(prop, `test-id-${testIdCounter}`);
         }
         return ids.get(prop);
       }
@@ -3516,8 +3624,6 @@ function getTestIds() {
 
 // src/getWidget.tsx
 var import_react = require("react");
-var import_get20 = __toESM(require("lodash/get"), 1);
-var import_set4 = __toESM(require("lodash/set"), 1);
 var import_react_is = __toESM(require("react-is"), 1);
 var import_jsx_runtime = require("react/jsx-runtime");
 var widgetMap = {
@@ -3573,11 +3679,11 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = (0, import_get20.default)(AWidget, "MergedWidget");
+  let { MergedWidget } = AWidget;
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps?.options || {};
     MergedWidget = ({ options, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AWidget, { options: { ...defaultOptions, ...options }, ...props });
-    (0, import_set4.default)(AWidget, "MergedWidget", MergedWidget);
+    AWidget.MergedWidget = MergedWidget;
   }
   return MergedWidget;
 }
@@ -3616,12 +3722,18 @@ function hashString(string) {
   return hash.toString(16);
 }
 function sortedJSONStringify(object) {
-  const allKeys = /* @__PURE__ */ new Set();
-  JSON.stringify(object, (key, value) => {
-    allKeys.add(key);
-    return value;
-  });
-  return JSON.stringify(object, Array.from(allKeys).sort());
+  function shouldIncludeValue(value) {
+    return value !== void 0 && typeof value !== "function" && typeof value !== "symbol";
+  }
+  if (Array.isArray(object)) {
+    return `[${object.map((x) => x === void 0 ? "undefined" : sortedJSONStringify(x)).join(",")}]`;
+  }
+  if (object === null || typeof object !== "object") {
+    return JSON.stringify(typeof object === "function" ? null : object);
+  }
+  const record = object;
+  const sortedValues = Object.keys(record).sort().filter((key) => shouldIncludeValue(record[key])).map((key) => `${JSON.stringify(key)}:${sortedJSONStringify(record[key])}`);
+  return `{${sortedValues.join(",")}}`;
 }
 function hashObject(object) {
   return hashString(sortedJSONStringify(object));
@@ -3645,9 +3757,8 @@ function hasWidget(schema, widget, registeredWidgets = {}) {
 }
 
 // src/idGenerators.ts
-var import_isString4 = __toESM(require("lodash/isString"), 1);
 function idGenerator(id, suffix) {
-  const theId = (0, import_isString4.default)(id) ? id : id[ID_KEY];
+  const theId = typeof id === "string" ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
 function descriptionId(id) {
@@ -3680,11 +3791,14 @@ function optionalControlsId(id, element) {
 }
 
 // src/isFormDataAvailable.ts
-var import_isEmpty6 = __toESM(require("lodash/isEmpty"), 1);
-var import_isNil5 = __toESM(require("lodash/isNil"), 1);
-var import_isObject13 = __toESM(require("lodash/isObject"), 1);
 function isFormDataAvailable(formData) {
-  return !(0, import_isNil5.default)(formData) && (!(0, import_isObject13.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty6.default)(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
@@ -3720,14 +3834,12 @@ function logUnsupportedDefaultForEnum(id, schema, enumOptions, multiple = false)
 }
 
 // src/lookupFromFormContext.ts
-var import_get21 = __toESM(require("lodash/get"), 1);
-var import_has6 = __toESM(require("lodash/has"), 1);
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
-  if ((0, import_has6.default)(regOrFc, FORM_CONTEXT_NAME)) {
+  if (hasByPath(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return (0, import_get21.default)(regOrFc, [...lookupPath, toLookup], fallback);
+  return getByPath(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/nameGenerators.ts
@@ -3750,6 +3862,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)) {
@@ -3864,7 +3980,6 @@ function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
 }
 
 // src/resolveUiSchema.ts
-var import_isEmpty7 = __toESM(require("lodash/isEmpty"), 1);
 function resolveUiSchema(schema, localUiSchema, registry) {
   const ref = schema[RJSF_REF_KEY] ?? schema[REF_KEY];
   const definitions = registry.uiSchemaDefinitions;
@@ -3872,7 +3987,7 @@ function resolveUiSchema(schema, localUiSchema, registry) {
   let result;
   if (!definitionUiSchema) {
     result = localUiSchema || {};
-  } else if (!localUiSchema || (0, import_isEmpty7.default)(localUiSchema)) {
+  } else if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
     result = { ...definitionUiSchema };
   } else {
     result = mergeObjects(definitionUiSchema, localUiSchema);
@@ -4003,12 +4118,12 @@ function shouldRender(component, nextProps, nextState, updateStrategy = "customD
 }
 
 // src/shouldRenderOptionalField.ts
-var import_isObject15 = __toESM(require("lodash/isObject"), 1);
-var import_uniq2 = __toESM(require("lodash/uniq"), 1);
 function getSchemaTypesForXxxOf(schemas) {
-  const allTypes = (0, import_uniq2.default)(
-    schemas.map((s) => (0, import_isObject15.default)(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) {
@@ -4033,46 +4148,29 @@ function toDateString(dateObject, time = true) {
 }
 
 // src/toErrorList.ts
-var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"), 1);
 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 ((0, import_isPlainObject3.default)(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
-var import_toPath = __toESM(require("lodash/toPath"), 1);
 function toErrorSchema(errors) {
   const builder = new ErrorSchemaBuilder();
   if (errors.length) {
     errors.forEach((error) => {
       const { property, message } = error;
-      const path = property === "." ? [] : (0, import_toPath.default)(property);
-      if (path.length > 0 && path[0] === "") {
-        path.splice(0, 1);
-      }
+      const path = property ? toPath(property) : [];
       if (message) {
         builder.addErrors(message, path);
       }
@@ -4095,17 +4193,19 @@ function toFieldPathId(fieldPath, globalFormOptions, parentPath, isMultiValue) {
 }
 
 // src/unwrapErrorHandler.ts
-var import_isPlainObject4 = __toESM(require("lodash/isPlainObject"), 1);
 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 ((0, import_isPlainObject4.default)(childSchema)) {
+    const childSchema = errors[key];
+    if (isPlainObject(childSchema)) {
       return {
         ...acc,
-        [key]: unwrapErrorHandler(childSchema)
+        [key]: unwrapErrors(childSchema)
       };
     }
     return { ...acc, [key]: childSchema };
@@ -4330,7 +4430,6 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-var import_isEmpty8 = __toESM(require("lodash/isEmpty"), 1);
 function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -4338,7 +4437,7 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!(0, import_isEmpty8.default)(oldErrorSchema)) {
+  if (oldErrorSchema && Object.keys(oldErrorSchema).length > 0) {
     errorSchema = mergeObjects(
       oldErrorSchema,
       additionalErrorSchema,
@@ -4350,7 +4449,6 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
 }
 
 // src/withIdRefPrefix.ts
-var import_isObject16 = __toESM(require("lodash/isObject"), 1);
 function withIdRefPrefixObject(node) {
   const realObj = node;
   for (const key in realObj) {
@@ -4372,7 +4470,7 @@ function withIdRefPrefix(schemaNode) {
   if (Array.isArray(schemaNode)) {
     return withIdRefPrefixArray([...schemaNode]);
   }
-  if ((0, import_isObject16.default)(schemaNode)) {
+  if (isObject(schemaNode)) {
     return withIdRefPrefixObject({ ...schemaNode });
   }
   return schemaNode;
@@ -4422,20 +4520,18 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   return TranslatableString2;
 })(TranslatableString || {});
 
-// src/parser/schemaParser.ts
-var import_forEach = __toESM(require("lodash/forEach"), 1);
-
 // src/parser/ParserValidator.ts
-var import_get22 = __toESM(require("lodash/get"), 1);
 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));
   }
@@ -4452,7 +4548,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = (0, import_get22.default)(schema, ID_KEY, hash);
+    const key = schema[ID_KEY] ?? hash;
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -4525,9 +4621,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]) {
-          (0, import_forEach.default)(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") {