@limetech/lime-elements 39.20.0 → 39.22.0

package/dist/cjs/limel-form.cjs.entry.js

@@ -2,10 +2,9 @@
 
 var index$1 = require('./index-BjHIBY-I.js');
 var _commonjsHelpers = require('./_commonjsHelpers-CFO10eej.js');
-var _baseIsEqual = require('./_baseIsEqual-aOPReRWl.js');
 var _baseIteratee = require('./_baseIteratee-DggA4e7a.js');
 var pickBy = require('./pickBy-kLjYLoam.js');
-var isEqual = require('./isEqual-bXyw7kXo.js');
+var _baseIsEqual = require('./_baseIsEqual-aOPReRWl.js');
 var identity$1 = require('./identity-Dz5mxHaJ.js');
 var _isIterateeCall = require('./_isIterateeCall-CPWXFS_s.js');
 var cloneDeep = require('./cloneDeep-CxFNKF1Y.js');
@@ -20,6 +19,7 @@ var isObjectLike = require('./isObjectLike-Dlpn-j-1.js');
 var isEmpty = require('./isEmpty-EBCFxX1S.js');
 var isSymbol = require('./isSymbol-DxAVNJfH.js');
 var isArrayLike = require('./isArrayLike-_dR1U5-Y.js');
+var isEqual = require('./isEqual-bXyw7kXo.js');
 var moment = require('./moment-CqRdiK10.js');
 var multiple = require('./multiple-DYfiga7l.js');
 require('./_getNative-B4n5HX2B.js');
@@ -149,7 +149,7 @@ var funcProto = Function.prototype,
 var funcToString = funcProto.toString;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+var hasOwnProperty$2 = objectProto$1.hasOwnProperty;
 
 /** Used to infer the `Object` constructor. */
 var objectCtorString = funcToString.call(Object);
@@ -190,7 +190,7 @@ function isPlainObject(value) {
   if (proto === null) {
     return true;
   }
-  var Ctor = hasOwnProperty$1.call(proto, 'constructor') && proto.constructor;
+  var Ctor = hasOwnProperty$2.call(proto, 'constructor') && proto.constructor;
   return typeof Ctor == 'function' && Ctor instanceof Ctor &&
     funcToString.call(Ctor) == objectCtorString;
 }
@@ -906,44 +906,6 @@ function parent(object, path) {
   return path.length < 2 ? object : _baseIteratee.baseGet(object, baseSlice(path, 0, -1));
 }
 
-/**
- * This method is like `_.isEqual` except that it accepts `customizer` which
- * is invoked to compare values. If `customizer` returns `undefined`, comparisons
- * are handled by the method instead. The `customizer` is invoked with up to
- * six arguments: (objValue, othValue [, index|key, object, other, stack]).
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to compare.
- * @param {*} other The other value to compare.
- * @param {Function} [customizer] The function to customize comparisons.
- * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
- * @example
- *
- * function isGreeting(value) {
- *   return /^h(?:i|ello)$/.test(value);
- * }
- *
- * function customizer(objValue, othValue) {
- *   if (isGreeting(objValue) && isGreeting(othValue)) {
- *     return true;
- *   }
- * }
- *
- * var array = ['hello', 'goodbye'];
- * var other = ['hi', 'goodbye'];
- *
- * _.isEqualWith(array, other, customizer);
- * // => true
- */
-function isEqualWith(value, other, customizer) {
-  customizer = typeof customizer == 'function' ? customizer : undefined;
-  var result = customizer ? customizer(value, other) : undefined;
-  return result === undefined ? _baseIsEqual.baseIsEqual(value, other, undefined, customizer) : !!result;
-}
-
 /** `Object#toString` result references. */
 var numberTag = '[object Number]';
 
@@ -1100,7 +1062,7 @@ var merge = createAssigner(function(object, source, srcIndex) {
 var objectProto = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+var hasOwnProperty$1 = objectProto.hasOwnProperty;
 
 /**
  * The base implementation of `_.unset`.
@@ -1127,7 +1089,7 @@ function baseUnset(object, path) {
     var key = _baseIteratee.toKey(path[index]);
 
     // Always block "__proto__" anywhere in the path if it's not expected
-    if (key === '__proto__' && !hasOwnProperty.call(object, '__proto__')) {
+    if (key === '__proto__' && !hasOwnProperty$1.call(object, '__proto__')) {
       return false;
     }
 
@@ -18535,24 +18497,634 @@ function createErrorHandler(formData) {
     return handler;
 }
 
-/** Implements a deep equals using the `lodash.isEqualWith` function, that provides a customized comparator that
- * assumes all functions are equivalent.
+const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { hasOwnProperty } = Object.prototype;
+/**
+ * Combine two comparators into a single comparators.
+ */
+function combineComparators(comparatorA, comparatorB) {
+    return function isEqual(a, b, state) {
+        return comparatorA(a, b, state) && comparatorB(a, b, state);
+    };
+}
+/**
+ * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
+ * for circular references to be safely included in the comparison without creating
+ * stack overflows.
+ */
+function createIsCircular(areItemsEqual) {
+    return function isCircular(a, b, state) {
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
+            return areItemsEqual(a, b, state);
+        }
+        const { cache } = state;
+        const cachedA = cache.get(a);
+        const cachedB = cache.get(b);
+        if (cachedA && cachedB) {
+            return cachedA === b && cachedB === a;
+        }
+        cache.set(a, b);
+        cache.set(b, a);
+        const result = areItemsEqual(a, b, state);
+        cache.delete(a);
+        cache.delete(b);
+        return result;
+    };
+}
+/**
+ * Get the properties to strictly examine, which include both own properties that are
+ * not enumerable and symbol properties.
+ */
+function getStrictProperties(object) {
+    return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+/**
+ * Whether the object contains the property passed as an own property.
+ */
+const hasOwn = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
+
+const PREACT_VNODE = '__v';
+const PREACT_OWNER = '__o';
+const REACT_OWNER = '_owner';
+const { getOwnPropertyDescriptor, keys } = Object;
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+ *
+ * @note
+ * When available in the environment, this is just a re-export of the global
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+ */
+const sameValueEqual = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+Object.is
+    || function sameValueEqual(a, b) {
+        return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;
+    };
+/**
+ * Whether the values passed are equal based on a
+ * [Strict Equality Comparison](https://262.ecma-international.org/7.0/#sec-strict-equality-comparison) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`).
  *
- * @param a - The first element to compare
- * @param b - The second element to compare
- * @returns - True if the `a` and `b` are deeply equal, false otherwise
+ * @note
+ * This is mainly available as a convenience function, such as being a default when a function to determine equality between
+ * two objects is used.
  */
-function deepEquals(a, b) {
-    return isEqualWith(a, b, (obj, other) => {
-        if (typeof obj === 'function' && typeof other === 'function') {
-            // Assume all functions are equivalent
-            // see https://github.com/rjsf-team/react-jsonschema-form/issues/255
+function strictEqual(a, b) {
+    return a === b;
+}
+/**
+ * Whether the array buffers are equal in value.
+ */
+function areArrayBuffersEqual(a, b) {
+    return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
+}
+/**
+ * Whether the arrays are equal in value.
+ */
+function areArraysEqual(a, b, state) {
+    let index = a.length;
+    if (b.length !== index) {
+        return false;
+    }
+    while (index-- > 0) {
+        if (!state.equals(a[index], b[index], index, index, a, b, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the dataviews are equal in value.
+ */
+function areDataViewsEqual(a, b) {
+    return (a.byteLength === b.byteLength
+        && areTypedArraysEqual(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)));
+}
+/**
+ * Whether the dates passed are equal in value.
+ */
+function areDatesEqual(a, b) {
+    return sameValueEqual(a.getTime(), b.getTime());
+}
+/**
+ * Whether the errors passed are equal in value.
+ */
+function areErrorsEqual(a, b) {
+    return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
+}
+/**
+ * Whether the `Map`s are equal in value.
+ */
+function areMapsEqual(a, b, state) {
+    const size = a.size;
+    if (size !== b.size) {
+        return false;
+    }
+    if (!size) {
+        return true;
+    }
+    const matchedIndices = new Array(size);
+    const aIterable = a.entries();
+    let aResult;
+    let bResult;
+    let index = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while ((aResult = aIterable.next())) {
+        if (aResult.done) {
+            break;
+        }
+        const bIterable = b.entries();
+        let hasMatch = false;
+        let matchIndex = 0;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        while ((bResult = bIterable.next())) {
+            if (bResult.done) {
+                break;
+            }
+            if (matchedIndices[matchIndex]) {
+                matchIndex++;
+                continue;
+            }
+            const aEntry = aResult.value;
+            const bEntry = bResult.value;
+            if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state)
+                && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+                hasMatch = matchedIndices[matchIndex] = true;
+                break;
+            }
+            matchIndex++;
+        }
+        if (!hasMatch) {
+            return false;
+        }
+        index++;
+    }
+    return true;
+}
+/**
+ * Whether the objects are equal in value.
+ */
+function areObjectsEqual(a, b, state) {
+    const properties = keys(a);
+    let index = properties.length;
+    if (keys(b).length !== index) {
+        return false;
+    }
+    // Decrementing `while` showed faster results than either incrementing or
+    // decrementing `for` loop and than an incrementing `while` loop. Declarative
+    // methods like `some` / `every` were not used to avoid incurring the garbage
+    // cost of anonymous callbacks.
+    while (index-- > 0) {
+        if (!isPropertyEqual(a, b, state, properties[index])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the objects are equal in value with strict property checking.
+ */
+function areObjectsEqualStrict(a, b, state) {
+    const properties = getStrictProperties(a);
+    let index = properties.length;
+    if (getStrictProperties(b).length !== index) {
+        return false;
+    }
+    let property;
+    let descriptorA;
+    let descriptorB;
+    // Decrementing `while` showed faster results than either incrementing or
+    // decrementing `for` loop and than an incrementing `while` loop. Declarative
+    // methods like `some` / `every` were not used to avoid incurring the garbage
+    // cost of anonymous callbacks.
+    while (index-- > 0) {
+        property = properties[index];
+        if (!isPropertyEqual(a, b, state, property)) {
+            return false;
+        }
+        descriptorA = getOwnPropertyDescriptor(a, property);
+        descriptorB = getOwnPropertyDescriptor(b, property);
+        if ((descriptorA || descriptorB)
+            && (!descriptorA
+                || !descriptorB
+                || descriptorA.configurable !== descriptorB.configurable
+                || descriptorA.enumerable !== descriptorB.enumerable
+                || descriptorA.writable !== descriptorB.writable)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the primitive wrappers passed are equal in value.
+ */
+function arePrimitiveWrappersEqual(a, b) {
+    return sameValueEqual(a.valueOf(), b.valueOf());
+}
+/**
+ * Whether the regexps passed are equal in value.
+ */
+function areRegExpsEqual(a, b) {
+    return a.source === b.source && a.flags === b.flags;
+}
+/**
+ * Whether the `Set`s are equal in value.
+ */
+function areSetsEqual(a, b, state) {
+    const size = a.size;
+    if (size !== b.size) {
+        return false;
+    }
+    if (!size) {
+        return true;
+    }
+    const matchedIndices = new Array(size);
+    const aIterable = a.values();
+    let aResult;
+    let bResult;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while ((aResult = aIterable.next())) {
+        if (aResult.done) {
+            break;
+        }
+        const bIterable = b.values();
+        let hasMatch = false;
+        let matchIndex = 0;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        while ((bResult = bIterable.next())) {
+            if (bResult.done) {
+                break;
+            }
+            if (!matchedIndices[matchIndex]
+                && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+                hasMatch = matchedIndices[matchIndex] = true;
+                break;
+            }
+            matchIndex++;
+        }
+        if (!hasMatch) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the TypedArray instances are equal in value.
+ */
+function areTypedArraysEqual(a, b) {
+    let index = a.byteLength;
+    if (b.byteLength !== index || a.byteOffset !== b.byteOffset) {
+        return false;
+    }
+    while (index-- > 0) {
+        if (a[index] !== b[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the URL instances are equal in value.
+ */
+function areUrlsEqual(a, b) {
+    return (a.hostname === b.hostname
+        && a.pathname === b.pathname
+        && a.protocol === b.protocol
+        && a.port === b.port
+        && a.hash === b.hash
+        && a.username === b.username
+        && a.password === b.password);
+}
+function isPropertyEqual(a, b, state, property) {
+    if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE)
+        && (a.$$typeof || b.$$typeof)) {
+        return true;
+    }
+    return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
+}
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const toString = Object.prototype.toString;
+/**
+ * Create a comparator method based on the type-specific equality comparators passed.
+ */
+function createEqualityComparator(config) {
+    const supportedComparatorMap = createSupportedComparatorMap(config);
+    const { areArraysEqual, areDatesEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, getUnsupportedCustomComparator, } = config;
+    /**
+     * compare the value of the two objects and return true if they are equivalent in values
+     */
+    return function comparator(a, b, state) {
+        // If the items are strictly equal, no need to do a value comparison.
+        if (a === b) {
             return true;
         }
-        return undefined; // fallback to default isEquals behavior
-    });
+        // If either of the items are nullish and fail the strictly equal check
+        // above, then they must be unequal.
+        if (a == null || b == null) {
+            return false;
+        }
+        const type = typeof a;
+        if (type !== typeof b) {
+            return false;
+        }
+        if (type !== 'object') {
+            if (type === 'number' || type === 'bigint') {
+                return areNumbersEqual(a, b, state);
+            }
+            if (type === 'function') {
+                return areFunctionsEqual(a, b, state);
+            }
+            // If a primitive value that is not strictly equal, it must be unequal.
+            return false;
+        }
+        const constructor = a.constructor;
+        // Checks are listed in order of commonality of use-case:
+        //   1. Common complex object types (plain object, array)
+        //   2. Common data values (date, regexp)
+        //   3. Less-common complex object types (map, set)
+        //   4. Less-common data values (promise, primitive wrappers)
+        // Inherently this is both subjective and assumptive, however
+        // when reviewing comparable libraries in the wild this order
+        // appears to be generally consistent.
+        // Constructors should match, otherwise there is potential for false positives
+        // between class and subclass or custom object and POJO.
+        if (constructor !== b.constructor) {
+            return false;
+        }
+        // Try to fast-path equality checks for other complex object types in the
+        // same realm to avoid capturing the string tag. Strict equality is used
+        // instead of `instanceof` because it is more performant for the common
+        // use-case. If someone is creating a subclass from a native class, it will be
+        // handled with the string tag comparison.
+        if (constructor === Object) {
+            return areObjectsEqual(a, b, state);
+        }
+        if (constructor === Array) {
+            return areArraysEqual(a, b, state);
+        }
+        if (constructor === Date) {
+            return areDatesEqual(a, b, state);
+        }
+        if (constructor === RegExp) {
+            return areRegExpsEqual(a, b, state);
+        }
+        if (constructor === Map) {
+            return areMapsEqual(a, b, state);
+        }
+        if (constructor === Set) {
+            return areSetsEqual(a, b, state);
+        }
+        if (constructor === Promise) {
+            // Avoid tag checks for promise values, since we know if they are not referentially equal
+            // then they are not equal.
+            return false;
+        }
+        // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing
+        // the string tag or doing an `instanceof` in edge cases.
+        if (Array.isArray(a)) {
+            return areArraysEqual(a, b, state);
+        }
+        // Since this is a custom object, capture the string tag to determining its type.
+        // This is reasonably performant in modern environments like v8 and SpiderMonkey.
+        const tag = toString.call(a);
+        const supportedComparator = supportedComparatorMap[tag];
+        if (supportedComparator) {
+            return supportedComparator(a, b, state);
+        }
+        const unsupportedCustomComparator = getUnsupportedCustomComparator && getUnsupportedCustomComparator(a, b, state, tag);
+        if (unsupportedCustomComparator) {
+            return unsupportedCustomComparator(a, b, state);
+        }
+        // If not matching any tags that require a specific type of comparison, then we hard-code false because
+        // the only thing remaining is strict equality, which has already been compared. This is for a few reasons:
+        //   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, this is the only
+        //     comparison that can be made.
+        //   - For types that can be introspected but do not have an objective definition of what
+        //     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.
+        // In all cases, these decisions should be reevaluated based on changes to the language and
+        // common development practices.
+        return false;
+    };
+}
+/**
+ * Create the configuration object used for building comparators.
+ */
+function createEqualityComparatorConfig({ circular, createCustomConfig, strict, }) {
+    let config = {
+        areArrayBuffersEqual,
+        areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+        areDataViewsEqual,
+        areDatesEqual: areDatesEqual,
+        areErrorsEqual: areErrorsEqual,
+        areFunctionsEqual: strictEqual,
+        areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
+        areNumbersEqual: sameValueEqual,
+        areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
+        arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
+        areRegExpsEqual: areRegExpsEqual,
+        areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+        areTypedArraysEqual: strict
+            ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
+            : areTypedArraysEqual,
+        areUrlsEqual: areUrlsEqual,
+        getUnsupportedCustomComparator: undefined,
+    };
+    if (createCustomConfig) {
+        config = Object.assign({}, config, createCustomConfig(config));
+    }
+    if (circular) {
+        const areArraysEqual = createIsCircular(config.areArraysEqual);
+        const areMapsEqual = createIsCircular(config.areMapsEqual);
+        const areObjectsEqual = createIsCircular(config.areObjectsEqual);
+        const areSetsEqual = createIsCircular(config.areSetsEqual);
+        config = Object.assign({}, config, {
+            areArraysEqual,
+            areMapsEqual,
+            areObjectsEqual,
+            areSetsEqual,
+        });
+    }
+    return config;
+}
+/**
+ * Default equality comparator pass-through, used as the standard `isEqual` creator for
+ * use inside the built comparator.
+ */
+function createInternalEqualityComparator(compare) {
+    return function (a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
+        return compare(a, b, state);
+    };
+}
+/**
+ * Create the `isEqual` function used by the consuming application.
+ */
+function createIsEqual({ circular, comparator, createState, equals, strict }) {
+    if (createState) {
+        return function isEqual(a, b) {
+            const { cache = circular ? new WeakMap() : undefined, meta } = createState();
+            return comparator(a, b, {
+                cache,
+                equals,
+                meta,
+                strict,
+            });
+        };
+    }
+    if (circular) {
+        return function isEqual(a, b) {
+            return comparator(a, b, {
+                cache: new WeakMap(),
+                equals,
+                meta: undefined,
+                strict,
+            });
+        };
+    }
+    const state = {
+        cache: undefined,
+        equals,
+        meta: undefined,
+        strict,
+    };
+    return function isEqual(a, b) {
+        return comparator(a, b, state);
+    };
+}
+/**
+ * Create a map of `toString()` values to their respective handlers for `tag`-based lookups.
+ */
+function createSupportedComparatorMap({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, }) {
+    return {
+        '[object Arguments]': areObjectsEqual,
+        '[object Array]': areArraysEqual,
+        '[object ArrayBuffer]': areArrayBuffersEqual,
+        '[object AsyncGeneratorFunction]': areFunctionsEqual,
+        '[object BigInt]': areNumbersEqual,
+        '[object BigInt64Array]': areTypedArraysEqual,
+        '[object BigUint64Array]': areTypedArraysEqual,
+        '[object Boolean]': arePrimitiveWrappersEqual,
+        '[object DataView]': areDataViewsEqual,
+        '[object Date]': areDatesEqual,
+        // If an error tag, it should be tested explicitly. Like RegExp, the properties are not
+        // enumerable, and therefore will give false positives if tested like a standard object.
+        '[object Error]': areErrorsEqual,
+        '[object Float16Array]': areTypedArraysEqual,
+        '[object Float32Array]': areTypedArraysEqual,
+        '[object Float64Array]': areTypedArraysEqual,
+        '[object Function]': areFunctionsEqual,
+        '[object GeneratorFunction]': areFunctionsEqual,
+        '[object Int8Array]': areTypedArraysEqual,
+        '[object Int16Array]': areTypedArraysEqual,
+        '[object Int32Array]': areTypedArraysEqual,
+        '[object Map]': areMapsEqual,
+        '[object Number]': arePrimitiveWrappersEqual,
+        '[object Object]': (a, b, state) => 
+        // The exception for value comparison is custom `Promise`-like class instances. These should
+        // be treated the same as standard `Promise` objects, which means strict equality, and if
+        // it reaches this point then that strict equality comparison has already failed.
+        typeof a.then !== 'function' && typeof b.then !== 'function' && areObjectsEqual(a, b, state),
+        // For RegExp, the properties are not enumerable, and therefore will give false positives if
+        // tested like a standard object.
+        '[object RegExp]': areRegExpsEqual,
+        '[object Set]': areSetsEqual,
+        '[object String]': arePrimitiveWrappersEqual,
+        '[object URL]': areUrlsEqual,
+        '[object Uint8Array]': areTypedArraysEqual,
+        '[object Uint8ClampedArray]': areTypedArraysEqual,
+        '[object Uint16Array]': areTypedArraysEqual,
+        '[object Uint32Array]': areTypedArraysEqual,
+    };
 }
 
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+createCustomEqual();
+/**
+ * Whether the items passed are deeply-equal in value based on strict comparison.
+ */
+createCustomEqual({ strict: true });
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+createCustomEqual({ circular: true });
+/**
+ * Whether the items passed are deeply-equal in value, including circular references,
+ * based on strict comparison.
+ */
+createCustomEqual({
+    circular: true,
+    strict: true,
+});
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+createCustomEqual({
+    createInternalComparator: () => sameValueEqual,
+});
+/**
+ * Whether the items passed are shallowly-equal in value based on strict comparison
+ */
+createCustomEqual({
+    strict: true,
+    createInternalComparator: () => sameValueEqual,
+});
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+createCustomEqual({
+    circular: true,
+    createInternalComparator: () => sameValueEqual,
+});
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references,
+ * based on strict comparison.
+ */
+createCustomEqual({
+    circular: true,
+    createInternalComparator: () => sameValueEqual,
+    strict: true,
+});
+/**
+ * Create a custom equality comparison method.
+ *
+ * This can be done to create very targeted comparisons in extreme hot-path scenarios
+ * where the standard methods are not performant enough, but can also be used to provide
+ * support for legacy environments that do not support expected features like
+ * `RegExp.prototype.flags` out of the box.
+ */
+function createCustomEqual(options = {}) {
+    const { circular = false, createInternalComparator: createCustomInternalComparator, createState, strict = false, } = options;
+    const config = createEqualityComparatorConfig(options);
+    const comparator = createEqualityComparator(config);
+    const equals = createCustomInternalComparator
+        ? createCustomInternalComparator(comparator)
+        : createInternalEqualityComparator(comparator);
+    return createIsEqual({ circular, comparator, createState, equals, strict });
+}
+
+/** Implements a deep equals using `fast-equals.createCustomEqual`. Functions
+ * are always considered equal, and circular references are tracked to avoid
+ * infinite recursion on self-referential inputs.
+ *
+ * @param a - The first element to compare
+ * @param b - The second element to compare
+ * @returns - True if the `a` and `b` are deeply equal, false otherwise
+ */
+const deepEquals = createCustomEqual({
+    circular: true,
+    createCustomConfig: () => ({
+        areFunctionsEqual(_a, b) {
+            return typeof b === 'function';
+        },
+    }),
+});
+
 const objProto = Object.prototype;
 function isRecordEmpty(rec) {
     for (const key in rec) {
@@ -21614,7 +22186,7 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
         const data = _baseIteratee.get(formData, selectorField);
         if (data !== undefined) {
             return xxxOfs.find((xxx) => {
-                return isEqual.isEqual(_baseIteratee.get(xxx, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], _baseIteratee.get(xxx, [PROPERTIES_KEY, selectorField, CONST_KEY])), data);
+                return deepEquals(_baseIteratee.get(xxx, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], _baseIteratee.get(xxx, [PROPERTIES_KEY, selectorField, CONST_KEY])), data);
             });
         }
     }
@@ -22498,11 +23070,6 @@ function getObjectDefaults(validator, rawSchema, { rawFormData, rootSchema = {},
                 ? retrievedSchema.additionalProperties
                 : {};
             const keys = new Set();
-            if (isObject(defaults)) {
-                Object.keys(defaults)
-                    .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
-                    .forEach((key) => keys.add(key));
-            }
             const formDataRequired = [];
             Object.keys(formData)
                 .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
@@ -22510,6 +23077,14 @@ function getObjectDefaults(validator, rawSchema, { rawFormData, rootSchema = {},
                 keys.add(key);
                 formDataRequired.push(key);
             });
+            // Only seed keys from schema defaults when formData has no additionalProperties of its own.
+            // If the user already has data (e.g. after a key rename), injecting default keys would
+            // re-add stale entries that no longer exist in formData.
+            if (isObject(defaults) && formDataRequired.length === 0) {
+                Object.keys(defaults)
+                    .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key])
+                    .forEach((key) => keys.add(key));
+            }
             keys.forEach((key) => {
                 var _a;
                 const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
@@ -23498,6 +24073,67 @@ function englishStringTranslator(stringToTranslate, params) {
     return replaceStringParameters(stringToTranslate, params);
 }
 
+/** Determines whether the given `value` is (one of) the `selected` value(s).
+ *
+ * @param value - The value being checked to see if it is selected
+ * @param selected - The current selected value or list of values
+ * @returns - true if the `value` is one of the `selected` ones, false otherwise
+ */
+function enumOptionsIsSelected(value, selected) {
+    if (Array.isArray(selected)) {
+        return selected.some((sel) => deepEquals(sel, value));
+    }
+    return deepEquals(selected, value);
+}
+
+/** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the
+ * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then
+ * stored in an array. If `multiple` is true, that array is returned, otherwise the first element in the array is
+ * returned.
+ *
+ * @param value - The single value or list of values for which indexes are desired
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @param [multiple=false] - Optional flag, if true will return a list of index, otherwise a single one
+ * @returns - A single string index for the first `value` in `allEnumOptions`, if not `multiple`. Otherwise, the list
+ *        of indexes for (each of) the value(s) in `value`.
+ */
+function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false) {
+    const selectedIndexes = allEnumOptions
+        .map((opt, index) => (enumOptionsIsSelected(opt.value, value) ? String(index) : undefined))
+        .filter((opt) => typeof opt !== 'undefined');
+    if (!multiple) {
+        return selectedIndexes[0];
+    }
+    return selectedIndexes;
+}
+
+/** Computes the value to pass to a select element's `value` attribute.
+ *
+ * When `format` is `'realValue'`, converts form data values to strings.
+ * When `format` is `'indexed'` (the default), resolves to index-based values via
+ * `enumOptionsIndexForValue`. Returns `emptyValue` when the current value is empty.
+ *
+ * @param value - The current form data value
+ * @param enumOptions - The available enum options
+ * @param multiple - Whether the select allows multiple selections
+ * @param [format='indexed'] - How option values are encoded on the DOM
+ * @param emptyValue - The value to return when the selection is empty
+ * @returns The value to use for the select element's `value` attribute
+ */
+function enumOptionSelectedValue(value, enumOptions, multiple, format = 'indexed', emptyValue) {
+    const isEmpty = typeof value === 'undefined' ||
+        (multiple && Array.isArray(value) && value.length < 1) ||
+        (!multiple && value === emptyValue);
+    if (isEmpty) {
+        return emptyValue;
+    }
+    if (format === 'realValue') {
+        return multiple ? value.map(String) : String(value);
+    }
+    const indexes = enumOptionsIndexForValue(value, enumOptions, multiple);
+    return typeof indexes === 'undefined' ? emptyValue : indexes;
+}
+
 /** Returns the value(s) from `allEnumOptions` at the index(es) provided by `valueIndex`. If `valueIndex` is not an
  * array AND the index is not valid for `allEnumOptions`, `emptyValue` is returned. If `valueIndex` is an array, AND it
  * contains an invalid index, the returned array will have the resulting undefined values filtered out, leaving only
@@ -23522,6 +24158,84 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
     return option ? option.value : emptyValue;
 }
 
+/** Resolves a single DOM value string back to its typed enum value in `'realValue'` mode.
+ *
+ * First attempts a reverse lookup by matching `String(opt.value)` against the input.
+ * If no option matches and the input parses as a valid index, falls back to the
+ * option at that index — this is how object/array enum values round-trip, since
+ * they are encoded as indices by the encoder.
+ *
+ * @param value - A single string value from a DOM attribute
+ * @param enumOptions - The available enum options
+ * @param emptyValue - The value to return when the input is empty, options are missing, or no match is found
+ * @returns The original typed enum value, or `emptyValue`
+ */
+function decodeSingle(value, enumOptions, emptyValue) {
+    if (value === '' || !Array.isArray(enumOptions)) {
+        return emptyValue;
+    }
+    const match = enumOptions.find((opt) => String(opt.value) === value);
+    if (match) {
+        return match.value;
+    }
+    // Fallback: value might be an index (for object/array enum values)
+    const index = Number(value);
+    if (!isNaN(index) && index >= 0 && index < enumOptions.length) {
+        return enumOptions[index].value;
+    }
+    return emptyValue;
+}
+/** Decodes a string from a DOM value attribute back to a typed enum value.
+ *
+ * When `format` is `'realValue'`, does a reverse lookup: finds the enum option
+ * whose `String(value)` matches the input string and returns the original typed value.
+ * For object/array values that were encoded as indices, falls back to index resolution.
+ *
+ * When `format` is `'indexed'` (the default), uses index-based resolution via
+ * `enumOptionsValueForIndex`.
+ *
+ * @param value - The string value(s) from the DOM
+ * @param enumOptions - The available enum options
+ * @param [format='indexed'] - How the values were encoded on the DOM
+ * @param emptyValue - The value to return for empty/missing selections
+ * @returns The original typed enum value(s)
+ */
+function enumOptionValueDecoder(value, enumOptions, format = 'indexed', emptyValue) {
+    if (format !== 'realValue') {
+        return enumOptionsValueForIndex(value, enumOptions, emptyValue);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => decodeSingle(v, enumOptions, emptyValue));
+    }
+    return decodeSingle(value, enumOptions, emptyValue);
+}
+
+/** Encodes an enum option value into a string for a DOM value attribute.
+ *
+ * When `format` is `'realValue'`, primitive values are converted via `String()`.
+ * Non-primitive values (objects, arrays) fall back to the index since
+ * `String()` would produce `"[object Object]"`.
+ *
+ * When `format` is `'indexed'` (the default), returns the index as a string.
+ *
+ * @param value - The typed enum value
+ * @param index - The option's position in the enumOptions array
+ * @param [format='indexed'] - How to encode the value for the DOM attribute
+ * @returns The string to use as the DOM value attribute
+ */
+function enumOptionValueEncoder(value, index, format = 'indexed') {
+    if (format !== 'realValue') {
+        return String(index);
+    }
+    if (isNil(value)) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        return String(index);
+    }
+    return String(value);
+}
+
 /** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is
  * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is
  * a single value, then if the enum option value with the `valueIndex` in `allEnumOptions` matches `selected`, undefined
@@ -23542,40 +24256,6 @@ function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
     return deepEquals(value, selected) ? undefined : selected;
 }
 
-/** Determines whether the given `value` is (one of) the `selected` value(s).
- *
- * @param value - The value being checked to see if it is selected
- * @param selected - The current selected value or list of values
- * @returns - true if the `value` is one of the `selected` ones, false otherwise
- */
-function enumOptionsIsSelected(value, selected) {
-    if (Array.isArray(selected)) {
-        return selected.some((sel) => deepEquals(sel, value));
-    }
-    return deepEquals(selected, value);
-}
-
-/** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the
- * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then
- * stored in an array. If `multiple` is true, that array is returned, otherwise the first element in the array is
- * returned.
- *
- * @param value - The single value or list of values for which indexes are desired
- * @param [allEnumOptions=[]] - The list of all the known enumOptions
- * @param [multiple=false] - Optional flag, if true will return a list of index, otherwise a single one
- * @returns - A single string index for the first `value` in `allEnumOptions`, if not `multiple`. Otherwise, the list
- *        of indexes for (each of) the value(s) in `value`.
- */
-function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false) {
-    const selectedIndexes = allEnumOptions
-        .map((opt, index) => (enumOptionsIsSelected(opt.value, value) ? String(index) : undefined))
-        .filter((opt) => typeof opt !== 'undefined');
-    if (!multiple) {
-        return selectedIndexes[0];
-    }
-    return selectedIndexes;
-}
-
 /** Add the enum option value at the `valueIndex` to the list of `selected` values in the proper order as defined by
  * `allEnumOptions`
  *
@@ -23821,6 +24501,15 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
             }
         }
     }
+    // For date/time input types, propagate formatMinimum/formatMaximum to min/max
+    if (['date', 'datetime-local', 'time', 'week', 'month'].includes(inputProps.type)) {
+        if (schema.formatMinimum !== undefined) {
+            inputProps.min = schema.formatMinimum;
+        }
+        if (schema.formatMaximum !== undefined) {
+            inputProps.max = schema.formatMaximum;
+        }
+    }
     if (options.autocomplete) {
         inputProps.autoComplete = options.autocomplete;
     }
@@ -23830,6 +24519,23 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
     return inputProps;
 }
 
+/** Resolves the effective `optionValueFormat` for enum-backed widgets.
+ *
+ * Provides a single source of truth for the default DOM encoding format
+ * (`'indexed'`) used by `SelectWidget`, `RadioWidget`, and `CheckboxesWidget`.
+ * Widgets should call this helper once and pass the result to
+ * `enumOptionValueEncoder`, `enumOptionValueDecoder`, and `enumOptionSelectedValue`
+ * rather than reading `options.optionValueFormat` directly.
+ *
+ * @param options - The widget options (typically from the `options` prop, already
+ *   resolved from `ui:options` and `ui:globalOptions`)
+ * @returns The resolved `OptionValueFormat`, defaulting to `'indexed'` when not set
+ */
+function getOptionValueFormat(options) {
+    var _a;
+    return (_a = options === null || options === void 0 ? void 0 : options.optionValueFormat) !== null && _a !== void 0 ? _a : 'indexed';
+}
+
 /** The default submit button options, exported for testing purposes
  */
 const DEFAULT_OPTIONS = {
@@ -24246,12 +24952,12 @@ function isFormDataAvailable(formData) {
  */
 function isRootSchema(registry, schemaToCompare) {
     const { rootSchema, schemaUtils } = registry;
-    if (isEqual.isEqual(schemaToCompare, rootSchema)) {
+    if (deepEquals(schemaToCompare, rootSchema)) {
         return true;
     }
     if (REF_KEY in rootSchema) {
         const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-        return isEqual.isEqual(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
+        return deepEquals(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
     }
     return false;
 }
@@ -24286,6 +24992,111 @@ function lookupFromFormContext(regOrFc, toLookup, fallback) {
     return _baseIteratee.get(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
+/** Determines whether a value is considered "empty" for the purposes of optional object pruning.
+ * A value is empty if it is `undefined`, `null`, an empty string, or an object where all own
+ * properties are themselves empty.
+ *
+ * @param value - The value to check
+ * @returns True if the value is considered empty
+ */
+function isValueEmpty(value) {
+    if (isNil(value) || value === '') {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        // An empty array is considered empty; a non-empty array is not
+        return value.length === 0;
+    }
+    if (isObject(value)) {
+        const obj = value;
+        const keys = Object.keys(obj);
+        return keys.every((key) => isValueEmpty(obj[key]));
+    }
+    return false;
+}
+/** Recursively removes optional objects from the `formData` that are empty (i.e., all their fields
+ * are undefined, null, empty strings, or themselves empty optional objects). This solves the problem
+ * where interacting with fields inside an optional object "activates" it permanently, making the
+ * form unsubmittable when the optional object has required inner fields.
+ *
+ * An object property is considered "optional" when it is NOT listed in its parent schema's `required`
+ * array.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The JSON schema describing the `formData`
+ * @param [rootSchema] - The root schema, used primarily to look up `$ref`s
+ * @param [formData] - The current form data to prune
+ * @returns - A new copy of `formData` with empty optional objects removed, or `undefined` if the
+ *           entire formData was pruned
+ */
+function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
+    if (!isObject(schema)) {
+        return formData;
+    }
+    const resolvedSchema = retrieveSchema(validator, schema, rootSchema, formData);
+    if (Array.isArray(formData)) {
+        const itemsSchema = resolvedSchema.items;
+        if (!itemsSchema) {
+            return formData;
+        }
+        let hasChanges = false;
+        const mapped = formData.map((item, index) => {
+            let itemSchema = itemsSchema;
+            if (Array.isArray(itemsSchema)) {
+                itemSchema = itemsSchema[index] || resolvedSchema.additionalItems || {};
+            }
+            const cleaned = removeOptionalEmptyObjects(validator, itemSchema, rootSchema, item);
+            if (cleaned !== item) {
+                hasChanges = true;
+            }
+            return cleaned === undefined ? {} : cleaned;
+        });
+        // Although T is an array type here, we still need to cast it back to T since TS
+        // doesn't narrow the generic T automatically
+        return hasChanges ? mapped : formData;
+    }
+    const { properties, required: requiredFields = [] } = resolvedSchema;
+    if (!isObject(formData) || !properties) {
+        return formData;
+    }
+    const result = {};
+    const data = formData;
+    let hasAnyValue = false;
+    for (const key of Object.keys(data)) {
+        const value = data[key];
+        const propertySchema = (properties[key] || {});
+        const isRequired = requiredFields.includes(key);
+        const isObj = isObject(value);
+        const isArr = Array.isArray(value);
+        if ((isObj || isArr) && properties[key]) {
+            // Recursively process nested objects and arrays
+            const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
+            if (!isRequired && isValueEmpty(cleaned)) {
+                // This is an optional property and the cleaned result is empty — omit it
+                continue;
+            }
+            result[key] = cleaned;
+            hasAnyValue = true;
+        }
+        else if (!isRequired && isValueEmpty(value) && properties[key]) {
+            // Optional scalar property that is empty — omit it
+            continue;
+        }
+        else {
+            result[key] = value;
+            if (!isValueEmpty(value)) {
+                hasAnyValue = true;
+            }
+        }
+    }
+    // If the entire object ended up empty after pruning, return undefined so that the
+    // caller (which may itself be a recursive call) can decide whether to keep or drop it
+    if (!hasAnyValue && Object.keys(result).length === 0) {
+        return undefined;
+    }
+    return result;
+}
+
 /** Given a list of `properties` and an `order` list, returns a list that contains the `properties` ordered correctly.
  * If `order` is not an array, then the untouched `properties` list is returned. Otherwise `properties` is ordered per
  * the `order` list. If `order` contains a '*' then any `properties` that are not mentioned explicity in `order` will be
@@ -24356,104 +25167,18 @@ function parseDateString(dateString, includeTime = true) {
     };
 }
 
-// Keywords where child schemas map to uiSchema at the SAME key
-const SAME_KEY_KEYWORDS = [ITEMS_KEY, ADDITIONAL_PROPERTIES_KEY];
-// Keywords where child schemas are in an array, each mapping to uiSchema[keyword][i]
-const ARRAY_KEYWORDS = [ONE_OF_KEY, ANY_OF_KEY, ALL_OF_KEY];
-/** Expands `ui:definitions` into the uiSchema by walking the schema tree and finding all `$ref`s.
- * Called once at form initialization to pre-expand definitions into the uiSchema structure.
- *
- * For recursive schemas, expansion stops at recursion points to avoid infinite loops.
- * Runtime resolution via `resolveUiSchema` handles these cases using registry definitions.
- *
- * @param currentSchema - The current schema node being processed
- * @param uiSchema - The uiSchema at the current path
- * @param registry - The registry containing rootSchema and uiSchemaDefinitions
- * @param visited - Set of $refs already visited (to detect recursion)
- * @returns - The expanded uiSchema with definitions merged in
- */
-function expandUiSchemaDefinitions(currentSchema, uiSchema, registry, visited = new Set()) {
-    const { rootSchema, uiSchemaDefinitions: definitions } = registry;
-    let result = { ...uiSchema };
-    let resolvedSchema = currentSchema;
-    const ref = currentSchema[REF_KEY];
-    const isRecursive = ref && visited.has(ref);
-    if (ref) {
-        visited.add(ref);
-        if (definitions && ref in definitions) {
-            result = mergeObjects(definitions[ref], result);
-        }
-        if (isRecursive) {
-            return result;
-        }
-        try {
-            resolvedSchema = findSchemaDefinition(ref, rootSchema);
-        }
-        catch (_a) {
-            resolvedSchema = currentSchema;
-        }
-    }
-    // Process properties (each property maps to uiSchema[propName] - flattened)
-    const properties = resolvedSchema[PROPERTIES_KEY];
-    if (properties && isObject(properties)) {
-        for (const [propName, propSchema] of Object.entries(properties)) {
-            const propUiSchema = (result[propName] || {});
-            const expanded = expandUiSchemaDefinitions(propSchema, propUiSchema, registry, new Set(visited));
-            if (Object.keys(expanded).length > 0) {
-                result[propName] = expanded;
-            }
-        }
-    }
-    // Process keywords where child maps to same key in uiSchema (items, additionalProperties)
-    for (const keyword of SAME_KEY_KEYWORDS) {
-        const subSchema = resolvedSchema[keyword];
-        if (subSchema && isObject(subSchema) && !Array.isArray(subSchema)) {
-            const currentUiSchema = result[keyword];
-            if (typeof currentUiSchema !== 'function') {
-                const subUiSchema = (currentUiSchema || {});
-                const expanded = expandUiSchemaDefinitions(subSchema, subUiSchema, registry, new Set(visited));
-                if (Object.keys(expanded).length > 0) {
-                    result[keyword] = expanded;
-                }
-            }
-        }
-    }
-    // Process array keywords (oneOf, anyOf, allOf) - each option maps to uiSchema[keyword][i]
-    for (const keyword of ARRAY_KEYWORDS) {
-        const schemaOptions = resolvedSchema[keyword];
-        if (Array.isArray(schemaOptions) && schemaOptions.length > 0) {
-            const currentUiSchemaArray = result[keyword];
-            const uiSchemaArray = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
-            let hasExpanded = false;
-            for (let i = 0; i < schemaOptions.length; i++) {
-                const optionSchema = schemaOptions[i];
-                const optionUiSchema = (uiSchemaArray[i] || {});
-                const expanded = expandUiSchemaDefinitions(optionSchema, optionUiSchema, registry, new Set(visited));
-                if (Object.keys(expanded).length > 0) {
-                    uiSchemaArray[i] = expanded;
-                    hasExpanded = true;
-                }
-            }
-            if (hasExpanded) {
-                result[keyword] = uiSchemaArray;
-            }
-        }
-    }
-    return result;
-}
 /** Resolves the uiSchema for a given schema, considering `ui:definitions` stored in the registry.
  *
- * This function is called at runtime for each field. It handles recursive schemas where the
- * pre-expansion in `expandUiSchemaDefinitions` couldn't go deeper.
- *
- * When the schema contains a `$ref`, this function looks up the corresponding uiSchema definition
- * from `registry.uiSchemaDefinitions` and merges it with any local uiSchema overrides.
+ * Called at runtime for each field. When the schema contains a `$ref`, looks up the corresponding
+ * uiSchema definition from `registry.uiSchemaDefinitions` and merges it with local overrides.
+ * For schemas with `oneOf`/`anyOf` branches, also populates `uiSchema[keyword][i]` for branches
+ * whose `$ref` matches a definition, so `MultiSchemaField` can read dropdown option titles.
  *
  * Resolution order (later sources override earlier):
  * 1. `ui:definitions[$ref]` - base definition from registry
  * 2. `localUiSchema` - local overrides at current path
  *
- * @param schema - The JSON schema (may still contain `$ref` for recursive schemas)
+ * @param schema - The JSON schema (may contain `$ref` or `RJSF_REF_KEY`)
  * @param localUiSchema - The uiSchema at the current path (local overrides)
  * @param registry - The registry containing `uiSchemaDefinitions`
  * @returns - The resolved uiSchema with definitions merged in
@@ -24461,14 +25186,54 @@ function expandUiSchemaDefinitions(currentSchema, uiSchema, registry, visited =
 function resolveUiSchema(schema, localUiSchema, registry) {
     var _a, _b;
     const ref = ((_a = schema[RJSF_REF_KEY]) !== null && _a !== void 0 ? _a : schema[REF_KEY]);
-    const definitionUiSchema = ref ? (_b = registry.uiSchemaDefinitions) === null || _b === void 0 ? void 0 : _b[ref] : undefined;
+    const definitions = registry.uiSchemaDefinitions;
+    const definitionUiSchema = ref && definitions ? definitions[ref] : undefined;
+    let result;
     if (!definitionUiSchema) {
-        return localUiSchema || {};
+        result = localUiSchema || {};
     }
-    if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
-        return { ...definitionUiSchema };
+    else if (!localUiSchema || isEmpty.isEmpty(localUiSchema)) {
+        result = { ...definitionUiSchema };
+    }
+    else {
+        result = mergeObjects(definitionUiSchema, localUiSchema);
+    }
+    // Walk oneOf/anyOf branches to populate uiSchema[keyword][i] so MultiSchemaField
+    // can read dropdown option titles at the parent level.
+    if (definitions) {
+        let resolvedSchema = schema;
+        if (ref && schema[REF_KEY] && !schema[RJSF_REF_KEY]) {
+            try {
+                resolvedSchema = findSchemaDefinition(ref, registry.rootSchema);
+            }
+            catch (e) {
+                console.warn('could not resolve $ref in resolveUiSchema:\n', e);
+                return result;
+            }
+        }
+        for (const keyword of [ONE_OF_KEY, ANY_OF_KEY]) {
+            const schemaOptions = resolvedSchema[keyword];
+            if (!Array.isArray(schemaOptions) || schemaOptions.length === 0) {
+                continue;
+            }
+            const currentUiSchemaArray = result[keyword];
+            const uiSchemaArray = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
+            let hasExpanded = false;
+            for (let i = 0; i < schemaOptions.length; i++) {
+                const option = schemaOptions[i];
+                const optionRef = ((_b = option === null || option === void 0 ? void 0 : option[RJSF_REF_KEY]) !== null && _b !== void 0 ? _b : option === null || option === void 0 ? void 0 : option[REF_KEY]);
+                if (optionRef && optionRef in definitions) {
+                    const optionUiSchema = (uiSchemaArray[i] || {});
+                    uiSchemaArray[i] = mergeObjects(definitions[optionRef], optionUiSchema);
+                    hasExpanded = true;
+                }
+            }
+            if (hasExpanded) {
+                result[keyword] = uiSchemaArray;
+            }
+        }
     }
-    return mergeObjects(definitionUiSchema, localUiSchema);
+    return result;
 }
 
 /** Check to see if a `schema` specifies that a value must be true. This happens when:
@@ -24779,7 +25544,7 @@ function useAltDateWidgetProps(props) {
  */
 function useDeepCompareMemo(newValue) {
     const valueRef = reactExports.useRef(newValue);
-    if (!isEqual.isEqual(newValue, valueRef.current)) {
+    if (!deepEquals(newValue, valueRef.current)) {
         valueRef.current = newValue;
     }
     return valueRef.current;
@@ -25704,10 +26469,12 @@ function ArrayField$1(props) {
      * @param index - The index of the item being changed
      */
     const handleChange = reactExports.useCallback((value, path, newErrorSchema, id) => {
+        const lastPathIsItemIndex = typeof path.at(-1) === 'number';
         onChange(
         // We need to treat undefined items as nulls to have validation.
         // See https://github.com/tdegrunt/jsonschema/issues/206
-        value === undefined ? null : value, path, newErrorSchema, id);
+        // Only set to null for array items, and not for object properties within array items
+        lastPathIsItemIndex && value === undefined ? null : value, path, newErrorSchema, id);
     }, [onChange]);
     /** Callback handler used to change the value for a checkbox */
     const onSelectChange = reactExports.useCallback((value) => {
@@ -27023,11 +27790,14 @@ function ObjectField$1(props) {
     const { schema: rawSchema, uiSchema = {}, formData, errorSchema, fieldPathId, name, required = false, disabled, readonly, hideError, onBlur, onFocus, onChange, registry, title, } = props;
     const { fields, schemaUtils, translateString, globalUiOptions } = registry;
     const { OptionalDataControlsField } = fields;
+    const formDataRef = reactExports.useRef(formData);
+    formDataRef.current = formData;
     const schema = schemaUtils.retrieveSchema(rawSchema, formData, true);
     const uiOptions = getUiOptions(uiSchema, globalUiOptions);
     const { properties: schemaProperties = {} } = schema;
     // All the children will use childFieldPathId if present in the props, falling back to the fieldPathId
     const childFieldPathId = props.childFieldPathId ?? fieldPathId;
+    const lastRenamedProperty = reactExports.useRef({ previousKey: '', currentKey: undefined });
     const templateTitle = uiOptions.title ?? schema.title ?? title ?? name;
     const description = uiOptions.description ?? schema.description;
     const renderOptionalField = shouldRenderOptionalField(registry, schema, required, uiSchema);
@@ -27087,6 +27857,10 @@ function ObjectField$1(props) {
             // Cast this to make the `set` work properly
             set(newFormData, newKey, newValue);
         }
+        if (lastRenamedProperty.current.previousKey === newKey) {
+            lastRenamedProperty.current.currentKey = newKey;
+            lastRenamedProperty.current.previousKey = getAvailableKey(newKey, newFormData);
+        }
         onChange(newFormData, childFieldPathId.path);
     }, [formData, onChange, registry, childFieldPathId, getAvailableKey, schema]);
     /** Returns a callback function that deals with the rename of a key for an additional property for a schema. That
@@ -27098,9 +27872,10 @@ function ObjectField$1(props) {
      */
     const handleKeyRename = reactExports.useCallback((oldKey, newKey) => {
         if (oldKey !== newKey) {
-            const actualNewKey = getAvailableKey(newKey, formData);
+            const currentFormData = formDataRef.current;
+            const actualNewKey = getAvailableKey(newKey, currentFormData);
             const newFormData = {
-                ...formData,
+                ...currentFormData,
             };
             const newKeys = { [oldKey]: actualNewKey };
             const keyValues = Object.keys(newFormData).map((key) => {
@@ -27108,15 +27883,31 @@ function ObjectField$1(props) {
                 return { [newKey]: newFormData[key] };
             });
             const renamedObj = Object.assign({}, ...keyValues);
+            formDataRef.current = renamedObj;
+            if (oldKey !== lastRenamedProperty.current.currentKey) {
+                lastRenamedProperty.current.previousKey = oldKey;
+            }
+            lastRenamedProperty.current.currentKey = actualNewKey;
             onChange(renamedObj, childFieldPathId.path);
         }
-    }, [formData, onChange, childFieldPathId, getAvailableKey]);
+    }, [onChange, childFieldPathId, getAvailableKey]);
     /** Handles the remove click which calls the `onChange` callback with the special ADDITIONAL_PROPERTY_FIELD_REMOVE
      * value for the path plus the key to be removed
      */
     const handleRemoveProperty = reactExports.useCallback((key) => {
         onChange(ADDITIONAL_PROPERTY_KEY_REMOVE, [...childFieldPathId.path, key]);
     }, [onChange, childFieldPathId]);
+    /** Returns the stable React key for a property. For the most recently renamed
+     * additional property, returns the previous key so that React reuses the
+     * existing component instance instead of unmounting/remounting it. This
+     * preserves DOM focus naturally without manual focus management.
+     */
+    const getStableKey = reactExports.useCallback((property) => {
+        if (lastRenamedProperty.current.currentKey === property) {
+            return lastRenamedProperty.current.previousKey;
+        }
+        return property;
+    }, []);
     if (!renderOptionalField || hasFormData) {
         try {
             const properties = Object.keys(schemaProperties);
@@ -27136,7 +27927,7 @@ function ObjectField$1(props) {
             const addedByAdditionalProperties = pickBy.has(schema, [PROPERTIES_KEY, name, ADDITIONAL_PROPERTY_FLAG]);
             const fieldUiSchema = addedByAdditionalProperties ? uiSchema.additionalProperties : uiSchema[name];
             const hidden = getUiOptions(fieldUiSchema).widget === 'hidden';
-            const content = (jsxRuntimeExports.jsx(ObjectFieldProperty, { propertyName: name, required: isRequired(schema, name), schema: _baseIteratee.get(schema, [PROPERTIES_KEY, name], {}), uiSchema: fieldUiSchema, errorSchema: _baseIteratee.get(errorSchema, [name]), fieldPathId: childFieldPathId, formData: _baseIteratee.get(formData, [name]), handleKeyRename: handleKeyRename, handleRemoveProperty: handleRemoveProperty, addedByAdditionalProperties: addedByAdditionalProperties, onChange: onChange, onBlur: onBlur, onFocus: onFocus, registry: registry, disabled: disabled, readonly: readonly, hideError: hideError }, name));
+            const content = (jsxRuntimeExports.jsx(ObjectFieldProperty, { propertyName: name, required: isRequired(schema, name), schema: _baseIteratee.get(schema, [PROPERTIES_KEY, name], {}), uiSchema: fieldUiSchema, errorSchema: _baseIteratee.get(errorSchema, [name]), fieldPathId: childFieldPathId, formData: _baseIteratee.get(formData, [name]), handleKeyRename: handleKeyRename, handleRemoveProperty: handleRemoveProperty, addedByAdditionalProperties: addedByAdditionalProperties, onChange: onChange, onBlur: onBlur, onFocus: onFocus, registry: registry, disabled: disabled, readonly: readonly, hideError: hideError }, getStableKey(name)));
             return {
                 content,
                 name,
@@ -27881,7 +28672,7 @@ function WrapIfAdditionalTemplate(props) {
         return (jsxRuntimeExports.jsx("div", { className: uiClassNames, style: style, children: children }));
     }
     const margin = hasDescription ? 46 : 26;
-    return (jsxRuntimeExports.jsx("div", { className: uiClassNames, style: style, children: jsxRuntimeExports.jsxs("div", { className: 'row', children: [jsxRuntimeExports.jsx("div", { className: 'col-xs-5 form-additional', children: jsxRuntimeExports.jsxs("div", { className: 'form-group', children: [displayLabel && jsxRuntimeExports.jsx(Label, { label: keyLabel, required: required, id: `${id}-key` }), displayLabel && rawDescription && jsxRuntimeExports.jsx("div", { children: "\u00A0" }), jsxRuntimeExports.jsx("input", { className: 'form-control', type: 'text', id: `${id}-key`, onBlur: onKeyRenameBlur, defaultValue: label })] }) }), jsxRuntimeExports.jsx("div", { className: 'form-additional form-group col-xs-5', children: children }), jsxRuntimeExports.jsx("div", { className: 'col-xs-2', style: { marginTop: displayLabel ? `${margin}px` : undefined }, children: jsxRuntimeExports.jsx(RemoveButton, { id: buttonId(id, 'remove'), className: 'rjsf-object-property-remove btn-block', style: { border: '0' }, disabled: disabled || readonly, onClick: onRemoveProperty, uiSchema: uiSchema, registry: registry }) })] }) }));
+    return (jsxRuntimeExports.jsx("div", { className: uiClassNames, style: style, children: jsxRuntimeExports.jsxs("div", { className: 'row', children: [jsxRuntimeExports.jsx("div", { className: 'col-xs-5 form-additional', children: jsxRuntimeExports.jsxs("div", { className: 'form-group', children: [displayLabel && jsxRuntimeExports.jsx(Label, { label: keyLabel, required: required, id: `${id}-key` }), displayLabel && rawDescription && jsxRuntimeExports.jsx("div", { children: "\u00A0" }), jsxRuntimeExports.jsx("input", { className: 'form-control', type: 'text', id: `${id}-key`, onBlur: onKeyRenameBlur, defaultValue: label }, label)] }) }), jsxRuntimeExports.jsx("div", { className: 'form-additional form-group col-xs-5', children: children }), jsxRuntimeExports.jsx("div", { className: 'col-xs-2', style: { marginTop: displayLabel ? `${margin}px` : undefined }, children: jsxRuntimeExports.jsx(RemoveButton, { id: buttonId(id, 'remove'), className: 'rjsf-object-property-remove btn-block', style: { border: '0' }, disabled: disabled || readonly, onClick: onRemoveProperty, uiSchema: uiSchema, registry: registry }) })] }) }));
 }
 
 function templates() {
@@ -27954,10 +28745,12 @@ function CheckboxWidget({ schema, uiSchema, options, id, value, disabled, readon
  *
  * @param props - The `WidgetProps` for this component
  */
-function CheckboxesWidget({ id, disabled, options: { inline = false, enumOptions, enumDisabled, emptyValue }, value, autofocus = false, readonly, onChange, onBlur, onFocus, htmlName, }) {
+function CheckboxesWidget({ id, disabled, options, value, autofocus = false, readonly, onChange, onBlur, onFocus, htmlName, }) {
+    const { inline = false, enumOptions, enumDisabled, emptyValue } = options;
+    const optionValueFormat = getOptionValueFormat(options);
     const checkboxesValues = Array.isArray(value) ? value : [value];
-    const handleBlur = reactExports.useCallback(({ target }) => onBlur(id, enumOptionsValueForIndex(target && target.value, enumOptions, emptyValue)), [onBlur, id, enumOptions, emptyValue]);
-    const handleFocus = reactExports.useCallback(({ target }) => onFocus(id, enumOptionsValueForIndex(target && target.value, enumOptions, emptyValue)), [onFocus, id, enumOptions, emptyValue]);
+    const handleBlur = reactExports.useCallback(({ target }) => onBlur(id, enumOptionValueDecoder(target && target.value, enumOptions, optionValueFormat, emptyValue)), [onBlur, id, enumOptions, emptyValue, optionValueFormat]);
+    const handleFocus = reactExports.useCallback(({ target }) => onFocus(id, enumOptionValueDecoder(target && target.value, enumOptions, optionValueFormat, emptyValue)), [onFocus, id, enumOptions, emptyValue, optionValueFormat]);
     return (jsxRuntimeExports.jsx("div", { className: 'checkboxes', id: id, children: Array.isArray(enumOptions) &&
             enumOptions.map((option, index) => {
                 const checked = enumOptionsIsSelected(option.value, checkboxesValues);
@@ -27971,7 +28764,7 @@ function CheckboxesWidget({ id, disabled, options: { inline = false, enumOptions
                         onChange(enumOptionsDeselectValue(index, checkboxesValues, enumOptions));
                     }
                 };
-                const checkbox = (jsxRuntimeExports.jsxs("span", { children: [jsxRuntimeExports.jsx("input", { type: 'checkbox', id: optionId(id, index), name: htmlName || id, checked: checked, value: String(index), disabled: disabled || itemDisabled || readonly, autoFocus: autofocus && index === 0, onChange: handleChange, onBlur: handleBlur, onFocus: handleFocus, "aria-describedby": ariaDescribedByIds(id) }), jsxRuntimeExports.jsx("span", { children: option.label })] }));
+                const checkbox = (jsxRuntimeExports.jsxs("span", { children: [jsxRuntimeExports.jsx("input", { type: 'checkbox', id: optionId(id, index), name: htmlName || id, checked: checked, value: enumOptionValueEncoder(option.value, index, optionValueFormat), disabled: disabled || itemDisabled || readonly, autoFocus: autofocus && index === 0, onChange: handleChange, onBlur: handleBlur, onFocus: handleFocus, "aria-describedby": ariaDescribedByIds(id) }), jsxRuntimeExports.jsx("span", { children: option.label })] }));
                 return inline ? (jsxRuntimeExports.jsx("label", { className: `checkbox-inline ${disabledCls}`, children: checkbox }, index)) : (jsxRuntimeExports.jsx("div", { className: `checkbox ${disabledCls}`, children: jsxRuntimeExports.jsx("label", { children: checkbox }) }, index));
             }) }));
 }
@@ -28089,15 +28882,16 @@ function PasswordWidget(props) {
  */
 function RadioWidget({ options, value, required, disabled, readonly, autofocus = false, onBlur, onFocus, onChange, id, htmlName, }) {
     const { enumOptions, enumDisabled, inline, emptyValue } = options;
-    const handleBlur = reactExports.useCallback(({ target }) => onBlur(id, enumOptionsValueForIndex(target && target.value, enumOptions, emptyValue)), [onBlur, enumOptions, emptyValue, id]);
-    const handleFocus = reactExports.useCallback(({ target }) => onFocus(id, enumOptionsValueForIndex(target && target.value, enumOptions, emptyValue)), [onFocus, enumOptions, emptyValue, id]);
+    const optionValueFormat = getOptionValueFormat(options);
+    const handleBlur = reactExports.useCallback(({ target }) => onBlur(id, enumOptionValueDecoder(target && target.value, enumOptions, optionValueFormat, emptyValue)), [onBlur, enumOptions, emptyValue, id, optionValueFormat]);
+    const handleFocus = reactExports.useCallback(({ target }) => onFocus(id, enumOptionValueDecoder(target && target.value, enumOptions, optionValueFormat, emptyValue)), [onFocus, enumOptions, emptyValue, id, optionValueFormat]);
     return (jsxRuntimeExports.jsx("div", { className: 'field-radio-group', id: id, role: 'radiogroup', children: Array.isArray(enumOptions) &&
             enumOptions.map((option, i) => {
                 const checked = enumOptionsIsSelected(option.value, value);
                 const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.indexOf(option.value) !== -1;
                 const disabledCls = disabled || itemDisabled || readonly ? 'disabled' : '';
                 const handleChange = () => onChange(option.value);
-                const radio = (jsxRuntimeExports.jsxs("span", { children: [jsxRuntimeExports.jsx("input", { type: 'radio', id: optionId(id, i), checked: checked, name: htmlName || id, required: required, value: String(i), disabled: disabled || itemDisabled || readonly, autoFocus: autofocus && i === 0, onChange: handleChange, onBlur: handleBlur, onFocus: handleFocus, "aria-describedby": ariaDescribedByIds(id) }), jsxRuntimeExports.jsx("span", { children: option.label })] }));
+                const radio = (jsxRuntimeExports.jsxs("span", { children: [jsxRuntimeExports.jsx("input", { type: 'radio', id: optionId(id, i), checked: checked, name: htmlName || id, required: required, value: enumOptionValueEncoder(option.value, i, optionValueFormat), disabled: disabled || itemDisabled || readonly, autoFocus: autofocus && i === 0, onChange: handleChange, onBlur: handleBlur, onFocus: handleFocus, "aria-describedby": ariaDescribedByIds(id) }), jsxRuntimeExports.jsx("span", { children: option.label })] }));
                 return inline ? (jsxRuntimeExports.jsx("label", { className: `radio-inline ${disabledCls}`, children: radio }, i)) : (jsxRuntimeExports.jsx("div", { className: `radio ${disabledCls}`, children: jsxRuntimeExports.jsx("label", { children: radio }) }, i));
             }) }));
 }
@@ -28191,24 +28985,25 @@ function getValue(event, multiple) {
 function SelectWidget({ schema, id, options, value, required, disabled, readonly, multiple = false, autofocus = false, onChange, onBlur, onFocus, placeholder, htmlName, }) {
     const { enumOptions, enumDisabled, emptyValue: optEmptyVal } = options;
     const emptyValue = multiple ? [] : '';
+    const optionValueFormat = getOptionValueFormat(options);
     const handleFocus = reactExports.useCallback((event) => {
         const newValue = getValue(event, multiple);
-        return onFocus(id, enumOptionsValueForIndex(newValue, enumOptions, optEmptyVal));
-    }, [onFocus, id, multiple, enumOptions, optEmptyVal]);
+        return onFocus(id, enumOptionValueDecoder(newValue, enumOptions, optionValueFormat, optEmptyVal));
+    }, [onFocus, id, multiple, enumOptions, optEmptyVal, optionValueFormat]);
     const handleBlur = reactExports.useCallback((event) => {
         const newValue = getValue(event, multiple);
-        return onBlur(id, enumOptionsValueForIndex(newValue, enumOptions, optEmptyVal));
-    }, [onBlur, id, multiple, enumOptions, optEmptyVal]);
+        return onBlur(id, enumOptionValueDecoder(newValue, enumOptions, optionValueFormat, optEmptyVal));
+    }, [onBlur, id, multiple, enumOptions, optEmptyVal, optionValueFormat]);
     const handleChange = reactExports.useCallback((event) => {
         const newValue = getValue(event, multiple);
-        return onChange(enumOptionsValueForIndex(newValue, enumOptions, optEmptyVal));
-    }, [onChange, multiple, enumOptions, optEmptyVal]);
-    const selectedIndexes = enumOptionsIndexForValue(value, enumOptions, multiple);
+        return onChange(enumOptionValueDecoder(newValue, enumOptions, optionValueFormat, optEmptyVal));
+    }, [onChange, multiple, enumOptions, optEmptyVal, optionValueFormat]);
+    const selectValue = enumOptionSelectedValue(value, enumOptions, multiple, optionValueFormat, emptyValue);
     const showPlaceholderOption = !multiple && schema.default === undefined;
-    return (jsxRuntimeExports.jsxs("select", { id: id, name: htmlName || id, multiple: multiple, role: 'combobox', className: 'form-control', value: typeof selectedIndexes === 'undefined' ? emptyValue : selectedIndexes, required: required, disabled: disabled || readonly, autoFocus: autofocus, onBlur: handleBlur, onFocus: handleFocus, onChange: handleChange, "aria-describedby": ariaDescribedByIds(id), children: [showPlaceholderOption && jsxRuntimeExports.jsx("option", { value: '', children: placeholder }), Array.isArray(enumOptions) &&
+    return (jsxRuntimeExports.jsxs("select", { id: id, name: htmlName || id, multiple: multiple, role: 'combobox', className: 'form-control', value: selectValue, required: required, disabled: disabled || readonly, autoFocus: autofocus, onBlur: handleBlur, onFocus: handleFocus, onChange: handleChange, "aria-describedby": ariaDescribedByIds(id), children: [showPlaceholderOption && jsxRuntimeExports.jsx("option", { value: '', children: placeholder }), Array.isArray(enumOptions) &&
                 enumOptions.map(({ value, label }, i) => {
                     const disabled = enumDisabled && enumDisabled.indexOf(value) !== -1;
-                    return (jsxRuntimeExports.jsx("option", { value: String(i), disabled: disabled, children: label }, i));
+                    return (jsxRuntimeExports.jsx("option", { value: enumOptionValueEncoder(value, i, optionValueFormat), disabled: disabled, children: label }, i));
                 })] }));
 }
 
@@ -28546,10 +29341,6 @@ let Form$1 = class Form extends reactExports.Component {
         // Only store a new registry when the props cause a different one to be created
         const newRegistry = this.getRegistry(props, rootSchema, schemaUtils);
         const registry = deepEquals(state.registry, newRegistry) ? state.registry : newRegistry;
-        // Pre-expand ui:definitions into the uiSchema structure (must happen after registry is created)
-        const expandedUiSchema = registry.uiSchemaDefinitions
-            ? expandUiSchemaDefinitions(rootSchema, uiSchema, registry)
-            : uiSchema;
         // Only compute a new `fieldPathId` when the `idPrefix` is different than the existing fieldPathId's ID_KEY
         const fieldPathId = state.fieldPathId && state.fieldPathId?.[ID_KEY] === registry.globalFormOptions.idPrefix
             ? state.fieldPathId
@@ -28557,7 +29348,7 @@ let Form$1 = class Form extends reactExports.Component {
         const nextState = {
             schemaUtils,
             schema: rootSchema,
-            uiSchema: expandedUiSchema,
+            uiSchema,
             fieldPathId,
             formData,
             edit,
@@ -28731,9 +29522,13 @@ let Form$1 = class Form extends reactExports.Component {
         this._isProcessingUserChange = true;
         const { newValue, path, id } = this.pendingChanges[0];
         const { newErrorSchema } = this.pendingChanges[0];
-        const { extraErrors, omitExtraData, liveOmit, noValidate, liveValidate, onChange } = this.props;
+        const { extraErrors, omitExtraData, liveOmit, noValidate, liveValidate, onChange, removeEmptyOptionalObjects } = this.props;
         const { formData: oldFormData, schemaUtils, schema, fieldPathId, schemaValidationErrorSchema, errors } = this.state;
-        let { customErrors, errorSchema: originalErrorSchema } = this.state;
+        let { customErrors } = this.state;
+        // Use the un-merged AJV-only schema as the base for re-merging extraErrors. Mirrors the
+        // pattern in getStateFromProps/getDerivedStateFromProps and avoids the duplication that
+        // happened when state.errorSchema (already containing merged extraErrors) was passed in.
+        let mergeBaseErrorSchema = schemaValidationErrorSchema;
         const rootPathId = fieldPathId.path[0] || '';
         const isRootPath = !path || path.length === 0 || (path.length === 1 && path[0] === rootPathId);
         let retrievedSchema = this.state.retrievedSchema;
@@ -28770,18 +29565,27 @@ let Form$1 = class Form extends reactExports.Component {
                 formData: newFormData,
             };
         }
+        if (removeEmptyOptionalObjects) {
+            newFormData = removeOptionalEmptyObjects(schemaUtils.getValidator(), schema, schemaUtils.getRootSchema(), newFormData);
+            state = {
+                ...state,
+                formData: newFormData,
+            };
+        }
         if (newErrorSchema) {
             // First check to see if there is an existing validation error on this path...
             // @ts-expect-error TS2590, because getting from the error schema is confusing TS
             const oldValidationError = !isRootPath ? _baseIteratee.get(schemaValidationErrorSchema, path) : schemaValidationErrorSchema;
             // If there is an old validation error for this path, assume we are updating it directly
             if (!isEmpty.isEmpty(oldValidationError)) {
-                // Update the originalErrorSchema "in place" or replace it if it is the root
+                // Apply the user-supplied newErrorSchema onto a clone of the AJV-only base, so that
+                // mergeErrors below sees the user's error at this path without mutating shared state.
                 if (!isRootPath) {
-                    set(originalErrorSchema, path, newErrorSchema);
+                    mergeBaseErrorSchema = cloneDeep.cloneDeep(schemaValidationErrorSchema);
+                    set(mergeBaseErrorSchema, path, newErrorSchema);
                 }
                 else {
-                    originalErrorSchema = newErrorSchema;
+                    mergeBaseErrorSchema = newErrorSchema;
                 }
             }
             else {
@@ -28806,12 +29610,12 @@ let Form$1 = class Form extends reactExports.Component {
         }
         // If there are pending changes in the queue, skip live validation since it will happen with the last change
         if (mustValidate && this.pendingChanges.length === 1) {
-            const liveValidation = this.liveValidate(schema, schemaUtils, originalErrorSchema, newFormData, extraErrors, customErrors, retrievedSchema);
+            const liveValidation = this.liveValidate(schema, schemaUtils, mergeBaseErrorSchema, newFormData, extraErrors, customErrors, retrievedSchema);
             state = { formData: newFormData, ...liveValidation, customErrors };
         }
         else if (!noValidate && newErrorSchema) {
             // Merging 'newErrorSchema' into 'errorSchema' to display the custom raised errors.
-            const mergedErrors = this.mergeErrors({ errorSchema: originalErrorSchema, errors }, extraErrors, customErrors);
+            const mergedErrors = this.mergeErrors({ errorSchema: mergeBaseErrorSchema, errors }, extraErrors, customErrors);
             state = {
                 formData: newFormData,
                 ...mergedErrors,
@@ -28870,19 +29674,23 @@ let Form$1 = class Form extends reactExports.Component {
      * @param data - The data associated with the field that was blurred
      */
     onBlur = (id, data) => {
-        const { onBlur, omitExtraData, liveOmit, liveValidate } = this.props;
+        const { onBlur, omitExtraData, liveOmit, liveValidate, removeEmptyOptionalObjects } = this.props;
         if (onBlur) {
             onBlur(id, data);
         }
         if ((omitExtraData === true && liveOmit === 'onBlur') || liveValidate === 'onBlur') {
             const { onChange, extraErrors } = this.props;
-            const { formData } = this.state;
+            const { formData, schemaUtils, schema } = this.state;
             let newFormData = formData;
             let state = { formData: newFormData };
             if (omitExtraData === true && liveOmit === 'onBlur') {
                 newFormData = this.omitExtraData(formData);
                 state = { formData: newFormData };
             }
+            if (removeEmptyOptionalObjects) {
+                newFormData = removeOptionalEmptyObjects(schemaUtils.getValidator(), schema, schemaUtils.getRootSchema(), newFormData);
+                state = { ...state, formData: newFormData };
+            }
             if (liveValidate === 'onBlur') {
                 const { schema, schemaUtils, errorSchema, customErrors, retrievedSchema } = this.state;
                 const liveValidation = this.liveValidate(schema, schemaUtils, errorSchema, newFormData, extraErrors, customErrors, retrievedSchema);
@@ -28929,11 +29737,15 @@ let Form$1 = class Form extends reactExports.Component {
             return;
         }
         event.persist();
-        const { omitExtraData, extraErrors, noValidate, onSubmit } = this.props;
+        const { omitExtraData, extraErrors, noValidate, onSubmit, removeEmptyOptionalObjects } = this.props;
         let { formData: newFormData } = this.state;
         if (omitExtraData === true) {
             newFormData = this.omitExtraData(newFormData);
         }
+        if (removeEmptyOptionalObjects) {
+            const { schemaUtils, schema } = this.state;
+            newFormData = removeOptionalEmptyObjects(schemaUtils.getValidator(), schema, schemaUtils.getRootSchema(), newFormData);
+        }
         if (noValidate || this.validateFormWithFormData(newFormData)) {
             // There are no errors generated through schema validation.
             // Check for user provided errors and update state accordingly.
@@ -29026,8 +29838,9 @@ let Form$1 = class Form extends reactExports.Component {
         const elementId = path.join(idSeparator);
         let field = this.formElement.current.elements[elementId];
         if (!field) {
-            // if not an exact match, try finding an input starting with the element id (like radio buttons or checkboxes)
-            field = this.formElement.current.querySelector(`input[id^="${elementId}"`);
+            // if not an exact match, try finding a focusable element starting with the element id (like radio buttons or checkboxes)
+            // some themes (e.g. shadcn) use button elements instead of native inputs for radio groups
+            field = this.formElement.current.querySelector(`input[id^="${elementId}"], button[id^="${elementId}"]`);
         }
         if (field && field.length) {
             // If we got a list with length > 0
@@ -29101,11 +29914,15 @@ let Form$1 = class Form extends reactExports.Component {
      * @returns - True if the form is valid, false otherwise.
      */
     validateForm() {
-        const { omitExtraData } = this.props;
+        const { omitExtraData, removeEmptyOptionalObjects } = this.props;
         let { formData: newFormData } = this.state;
         if (omitExtraData === true) {
             newFormData = this.omitExtraData(newFormData);
         }
+        if (removeEmptyOptionalObjects) {
+            const { schemaUtils, schema } = this.state;
+            newFormData = removeOptionalEmptyObjects(schemaUtils.getValidator(), schema, schemaUtils.getRootSchema(), newFormData);
+        }
         return this.validateFormWithFormData(newFormData);
     }
     /** Renders the `Form` fields inside the <form> | `tagName` or `_internalFormWrapper`, rendering any errors if
@@ -35784,13 +36601,50 @@ function createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverr
     return ajv;
 }
 
+/** Filters duplicate errors from `anyOf`/`oneOf` schema paths according to the `suppressDuplicateFiltering` flag.
+ *
+ * @param errorList - The list of `RJSFValidationError`s to filter
+ * @param [suppressDuplicateFiltering='none'] - Controls which duplicate filtering is suppressed:
+ *   - `'none'` (default): filters duplicates for both `anyOf` and `oneOf`
+ *   - `'all'`: returns `errorList` unmodified
+ *   - `'anyOf'`: suppresses filtering for `anyOf` errors; `oneOf` duplicates are still filtered
+ *   - `'oneOf'`: suppresses filtering for `oneOf` errors; `anyOf` duplicates are still filtered
+ */
+function filterDuplicateErrors(errorList, suppressDuplicateFiltering = 'none') {
+    if (suppressDuplicateFiltering === 'all') {
+        return errorList;
+    }
+    return errorList.reduce((acc, err) => {
+        const { message, schemaPath } = err;
+        // Compute the index only when filtering for that keyword is not suppressed.
+        // 'all' is already handled above; within the reduce, only 'none', 'anyOf', and 'oneOf' are possible.
+        const anyOfIndex = suppressDuplicateFiltering !== 'anyOf' ? schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.indexOf(`/${ANY_OF_KEY}/`) : undefined;
+        const oneOfIndex = suppressDuplicateFiltering !== 'oneOf' ? schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.indexOf(`/${ONE_OF_KEY}/`) : undefined;
+        let schemaPrefix;
+        if (anyOfIndex && anyOfIndex >= 0) {
+            schemaPrefix = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.substring(0, anyOfIndex);
+        }
+        else if (oneOfIndex && oneOfIndex >= 0) {
+            schemaPrefix = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.substring(0, oneOfIndex);
+        }
+        // If there is a schemaPrefix, then search for a duplicate message with the same prefix, otherwise undefined
+        const dup = schemaPrefix
+            ? acc.find((e) => { var _a; return e.message === message && ((_a = e.schemaPath) === null || _a === void 0 ? void 0 : _a.startsWith(schemaPrefix)); })
+            : undefined;
+        if (!dup) {
+            acc.push(err);
+        }
+        return acc;
+    }, []);
+}
 /** Transforming the error output from ajv to format used by @rjsf/utils.
  * At some point, components should be updated to support ajv.
  *
  * @param errors - The list of AJV errors to convert to `RJSFValidationErrors`
  * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+ * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
  */
-function transformRJSFValidationErrors(errors = [], uiSchema) {
+function transformRJSFValidationErrors(errors = [], uiSchema, suppressDuplicateFiltering) {
     const errorList = errors.map((e) => {
         var _a;
         const { instancePath, keyword, params, schemaPath, parentSchema, ...rest } = e;
@@ -35860,29 +36714,7 @@ function transformRJSFValidationErrors(errors = [], uiSchema) {
             title: uiTitle,
         };
     });
-    // Filter out duplicates around anyOf/oneOf messages
-    return errorList.reduce((acc, err) => {
-        const { message, schemaPath } = err;
-        const anyOfIndex = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.indexOf(`/${ANY_OF_KEY}/`);
-        const oneOfIndex = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.indexOf(`/${ONE_OF_KEY}/`);
-        let schemaPrefix;
-        // Look specifically for `/anyOr/` or `/oneOf/` within the schemaPath information
-        if (anyOfIndex && anyOfIndex >= 0) {
-            schemaPrefix = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.substring(0, anyOfIndex);
-        }
-        else if (oneOfIndex && oneOfIndex >= 0) {
-            schemaPrefix = schemaPath === null || schemaPath === void 0 ? void 0 : schemaPath.substring(0, oneOfIndex);
-        }
-        // If there is a schemaPrefix, then search for a duplicate message with the same prefix, otherwise undefined
-        const dup = schemaPrefix
-            ? acc.find((e) => { var _a; return e.message === message && ((_a = e.schemaPath) === null || _a === void 0 ? void 0 : _a.startsWith(schemaPrefix)); })
-            : undefined;
-        if (!dup) {
-            // Only push an error that is not a duplicate
-            acc.push(err);
-        }
-        return acc;
-    }, []);
+    return filterDuplicateErrors(errorList, suppressDuplicateFiltering);
 }
 /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
  * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
@@ -35896,10 +36728,11 @@ function transformRJSFValidationErrors(errors = [], uiSchema) {
  * @param [customValidate] - An optional function that is used to perform custom validation
  * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
  * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+ * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
  */
-function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema) {
+function processRawValidationErrors(validator, rawErrors, formData, schema, customValidate, transformErrors, uiSchema, suppressDuplicateFiltering) {
     const { validationError: invalidSchemaError } = rawErrors;
-    let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema);
+    let errors = transformRJSFValidationErrors(rawErrors.errors, uiSchema, suppressDuplicateFiltering);
     if (invalidSchemaError) {
         errors = [...errors, { stack: invalidSchemaError.message }];
     }
@@ -35934,14 +36767,22 @@ class AJV8Validator {
      * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
      */
     constructor(options, localizer) {
-        const { additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass, extenderFn } = options;
+        /** True once a `rootSchema` has been registered with Ajv in this lifecycle.
+         *
+         * @private
+         */
+        this.hasRegisteredRootSchema = false;
+        const { additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass, extenderFn, suppressDuplicateFiltering, } = options;
         this.ajv = createAjvInstance(additionalMetaSchemas, customFormats, ajvOptionsOverrides, ajvFormatOptions, AjvClass, extenderFn);
         this.localizer = localizer;
+        this.suppressDuplicateFiltering = suppressDuplicateFiltering;
     }
     /** Resets the internal AJV validator to clear schemas from it. Can be helpful for resetting the validator for tests.
      */
     reset() {
         this.ajv.removeSchema();
+        this.lastSeenRootSchema = undefined;
+        this.hasRegisteredRootSchema = false;
     }
     /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
      * by the playground. Returns the `errors` from the validation
@@ -36029,14 +36870,19 @@ class AJV8Validator {
      */
     validateFormData(formData, schema, customValidate, transformErrors, uiSchema) {
         const rawErrors = this.rawValidation(schema, formData);
-        return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
+        return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema, this.suppressDuplicateFiltering);
     }
     /**
      * This function checks if a schema needs to be added and if the root schemas don't match it removes the old root schema from the ajv instance and adds the new one.
+     * When called repeatedly with the same `rootSchema` reference the deep-equality check is skipped.
+     *
      * @param rootSchema - The root schema used to provide $ref resolutions
      */
     handleSchemaUpdate(rootSchema) {
         var _a, _b;
+        if (this.lastSeenRootSchema === rootSchema && this.hasRegisteredRootSchema) {
+            return;
+        }
         const rootSchemaId = (_a = rootSchema[ID_KEY]) !== null && _a !== void 0 ? _a : ROOT_SCHEMA_PREFIX;
         // add the rootSchema ROOT_SCHEMA_PREFIX as id.
         // if schema validator instance doesn't exist, add it.
@@ -36048,6 +36894,8 @@ class AJV8Validator {
             this.ajv.removeSchema(rootSchemaId);
             this.ajv.addSchema(rootSchema, rootSchemaId);
         }
+        this.lastSeenRootSchema = rootSchema;
+        this.hasRegisteredRootSchema = true;
     }
     /** Validates data against a schema, returning true if the data is valid, or
      * false otherwise. If the schema is invalid, then this function will return